fix(sdk-coin-sol): handling sol 2022 token recoveries

abhishekagrawal080 · abhishekagrawal080 · commit bde64bcc15eb · 2025-06-18T16:20:08.000+05:30
TICKET: WIN-5929
diff --git a/modules/sdk-coin-sol/src/sol.ts b/modules/sdk-coin-sol/src/sol.ts
@@ -58,6 +58,8 @@ import {
   isValidPublicKey,
   validateRawTransaction,
 } from './lib/utils';
+import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+
 export const DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds
 
 export interface TransactionFee {
@@ -154,6 +156,7 @@ export interface SolRecoveryOptions extends MPCRecoveryOptions {
   closeAtaAddress?: string;
   // destination address where token should be sent before closing the ATA address
   recoveryDestinationAtaAddress?: string;
+  programId?: string; // programId of the token
 }
 
 export interface SolConsolidationRecoveryOptions extends MPCConsolidationRecoveryOptions {
@@ -638,7 +641,7 @@ export class Sol extends BaseCoin {
     };
   }
 
-  protected async getTokenAccountsByOwner(pubKey = ''): Promise<[] | TokenAccount[]> {
+  protected async getTokenAccountsByOwner(pubKey = '', programId = ''): Promise<[] | TokenAccount[]> {
     const response = await this.getDataFromNode({
       payload: {
         id: '1',
@@ -647,7 +650,10 @@ export class Sol extends BaseCoin {
         params: [
           pubKey,
           {
-            programId: 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+            programId:
+              programId.toString().toLowerCase() === TOKEN_2022_PROGRAM_ID.toString().toLowerCase()
+                ? TOKEN_2022_PROGRAM_ID.toString()
+                : TOKEN_PROGRAM_ID.toString(),
           },
           {
             encoding: 'jsonParsed',
@@ -793,7 +799,7 @@ export class Sol extends BaseCoin {
 
     // check for possible token recovery, recover the token provide by user
     if (params.tokenContractAddress) {
-      const tokenAccounts = await this.getTokenAccountsByOwner(bs58EncodedPublicKey);
+      const tokenAccounts = await this.getTokenAccountsByOwner(bs58EncodedPublicKey, params.programId);
       if (tokenAccounts.length !== 0) {
         // there exists token accounts on the given address, but need to check certain conditions:
         // 1. if there is a recoverable balance
@@ -824,7 +830,10 @@ export class Sol extends BaseCoin {
             .feePayer(bs58EncodedPublicKey);
 
           // need to get all token accounts of the recipient address and need to create them if they do not exist
-          const recipientTokenAccounts = await this.getTokenAccountsByOwner(params.recoveryDestination);
+          const recipientTokenAccounts = await this.getTokenAccountsByOwner(
+            params.recoveryDestination,
+            params.programId
+          );
 
           for (const tokenAccount of recovereableTokenAccounts) {
             let recipientTokenAccountExists = false;
@@ -851,6 +860,10 @@ export class Sol extends BaseCoin {
               txBuilder.createAssociatedTokenAccount({
                 ownerAddress: params.recoveryDestination,
                 tokenName: tokenName,
+                programId:
+                  params.programId?.toString().toLowerCase() === TOKEN_2022_PROGRAM_ID.toString().toLowerCase()
+                    ? TOKEN_2022_PROGRAM_ID.toString()
+                    : TOKEN_PROGRAM_ID.toString(),
               });
               // add rent exempt amount to total fee for each token account that has to be created
               totalFeeForTokenRecovery = totalFeeForTokenRecovery.plus(rentExemptAmount);
diff --git a/modules/sdk-coin-sol/test/fixtures/sol.ts b/modules/sdk-coin-sol/test/fixtures/sol.ts
@@ -411,6 +411,96 @@ const getTokenAccountsByOwnerResponse2 = {
   },
 };
 
+const getTokenAccountsByOwnerForSol2022Response = {
+  status: 200,
+  body: {
+    jsonrpc: '2.0',
+    result: {
+      context: {
+        apiVersion: '1.17.5',
+        slot: 259019329,
+      },
+      value: [
+        {
+          account: {
+            data: {
+              parsed: {
+                info: {
+                  isNative: false,
+                  mint: '5NR1bQwLWqjbkhbQ1hx72HKJybbuvwkDnUZNoAZ2VhW6',
+                  owner: 'cyggsFnDvbfsPeiFXziebWsWAp6bW5Nc5SePTx8mebL',
+                  state: 'initialized',
+                  tokenAmount: {
+                    amount: '2000000000',
+                    decimals: 9,
+                    uiAmount: 2,
+                    uiAmountString: '2',
+                  },
+                },
+                type: 'account',
+              },
+              program: 'spl-token',
+              space: 165,
+            },
+            executable: false,
+            lamports: 2039280,
+            owner: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+            rentEpoch: 18446744073709552000,
+            space: 165,
+          },
+          pubkey: '5seRT43oRMkVgwxEssfci6Zgs9PJkt4igjqRiEjL5g3v',
+        },
+      ],
+    },
+    id: '1',
+  },
+};
+
+const getTokenAccountsByOwnerForSol2022Response2 = {
+  status: 200,
+  body: {
+    jsonrpc: '2.0',
+    result: {
+      context: {
+        apiVersion: '1.17.5',
+        slot: 259019329,
+      },
+      value: [
+        {
+          account: {
+            data: {
+              parsed: {
+                info: {
+                  isNative: false,
+                  mint: '5NR1bQwLWqjbkhbQ1hx72HKJybbuvwkDnUZNoAZ2VhW6',
+                  owner: 'HMEgbR4S2hLKfst2VZUVpHVUu4FioFPyW5iUuJvZdMvs',
+                  state: 'initialized',
+                  tokenAmount: {
+                    amount: '2000000000',
+                    decimals: 9,
+                    uiAmount: 2,
+                    uiAmountString: '2',
+                  },
+                },
+                type: 'account',
+              },
+              program: 'spl-token',
+              space: 165,
+            },
+            executable: false,
+            lamports: 2039280,
+            owner: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+            rentEpoch: 18446744073709552000,
+            space: 165,
+          },
+          pubkey: 'E2ZC9Kgc1aq3q7ect4iyF3zVgJWCfomRGsg98hkJxm6k',
+        },
+      ],
+    },
+    id: '1',
+  },
+};
+
 const getTokenAccountsByOwnerResponseNoAccounts = {
   status: 200,
   body: {
@@ -502,6 +592,8 @@ export const SolResponses = {
   getTokenAccountsByOwnerResponse2,
   getTokenAccountsByOwnerResponse3,
   getTokenAccountsByOwnerResponseNoAccounts,
+  getTokenAccountsByOwnerForSol2022Response,
+  getTokenAccountsByOwnerForSol2022Response2,
   getMinimumBalanceForRentExemptionResponse,
   broadcastTransactionResponse,
   broadcastTransactionResponse1,
diff --git a/modules/sdk-coin-sol/test/unit/sol.ts b/modules/sdk-coin-sol/test/unit/sol.ts
@@ -14,6 +14,7 @@ import * as testData from '../fixtures/sol';
 import * as resources from '../resources/sol';
 import { getBuilderFactory } from './getBuilderFactory';
 import { solBackupKey } from './fixtures/solBackupKey';
+import { TOKEN_2022_PROGRAM_ID } from '@solana/spl-token';
 
 describe('SOL:', function () {
   let bitgo: TestBitGoAPI;
@@ -1487,6 +1488,7 @@ describe('SOL:', function () {
     const sandBox = sinon.createSandbox();
     const coin = coins.get('tsol');
     const usdtMintAddress = '9cgpBeNZ2HnLda7NWaaU1i3NyTstk2c4zCMUcoAGsi9C';
+    const t22mintAddress = '5NR1bQwLWqjbkhbQ1hx72HKJybbuvwkDnUZNoAZ2VhW6';
     let callBack;
 
     beforeEach(() => {
@@ -1685,6 +1687,42 @@ describe('SOL:', function () {
           },
         })
         .resolves(testData.SolResponses.getTokenAccountsByOwnerResponse);
+      callBack
+        .withArgs({
+          payload: {
+            id: '1',
+            jsonrpc: '2.0',
+            method: 'getTokenAccountsByOwner',
+            params: [
+              testData.keys.destinationPubKey2,
+              {
+                programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+              },
+              {
+                encoding: 'jsonParsed',
+              },
+            ],
+          },
+        })
+        .resolves(testData.SolResponses.getTokenAccountsByOwnerForSol2022Response2);
+      callBack
+        .withArgs({
+          payload: {
+            id: '1',
+            jsonrpc: '2.0',
+            method: 'getTokenAccountsByOwner',
+            params: [
+              testData.wrwUser.walletAddress0,
+              {
+                programId: 'TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb',
+              },
+              {
+                encoding: 'jsonParsed',
+              },
+            ],
+          },
+        })
+        .resolves(testData.SolResponses.getTokenAccountsByOwnerForSol2022Response);
       callBack
         .withArgs({
           payload: {
@@ -2019,6 +2057,56 @@ describe('SOL:', function () {
       sandBox.assert.callCount(solCoin.getDataFromNode, 7);
     });
 
+    it('should recover sol 2022 tokens to recovery destination with existing token accounts', async function () {
+      const tokenTxn = await basecoin.recover({
+        userKey: testData.wrwUser.userKey,
+        backupKey: testData.wrwUser.backupKey,
+        bitgoKey: testData.wrwUser.bitgoKey,
+        recoveryDestination: testData.keys.destinationPubKey2,
+        tokenContractAddress: t22mintAddress,
+        walletPassphrase: testData.wrwUser.walletPassphrase,
+        durableNonce: {
+          publicKey: testData.keys.durableNoncePubKey,
+          secretKey: testData.keys.durableNoncePrivKey,
+        },
+        programId: TOKEN_2022_PROGRAM_ID.toString(),
+      });
+
+      tokenTxn.should.not.be.empty();
+      tokenTxn.should.hasOwnProperty('serializedTx');
+      tokenTxn.should.hasOwnProperty('scanIndex');
+      should.equal((tokenTxn as MPCTx).scanIndex, 0);
+
+      const tokenTxnDeserialize = new Transaction(coin);
+      tokenTxnDeserialize.fromRawTransaction((tokenTxn as MPCTx).serializedTx);
+      const tokenTxnJson = tokenTxnDeserialize.toJson();
+      console.log(tokenTxnJson);
+      should.equal(tokenTxnJson.nonce, testData.SolInputData.durableNonceBlockhash);
+      should.equal(tokenTxnJson.feePayer, testData.wrwUser.walletAddress0);
+      should.equal(tokenTxnJson.numSignatures, testData.SolInputData.durableNonceSignatures);
+
+      const instructionsData = tokenTxnJson.instructionsData as TokenTransfer[];
+      should.equal(instructionsData.length, 2);
+      should.equal(instructionsData[0].type, 'NonceAdvance');
+
+      const source2022TokenAccount = await getAssociatedTokenAccountAddress(
+        t22mintAddress,
+        testData.wrwUser.walletAddress0
+      );
+      const destination2022TokenAccount = await getAssociatedTokenAccountAddress(
+        t22mintAddress,
+        testData.keys.destinationPubKey2
+      );
+      should.equal(instructionsData[1].type, 'TokenTransfer');
+      should.equal(instructionsData[1].params.fromAddress, testData.wrwUser.walletAddress0);
+      should.equal(instructionsData[1].params.toAddress, destination2022TokenAccount);
+      should.equal(instructionsData[1].params.amount, '2000000000');
+      should.equal(instructionsData[1].params.tokenName, 'tsol:t22mint');
+      should.equal(instructionsData[1].params.sourceAddress, source2022TokenAccount);
+      const solCoin = basecoin as any;
+      sandBox.assert.callCount(solCoin.getDataFromNode, 7);
+    });
+
     it('should recover sol tokens to recovery destination with existing token accounts for unsigned sweep recoveries', async function () {
       const feeResponse = testData.SolResponses.getFeesForMessageResponse;
       feeResponse.body.result.value = 10000;
