Merge pull request #6458 from BitGo/WIN-6253-revert

revert: remove statics dependency from sol module

Author: abhishekagrawal080

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

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

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

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

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

@@ -52,23 +52,21 @@ import { getInstructionType } from './utils';
 export function instructionParamsFactory(
   type: TransactionType,
   instructions: TransactionInstruction[],
-  coinName?: string,
-  instructionMetadata?: InstructionParams[],
-  _useTokenAddressTokenName?: boolean
+  coinName?: string
 ): InstructionParams[] {
   switch (type) {
     case TransactionType.WalletInitialization:
       return parseWalletInitInstructions(instructions);
     case TransactionType.Send:
-      return parseSendInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);
+      return parseSendInstructions(instructions);
     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, instructionMetadata, _useTokenAddressTokenName);
+      return parseAtaInitInstructions(instructions);
     case TransactionType.CloseAssociatedTokenAccount:
       return parseAtaCloseInstructions(instructions);
     case TransactionType.StakingAuthorize:
@@ -122,9 +120,7 @@ function parseWalletInitInstructions(instructions: TransactionInstruction[]): Ar
  * @returns {InstructionParams[]} An array containing instruction params for Send tx
  */
 function parseSendInstructions(
-  instructions: TransactionInstruction[],
-  instructionMetadata?: InstructionParams[],
-  _useTokenAddressTokenName?: boolean
+  instructions: TransactionInstruction[]
 ): Array<Nonce | Memo | Transfer | TokenTransfer | AtaInit | AtaClose | SetPriorityFee> {
   const instructionData: Array<Nonce | Memo | Transfer | TokenTransfer | AtaInit | AtaClose | SetPriorityFee> = [];
   for (const instruction of instructions) {
@@ -164,12 +160,7 @@ function parseSendInstructions(
         } else {
           tokenTransferInstruction = decodeTransferCheckedInstruction(instruction, TOKEN_2022_PROGRAM_ID);
         }
-        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 tokenName = findTokenName(tokenTransferInstruction.keys.mint.pubkey.toString());
         const tokenTransfer: TokenTransfer = {
           type: InstructionBuilderTypes.TokenTransfer,
           params: {
@@ -178,20 +169,13 @@ 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, instructionMetadata, _useTokenAddressTokenName);
-        let programID: string | undefined;
-        if (instruction.programId) {
-          programID = instruction.programId.toString();
-        }
+        const mintTokenName = findTokenName(mintAddress);
 
         const ataInit: AtaInit = {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
@@ -201,7 +185,6 @@ function parseSendInstructions(
             ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
             payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
             tokenName: mintTokenName,
-            programId: programID,
           },
         };
         instructionData.push(ataInit);
@@ -669,11 +652,7 @@ 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[],
-  instructionMetadata?: InstructionParams[],
-  _useTokenAddressTokenName?: boolean
-): Array<AtaInit | Memo | Nonce> {
+function parseAtaInitInstructions(instructions: TransactionInstruction[]): Array<AtaInit | Memo | Nonce> {
   const instructionData: Array<AtaInit | Memo | Nonce> = [];
   let memo: Memo | undefined;
 
@@ -696,11 +675,8 @@ function parseAtaInitInstructions(
         break;
       case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
         const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();
-        const tokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);
-        let programID: string | undefined;
-        if (instruction.programId) {
-          programID = instruction.programId.toString();
-        }
+        const tokenName = findTokenName(mintAddress);
+
         const ataInit: AtaInit = {
           type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
           params: {
@@ -709,7 +685,6 @@ function parseAtaInitInstructions(
             ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
             payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
             tokenName,
-            programId: programID,
           },
         };
         instructionData.push(ataInit);
@@ -856,11 +831,7 @@ function parseStakingAuthorizeRawInstructions(instructions: TransactionInstructi
   return instructionData;
 }
 
-function findTokenName(
-  mintAddress: string,
-  instructionMetadata?: InstructionParams[],
-  _useTokenAddressTokenName?: boolean
-): string {
+function findTokenName(mintAddress: string): string {
   let token: string | undefined;
 
   coins.forEach((value, key) => {
@@ -869,26 +840,6 @@ function findTokenName(
     }
   });
 
-  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 { SolCoin } from '@bitgo/statics';
+import { coins, SolCoin } from '@bitgo/statics';
 import {
   createAssociatedTokenAccountInstruction,
   createCloseAccountInstruction,
@@ -35,7 +35,6 @@ import {
   WalletInit,
   SetPriorityFee,
 } from './iface';
-import { getSolTokenFromTokenName } from './utils';
 
 /**
  * Construct Solana instructions from instructions params
@@ -158,43 +157,28 @@ function tokenTransferInstruction(data: TokenTransfer): TransactionInstruction[]
   assert(amount, 'Missing amount param');
   assert(tokenName, 'Missing token name');
   assert(sourceAddress, 'Missing ata address');
-  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);
-  }
-
+  const token = coins.get(data.params.tokenName);
+  assert(token instanceof SolCoin);
   let transferInstruction: TransactionInstruction;
-  if (programId === TOKEN_2022_PROGRAM_ID.toString()) {
+  if (token.programId === TOKEN_2022_PROGRAM_ID.toString()) {
     transferInstruction = createTransferCheckedInstruction(
       new PublicKey(sourceAddress),
-      new PublicKey(tokenAddress),
+      new PublicKey(token.tokenAddress),
       new PublicKey(toAddress),
       new PublicKey(fromAddress),
       BigInt(amount),
-      decimalPlaces,
+      token.decimalPlaces,
       [],
       TOKEN_2022_PROGRAM_ID
     );
   } else {
     transferInstruction = createTransferCheckedInstruction(
       new PublicKey(sourceAddress),
-      new PublicKey(tokenAddress),
+      new PublicKey(token.tokenAddress),
       new PublicKey(toAddress),
       new PublicKey(fromAddress),
       BigInt(amount),
-      decimalPlaces
+      token.decimalPlaces
     );
   }
   return [transferInstruction];