feat: add Whitelist message ability to whitelist SPL tokens on Solana

e2e/runner/setup_solana.go

@@ -53,7 +53,7 @@ func (r *E2ERunner) SetupSolana(deployerPrivateKey string) {
 	inst.AccountValues = accountSlice
 
 	inst.DataBytes, err = borsh.Serialize(solanacontracts.InitializeParams{
-		Discriminator: solanacontracts.DiscriminatorInitialize(),
+		Discriminator: solanacontracts.DiscriminatorInitialize,
 		TssAddress:    r.TSSAddress,
 		// #nosec G115 chain id always positive
 		ChainID: uint64(chains.SolanaLocalnet.ChainId),

e2e/runner/solana.go

@@ -51,7 +51,7 @@ func (r *E2ERunner) CreateDepositInstruction(
 
 	var err error
 	inst.DataBytes, err = borsh.Serialize(solanacontract.DepositInstructionParams{
-		Discriminator: solanacontract.DiscriminatorDeposit(),
+		Discriminator: solanacontract.DiscriminatorDeposit,
 		Amount:        amount,
 		Memo:          append(receiver.Bytes(), data...),
 	})

pkg/chains/chain.go

@@ -96,8 +96,8 @@
 	return chain.Vm == Vm_evm
 }
 
-func (chain Chain) IsSVMChain() bool {
-	return chain.Vm == Vm_svm
+func (chain Chain) IsSolanaChain() bool {
+	return chain.Consensus == Consensus_solana_consensus
 }
 
 func (chain Chain) IsBitcoinChain() bool {

pkg/contracts/solana/gateway.go

@@ -19,35 +19,20 @@ const (
 	AccountsNumDeposit = 3
 )
 
-// DiscriminatorInitialize returns the discriminator for Solana gateway 'initialize' instruction
-func DiscriminatorInitialize() [8]byte {
-	return idlgateway.IDLGateway.GetDiscriminator("initialize")
-}
-
-// DiscriminatorDeposit returns the discriminator for Solana gateway 'deposit' instruction
-func DiscriminatorDeposit() [8]byte {
-	return idlgateway.IDLGateway.GetDiscriminator("deposit")
-}
-
-// DiscriminatorDepositSPL returns the discriminator for Solana gateway 'deposit_spl_token' instruction
-func DiscriminatorDepositSPL() [8]byte {
-	return idlgateway.IDLGateway.GetDiscriminator("deposit_spl_token")
-}
-
-// DiscriminatorWithdraw returns the discriminator for Solana gateway 'withdraw' instruction
-func DiscriminatorWithdraw() [8]byte {
-	return idlgateway.IDLGateway.GetDiscriminator("withdraw")
-}
-
-// DiscriminatorWithdrawSPL returns the discriminator for Solana gateway 'withdraw_spl_token' instruction
-func DiscriminatorWithdrawSPL() [8]byte {
-	return idlgateway.IDLGateway.GetDiscriminator("withdraw_spl_token")
-}
-
-// DiscriminatorWhitelist returns the discriminator for Solana gateway 'whitelist_spl_mint' instruction
-func DiscriminatorWhitelistSplMint() [8]byte {
-	return idlgateway.IDLGateway.GetDiscriminator("whitelist_spl_mint")
-}
+var (
+	// DiscriminatorInitialize returns the discriminator for Solana gateway 'initialize' instruction
+	DiscriminatorInitialize = idlgateway.IDLGateway.GetDiscriminator("initialize")
+	// DiscriminatorDeposit returns the discriminator for Solana gateway 'deposit' instruction
+	DiscriminatorDeposit = idlgateway.IDLGateway.GetDiscriminator("deposit")
+	// DiscriminatorDepositSPL returns the discriminator for Solana gateway 'deposit_spl_token' instruction
+	DiscriminatorDepositSPL = idlgateway.IDLGateway.GetDiscriminator("deposit_spl_token")
+	// DiscriminatorWithdraw returns the discriminator for Solana gateway 'withdraw' instruction
+	DiscriminatorWithdraw = idlgateway.IDLGateway.GetDiscriminator("withdraw")
+	// DiscriminatorWithdrawSPL returns the discriminator for Solana gateway 'withdraw_spl_token' instruction
+	DiscriminatorWithdrawSPL = idlgateway.IDLGateway.GetDiscriminator("withdraw_spl_token")
+	// DiscriminatorWhitelist returns the discriminator for Solana gateway 'whitelist_spl_mint' instruction
+	DiscriminatorWhitelistSplMint = idlgateway.IDLGateway.GetDiscriminator("whitelist_spl_mint")
+)
 
 // ParseGatewayAddressAndPda parses the gateway id and program derived address from the given string
 func ParseGatewayIDAndPda(address string) (solana.PublicKey, solana.PublicKey, error) {

pkg/contracts/solana/gateway_message.go

@@ -110,9 +110,11 @@
 
 // MsgWhitelist is the message for the Solana gateway whitelist_spl_mint instruction
 type MsgWhitelist struct {
-	// whitelistCandidate is the whitelist candidate
+	// whitelistCandidate is the SPL token to be whitelisted in gateway program
 	whitelistCandidate solana.PublicKey
-	whitelistEntry     solana.PublicKey
+
+	// whitelistEntry is the entry in gateway program representing whitelisted SPL token
+	whitelistEntry solana.PublicKey
 
 	// chainID is the chain ID of Solana chain
 	chainID uint64
@@ -139,22 +141,22 @@
 }
 
 // To returns the recipient address of the message
 func (msg *MsgWhitelist) WhitelistCandidate() solana.PublicKey {
 	return msg.whitelistCandidate
 }
 
 func (msg *MsgWhitelist) WhitelistEntry() solana.PublicKey {
 	return msg.whitelistEntry
 }
 
 // ChainID returns the chain ID of the message
 func (msg *MsgWhitelist) ChainID() uint64 {
 	return msg.chainID
 }
 
 // Nonce returns the nonce of the message
 func (msg *MsgWhitelist) Nonce() uint64 {
 	return msg.nonce
 }
 
 // Hash packs the whitelist message and computes the hash
@@ -176,32 +178,32 @@
 }
 
 // SetSignature attaches the signature to the message
 func (msg *MsgWhitelist) SetSignature(signature [65]byte) *MsgWhitelist {
 	msg.signature = signature
 	return msg
 }
 
 // SigRSV returns the full 65-byte [R+S+V] signature
 func (msg *MsgWhitelist) SigRSV() [65]byte {
 	return msg.signature
 }
 
 // SigRS returns the 64-byte [R+S] core part of the signature
 func (msg *MsgWhitelist) SigRS() [64]byte {
 	var sig [64]byte
 	copy(sig[:], msg.signature[:64])
 	return sig
 }
 
 // SigV returns the V part (recovery ID) of the signature
 func (msg *MsgWhitelist) SigV() uint8 {
 	return msg.signature[64]
 }
 
 // Signer returns the signer of the message
 func (msg *MsgWhitelist) Signer() (common.Address, error) {
 	msgHash := msg.Hash()
 	msgSig := msg.SigRSV()
 
 	return RecoverSigner(msgHash[:], msgSig[:])
 }

pkg/contracts/solana/gateway_message_test.go

@@ -29,3 +29,21 @@ func Test_MsgWithdrawHash(t *testing.T) {
 		require.True(t, bytes.Equal(hash[:], wantHashBytes))
 	})
 }
+
+func Test_MsgWhitelistHash(t *testing.T) {
+	t.Run("should pass for archived inbound, receipt and cctx", func(t *testing.T) {
+		// #nosec G115 always positive
+		chainID := uint64(chains.SolanaLocalnet.ChainId)
+		nonce := uint64(0)
+		whitelistCandidate := solana.MustPublicKeyFromBase58("37yGiHAnLvWZUNVwu9esp74YQFqxU1qHCbABkDvRddUQ")
+		whitelistEntry := solana.MustPublicKeyFromBase58("2kJndCL9NBR36ySiQ4bmArs4YgWQu67LmCDfLzk5Gb7s")
+
+		wantHash := "cde8fa3ab24b50320db1c47f30492e789177d28e76208176f0a52b8ed54ce2dd"
+		wantHashBytes, err := hex.DecodeString(wantHash)
+		require.NoError(t, err)
+
+		// create new withdraw message
+		hash := contracts.NewMsgWhitelist(whitelistCandidate, whitelistEntry, chainID, nonce).Hash()
+		require.True(t, bytes.Equal(hash[:], wantHashBytes))
+	})
+}

pkg/contracts/solana/instruction.go

@@ -99,7 +99,7 @@
 	}
 
 	// check the discriminator to ensure it's a 'withdraw' instruction
-	if inst.Discriminator != DiscriminatorWithdraw() {
+	if inst.Discriminator != DiscriminatorWithdraw {
 		return nil, fmt.Errorf("not a withdraw instruction: %v", inst.Discriminator)
 	}
 
@@ -138,38 +138,38 @@
 }
 
 // Signer returns the signer of the signature contained
 func (inst *WhitelistInstructionParams) Signer() (signer common.Address, err error) {
 	var signature [65]byte
 	copy(signature[:], inst.Signature[:64])
 	signature[64] = inst.RecoveryID
 
 	return RecoverSigner(inst.MessageHash[:], signature[:])
 }
 
 // GatewayNonce returns the nonce of the instruction
 func (inst *WhitelistInstructionParams) GatewayNonce() uint64 {
 	return inst.Nonce
 }
 
 // TokenAmount returns the amount of the instruction
 func (inst *WhitelistInstructionParams) TokenAmount() uint64 {
 	return 0
 }
 
 // ParseInstructionWhitelist tries to parse the instruction as a 'whitelist_spl_mint'.
 // It returns nil if the instruction can't be parsed as a 'whitelist_spl_mint'.
 func ParseInstructionWhitelist(instruction solana.CompiledInstruction) (*WhitelistInstructionParams, error) {
 	// try deserializing instruction as a 'whitelist_spl_mint'
 	inst := &WhitelistInstructionParams{}
 	err := borsh.Deserialize(inst, instruction.Data)
 	if err != nil {
 		return nil, errors.Wrap(err, "error deserializing instruction")
 	}
 
 	// check the discriminator to ensure it's a 'whitelist_spl_mint' instruction
-	if inst.Discriminator != DiscriminatorWhitelistSplMint() {
+	if inst.Discriminator != DiscriminatorWhitelistSplMint {
 		return nil, fmt.Errorf("not a whitelist_spl_mint instruction: %v", inst.Discriminator)
 	}
 
 	return inst, nil
 }

x/crosschain/keeper/msg_server_whitelist_erc20.go

@@ -48,7 +48,7 @@ func (k msgServer) WhitelistERC20(
 			)
 		}
 
-	case chain.IsSVMChain():
+	case chain.IsSolanaChain():
 		_, err := solana.PublicKeyFromBase58(msg.Erc20Address)
 		if err != nil {
 			return nil, errorsmod.Wrapf(

zetaclient/chains/solana/observer/inbound.go

@@ -281,7 +281,7 @@ func (ob *Observer) ParseInboundAsDeposit(
 	}
 
 	// check if the instruction is a deposit or not
-	if inst.Discriminator != solanacontracts.DiscriminatorDeposit() {
+	if inst.Discriminator != solanacontracts.DiscriminatorDeposit {
 		return nil, nil
 	}
 

zetaclient/chains/solana/observer/outbound_test.go

@@ -35,6 +35,9 @@ const (
 
 	// tssAddressTest is the TSS address for testing
 	tssAddressTest = "0x05C7dBdd1954D59c9afaB848dA7d8DD3F35e69Cd"
+
+	// whitelistTxTest is local devnet tx result for testing
+	whitelistTxTest = "phM9bESbiqojmpkkUxgjed8EABkxvPGNau9q31B8Yk1sXUtsxJvd6G9VbZZQPsEyn6RiTH4YBtqJ89omqfbbNNY"
 )
 
 // createTestObserver creates a test observer for testing
@@ -294,3 +297,63 @@ func Test_ParseInstructionWithdraw(t *testing.T) {
 		require.Nil(t, inst)
 	})
 }
+
+func Test_ParseInstructionWhitelist(t *testing.T) {
+	// the test chain and transaction hash
+	chain := chains.SolanaDevnet
+	txHash := whitelistTxTest
+	txAmount := uint64(0)
+
+	t.Run("should parse instruction whitelist", func(t *testing.T) {
+		// tss address used in local devnet
+		tssAddress := "0x7E8c7bAcd3c6220DDC35A4EA1141BE14F2e1dFEB"
+		// load and unmarshal archived transaction
+		txResult := testutils.LoadSolanaOutboundTxResult(t, TestDataDir, chain.ChainId, txHash)
+		tx, err := txResult.Transaction.GetTransaction()
+		require.NoError(t, err)
+
+		instruction := tx.Message.Instructions[0]
+		inst, err := contracts.ParseInstructionWhitelist(instruction)
+		require.NoError(t, err)
+
+		// check sender, nonce and amount
+		sender, err := inst.Signer()
+		require.NoError(t, err)
+		require.Equal(t, tssAddress, sender.String())
+		require.EqualValues(t, inst.GatewayNonce(), 3)
+		require.EqualValues(t, inst.TokenAmount(), txAmount)
+	})
+
+	t.Run("should return error on invalid instruction data", func(t *testing.T) {
+		// load and unmarshal archived transaction
+		txResult := testutils.LoadSolanaOutboundTxResult(t, TestDataDir, chain.ChainId, txHash)
+		txFake, err := txResult.Transaction.GetTransaction()
+		require.NoError(t, err)
+
+		// set invalid instruction data
+		instruction := txFake.Message.Instructions[0]
+		instruction.Data = []byte("invalid instruction data")
+
+		inst, err := contracts.ParseInstructionWhitelist(instruction)
+		require.ErrorContains(t, err, "error deserializing instruction")
+		require.Nil(t, inst)
+	})
+
+	t.Run("should return error on discriminator mismatch", func(t *testing.T) {
+		// load and unmarshal archived transaction
+		txResult := testutils.LoadSolanaOutboundTxResult(t, TestDataDir, chain.ChainId, txHash)
+		txFake, err := txResult.Transaction.GetTransaction()
+		require.NoError(t, err)
+
+		// overwrite discriminator (first 8 bytes)
+		instruction := txFake.Message.Instructions[0]
+		fakeDiscriminator := "b712469c946da12100980d0000000000"
+		fakeDiscriminatorBytes, err := hex.DecodeString(fakeDiscriminator)
+		require.NoError(t, err)
+		copy(instruction.Data, fakeDiscriminatorBytes)
+
+		inst, err := contracts.ParseInstructionWhitelist(instruction)
+		require.ErrorContains(t, err, "not a whitelist_spl_mint instruction")
+		require.Nil(t, inst)
+	})
+}

zetaclient/chains/solana/signer/signer.go

@@ -124,62 +124,62 @@
 	chainID := signer.Chain().ChainId
 	nonce := params.TssNonce
 	coinType := cctx.InboundParams.CoinType
 
 	// skip relaying the transaction if this signer hasn't set the relayer key
 	if !signer.HasRelayerKey() {
+		logger.Warn().Msgf("TryProcessOutbound: no relayer key configured")
 		return
 	}
 
 	var tx *solana.Transaction
 
 	switch coinType {
 	case coin.CoinType_Cmd:
 		whitelistTx, err := signer.prepareWhitelistTx(ctx, cctx, height)
 		if err != nil {
 			logger.Error().Err(err).Msgf("TryProcessOutbound: Fail to sign whitelist outbound")
 			return
 		}
 
 		tx = whitelistTx
 
 	case coin.CoinType_Gas:
 		withdrawTx, err := signer.prepareWithdrawTx(ctx, cctx, height, logger)
 		if err != nil {
 			logger.Error().Err(err).Msgf("TryProcessOutbound: Fail to sign withdraw outbound")
 			return
 		}
 
 		tx = withdrawTx
 	default:
 		logger.Error().
-			Msgf("TryProcessOutbound: can only send SOL to the Solana network for chain %d nonce %d", chainID, nonce)
+			Msgf("TryProcessOutbound: can only send SOL to the Solana network")
 		return
 	}
 
 	// set relayer balance metrics
 	signer.SetRelayerBalanceMetrics(ctx)
 
 	// broadcast the signed tx to the Solana network with preflight check
 	txSig, err := signer.client.SendTransactionWithOpts(
 		ctx,
 		tx,
 		// Commitment "finalized" is too conservative for preflight check and
 		// it results in repeated broadcast attempts that only 1 will succeed.
 		// Commitment "processed" will simulate tx against more recent state
 		// thus fails faster once a tx is already broadcasted and processed by the cluster.
 		// This reduces the number of "failed" txs due to repeated broadcast attempts.
 		rpc.TransactionOpts{PreflightCommitment: rpc.CommitmentProcessed},
 	)
 	if err != nil {
-		signer.Logger().
-			Std.Warn().
+		logger.Error().
 			Err(err).
-			Msgf("TryProcessOutbound: broadcast error for chain %d nonce %d", chainID, nonce)
+			Msgf("TryProcessOutbound: broadcast error")
 		return
 	}
 
 	// report the outbound to the outbound tracker
 	signer.reportToOutboundTracker(ctx, zetacoreClient, chainID, nonce, txSig, logger)
 }
 
 func (signer *Signer) prepareWithdrawTx(
@@ -187,8 +187,8 @@
 	cctx *types.CrossChainTx,
 	height uint64,
 	logger zerolog.Logger,
 ) (*solana.Transaction, error) {
 	params := cctx.GetCurrentOutboundParam()
 	// compliance check
 	cancelTx := compliance.IsCctxRestricted(cctx)
 	if cancelTx {
@@ -196,7 +196,7 @@
 			logger,
 			signer.Logger().Compliance,
 			true,
 			signer.Chain().ChainId,
 			cctx.Index,
 			cctx.InboundParams.Sender,
 			params.Receiver,
@@ -205,55 +205,55 @@
 	}
 
 	// sign gateway withdraw message by TSS
-	msg, err := signer.SignMsgWithdraw(ctx, params, height, cancelTx)
+	msg, err := signer.createAndSignMsgWithdraw(ctx, params, height, cancelTx)
 	if err != nil {
 		return nil, err
 	}
 
 	// sign the withdraw transaction by relayer key
-	tx, err := signer.SignWithdrawTx(ctx, *msg)
+	tx, err := signer.signWithdrawTx(ctx, *msg)
 	if err != nil {
 		return nil, err
 	}
 
 	return tx, nil
 }
 
 func (signer *Signer) prepareWhitelistTx(
 	ctx context.Context,
 	cctx *types.CrossChainTx,
 	height uint64,
 ) (*solana.Transaction, error) {
 	params := cctx.GetCurrentOutboundParam()
 	relayedMsg := strings.Split(cctx.RelayedMessage, ":")
 	if len(relayedMsg) != 2 {
 		return nil, fmt.Errorf("TryProcessOutbound: invalid relayed msg")
 	}
 
 	pk, err := solana.PublicKeyFromBase58(relayedMsg[1])
 	if err != nil {
 		return nil, err
 	}
 
 	seed := [][]byte{[]byte("whitelist"), pk.Bytes()}
 	whitelistEntryPDA, _, err := solana.FindProgramAddress(seed, signer.gatewayID)
 	if err != nil {
 		return nil, err
 	}
 
 	// sign gateway whitelist message by TSS
-	msg, err := signer.SignMsgWhitelist(ctx, params, height, pk, whitelistEntryPDA)
+	msg, err := signer.createAndSignMsgWhitelist(ctx, params, height, pk, whitelistEntryPDA)
 	if err != nil {
 		return nil, err
 	}
 
 	// sign the whitelist transaction by relayer key
-	tx, err := signer.SignWhitelistTx(ctx, msg)
+	tx, err := signer.signWhitelistTx(ctx, msg)
 	if err != nil {
 		return nil, err
 	}
 
 	return tx, nil
 }
 
 // SetGatewayAddress sets the gateway address

zetaclient/chains/solana/signer/whitelist.go

@@ -12,95 +12,95 @@
 	"github.com/zeta-chain/node/x/crosschain/types"
 )
 
-// SignMsgWhitelist signs a whitelist message (for gateway whitelist_spl_mint instruction) with TSS.
-func (signer *Signer) SignMsgWhitelist(
+// createAndSignMsgWhitelist creates and signs a whitelist message (for gateway whitelist_spl_mint instruction) with TSS.
+func (signer *Signer) createAndSignMsgWhitelist(
 	ctx context.Context,
 	params *types.OutboundParams,
 	height uint64,
 	whitelistCandidate solana.PublicKey,
 	whitelistEntry solana.PublicKey,
 ) (*contracts.MsgWhitelist, error) {
 	chain := signer.Chain()
 	// #nosec G115 always positive
 	chainID := uint64(signer.Chain().ChainId)
 	nonce := params.TssNonce
 
 	// prepare whitelist msg and compute hash
 	msg := contracts.NewMsgWhitelist(whitelistCandidate, whitelistEntry, chainID, nonce)
 	msgHash := msg.Hash()
 
 	// sign the message with TSS to get an ECDSA signature.
 	// the produced signature is in the [R || S || V] format where V is 0 or 1.
 	signature, err := signer.TSS().Sign(ctx, msgHash[:], height, nonce, chain.ChainId, "")
 	if err != nil {
 		return nil, errors.Wrap(err, "Key-sign failed")
 	}
 	signer.Logger().Std.Info().Msgf("Key-sign succeed for chain %d nonce %d", chainID, nonce)
 
 	// attach the signature and return
 	return msg.SetSignature(signature), nil
 }
 
-// SignWhitelistTx wraps the whitelist 'msg' into a Solana transaction and signs it with the relayer key.
-func (signer *Signer) SignWhitelistTx(ctx context.Context, msg *contracts.MsgWhitelist) (*solana.Transaction, error) {
+// signWhitelistTx wraps the whitelist 'msg' into a Solana transaction and signs it with the relayer key.
+func (signer *Signer) signWhitelistTx(ctx context.Context, msg *contracts.MsgWhitelist) (*solana.Transaction, error) {
 	// create whitelist_spl_mint instruction with program call data
 	var err error
 	var inst solana.GenericInstruction
 	inst.DataBytes, err = borsh.Serialize(contracts.WhitelistInstructionParams{
-		Discriminator: contracts.DiscriminatorWhitelistSplMint(),
+		Discriminator: contracts.DiscriminatorWhitelistSplMint,
 		Signature:     msg.SigRS(),
 		RecoveryID:    msg.SigV(),
 		MessageHash:   msg.Hash(),
 		Nonce:         msg.Nonce(),
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "cannot serialize whitelist_spl_mint instruction")
 	}
 
 	// attach required accounts to the instruction
 	privkey := signer.relayerKey
 	attachWhitelistAccounts(
 		&inst,
 		privkey.PublicKey(),
 		signer.pda,
 		msg.WhitelistCandidate(),
 		msg.WhitelistEntry(),
 		signer.gatewayID,
 	)
 
 	// get a recent blockhash
 	recent, err := signer.client.GetLatestBlockhash(ctx, rpc.CommitmentFinalized)
 	if err != nil {
 		return nil, errors.Wrap(err, "GetLatestBlockhash error")
 	}
 
 	// create a transaction that wraps the instruction
 	tx, err := solana.NewTransaction(
 		[]solana.Instruction{
 			// TODO: outbound now uses 5K lamports as the fixed fee, we could explore priority fee and compute budget
 			// https://github.com/zeta-chain/node/issues/2599
 			// programs.ComputeBudgetSetComputeUnitLimit(computeUnitLimit),
 			// programs.ComputeBudgetSetComputeUnitPrice(computeUnitPrice),
 			&inst},
 		recent.Value.Blockhash,
 		solana.TransactionPayer(privkey.PublicKey()),
 	)
 	if err != nil {
 		return nil, errors.Wrap(err, "NewTransaction error")
 	}
 
 	// relayer signs the transaction
 	_, err = tx.Sign(func(key solana.PublicKey) *solana.PrivateKey {
 		if key.Equals(privkey.PublicKey()) {
 			return privkey
 		}
 		return nil
 	})
 	if err != nil {
 		return nil, errors.Wrap(err, "signer unable to sign transaction")
 	}
 
 	return tx, nil
 }
 
 // attachWhitelistAccounts attaches the required accounts for the gateway whitelist instruction.
@@ -111,15 +111,15 @@
 	whitelistCandidate solana.PublicKey,
 	whitelistEntry solana.PublicKey,
 	gatewayID solana.PublicKey,
 ) {
 	// attach required accounts to the instruction
 	var accountSlice []*solana.AccountMeta
 	accountSlice = append(accountSlice, solana.Meta(whitelistEntry).WRITE())
 	accountSlice = append(accountSlice, solana.Meta(whitelistCandidate))
 	accountSlice = append(accountSlice, solana.Meta(pda).WRITE())
 	accountSlice = append(accountSlice, solana.Meta(signer).WRITE().SIGNER())
 	accountSlice = append(accountSlice, solana.Meta(solana.SystemProgramID))
 	inst.ProgID = gatewayID
 
 	inst.AccountValues = accountSlice
 }

zetaclient/chains/solana/signer/withdraw.go

@@ -13,8 +13,8 @@
 	"github.com/zeta-chain/node/x/crosschain/types"
 )
 
-// SignMsgWithdraw signs a withdraw message (for gateway withdraw/withdraw_spl instruction) with TSS.
-func (signer *Signer) SignMsgWithdraw(
+// createAndSignMsgWithdraw creates and signs a withdraw message (for gateway withdraw/withdraw_spl instruction) with TSS.
+func (signer *Signer) createAndSignMsgWithdraw(
 	ctx context.Context,
 	params *types.OutboundParams,
 	height uint64,
@@ -53,13 +53,13 @@
 	return msg.SetSignature(signature), nil
 }
 
-// SignWithdrawTx wraps the withdraw 'msg' into a Solana transaction and signs it with the relayer key.
-func (signer *Signer) SignWithdrawTx(ctx context.Context, msg contracts.MsgWithdraw) (*solana.Transaction, error) {
+// signWithdrawTx wraps the withdraw 'msg' into a Solana transaction and signs it with the relayer key.
+func (signer *Signer) signWithdrawTx(ctx context.Context, msg contracts.MsgWithdraw) (*solana.Transaction, error) {
 	// create withdraw instruction with program call data
 	var err error
 	var inst solana.GenericInstruction
 	inst.DataBytes, err = borsh.Serialize(contracts.WithdrawInstructionParams{
-		Discriminator: contracts.DiscriminatorWithdraw(),
+		Discriminator: contracts.DiscriminatorWithdraw,
 		Amount:        msg.Amount(),
 		Signature:     msg.SigRS(),
 		RecoveryID:    msg.SigV(),