Implement TON VoteOutboundIfConfirmed

zetaclient/chains/ton/observer/outbound.go

@@ -3,6 +3,7 @@ package observer
 import (
 	"context"
 
+	"cosmossdk.io/math"
 	eth "github.com/ethereum/go-ethereum/common"
 	"github.com/pkg/errors"
 	"github.com/rs/zerolog"
@@ -15,6 +16,7 @@ import (
 	"github.com/zeta-chain/node/zetaclient/chains/interfaces"
 	"github.com/zeta-chain/node/zetaclient/chains/ton/liteapi"
 	zctx "github.com/zeta-chain/node/zetaclient/context"
+	gasconst "github.com/zeta-chain/node/zetaclient/zetacore"
 )
 
 type outbound struct {
@@ -23,8 +25,29 @@ type outbound struct {
 	nonce         uint64
 }
 
-func (ob *Observer) VoteOutboundIfConfirmed(_ context.Context, _ *cc.CrossChainTx) (bool, error) {
-	return false, errors.New("not implemented")
+// VoteOutboundIfConfirmed checks outbound status and returns (continueKeysign, error)
+func (ob *Observer) VoteOutboundIfConfirmed(ctx context.Context, cctx *cc.CrossChainTx) (bool, error) {
+	nonce := cctx.GetCurrentOutboundParam().TssNonce
+
+	outboundRes, exists := ob.getOutboundByNonce(nonce)
+	if !exists {
+		return true, nil
+	}
+
+	withdrawal, err := outboundRes.tx.Withdrawal()
+	if err != nil {
+		return false, errors.Wrap(err, "unable to get withdrawal")
+	}
+
+	// TODO: Add compliance check
+	// https://github.com/zeta-chain/node/issues/2916
+
+	txHash := liteapi.TransactionToHashString(&outboundRes.tx.Transaction)
+	if err = ob.postVoteOutbound(ctx, cctx, withdrawal, txHash, outboundRes.receiveStatus); err != nil {
+		return false, errors.Wrap(err, "unable to post vote")
+	}
+
+	return false, nil
 }
 
 // watchOutbound watches outbound transactions and caches them in-memory so they can be used later in
@@ -207,6 +230,7 @@ func extractWithdrawal(tx *toncontracts.Transaction) (toncontracts.Withdrawal, e
 	return w, s, nil
 }
 
+// getOutboundByNonce returns outbound by nonce
 func (ob *Observer) getOutboundByNonce(nonce uint64) (outbound, bool) {
 	v, ok := ob.outbounds.Get(nonce)
 	if !ok {
@@ -216,6 +240,84 @@ func (ob *Observer) getOutboundByNonce(nonce uint64) (outbound, bool) {
 	return v.(outbound), true
 }
 
+// setOutboundByNonce stores outbound by nonce
 func (ob *Observer) setOutboundByNonce(o outbound) {
 	ob.outbounds.Add(o.nonce, o)
 }
+
+func (ob *Observer) postVoteOutbound(
+	ctx context.Context,
+	cctx *cc.CrossChainTx,
+	w toncontracts.Withdrawal,
+	txHash string,
+	status chains.ReceiveStatus,
+) error {
+	// I. Gas
+	// TON implements a different tx fee model. Basically, each operation in our Gateway has a
+	// tx_fee(operation) which is based on hard-coded gas values per operation
+	// multiplied by the current gas fees on-chain. Each withdrawal tx takes gas directly
+	// from the Gateway i.e. gw pays tx fees for itself.
+	//
+	// - Gas price is stores in zetacore thanks to Observer.postGasPrice()
+	// - Gas limit should be hardcoded in TON ZRC-20
+	//
+	// II. Block height
+	// TON doesn't sequential block height because different txs might end up in different shard chains
+	// tlb.BlockID is essentially a workchain+shard+seqno tuple. We can't use it as a block height. Thus let's use 0.
+	// Note that for the sake of gas tracking, we use masterchain block height (not applicable here).
+	const (
+		outboundGasUsed     = 0
+		outboundGasPrice    = 0
+		outboundGasLimit    = 0
+		outboundBlockHeight = 0
+	)
+
+	var (
+		chainID       = ob.Chain().ChainId
+		nonce         = cctx.GetCurrentOutboundParam().TssNonce
+		signerAddress = ob.ZetacoreClient().GetKeys().GetOperatorAddress()
+		coinType      = cctx.InboundParams.CoinType
+	)
+
+	msg := cc.NewMsgVoteOutbound(
+		signerAddress.String(),
+		cctx.Index,
+		txHash,
+		outboundBlockHeight,
+		outboundGasUsed,
+		math.NewInt(outboundGasPrice),
+		outboundGasLimit,
+		w.Amount,
+		status,
+		chainID,
+		nonce,
+		coinType,
+	)
+
+	const gasLimit = gasconst.PostVoteOutboundGasLimit
+
+	var retryGasLimit uint64
+	if msg.Status == chains.ReceiveStatus_failed {
+		retryGasLimit = gasconst.PostVoteOutboundRevertGasLimit
+	}
+
+	log := ob.Logger().Outbound.With().
+		Uint64("outbound.nonce", nonce).
+		Str("outbound.outbound_tx_hash", txHash).
+		Logger()
+
+	zetaTxHash, ballot, err := ob.ZetacoreClient().PostVoteOutbound(ctx, gasLimit, retryGasLimit, msg)
+	if err != nil {
+		log.Error().Err(err).Msg("PostVoteOutbound: error posting vote")
+		return err
+	}
+
+	if zetaTxHash != "" {
+		log.Info().
+			Str("outbound.vote_tx_hash", zetaTxHash).
+			Str("outbound.ballot_id", ballot).
+			Msg("PostVoteOutbound: posted vote")
+	}
+
+	return nil
+}