Merge pull request #6272 from BitGo/sol-statics

remove statics dependency from sol module

Author: mukeshsp

modules/sdk-coin-sol/src/lib/ataInitializationBuilder.ts

@@ -42,6 +42,8 @@ export class AtaInitializationBuilder extends TransactionBuilder {
         this._tokenAssociateRecipients.push({
           ownerAddress: ataInitInstruction.params.ownerAddress,
           tokenName: ataInitInstruction.params.tokenName,
+          tokenAddress: ataInitInstruction.params.mintAddress,
+          programId: ataInitInstruction.params.programId,
         });
       }
     }
@@ -115,10 +117,15 @@ export class AtaInitializationBuilder extends TransactionBuilder {
     }
     validateOwnerAddress(recipient.ownerAddress);
     const token = getSolTokenFromTokenName(recipient.tokenName);
-    if (!token) {
+    let tokenAddress: string;
+    if (recipient.tokenAddress) {
+      tokenAddress = recipient.tokenAddress;
+    } else if (token) {
+      tokenAddress = token.tokenAddress;
+    } else {
       throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + recipient.tokenName);
     }
-    validateMintAddress(token.tokenAddress);
+    validateMintAddress(tokenAddress);
 
     this._tokenAssociateRecipients.push(recipient);
     return this;
