feat(solana): Add SolanaTransaction.insertTransferInstruction() (trustwallet#4523)

* feat(solana): Add `transfer_to_fee_payer` instruction

* feat(solana): Add `tw_solana_transaction_insert_transfer_instruction` FFI

* feat(solana): Add a note comment

* feat(solana): Add one more comment

Author: satoshiotomakan

rust/Cargo.lock

@@ -15,4 +15,5 @@ tw_hash = { path = "../../tw_hash" }
 tw_keypair = { path = "../../tw_keypair" }
 tw_memory = { path = "../../tw_memory" }
 tw_misc = { path = "../../tw_misc" }
+tw_number = { path = "../../tw_number" }
 tw_proto = { path = "../../tw_proto" }

rust/chains/tw_solana/Cargo.toml

@@ -132,10 +132,10 @@ pub trait InsertInstruction {
             .iter()
             .position(|key| *key == account.pubkey)
         {
-            let is_signer =
+            let existing_is_signer =
                 existing_index < self.message_header_mut().num_required_signatures as usize;
 
-            let is_writable = if is_signer {
+            let existing_is_writable = if existing_is_signer {
                 existing_index
                     < (self.message_header_mut().num_required_signatures
                         - self.message_header_mut().num_readonly_signed_accounts)
@@ -146,16 +146,30 @@ pub trait InsertInstruction {
                         - self.message_header_mut().num_readonly_unsigned_accounts as usize)
             };
 
-            if account.is_signer != is_signer {
-                return SigningError::err(SigningErrorType::Error_internal).context(
-                    "Account already exists but the `is_signer` attribute does not match",
-                );
+            match (existing_is_signer, account.is_signer) {
+                // If new account requires weaker or the same signing permissions, it's ok.
+                (true, false) | (false, false) | (true, true) => (),
+                // If new account requires stronger signing permissions than we have already, then would need to reorder accounts.
+                // TODO: Implement reordering accounts if needed.
+                (false, true) => {
+                    return SigningError::err(SigningErrorType::Error_internal).context(
+                        "Account already exists but the `is_signer` attribute does not match",
+                    );
+                },
             }
-            if account.is_writable != is_writable {
-                return SigningError::err(SigningErrorType::Error_internal).context(
-                    "Account already exists but the `is_writable` attribute does not match",
-                );
+
+            match (existing_is_writable, account.is_writable) {
+                // If new account requires weaker or the same writable permissions, it's ok.
+                (true, false) | (false, false) | (true, true) => (),
+                // If new account requires stronger writable permissions than we have already, then would need to reorder accounts.
+                // TODO: Implement reordering accounts if needed.
+                (false, true) => {
+                    return SigningError::err(SigningErrorType::Error_internal).context(
+                        "Account already exists but the `is_writable` attribute does not match",
+                    );
+                },
             }
+
             // Return the existing index if validation passes
             return try_into_u8(existing_index);
         }

rust/chains/tw_solana/src/modules/insert_instruction.rs

@@ -66,6 +66,13 @@ impl InstructionBuilder {
         self
     }
 
+    pub fn maybe_add_instruction(&mut self, instruction: Option<Instruction>) -> &mut Self {
+        if let Some(instruction) = instruction {
+            self.instructions.push(instruction);
+        }
+        self
+    }
+
     pub fn add_instructions<I>(&mut self, instructions: I) -> &mut Self
     where
         I: IntoIterator<Item = Instruction>,

rust/chains/tw_solana/src/modules/instruction_builder/mod.rs

@@ -166,7 +166,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
             .maybe_memo(transfer.memo.as_ref())
-            .add_instruction(transfer_ix);
+            .add_instruction(transfer_ix)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -202,7 +203,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_advance_nonce(self.nonce_account()?, sender)
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
-            .add_instructions(deposit_ixs);
+            .add_instructions(deposit_ixs)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -222,7 +224,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_advance_nonce(self.nonce_account()?, sender)
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
-            .add_instruction(deactivate_ix);
+            .add_instruction(deactivate_ix)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -246,7 +249,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_advance_nonce(self.nonce_account()?, sender)
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
-            .add_instructions(deactivate_ixs);
+            .add_instructions(deactivate_ixs)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -274,7 +278,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_advance_nonce(self.nonce_account()?, sender)
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
-            .add_instruction(withdraw_ix);
+            .add_instruction(withdraw_ix)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -308,7 +313,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_advance_nonce(self.nonce_account()?, sender)
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
-            .add_instructions(withdraw_ixs);
+            .add_instructions(withdraw_ixs)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -342,7 +348,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_advance_nonce(self.nonce_account()?, funding_account)
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
-            .add_instruction(instruction);
+            .add_instruction(instruction)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -390,7 +397,8 @@ impl<'a> MessageBuilder<'a> {
             .maybe_priority_fee_price(self.priority_fee_price())
             .maybe_priority_fee_limit(self.priority_fee_limit())
             .maybe_memo(token_transfer.memo.as_ref())
-            .add_instruction(transfer_instruction);
+            .add_instruction(transfer_instruction)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -456,7 +464,8 @@ impl<'a> MessageBuilder<'a> {
             .add_instruction(create_account_instruction)
             // Optional memo. Order: before transfer, as per documentation.
             .maybe_memo(create_and_transfer.memo.as_ref())
-            .add_instruction(transfer_instruction);
+            .add_instruction(transfer_instruction)
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -489,7 +498,8 @@ impl<'a> MessageBuilder<'a> {
                 new_nonce_account,
                 create_nonce.rent,
                 DEFAULT_CREATE_NONCE_SPACE,
-            ));
+            ))
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -516,7 +526,8 @@ impl<'a> MessageBuilder<'a> {
                 signer,
                 recipient,
                 withdraw_nonce.value,
-            ));
+            ))
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -533,7 +544,8 @@ impl<'a> MessageBuilder<'a> {
         builder
             .maybe_advance_nonce(Some(nonce_account), signer)
             .maybe_priority_fee_price(self.priority_fee_price())
-            .maybe_priority_fee_limit(self.priority_fee_limit());
+            .maybe_priority_fee_limit(self.priority_fee_limit())
+            .maybe_add_instruction(self.transfer_to_fee_payer()?);
         Ok(builder.output())
     }
 
@@ -648,6 +660,24 @@ impl<'a> MessageBuilder<'a> {
             .map(|proto| proto.limit)
     }
 
+    fn transfer_to_fee_payer(&self) -> SigningResult<Option<Instruction>> {
+        let Some(ref transfer_to_fee_payer) = self.input.transfer_to_fee_payer else {
+            return Ok(None);
+        };
+
+        let from = self.signer_address()?;
+        let to = SolanaAddress::from_str(&transfer_to_fee_payer.recipient)
+            .into_tw()
+            .context("Invalid 'transfer_to_fee_payer.recipient' address")?;
+
+        let references = Self::parse_references(&transfer_to_fee_payer.references)?;
+
+        Ok(Some(
+            SystemInstructionBuilder::transfer(from, to, transfer_to_fee_payer.value)
+                .with_references(references),
+        ))
+    }
+
     fn parse_references(refs: &[Cow<'_, str>]) -> SigningResult<Vec<SolanaAddress>> {
         refs.iter()
             .map(|addr| SolanaAddress::from_str(addr).map_err(SigningError::from))

rust/chains/tw_solana/src/modules/message_builder.rs

@@ -9,21 +9,25 @@ use crate::modules::insert_instruction::InsertInstruction;
 use crate::modules::instruction_builder::compute_budget_instruction::{
     ComputeBudgetInstruction, ComputeBudgetInstructionBuilder, UnitLimit, UnitPrice,
 };
-use crate::modules::instruction_builder::system_instruction::SystemInstruction;
+use crate::modules::instruction_builder::system_instruction::{
+    SystemInstruction, SystemInstructionBuilder,
+};
 use crate::modules::message_decompiler::{InstructionWithoutAccounts, MessageDecompiler};
 use crate::modules::proto_builder::ProtoBuilder;
 use crate::modules::tx_signer::TxSigner;
 use crate::modules::PubkeySignatureMap;
 use crate::transaction::versioned::VersionedTransaction;
 use crate::SOLANA_ALPHABET;
 use std::borrow::Cow;
+use std::str::FromStr;
 use tw_coin_entry::error::prelude::*;
 use tw_coin_entry::signing_output_error;
 use tw_encoding::base58;
 use tw_encoding::base64::{self, STANDARD};
 use tw_hash::H256;
 use tw_keypair::{ed25519, KeyPairResult};
 use tw_memory::Data;
+use tw_number::U256;
 use tw_proto::Solana::Proto;
 
 pub struct SolanaTransaction;
@@ -210,6 +214,53 @@ impl SolanaTransaction {
             .to_base64()
             .tw_err(SigningErrorType::Error_internal)
     }
+
+    /// Inserts a SOL transfer instruction to the given transaction at the specified position, returning the updated transaction.
+    /// Please note that compute price and limit instructions should always be the first instructions if they are present in the transaction.
+    /// If you don't care about the position, use -1.
+    pub fn insert_transfer_instruction(
+        encoded_tx: &str,
+        insert_at: i32,
+        from: &str,
+        to: &str,
+        lamports: &str,
+    ) -> SigningResult<String> {
+        let tx_bytes = base64::decode(encoded_tx, STANDARD)?;
+        let from =
+            SolanaAddress::from_str(from).map_err(|_| SigningErrorType::Error_input_parse)?;
+        let to = SolanaAddress::from_str(to).map_err(|_| SigningErrorType::Error_input_parse)?;
+        let lamports = U256::from_str(lamports)
+            .and_then(u64::try_from)
+            .map_err(|_| SigningErrorType::Error_input_parse)?;
+
+        let mut tx: VersionedTransaction =
+            bincode::deserialize(&tx_bytes).map_err(|_| SigningErrorType::Error_input_parse)?;
+
+        if insert_at >= 0 && insert_at as usize > tx.message.instructions().len() {
+            return Err(SigningError::from(SigningErrorType::Error_invalid_params));
+        }
+
+        let final_insert_at = if insert_at < 0 {
+            tx.message.instructions().len() // Append to the end if negative
+        } else {
+            insert_at as usize // Use the specified position
+        };
+
+        // Create transfer instruction and insert it at the specified position.
+        let transfer_ix = SystemInstructionBuilder::transfer(from, to, lamports);
+        tx.message.insert_instruction(
+            final_insert_at,
+            transfer_ix.program_id,
+            transfer_ix.accounts,
+            transfer_ix.data,
+        )?;
+
+        // Set the correct number of zero signatures
+        let unsigned_tx = VersionedTransaction::unsigned(tx.message);
+        unsigned_tx
+            .to_base64()
+            .tw_err(SigningErrorType::Error_internal)
+    }
 }
 
 fn try_instruction_as_compute_budget(

rust/chains/tw_solana/src/modules/utils.rs

@@ -1009,3 +1009,42 @@ fn test_solana_sign_sponsored_transfer_token_with_external_fee_payer() {
     // https://solscan.io/tx/3z7beuRPcr6WmTRvCDNgSNXBaEUTAy8EYHN93eUiLXoFoj2VbWuPbvf7nQoZxTHbG6ChQuTJDqwaQnUzK4WxYaQA
     assert_eq!(output.encoded, "gnSfLvpTeWGFvEKGDNAwQpQYczANiAHcpj4ghRgKsJfTXJjqaGYnNG2Ay2JwR5XdRvdkeLjHdht7VctoJkxDcYLRNjWmFcb3khwZqV4oRcU3HCxqnjGbiFmBCTjsupUt4ZzsJs8DS9WGHPgQGfRVQdmq1Zv6Kd4KDR88aT3uLmdNsu1XP5Es5SFAqByGnwAnkthDfNvcmpW9iAsZdf4v7gTsgFZV14ZfsNh66TGzVJLepz689D4jKb19AyvPwBPYYsvpRLxeEaa3zJvsdBBoVkWMZzC2Y8oqxoPXCRXnxzKX9gJSew1P2bgZDN3j3BvFQ19zTYsdugGtRetV94yQgx5xh8Vk9Asbj3YCmEZpFMZborqeanvgK2mWs2rQmbanMY6Fi6FB1xN24YN2B38pK2g3DCYp6nNh1ueacrDakbyrRFCpyKo26yqrkqnbbKZ9roAgvrvm5zhju2GhWU5t5cPc4ADfZbfRWaV2ojETv1a9W838MB7h4N5a97kgkdnuuR5A4fJr5K4jizC2rNeLciDoZQuzoNE3TpnYqxpnJPQWQQB1vGHqdXTTiDc47i7kLm");
 }
+
+#[test]
+fn test_solana_sign_sponsored_transfer() {
+    const SOL_AMOUNT: u64 = 200_000;
+    const TOKEN_AMOUNT: u64 = 10_000;
+    const PRIVATE_KEY: &str = "7537978967203bdca1bcde4caa811c2771b36043a303824110cf240b10d9fde8";
+    const RECENT_BLOCKHASH: &str = "BTuHSa3pK17vmLR8NFGsn8uJdsYFvQXi5YhrNZKA5ggP";
+
+    let create_transfer_token = Proto::TokenTransfer {
+        token_mint_address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB".into(),
+        recipient_token_address: "DwvTHUygHJ2xdHBHT1HgvHaJfqHkPbS5omrGEEGpLHDc".into(),
+        sender_token_address: "DK8JGfS6Acsjh7KCdT7rEZ4ECNXztNmbJMs1mgjdZCXE".into(),
+        amount: TOKEN_AMOUNT,
+        decimals: 6,
+        ..Proto::TokenTransfer::default()
+    };
+
+    let transfer_to_fee_payer = Proto::Transfer {
+        recipient: "EkBtoCtDihccznHSF3P64kvcTt5xNxQ2jxYMjPXVH3DX".into(),
+        value: SOL_AMOUNT,
+        ..Proto::Transfer::default()
+    };
+
+    let input = Proto::SigningInput {
+        private_key: PRIVATE_KEY.decode_hex().unwrap().into(),
+        recent_blockhash: RECENT_BLOCKHASH.into(),
+        transaction_type: TransactionType::token_transfer_transaction(create_transfer_token),
+        transfer_to_fee_payer: Some(transfer_to_fee_payer),
+        tx_encoding: Proto::Encoding::Base64,
+        ..Proto::SigningInput::default()
+    };
+
+    let mut signer = AnySignerHelper::<Proto::SigningOutput>::default();
+    let output = signer.sign(CoinType::Solana, input);
+
+    assert_eq!(output.error, SigningError::OK);
+    // https://solscan.io/tx/52s8gt34WfZyJv1cDdadwA3V9PeRwazNqhVKDJ43F9JyxTE7ncqMSmqYAi1u4TsG2AyXNPbswG7krBHqWAhstCtL
+    assert_eq!(output.encoded, "Acms/WrZj/mOpUTTBFHLtBFKrMSAJPBBkD8qYK+oqgE0gFT5aoEfw5dlJZZl1edVde325gi0qVPai7ddgoP2WQUBAAMHgKRCBGe2W59ezw1CyHDoV4KZVuJFTtmsN0F25EL3I8228PMELJSiAl2nvEzyY4v/LfSQnxkFNlH4pjU2F3nMpcBeC+e4AaQzF6GCh63HW7KnhG+YuIbF1AvkM6nwOXMjzDg4vU3/xSfZJTqguxQVNsgitkm5dHCm6V6l4NCCDp7OAQ5gr+2yJxe9YxkvVBRaP5ZaM7uC0scCnrLOHiCCZAbd9uHXZaGT2cvhRs7reawctIXtX1s3kTqM9YV+/wCpAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACbeRZf0sbtT6rwdYyf6Z9h66lKwNsb48euTgiPa0h+WAIFBAEEAgAKDBAnAAAAAAAABgYCAAMMAgAAAEANAwAAAAAA");
+}