fix(solana/base): fix support for legacy tokens (CHAIN-1552)

xenoliss · xenoliss · commit 6df9663d0e44 · 2025-06-13T07:08:44.000Z
diff --git a/base/src/libraries/SVMTokenBridgeLib.sol b/base/src/libraries/SVMTokenBridgeLib.sol
@@ -8,7 +8,11 @@ library SVMTokenBridgeLib {
     ///                       Constants                        ///
     //////////////////////////////////////////////////////////////
 
-    /// @notice The TokenProgram 2022 ID on Solana.
+    /// @notice The TokenProgram ID on Solana (TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA).
+    Pubkey private constant _TOKEN_PROGRAM_ID =
+        Pubkey.wrap(0x06ddf6e1d765a193d9cbe146ceeb79ac1cb485ed5f5b37913a8cf5857eff00a9);
+
+    /// @notice The TokenProgram 2022 ID on Solana (TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb).
     Pubkey private constant _TOKEN_PROGRAM_2022_ID =
         Pubkey.wrap(0x06ddf6e1ee758fde18425dbce46ccddab61afc4d83b90d27febdf928d8a18bfc);
 
@@ -99,7 +103,9 @@ library SVMTokenBridgeLib {
             _tokenVaultIxAccount({remoteBridge: remoteBridge, localToken: localToken, remoteToken: remoteToken}); // token_vault
         serializedAccounts[2] = SVMLib.serializePubkeyAccount({pubkey: to, isWritable: true, isSigner: false}); // to_token_account
         serializedAccounts[3] =
-            SVMLib.serializePubkeyAccount({pubkey: _TOKEN_PROGRAM_2022_ID, isWritable: false, isSigner: false}); // token_program
+            SVMLib.serializePubkeyAccount({pubkey: _TOKEN_PROGRAM_ID, isWritable: false, isSigner: false}); // token_program
+        serializedAccounts[4] =
+            SVMLib.serializePubkeyAccount({pubkey: _TOKEN_PROGRAM_2022_ID, isWritable: false, isSigner: false}); // token_program_2022
 
         return Ix({
             programId: remoteBridge,
diff --git a/solana/programs/token_bridge/src/instructions/base_to_solana/finalize_bridge_spl.rs b/solana/programs/token_bridge/src/instructions/base_to_solana/finalize_bridge_spl.rs
@@ -1,5 +1,9 @@
 use anchor_lang::prelude::*;
-use anchor_spl::token_interface::{self, Mint, TokenAccount, TokenInterface, TransferChecked};
+use anchor_spl::{
+    token::Token,
+    token_2022::Token2022,
+    token_interface::{self, Mint, TokenAccount, TransferChecked},
+};
 
 use portal::constants::PORTAL_AUTHORITY_SEED;
 
@@ -31,7 +35,8 @@ pub struct FinalizeBridgeSpl<'info> {
     #[account(mut)]
     pub to_token_account: InterfaceAccount<'info, TokenAccount>,
 
-    pub token_program: Interface<'info, TokenInterface>,
+    pub token_program: Program<'info, Token>,
+    pub token_program_2022: Program<'info, Token2022>,
 }
 
 pub fn finalize_bridge_spl_handler(
@@ -47,8 +52,15 @@ pub fn finalize_bridge_spl_handler(
         &[ctx.bumps.token_vault],
     ]];
 
+    let token_program_info = if ctx.accounts.mint.to_account_info().owner == &anchor_spl::token::ID
+    {
+        ctx.accounts.token_program.to_account_info()
+    } else {
+        ctx.accounts.token_program_2022.to_account_info()
+    };
+
     let cpi_ctx = CpiContext::new_with_signer(
-        ctx.accounts.token_program.to_account_info(),
+        token_program_info,
         TransferChecked {
             mint: ctx.accounts.mint.to_account_info(),
             from: ctx.accounts.token_vault.to_account_info(),
@@ -64,7 +76,7 @@ pub fn finalize_bridge_spl_handler(
 mod tests {
     use super::*;
 
-    use anchor_lang::InstructionData;
+    use anchor_lang::{solana_program::native_token::LAMPORTS_PER_SOL, InstructionData};
     use anchor_spl::token::spl_token::state::Account as TokenAccount;
     use litesvm::LiteSVM;
     use solana_instruction::Instruction;
@@ -79,15 +91,21 @@ mod tests {
     use crate::{
         test_utils::{
             mock_mint, mock_remote_call, mock_token_account, mock_token_vault, portal_authority,
-            SPL_TOKEN_PROGRAM_ID,
         },
         ID as TOKEN_BRIDGE_PROGRAM_ID,
     };
 
-    const LAMPORTS_PER_SOL: u64 = 1_000_000_000;
+    #[test]
+    fn test_finalize_bridge_spl_success_token() {
+        test_finalize_bridge_spl_success_token_impl(anchor_spl::token::ID);
+    }
 
     #[test]
-    fn test_finalize_bridge_spl_success() {
+    fn test_finalize_bridge_spl_success_token_2022() {
+        test_finalize_bridge_spl_success_token_impl(anchor_spl::token_2022::ID);
+    }
+
+    fn test_finalize_bridge_spl_success_token_impl(token_program_id: Pubkey) {
         let mut svm = LiteSVM::new();
         svm.add_program_from_file(
             TOKEN_BRIDGE_PROGRAM_ID,
@@ -113,14 +131,27 @@ mod tests {
 
         // Create mint
         let mint = Keypair::new().pubkey();
-        mock_mint(&mut svm, mint, decimals);
+        mock_mint(&mut svm, mint, decimals, token_program_id);
 
         // Create token vault with funds
-        let token_vault = mock_token_vault(&mut svm, mint, remote_token, vault_initial_balance);
+        let token_vault = mock_token_vault(
+            &mut svm,
+            mint,
+            remote_token,
+            vault_initial_balance,
+            token_program_id,
+        );
 
         // Create destination token account
         let to_token_account = Keypair::new().pubkey();
-        mock_token_account(&mut svm, to_token_account, mint, recipient_pk, 0);
+        mock_token_account(
+            &mut svm,
+            to_token_account,
+            mint,
+            recipient_pk,
+            0,
+            token_program_id,
+        );
 
         // Compute the portal authority PDA
         let portal_authority = portal_authority();
@@ -131,7 +162,8 @@ mod tests {
             mint,
             token_vault,
             to_token_account,
-            token_program: SPL_TOKEN_PROGRAM_ID,
+            token_program: anchor_spl::token::ID,
+            token_program_2022: anchor_spl::token_2022::ID,
         }
         .to_account_metas(None)
         .into_iter()
diff --git a/solana/programs/token_bridge/src/instructions/base_to_solana/finalize_bridge_token.rs b/solana/programs/token_bridge/src/instructions/base_to_solana/finalize_bridge_token.rs
@@ -80,10 +80,7 @@ mod tests {
     use portal::{internal::Ix, ID as PORTAL_PROGRAM_ID};
 
     use crate::{
-        test_utils::{
-            mock_remote_call, mock_token_account, mock_wrapped_mint, portal_authority,
-            SPL_TOKEN_PROGRAM_ID,
-        },
+        test_utils::{mock_remote_call, mock_token_account, mock_wrapped_mint, portal_authority},
         ID as TOKEN_BRIDGE_PROGRAM_ID,
     };
 
@@ -121,7 +118,14 @@ mod tests {
 
         // Create destination token account (starts with 0 tokens)
         let to_token_account = Keypair::new().pubkey();
-        mock_token_account(&mut svm, to_token_account, wrapped_mint, recipient_pk, 0);
+        mock_token_account(
+            &mut svm,
+            to_token_account,
+            wrapped_mint,
+            recipient_pk,
+            0,
+            anchor_spl::token_2022::ID,
+        );
 
         // Compute the portal authority PDA
         let portal_authority = portal_authority();
@@ -131,7 +135,7 @@ mod tests {
             portal_authority,
             mint: wrapped_mint,
             to_token_account,
-            token_program: SPL_TOKEN_PROGRAM_ID,
+            token_program: anchor_spl::token_2022::ID,
         }
         .to_account_metas(None)
         .into_iter()
diff --git a/solana/programs/token_bridge/src/instructions/base_to_solana/wrap_token.rs b/solana/programs/token_bridge/src/instructions/base_to_solana/wrap_token.rs
@@ -224,7 +224,7 @@ mod tests {
     use solana_transaction::Transaction;
 
     use crate::{
-        test_utils::{bridge_authority, mock_messenger, SPL_TOKEN_PROGRAM_ID},
+        test_utils::{bridge_authority, mock_messenger},
         ID as TOKEN_BRIDGE_PROGRAM_ID,
     };
 
@@ -241,6 +241,12 @@ mod tests {
         svm.add_program_from_file(PORTAL_PROGRAM_ID, "../../target/deploy/portal.so")
             .unwrap();
 
+        println!(
+            "token_2022: {:?}",
+            hex::encode(anchor_spl::token_2022::ID.to_bytes())
+        );
+        println!("token: {:?}", hex::encode(anchor_spl::token::ID.to_bytes()));
+
         // Test parameters
         let partial_token_metadata = PartialTokenMetadata {
             remote_token: [0x42u8; 20],
@@ -271,7 +277,7 @@ mod tests {
         let wrap_token_accounts = crate::accounts::WrapToken {
             payer: payer.pubkey(),
             mint: wrapped_mint,
-            token_program: SPL_TOKEN_PROGRAM_ID,
+            token_program: anchor_spl::token_2022::ID,
             bridge_authority: bridge_authority(),
             portal: PORTAL_PROGRAM_ID,
             gas_fee_receiver: GAS_FEE_RECEIVER,
@@ -303,7 +309,7 @@ mod tests {
 
         // Verify that the mint was created correctly
         let mint_account = svm.get_account(&wrapped_mint).unwrap();
-        assert_eq!(mint_account.owner, SPL_TOKEN_PROGRAM_ID);
+        assert_eq!(mint_account.owner, anchor_spl::token_2022::ID);
 
         // Deserialize and verify mint properties
         let mint_data = mint_account.data;
diff --git a/solana/programs/token_bridge/src/test_utils.rs b/solana/programs/token_bridge/src/test_utils.rs
@@ -30,8 +30,6 @@ use crate::{
 };
 use portal::ID as PORTAL_PROGRAM_ID;
 
-pub const SPL_TOKEN_PROGRAM_ID: Pubkey = anchor_spl::token_2022::ID;
-
 pub fn portal_authority() -> Pubkey {
     let (portal_authority, _) = Pubkey::find_program_address(
         &[PORTAL_AUTHORITY_SEED, REMOTE_BRIDGE.as_ref()],
@@ -143,8 +141,12 @@ pub fn mock_wrapped_mint(
         ExtensionType::try_calculate_account_len::<Mint>(&[ExtensionType::MetadataPointer])
             .unwrap();
 
+    println!("account_size: {:?}", account_size);
+
     account_size += token_metadata.tlv_size_of().unwrap();
 
+    println!("account_size: {:?}", account_size);
+
     // Full buffer for the mint account
     let mut mint_data = vec![0u8; account_size];
 
@@ -180,7 +182,7 @@ pub fn mock_wrapped_mint(
         Account {
             lamports: 100 * LAMPORTS_PER_SOL,
             data: mint_data,
-            owner: SPL_TOKEN_PROGRAM_ID,
+            owner: anchor_spl::token_2022::ID,
             executable: false,
             rent_epoch: 0,
         },
@@ -190,7 +192,7 @@ pub fn mock_wrapped_mint(
     wrapped_mint
 }
 
-pub fn mock_mint(svm: &mut LiteSVM, mint: Pubkey, decimals: u8) {
+pub fn mock_mint(svm: &mut LiteSVM, mint: Pubkey, decimals: u8, token_program_id: Pubkey) {
     let mut mint_data = vec![0u8; Mint::LEN];
     Mint {
         mint_authority: COption::Some(mint),
@@ -206,7 +208,7 @@ pub fn mock_mint(svm: &mut LiteSVM, mint: Pubkey, decimals: u8) {
         Account {
             lamports: 100 * LAMPORTS_PER_SOL,
             data: mint_data,
-            owner: SPL_TOKEN_PROGRAM_ID,
+            owner: token_program_id,
             executable: false,
             rent_epoch: 0,
         },
@@ -219,13 +221,21 @@ pub fn mock_token_vault(
     mint: Pubkey,
     remote_token: [u8; 20],
     amount: u64,
+    token_program_id: Pubkey,
 ) -> Pubkey {
     let (token_vault, _) = Pubkey::find_program_address(
         &[TOKEN_VAULT_SEED, mint.as_ref(), remote_token.as_ref()],
         &TOKEN_BRIDGE_PROGRAM_ID,
     );
 
-    mock_token_account(svm, token_vault, mint, token_vault, amount);
+    mock_token_account(
+        svm,
+        token_vault,
+        mint,
+        token_vault,
+        amount,
+        token_program_id,
+    );
     token_vault
 }
 
@@ -235,6 +245,7 @@ pub fn mock_token_account(
     mint: Pubkey,
     owner: Pubkey,
     amount: u64,
+    token_program_id: Pubkey,
 ) {
     // Create token account data (SPL Token Account layout)
     let mut token_account_data = vec![0u8; 165]; // Token account size
@@ -255,7 +266,7 @@ pub fn mock_token_account(
         Account {
             lamports: 100 * LAMPORTS_PER_SOL,
             data: token_account_data,
-            owner: SPL_TOKEN_PROGRAM_ID,
+            owner: token_program_id,
             executable: false,
             rent_epoch: 0,
         },
