chore(sdk-coin-sol): remove statics dependency from sol module

Ticket: WIN-5679

Author: mukeshsp

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

@@ -115,10 +115,15 @@ export class AtaInitializationBuilder extends TransactionBuilder {
     }
     validateOwnerAddress(recipient.ownerAddress);
     const token = getSolTokenFromTokenName(recipient.tokenName);
-    if (!token) {
+    let tokenAddress: string;
+    if (token) {
+      tokenAddress = token.tokenAddress;
+    } else if (recipient.tokenAddress) {
+      tokenAddress = recipient.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 +146,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 (token) {
+          tokenAddress = token.tokenAddress;
+          programId = token.programId;
+        } else if (recipient.tokenAddress && recipient.programId) {
+          tokenAddress = recipient.tokenAddress;
+          programId = recipient.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,22 @@ import { getInstructionType } from './utils';
 export function instructionParamsFactory(
   type: TransactionType,
   instructions: TransactionInstruction[],
-  coinName?: string
+  coinName?: string,
+  instructionMetadata?: InstructionParams[]
 ): InstructionParams[] {
   switch (type) {
     case TransactionType.WalletInitialization:
       return parseWalletInitInstructions(instructions);
     case TransactionType.Send:
-      return parseSendInstructions(instructions);
+      return parseSendInstructions(instructions, instructionMetadata);
     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);
     case TransactionType.CloseAssociatedTokenAccount:
       return parseAtaCloseInstructions(instructions);
     case TransactionType.StakingAuthorize:
@@ -120,7 +121,8 @@ function parseWalletInitInstructions(instructions: TransactionInstruction[]): Ar
  * @returns {InstructionParams[]} An array containing instruction params for Send tx
  */
 function parseSendInstructions(
-  instructions: TransactionInstruction[]
+  instructions: TransactionInstruction[],
+  instructionMetadata?: InstructionParams[]
 ): 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 +162,7 @@ function parseSendInstructions(
         } else {
           tokenTransferInstruction = decodeTransferCheckedInstruction(instruction, TOKEN_2022_PROGRAM_ID);
         }
-        const tokenName = findTokenName(tokenTransferInstruction.keys.mint.pubkey.toString());
+        const tokenName = findTokenName(tokenTransferInstruction.keys.mint.pubkey.toString(), instructionMetadata);
         const tokenTransfer: TokenTransfer = {
           type: InstructionBuilderTypes.TokenTransfer,
           params: {
@@ -175,7 +177,7 @@ function parseSendInstructions(
         break;
       case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
         const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();
-        const mintTokenName = findTokenName(mintAddress);
+        const mintTokenName = findTokenName(mintAddress, instructionMetadata);
 
         const ataInit: AtaInit = {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
@@ -652,7 +654,10 @@ 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[]
+): Array<AtaInit | Memo | Nonce> {
   const instructionData: Array<AtaInit | Memo | Nonce> = [];
   let memo: Memo | undefined;
 
@@ -675,7 +680,7 @@ 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);
 
         const ataInit: AtaInit = {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
@@ -831,7 +836,7 @@ function parseStakingAuthorizeRawInstructions(instructions: TransactionInstructi
   return instructionData;
 }
 
-function findTokenName(mintAddress: string): string {
+function findTokenName(mintAddress: string, instructionMetadata?: InstructionParams[]): string {
   let token: string | undefined;
 
   coins.forEach((value, key) => {
@@ -840,6 +845,21 @@ 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;
+      }
+    });
+  }
   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 (token) {
+    assert(token instanceof SolCoin);
+    tokenAddress = token.tokenAddress;
+    decimalPlaces = token.decimalPlaces;
+    programId = token.programId;
+  } else if (data.params.tokenAddress && data.params.decimalPlaces) {
+    tokenAddress = data.params.tokenAddress;
+    decimalPlaces = data.params.decimalPlaces;
+    programId = data.params.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];

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

@@ -1,4 +1,4 @@
-import { BaseCoin as CoinConfig, SolCoin } from '@bitgo/statics';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { BuildTransactionError, TransactionType } from '@bitgo/sdk-core';
 import { Transaction } from './transaction';
 import {
@@ -19,6 +19,9 @@ export interface SendParams {
   address: string;
   amount: string;
   tokenName: string;
+  tokenAddress?: string;
+  programId?: string;
+  decimalPlaces?: number;
 }
 
 const UNSIGNED_BIGINT_MAX = BigInt('18446744073709551615');
@@ -69,7 +72,7 @@ export class TokenTransferBuilder extends TransactionBuilder {
    * @param {string} params.tokenName - name of token that is intended to send
    * @returns {TransactionBuilder} This transaction builder
    */
-  send({ address, amount, tokenName }: SendParams): this {
+  send({ address, amount, tokenName, tokenAddress, programId, decimalPlaces }: SendParams): this {
     validateAddress(address, 'address');
     if (!amount || !isValidAmount(amount)) {
       throw new BuildTransactionError('Invalid or missing amount, got: ' + amount);
@@ -78,7 +81,7 @@ export class TokenTransferBuilder extends TransactionBuilder {
       throw new BuildTransactionError(`input amount ${amount} exceeds big int limit ${UNSIGNED_BIGINT_MAX}`);
     }
 
-    this._sendParams.push({ address, amount, tokenName: tokenName });
+    this._sendParams.push({ address, amount, tokenName: tokenName, tokenAddress, programId, decimalPlaces });
     return this;
   }
 
@@ -92,10 +95,15 @@ export class TokenTransferBuilder extends TransactionBuilder {
   createAssociatedTokenAccount(recipient: TokenAssociateRecipient): this {
     validateOwnerAddress(recipient.ownerAddress);
     const token = getSolTokenFromTokenName(recipient.tokenName);
-    if (!token) {
+    let tokenAddress: string;
+    if (token) {
+      tokenAddress = token.tokenAddress;
+    } else if (recipient.tokenAddress) {
+      tokenAddress = recipient.tokenAddress;
+    } else {
       throw new BuildTransactionError('Invalid token name, got: ' + recipient.tokenName);
     }
-    validateMintAddress(token.tokenAddress);
+    validateMintAddress(tokenAddress);
 
     this._createAtaParams.push(recipient);
     return this;
@@ -107,16 +115,35 @@ export class TokenTransferBuilder extends TransactionBuilder {
     const sendInstructions = await Promise.all(
       this._sendParams.map(async (sendParams: SendParams): Promise<TokenTransfer> => {
         const coin = getSolTokenFromTokenName(sendParams.tokenName);
-        assert(coin instanceof SolCoin);
-        const sourceAddress = await getAssociatedTokenAccountAddress(coin.tokenAddress, this._sender);
+        let tokenAddress: string;
+        let tokenName: string;
+        let programId: string | undefined;
+        let decimals: number | undefined;
+        if (coin) {
+          tokenAddress = coin.tokenAddress;
+          tokenName = coin.name;
+          programId = coin.programId;
+          decimals = coin.decimalPlaces;
+        } else if (sendParams.tokenAddress) {
+          tokenAddress = sendParams.tokenAddress;
+          tokenName = sendParams.tokenName;
+          programId = sendParams.programId;
+          decimals = sendParams.decimalPlaces;
+        } else {
+          throw new Error(`Could not determine token information for ${sendParams.tokenName}`);
+        }
+        const sourceAddress = await getAssociatedTokenAccountAddress(tokenAddress, this._sender);
         return {
           type: InstructionBuilderTypes.TokenTransfer,
           params: {
             fromAddress: this._sender,
             toAddress: sendParams.address,
             amount: sendParams.amount,
-            tokenName: coin.name,
+            tokenName: tokenName,
             sourceAddress: sourceAddress,
+            tokenAddress: tokenAddress,
+            programId: programId,
+            decimalPlaces: decimals,
           },
         };
       })
@@ -127,20 +154,35 @@ export class TokenTransferBuilder extends TransactionBuilder {
     const createAtaInstructions = await Promise.all(
       uniqueCreateAtaParams.map(async (recipient: TokenAssociateRecipient): Promise<AtaInit> => {
         const coin = getSolTokenFromTokenName(recipient.tokenName);
-        assert(coin instanceof SolCoin);
+        let tokenAddress: string;
+        let tokenName: string;
+        let programId: string | undefined;
+        if (coin) {
+          tokenName = coin.name;
+          tokenAddress = coin.tokenAddress;
+          programId = coin.programId;
+        } else if (recipient.tokenAddress) {
+          tokenName = recipient.tokenName;
+          tokenAddress = recipient.tokenAddress;
+          programId = recipient.programId;
+        } else {
+          throw new Error(`Could not determine token information for ${recipient.tokenName}`);
+        }
+
         // Use the provided ataAddress if it exists, otherwise calculate it
         let ataAddress = recipient.ataAddress;
         if (!ataAddress) {
-          ataAddress = await getAssociatedTokenAccountAddress(coin.tokenAddress, recipient.ownerAddress);
+          ataAddress = await getAssociatedTokenAccountAddress(tokenAddress, recipient.ownerAddress);
         }
         return {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
           params: {
             ownerAddress: recipient.ownerAddress,
-            tokenName: coin.name,
-            mintAddress: coin.tokenAddress,
+            mintAddress: tokenAddress,
             ataAddress,
             payerAddress: this._sender,
+            tokenName: tokenName,
+            programId: programId,
           },
         };
       })