refactor(sdk-coin-sol): change marinade and jito flags to enum

BREAKING CHANGE: the `isMarinade` setter in transaction builders has been
removed.  Existing calls to `txBuilder.isMarinade` will have to be replaced
with `txBuilder.stakingType(StakingType.MARINADE)`.

Ticket: SC-2620

Author: haritkapadia

examples/ts/sol/stake-jito.ts

@@ -59,8 +59,8 @@ async function main() {
     .sender(account.publicKey.toBase58())
     .stakingAddress(JITO_STAKE_POOL_ADDRESS)
     .validator(JITO_STAKE_POOL_ADDRESS)
-    .isJito(true)
-    .jitoParams({
+    .stakingTypeParams({
+      type: 'JITO',
       stakePoolData: {
         managerFeeAccount: stakePoolAccount.account.data.managerFeeAccount.toString(),
         poolMint: stakePoolAccount.account.data.poolMint.toString(),

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

@@ -120,18 +120,27 @@ export interface Approve {
   };
 }
 
+export enum StakingType {
+  NATIVE = 'NATIVE',
+  MARINADE = 'MARINADE',
+  JITO = 'JITO',
+}
+
+export interface JitoStakingActivateParams {
+  stakePoolData: DepositSolStakePoolData;
+}
+
+export type StakingActivateExtraParams = JitoStakingActivateParams;
+
 export interface StakingActivate {
   type: InstructionBuilderTypes.StakingActivate;
   params: {
     fromAddress: string;
     stakingAddress: string;
     amount: string;
     validator: string;
-    isMarinade?: boolean;
-    isJito?: boolean;
-    jitoParams?: {
-      stakePoolData: DepositSolStakePoolData;
-    };
+    stakingType: StakingType;
+    extraParams?: StakingActivateExtraParams;
   };
 }
 
@@ -140,20 +149,23 @@ export interface StakingDelegate {
   params: { stakingAddress: string; fromAddress: string; validator: string };
 }
 
+export interface JitoStakingDeactivateParams {
+  stakePoolData: WithdrawStakeStakePoolData;
+  validatorAddress: string;
+  transferAuthorityAddress: string;
+}
+
+export type StakingDeactivateExtraParams = JitoStakingDeactivateParams;
+
 export interface StakingDeactivate {
   type: InstructionBuilderTypes.StakingDeactivate;
   params: {
     fromAddress: string;
     stakingAddress: string;
     amount?: string;
     unstakingAddress?: string;
-    isMarinade?: boolean;
-    isJito?: boolean;
-    jitoParams?: {
-      stakePoolData: WithdrawStakeStakePoolData;
-      validatorAddress: string;
-      transferAuthorityAddress: string;
-    };
+    stakingType: StakingType;
+    extraParams?: StakingDeactivateExtraParams;
     recipients?: Recipient[];
   };
 }

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

@@ -28,12 +28,7 @@ import {
 import { NotSupported, TransactionType } from '@bitgo/sdk-core';
 import { coins, SolCoin } from '@bitgo/statics';
 import assert from 'assert';
-import {
-  InstructionBuilderTypes,
-  JITO_STAKE_POOL_ADDRESS,
-  ValidInstructionTypesEnum,
-  walletInitInstructionIndexes,
-} from './constants';
+import { InstructionBuilderTypes, ValidInstructionTypesEnum, walletInitInstructionIndexes } from './constants';
 import {
   AtaClose,
   AtaInit,
@@ -53,6 +48,7 @@ import {
   SetPriorityFee,
   CustomInstruction,
   Approve,
+  StakingType,
 } from './iface';
 import { getInstructionType } from './utils';
 import { DepositSolParams, WithdrawStakeParams } from '@solana/spl-stake-pool';
@@ -330,14 +326,6 @@ function parseSendInstructions(
   return instructionData;
 }
 
-function stakingInstructionsIsMarinade(si: StakingInstructions): boolean {
-  return !!(si.delegate === undefined && si.depositSol === undefined);
-}
-
-function stakingInstructionsIsJito(si: StakingInstructions): boolean {
-  return !!(si.delegate === undefined && si.depositSol?.stakePool.toString() === JITO_STAKE_POOL_ADDRESS);
-}
-
 /**
  * Parses Solana instructions to create staking tx and delegate tx instructions params
  * Only supports Nonce, StakingActivate and Memo Solana instructions
@@ -403,39 +391,61 @@ function parseStakingActivateInstructions(
 
   validateStakingInstructions(stakingInstructions);
 
-  const stakingActivate: StakingActivate = {
-    type: InstructionBuilderTypes.StakingActivate,
-    params: {
-      fromAddress:
-        stakingInstructions.create?.fromPubkey.toString() ||
-        stakingInstructions.depositSol?.fundingAccount.toString() ||
-        '',
-      stakingAddress:
-        stakingInstructions.initialize?.stakePubkey.toString() ||
-        stakingInstructions.depositSol?.stakePool.toString() ||
-        '',
-      amount:
-        stakingInstructions.create?.lamports.toString() || stakingInstructions.depositSol?.lamports.toString() || '',
-      validator:
-        stakingInstructions.delegate?.votePubkey.toString() ||
-        stakingInstructions.initialize?.authorized.staker.toString() ||
-        stakingInstructions.depositSol?.stakePool.toString() ||
-        '',
-      isMarinade: stakingInstructionsIsMarinade(stakingInstructions),
-      isJito: stakingInstructionsIsJito(stakingInstructions),
-      ...(stakingInstructions.depositSol && stakingInstructionsIsJito(stakingInstructions)
-        ? {
-            jitoParams: {
-              stakePoolData: {
-                managerFeeAccount: stakingInstructions.depositSol.managerFeeAccount.toString(),
-                poolMint: stakingInstructions.depositSol.poolMint.toString(),
-                reserveStake: stakingInstructions.depositSol.reserveStake.toString(),
-              },
-            },
-          }
-        : {}),
-    },
-  };
+  let stakingActivate: StakingActivate | undefined;
+  // One case per StakingType
+  if (stakingInstructions.depositSol !== undefined) {
+    const stakingType = StakingType.JITO;
+    stakingActivate = {
+      type: InstructionBuilderTypes.StakingActivate,
+      params: {
+        stakingType,
+        fromAddress: stakingInstructions.depositSol.fundingAccount.toString(),
+        stakingAddress: stakingInstructions.depositSol.stakePool.toString(),
+        amount: stakingInstructions.depositSol.lamports.toString(),
+        validator: stakingInstructions.depositSol.stakePool.toString(),
+        extraParams: {
+          stakePoolData: {
+            managerFeeAccount: stakingInstructions.depositSol.managerFeeAccount.toString(),
+            poolMint: stakingInstructions.depositSol.poolMint.toString(),
+            reserveStake: stakingInstructions.depositSol.reserveStake.toString(),
+          },
+        },
+      },
+    };
+  } else if (
+    stakingInstructions.delegate === undefined &&
+    stakingInstructions.depositSol === undefined &&
+    stakingInstructions.create !== undefined &&
+    stakingInstructions.initialize !== undefined
+  ) {
+    const stakingType = StakingType.MARINADE;
+    stakingActivate = {
+      type: InstructionBuilderTypes.StakingActivate,
+      params: {
+        stakingType,
+        fromAddress: stakingInstructions.create.fromPubkey.toString(),
+        stakingAddress: stakingInstructions.initialize.stakePubkey.toString(),
+        amount: stakingInstructions.create.lamports.toString(),
+        validator: stakingInstructions.initialize.authorized.staker.toString(),
+      },
+    };
+  } else if (stakingInstructions.create !== undefined && stakingInstructions.initialize !== undefined) {
+    const stakingType = StakingType.NATIVE;
+    stakingActivate = {
+      type: InstructionBuilderTypes.StakingActivate,
+      params: {
+        stakingType,
+        fromAddress: stakingInstructions.create.fromPubkey.toString(),
+        stakingAddress: stakingInstructions.initialize.stakePubkey.toString(),
+        amount: stakingInstructions.create.lamports.toString(),
+        validator:
+          stakingInstructions.delegate?.votePubkey.toString() ||
+          stakingInstructions.initialize.authorized.staker.toString(),
+      },
+    };
+  }
+
+  assert(stakingActivate !== undefined, 'Missing stakingActivate');
   instructionData.push(stakingActivate);
 
   return instructionData;
@@ -490,19 +500,18 @@ interface StakingInstructions {
 }
 
 function validateStakingInstructions(stakingInstructions: StakingInstructions) {
-  if (stakingInstructionsIsJito(stakingInstructions)) {
-    if (!stakingInstructions.depositSol) {
-      throw new NotSupported('Invalid staking activate transaction, missing deposit sol instruction');
-    }
-  } else {
-    if (!stakingInstructions.create) {
-      throw new NotSupported('Invalid staking activate transaction, missing create stake account instruction');
-    }
-    if (!stakingInstructions.delegate && !stakingInstructions.initialize) {
-      throw new NotSupported(
-        'Invalid staking activate transaction, missing initialize stake account/delegate instruction'
-      );
-    }
+  if (stakingInstructions.delegate === undefined && stakingInstructions.depositSol !== undefined) {
+    return;
+  }
+
+  if (!stakingInstructions.create) {
+    throw new NotSupported('Invalid staking activate transaction, missing create stake account instruction');
+  }
+
+  if (!stakingInstructions.delegate && !stakingInstructions.initialize) {
+    throw new NotSupported(
+      'Invalid staking activate transaction, missing initialize stake account/delegate instruction'
+    );
   }
 }
 
@@ -634,50 +643,64 @@ function parseStakingDeactivateInstructions(
 
   for (const unstakingInstruction of unstakingInstructions) {
     validateUnstakingInstructions(unstakingInstruction);
-    const isMarinade =
-      unstakingInstruction.deactivate === undefined && unstakingInstruction.withdrawStake === undefined;
-    const stakingDeactivate: StakingDeactivate = {
-      type: InstructionBuilderTypes.StakingDeactivate,
-      params: {
-        fromAddress:
-          unstakingInstruction.deactivate?.authorizedPubkey.toString() ||
-          unstakingInstruction.withdrawStake?.destinationStakeAuthority.toString() ||
-          '',
-        stakingAddress:
-          unstakingInstruction.split?.stakePubkey.toString() ||
-          unstakingInstruction.deactivate?.stakePubkey.toString() ||
-          unstakingInstruction.withdrawStake?.stakePool.toString() ||
-          '',
-        amount:
-          unstakingInstruction.split?.lamports.toString() || unstakingInstruction.withdrawStake?.poolTokens.toString(),
-        unstakingAddress:
-          unstakingInstruction.split?.splitStakePubkey.toString() ||
-          unstakingInstruction.withdrawStake?.destinationStake.toString(),
-        isMarinade: isMarinade,
-        recipients: isMarinade
-          ? [
-              {
-                address: unstakingInstruction.transfer?.toPubkey.toString() || '',
-                amount: unstakingInstruction.transfer?.lamports.toString() || '',
-              },
-            ]
-          : undefined,
-        ...(unstakingInstruction.withdrawStake !== undefined
-          ? {
-              isJito: unstakingInstruction.withdrawStake !== undefined,
-              jitoParams: unstakingInstruction.withdrawStake && {
-                stakePoolData: {
-                  managerFeeAccount: unstakingInstruction.withdrawStake.managerFeeAccount.toString(),
-                  poolMint: unstakingInstruction.withdrawStake.poolMint.toString(),
-                  validatorList: unstakingInstruction.withdrawStake.validatorList.toString(),
-                },
-                validatorAddress: unstakingInstruction.withdrawStake.validatorStake.toString(),
-                transferAuthorityAddress: unstakingInstruction.withdrawStake.sourceTransferAuthority.toString(),
-              },
-            }
-          : {}),
-      },
-    };
+
+    let stakingDeactivate: StakingDeactivate | undefined;
+    // One case per StakingType
+    if (unstakingInstruction.withdrawStake !== undefined) {
+      const stakingType = StakingType.JITO;
+      stakingDeactivate = {
+        type: InstructionBuilderTypes.StakingDeactivate,
+        params: {
+          stakingType,
+          fromAddress: unstakingInstruction.withdrawStake.destinationStakeAuthority.toString(),
+          stakingAddress: unstakingInstruction.withdrawStake.stakePool.toString(),
+          amount: unstakingInstruction.withdrawStake.poolTokens.toString(),
+          unstakingAddress: unstakingInstruction.withdrawStake.destinationStake.toString(),
+          extraParams: {
+            stakePoolData: {
+              managerFeeAccount: unstakingInstruction.withdrawStake.managerFeeAccount.toString(),
+              poolMint: unstakingInstruction.withdrawStake.poolMint.toString(),
+              validatorListAccount: unstakingInstruction.withdrawStake.validatorList.toString(),
+            },
+            validatorAddress: unstakingInstruction.withdrawStake.validatorStake.toString(),
+            transferAuthorityAddress: unstakingInstruction.withdrawStake.sourceTransferAuthority.toString(),
+          },
+        },
+      };
+    } else if (unstakingInstruction.deactivate === undefined && unstakingInstruction.transfer !== undefined) {
+      const stakingType = StakingType.MARINADE;
+      stakingDeactivate = {
+        type: InstructionBuilderTypes.StakingDeactivate,
+        params: {
+          stakingType,
+          fromAddress: '',
+          stakingAddress: '',
+          recipients: [
+            {
+              address: unstakingInstruction.transfer.toPubkey.toString() || '',
+              amount: unstakingInstruction.transfer.lamports.toString() || '',
+            },
+          ],
+        },
+      };
+    } else {
+      const stakingType = StakingType.NATIVE;
+      stakingDeactivate = {
+        type: InstructionBuilderTypes.StakingDeactivate,
+        params: {
+          stakingType,
+          fromAddress: unstakingInstruction.deactivate?.authorizedPubkey.toString() || '',
+          stakingAddress:
+            unstakingInstruction.split?.stakePubkey.toString() ||
+            unstakingInstruction.deactivate?.stakePubkey.toString() ||
+            '',
+          amount: unstakingInstruction.split?.lamports.toString(),
+          unstakingAddress: unstakingInstruction.split?.splitStakePubkey.toString(),
+        },
+      };
+    }
+
+    assert(stakingDeactivate !== undefined, 'Missing stakingDeactivate');
     instructionData.push(stakingDeactivate);
   }
 

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

@@ -47,7 +47,7 @@ export interface StakePoolData {
   staker: string;
   stakeDepositAuthority: string;
   stakeWithdrawBumpSeed: number;
-  validatorList: string;
+  validatorListAccount: string;
   reserveStake: string;
   poolMint: string;
   managerFeeAccount: string;
@@ -209,7 +209,7 @@ export interface WithdrawStakeInstructionsParams {
   poolAmount: string;
 }
 
-export type WithdrawStakeStakePoolData = Pick<StakePoolData, 'poolMint' | 'validatorList' | 'managerFeeAccount'>;
+export type WithdrawStakeStakePoolData = Pick<StakePoolData, 'poolMint' | 'validatorListAccount' | 'managerFeeAccount'>;
 
 /**
  * Construct Solana depositSol stake pool instruction from parameters.
@@ -234,7 +234,7 @@ export function withdrawStakeInstructions(
   } = params;
 
   const poolMint = new PublicKey(stakePool.poolMint);
-  const validatorList = new PublicKey(stakePool.validatorList);
+  const validatorList = new PublicKey(stakePool.validatorListAccount);
   const managerFeeAccount = new PublicKey(stakePool.managerFeeAccount);
 
   const poolTokenAccount = getAssociatedTokenAddressSync(poolMint, tokenOwner);
@@ -291,9 +291,9 @@ export function decodeWithdrawStake(instruction: TransactionInstruction): Withdr
   const validatorList = parseKey(keys[i++], { isSigner: false, isWritable: true });
   const withdrawAuthority = parseKey(keys[i++], { isSigner: false, isWritable: false });
   const validatorStake = parseKey(keys[i++], { isSigner: false, isWritable: true });
-  const destinationStake = keys[i++].pubkey; // parseKey(keys[i++], { isSigner: false, isWritable: true });
-  const destinationStakeAuthority = keys[i++].pubkey; // parseKey(keys[i++], { isSigner: false, isWritable: false });
-  const sourceTransferAuthority = keys[i++].pubkey; // parseKey(keys[i++], { isSigner: true, isWritable: false });
+  const destinationStake = keys[i++].pubkey;
+  const destinationStakeAuthority = keys[i++].pubkey;
+  const sourceTransferAuthority = parseKey(keys[i++], { isSigner: true, isWritable: false });
   const sourcePoolAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
   const managerFeeAccount = parseKey(keys[i++], { isSigner: false, isWritable: true });
   const poolMint = parseKey(keys[i++], { isSigner: false, isWritable: true });