@@ -141,25 +148,33 @@ export class AtaInitializationBuilder extends TransactionBuilder {
     await Promise.all(
       this._tokenAssociateRecipients.map(async (recipient) => {
         const token = getSolTokenFromTokenName(recipient.tokenName);
-        if (!token) {
+        let tokenAddress: string;
+        let programId: string;
+        if (recipient.tokenAddress && recipient.programId) {
+          tokenAddress = recipient.tokenAddress;
+          programId = recipient.programId;
+        } else if (token) {
+          tokenAddress = token.tokenAddress;
+          programId = token.programId;
+        } else {
           throw new BuildTransactionError('Invalid transaction: invalid token name, got: ' + recipient.tokenName);
         }
 
         // Use the provided ataAddress if it exists, otherwise calculate it
         let ataPk = recipient.ataAddress;
         if (!ataPk) {
-          ataPk = await getAssociatedTokenAccountAddress(token.tokenAddress, recipient.ownerAddress);
+          ataPk = await getAssociatedTokenAccountAddress(tokenAddress, recipient.ownerAddress);
         }
 
         this._instructionsData.push({
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
           params: {
-            mintAddress: token.tokenAddress,
+            mintAddress: tokenAddress,
             ataAddress: ataPk,
             ownerAddress: recipient.ownerAddress,
             payerAddress: this._sender,
             tokenName: recipient.tokenName,
-            programId: token.programId,
+            programId: programId,
           },
         });
       })

modules/sdk-coin-sol/src/lib/iface.ts

@@ -72,6 +72,9 @@ export interface TokenTransfer {
     amount: string;
     tokenName: string;
     sourceAddress: string;
+    tokenAddress?: string;
+    decimalPlaces?: number;
+    programId?: string;
   };
 }
 
@@ -182,4 +185,6 @@ export class TokenAssociateRecipient {
   ownerAddress: string;
   tokenName: string;
   ataAddress?: string;
+  tokenAddress?: string;
+  programId?: string;
 }

modules/sdk-coin-sol/src/lib/instructionParamsFactory.ts

@@ -52,21 +52,23 @@ import { getInstructionType } from './utils';
 export function instructionParamsFactory(
   type: TransactionType,
   instructions: TransactionInstruction[],
-  coinName?: string
+  coinName?: string,
+  instructionMetadata?: InstructionParams[],
+  _useTokenAddressTokenName?: boolean
 ): InstructionParams[] {
   switch (type) {
     case TransactionType.WalletInitialization:
       return parseWalletInitInstructions(instructions);
     case TransactionType.Send:
-      return parseSendInstructions(instructions);
+      return parseSendInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);
     case TransactionType.StakingActivate:
       return parseStakingActivateInstructions(instructions);
     case TransactionType.StakingDeactivate:
       return parseStakingDeactivateInstructions(instructions, coinName);
     case TransactionType.StakingWithdraw:
       return parseStakingWithdrawInstructions(instructions);
     case TransactionType.AssociatedTokenAccountInitialization:
-      return parseAtaInitInstructions(instructions);
+      return parseAtaInitInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);
     case TransactionType.CloseAssociatedTokenAccount:
       return parseAtaCloseInstructions(instructions);
     case TransactionType.StakingAuthorize:
@@ -120,7 +122,9 @@ function parseWalletInitInstructions(instructions: TransactionInstruction[]): Ar
  * @returns {InstructionParams[]} An array containing instruction params for Send tx
  */
 function parseSendInstructions(
-  instructions: TransactionInstruction[]
+  instructions: TransactionInstruction[],
+  instructionMetadata?: InstructionParams[],
+  _useTokenAddressTokenName?: boolean
 ): Array<Nonce | Memo | Transfer | TokenTransfer | AtaInit | AtaClose | SetPriorityFee> {
   const instructionData: Array<Nonce | Memo | Transfer | TokenTransfer | AtaInit | AtaClose | SetPriorityFee> = [];
   for (const instruction of instructions) {
@@ -160,7 +164,12 @@ function parseSendInstructions(
         } else {
           tokenTransferInstruction = decodeTransferCheckedInstruction(instruction, TOKEN_2022_PROGRAM_ID);
         }
-        const tokenName = findTokenName(tokenTransferInstruction.keys.mint.pubkey.toString());
+        const tokenAddress = tokenTransferInstruction.keys.mint.pubkey.toString();
+        const tokenName = findTokenName(tokenAddress, instructionMetadata, _useTokenAddressTokenName);
+        let programIDForTokenTransfer: string | undefined;
+        if (instruction.programId) {
+          programIDForTokenTransfer = instruction.programId.toString();
+        }
         const tokenTransfer: TokenTransfer = {
           type: InstructionBuilderTypes.TokenTransfer,
           params: {
@@ -169,13 +178,20 @@ function parseSendInstructions(
             amount: tokenTransferInstruction.data.amount.toString(),
             tokenName,
             sourceAddress: tokenTransferInstruction.keys.source.pubkey.toString(),
+            tokenAddress: tokenAddress,
+            programId: programIDForTokenTransfer,
+            decimalPlaces: tokenTransferInstruction.data.decimals,
           },
         };
         instructionData.push(tokenTransfer);
         break;
       case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
         const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();
-        const mintTokenName = findTokenName(mintAddress);
+        const mintTokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);
+        let programID: string | undefined;
+        if (instruction.programId) {
+          programID = instruction.programId.toString();
+        }
 
         const ataInit: AtaInit = {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
@@ -185,6 +201,7 @@ function parseSendInstructions(
             ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
             payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
             tokenName: mintTokenName,
+            programId: programID,
           },
         };
         instructionData.push(ataInit);
@@ -652,7 +669,11 @@ const closeAtaInstructionKeysIndexes = {
  * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
  * @returns {InstructionParams[]} An array containing instruction params for Send tx
  */
-function parseAtaInitInstructions(instructions: TransactionInstruction[]): Array<AtaInit | Memo | Nonce> {
+function parseAtaInitInstructions(
+  instructions: TransactionInstruction[],
+  instructionMetadata?: InstructionParams[],
+  _useTokenAddressTokenName?: boolean
+): Array<AtaInit | Memo | Nonce> {
   const instructionData: Array<AtaInit | Memo | Nonce> = [];
   let memo: Memo | undefined;
 
@@ -675,8 +696,11 @@ function parseAtaInitInstructions(instructions: TransactionInstruction[]): Array
         break;
       case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
         const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();
-        const tokenName = findTokenName(mintAddress);
-
+        const tokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);
+        let programID: string | undefined;
+        if (instruction.programId) {
+          programID = instruction.programId.toString();
+        }
         const ataInit: AtaInit = {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
           params: {
@@ -685,6 +709,7 @@ function parseAtaInitInstructions(instructions: TransactionInstruction[]): Array
             ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
             payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
             tokenName,
+            programId: programID,
           },
         };
         instructionData.push(ataInit);
@@ -831,7 +856,11 @@ function parseStakingAuthorizeRawInstructions(instructions: TransactionInstructi
   return instructionData;
 }
 
-function findTokenName(mintAddress: string): string {
+function findTokenName(
+  mintAddress: string,
+  instructionMetadata?: InstructionParams[],
+  _useTokenAddressTokenName?: boolean
+): string {
   let token: string | undefined;
 
   coins.forEach((value, key) => {
@@ -840,6 +869,26 @@ function findTokenName(mintAddress: string): string {
     }
   });
 
+  if (!token && instructionMetadata) {
+    instructionMetadata.forEach((instruction) => {
+      if (
+        instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount &&
+        instruction.params.mintAddress === mintAddress
+      ) {
+        token = instruction.params.tokenName;
+      } else if (
+        instruction.type === InstructionBuilderTypes.TokenTransfer &&
+        instruction.params.tokenAddress === mintAddress
+      ) {
+        token = instruction.params.tokenName;
+      }
+    });
+  }
+
+  if (!token && _useTokenAddressTokenName) {
+    token = mintAddress;
+  }
+
   assert(token);
 
   return token;

modules/sdk-coin-sol/src/lib/solInstructionFactory.ts

@@ -1,4 +1,4 @@
-import { coins, SolCoin } from '@bitgo/statics';
+import { SolCoin } from '@bitgo/statics';
 import {
   createAssociatedTokenAccountInstruction,
   createCloseAccountInstruction,
@@ -35,6 +35,7 @@ import {
   WalletInit,
   SetPriorityFee,
 } from './iface';
+import { getSolTokenFromTokenName } from './utils';
 
 /**
  * Construct Solana instructions from instructions params
@@ -157,28 +158,43 @@ function tokenTransferInstruction(data: TokenTransfer): TransactionInstruction[]
   assert(amount, 'Missing amount param');
   assert(tokenName, 'Missing token name');
   assert(sourceAddress, 'Missing ata address');
-  const token = coins.get(data.params.tokenName);
-  assert(token instanceof SolCoin);
+  const token = getSolTokenFromTokenName(data.params.tokenName);
+  let tokenAddress: string;
+  let programId: string | undefined;
+  let decimalPlaces: number;
+  if (data.params.tokenAddress && data.params.decimalPlaces) {
+    tokenAddress = data.params.tokenAddress;
+    decimalPlaces = data.params.decimalPlaces;
+    programId = data.params.programId;
+  } else if (token) {
+    assert(token instanceof SolCoin);
+    tokenAddress = token.tokenAddress;
+    decimalPlaces = token.decimalPlaces;
+    programId = token.programId;
+  } else {
+    throw new Error('Invalid token name, got:' + data.params.tokenName);
+  }
+
   let transferInstruction: TransactionInstruction;
-  if (token.programId === TOKEN_2022_PROGRAM_ID.toString()) {
+  if (programId === TOKEN_2022_PROGRAM_ID.toString()) {
     transferInstruction = createTransferCheckedInstruction(
       new PublicKey(sourceAddress),
-      new PublicKey(token.tokenAddress),
+      new PublicKey(tokenAddress),
       new PublicKey(toAddress),
       new PublicKey(fromAddress),
       BigInt(amount),
-      token.decimalPlaces,
+      decimalPlaces,
       [],
       TOKEN_2022_PROGRAM_ID
     );
   } else {
     transferInstruction = createTransferCheckedInstruction(
       new PublicKey(sourceAddress),
-      new PublicKey(token.tokenAddress),
+      new PublicKey(tokenAddress),
       new PublicKey(toAddress),
       new PublicKey(fromAddress),
       BigInt(amount),
-      token.decimalPlaces
+      decimalPlaces
     );
   }
   return [transferInstruction];