feat(sdk-coin-sol): add unstake flow for marinade

Ticket: SC-1660

Author: Vijay-Jagannathan

modules/sdk-coin-sol/package.json

@@ -43,6 +43,7 @@
     "@bitgo/sdk-core": "^32.2.0",
     "@bitgo/sdk-lib-mpc": "^10.2.0",
     "@bitgo/statics": "^51.8.0",
+    "@bitgo/public-types": "4.28.1",
     "@solana/spl-token": "0.3.1",
     "@solana/web3.js": "1.92.1",
     "bignumber.js": "^9.0.0",

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

@@ -4,7 +4,7 @@ export const MEMO_PROGRAM_PK = 'MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr';
 
 export const SEED_LENGTH = 32;
 
-export const MAX_MEMO_LENGTH = 100;
+export const MAX_MEMO_LENGTH = 130;
 export const STAKE_ACCOUNT_RENT_EXEMPT_AMOUNT = 2282880;
 
 export const UNAVAILABLE_TEXT = 'UNAVAILABLE';

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

@@ -2,6 +2,7 @@ import { TransactionExplanation as BaseTransactionExplanation } from '@bitgo/sdk
 import { DecodedCloseAccountInstruction } from '@solana/spl-token';
 import { Blockhash, StakeInstructionType, SystemInstructionType, TransactionSignature } from '@solana/web3.js';
 import { InstructionBuilderTypes } from './constants';
+import { RecipientEntry } from '@bitgo/public-types';
 
 // TODO(STLX-9890): Add the interfaces for validityWindow and SequenceId
 export interface SolanaKeys {
@@ -98,6 +99,8 @@ export interface StakingDeactivate {
     stakingAddress: string;
     amount?: string;
     unstakingAddress?: string;
+    isMarinade?: boolean;
+    recipients?: RecipientEntry[];
   };
 }
 

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

@@ -16,6 +16,8 @@ import {
   ComputeBudgetInstruction,
 } from '@solana/web3.js';
 
+import { RecipientEntry } from '@bitgo/public-types';
+
 import { NotSupported, TransactionType } from '@bitgo/sdk-core';
 import { coins, SolCoin } from '@bitgo/statics';
 import assert from 'assert';
@@ -47,7 +49,8 @@ import { getInstructionType } from './utils';
  */
 export function instructionParamsFactory(
   type: TransactionType,
-  instructions: TransactionInstruction[]
+  instructions: TransactionInstruction[],
+  coinName?: string
 ): InstructionParams[] {
   switch (type) {
     case TransactionType.WalletInitialization:
@@ -57,7 +60,7 @@ export function instructionParamsFactory(
     case TransactionType.StakingActivate:
       return parseStakingActivateInstructions(instructions);
     case TransactionType.StakingDeactivate:
-      return parseStakingDeactivateInstructions(instructions);
+      return parseStakingDeactivateInstructions(instructions, coinName);
     case TransactionType.StakingWithdraw:
       return parseStakingWithdrawInstructions(instructions);
     case TransactionType.AssociatedTokenAccountInitialization:
@@ -358,7 +361,8 @@ function validateStakingInstructions(stakingInstructions: StakingInstructions) {
  * @returns {InstructionParams[]} An array containing instruction params for staking deactivate tx
  */
 function parseStakingDeactivateInstructions(
-  instructions: TransactionInstruction[]
+  instructions: TransactionInstruction[],
+  coinName?: string
 ): Array<Nonce | StakingDeactivate | Memo> {
   const instructionData: Array<Nonce | StakingDeactivate | Memo> = [];
   const unstakingInstructions: UnstakingInstructions[] = [];
@@ -467,6 +471,21 @@ function parseStakingDeactivateInstructions(
           '',
         amount: unstakingInstruction.split?.lamports.toString(),
         unstakingAddress: unstakingInstruction.split?.splitStakePubkey.toString(),
+        isMarinade: unstakingInstruction.deactivate === undefined,
+        recipients:
+          unstakingInstruction.deactivate === undefined
+            ? ([
+                {
+                  address: {
+                    address: unstakingInstruction.transfer?.toPubkey.toString(),
+                  },
+                  amount: {
+                    value: unstakingInstruction.transfer?.lamports.toString(),
+                    symbol: coinName,
+                  },
+                },
+              ] as RecipientEntry[])
+            : undefined,
       },
     };
     instructionData.push(stakingDeactivate);
@@ -485,6 +504,14 @@ interface UnstakingInstructions {
 
 function validateUnstakingInstructions(unstakingInstructions: UnstakingInstructions) {
   if (!unstakingInstructions.deactivate) {
+    if (
+      unstakingInstructions.transfer &&
+      !unstakingInstructions.allocate &&
+      !unstakingInstructions.assign &&
+      !unstakingInstructions.split
+    ) {
+      return;
+    }
     throw new NotSupported('Invalid deactivate stake transaction, missing deactivate stake account instruction');
   } else if (
     unstakingInstructions.allocate ||

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

@@ -243,10 +243,26 @@ function stakingInitializeInstruction(data: StakingActivate): TransactionInstruc
  */
 function stakingDeactivateInstruction(data: StakingDeactivate): TransactionInstruction[] {
   const {
-    params: { fromAddress, stakingAddress },
+    params: { fromAddress, stakingAddress, isMarinade, recipients },
   } = data;
   assert(fromAddress, 'Missing fromAddress param');
-  assert(stakingAddress, 'Missing stakingAddress param');
+  if (!isMarinade) {
+    assert(stakingAddress, 'Missing stakingAddress param');
+  }
+
+  if (isMarinade) {
+    const tx = new Transaction();
+    assert(recipients, 'Missing recipients param');
+    const toPubkeyAddress = new PublicKey(recipients[0].address.address || '');
+    const transferInstruction = SystemProgram.transfer({
+      fromPubkey: new PublicKey(fromAddress),
+      toPubkey: toPubkeyAddress,
+      lamports: parseInt(recipients[0].amount.value, 10),
+    });
+
+    tx.add(transferInstruction);
+    return tx.instructions;
+  }
 
   if (data.params.amount && data.params.unstakingAddress) {
     const tx = new Transaction();

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

@@ -7,12 +7,15 @@ import { StakingDeactivate, Transfer } from './iface';
 import { Transaction } from './transaction';
 import { TransactionBuilder } from './transactionBuilder';
 import { isValidStakingAmount, validateAddress } from './utils';
+import { RecipientEntry } from '@bitgo/public-types';
 
 export class StakingDeactivateBuilder extends TransactionBuilder {
   protected _stakingAddress: string;
   protected _stakingAddresses: string[];
   protected _amount?: string;
   protected _unstakingAddress: string;
+  protected _isMarinade = false;
+  protected _recipients: RecipientEntry[];
 
   constructor(_coinConfig: Readonly<CoinConfig>) {
     super(_coinConfig);
@@ -29,7 +32,13 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
     for (const instruction of this._instructionsData) {
       if (instruction.type === InstructionBuilderTypes.StakingDeactivate) {
         const deactivateInstruction: StakingDeactivate = instruction;
-        this.sender(deactivateInstruction.params.fromAddress);
+        this.isMarinade(deactivateInstruction.params.isMarinade ?? false);
+        if (!deactivateInstruction.params.isMarinade) {
+          this.sender(deactivateInstruction.params.fromAddress);
+        }
+        if (deactivateInstruction.params.isMarinade) {
+          this.recipients(deactivateInstruction.params.recipients ?? []);
+        }
         stakingAddresses.push(deactivateInstruction.params.stakingAddress);
         if (deactivateInstruction.params.amount && deactivateInstruction.params.unstakingAddress) {
           this.amount(deactivateInstruction.params.amount);
@@ -40,7 +49,9 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
     if (stakingAddresses.length > 1) {
       this.stakingAddresses(stakingAddresses);
     } else {
-      this.stakingAddress(stakingAddresses[0]);
+      if (!this._isMarinade) {
+        this.stakingAddress(stakingAddresses[0]);
+      }
     }
   }
 
@@ -91,6 +102,17 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
     return this;
   }
 
+  /**
+   * Setter to set the recipients object
+   *
+   * @param recipients RecipientEntry[] - The recipients object
+   * @returns {StakingDeactivateBuilder} This staking builder.
+   */
+  recipients(recipients: RecipientEntry[]): this {
+    this._recipients = recipients;
+    return this;
+  }
+
   /**
    * When partially unstaking move the amount to unstake to this account and initiate the
    * unstake process. The original stake account will continue staking.
@@ -106,9 +128,20 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
     return this;
   }
 
+  /**
+   * Set isMarinade flag
+   * @param {boolean} flag - true if the transaction is for Marinade, false by default if not set
+   * @returns {StakingActivateBuilder} This staking builder
+   */
+  isMarinade(flag: boolean): this {
+    this._isMarinade = flag;
+    return this;
+  }
+
   /** @inheritdoc */
   protected async buildImplementation(): Promise<Transaction> {
     assert(this._sender, 'Sender must be set before building the transaction');
+    assert(this._isMarinade !== undefined, 'isMarinade must be set before building the transaction');
 
     if (this._stakingAddresses && this._stakingAddresses.length > 0) {
       this._instructionsData = [];
@@ -123,7 +156,10 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
         this._instructionsData.push(stakingDeactivateData);
       }
     } else {
-      assert(this._stakingAddress, 'Staking address must be set before building the transaction');
+      if (!this._isMarinade) {
+        // we don't need stakingAddress in marinade staking deactivate txn
+        assert(this._stakingAddress, 'Staking address must be set before building the transaction');
+      }
 
       if (this._sender === this._stakingAddress) {
         throw new BuildTransactionError('Sender address cannot be the same as the Staking address');
@@ -136,7 +172,7 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
         );
       }
       this._instructionsData = [];
-      if (this._unstakingAddress) {
+      if (this._unstakingAddress && !this._isMarinade) {
         assert(
           this._amount,
           'If an unstaking address is given then a partial amount to unstake must also be set before building the transaction'
@@ -159,6 +195,8 @@ export class StakingDeactivateBuilder extends TransactionBuilder {
           stakingAddress: this._stakingAddress,
           amount: this._amount,
           unstakingAddress: this._unstakingAddress,
+          isMarinade: this._isMarinade,
+          recipients: this._recipients,
         },
       };
       this._instructionsData.push(stakingDeactivateData);

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

@@ -239,7 +239,11 @@ export class Transaction extends BaseTransaction {
         authWalletAddress: nonceInstruction.authorizedPubkey.toString(),
       };
     }
-    const instructionData = instructionParamsFactory(this._type, this._solTransaction.instructions);
+    const instructionData = instructionParamsFactory(
+      this._type,
+      this._solTransaction.instructions,
+      this._coinConfig.name
+    );
     if (this._type) {
       if (
         !durableNonce &&
@@ -284,7 +288,11 @@ export class Transaction extends BaseTransaction {
     }
     const outputs: Entry[] = [];
     const inputs: Entry[] = [];
-    const instructionParams = instructionParamsFactory(this.type, this._solTransaction.instructions);
+    const instructionParams = instructionParamsFactory(
+      this.type,
+      this._solTransaction.instructions,
+      this._coinConfig.name
+    );
 
     for (const instruction of instructionParams) {
       switch (instruction.type) {
@@ -378,7 +386,11 @@ export class Transaction extends BaseTransaction {
     if (validateRawMsgInstruction(this._solTransaction.instructions)) {
       return this.explainRawMsgAuthorizeTransaction();
     }
-    const decodedInstructions = instructionParamsFactory(this._type, this._solTransaction.instructions);
+    const decodedInstructions = instructionParamsFactory(
+      this._type,
+      this._solTransaction.instructions,
+      this._coinConfig.name
+    );
 
     let memo: string | undefined = undefined;
     let durableNonce: DurableNonceParams | undefined = undefined;

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

@@ -75,7 +75,7 @@ export abstract class TransactionBuilder extends BaseTransactionBuilder {
     this.sender(sender);
     this.feePayer(txData.feePayer as string);
     this.nonce(txData.nonce, txData.durableNonce);
-    this._instructionsData = instructionParamsFactory(tx.type, tx.solTransaction.instructions);
+    this._instructionsData = instructionParamsFactory(tx.type, tx.solTransaction.instructions, this._coinConfig.name);
     // Parse priority fee instruction data
     const filteredPriorityFeeInstructionsData = txData.instructionsData.filter(
       (data) => data.type === InstructionBuilderTypes.SetPriorityFee

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

@@ -276,11 +276,14 @@ export function getTransactionType(transaction: SolTransaction): TransactionType
   }
   validateIntructionTypes(instructions);
   // check if deactivate instruction does not exist because deactivate can be include a transfer instruction
+  const memoInstruction = instructions.find((instruction) => getInstructionType(instruction) === 'Memo');
+  const memoData = memoInstruction?.data.toString('utf-8');
   if (instructions.filter((instruction) => getInstructionType(instruction) === 'Deactivate').length == 0) {
     for (const instruction of instructions) {
       const instructionType = getInstructionType(instruction);
+      // Check if memo instruction is there and if it contains 'PrepareForRevoke' because Marinade staking deactivate transaction will have this
       if (
-        instructionType === ValidInstructionTypesEnum.Transfer ||
+        (instructionType === ValidInstructionTypesEnum.Transfer && !memoData?.includes('PrepareForRevoke')) ||
         instructionType === ValidInstructionTypesEnum.TokenTransfer
       ) {
         return TransactionType.Send;

modules/sdk-coin-sol/test/resources/sol.ts

@@ -173,6 +173,9 @@ export const MARINADE_STAKING_ACTIVATE_UNSIGNED_TX_WITH_MEMO =
 export const STAKING_DEACTIVATE_SIGNED_TX =
   'AUfyWtl4IUxhH21qX/H03hJZer1XxQaxL2r/uDTM/u1GzBIyePCHu78O2SkWGEYP6eDdiY3OLfJmUM1jiy8NCAoBAAIEReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96Qah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxjHdMkoVmOYaR1etoteuKObS21cc1VbIQAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQECAwEDAAQFAAAA';
 
+export const MARINADE_STAKING_DEACTIVATE_SIGNED_TX =
+  'AaiHUOzzeJaUzpdkm2BmLJI3AVOhFHTD5BnVMwUH3lRv8hKpH1fnXiXNm6ghZgNwhggXBAqhL3t4XEl+H7T95gIBAAIEReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0EL/kczKamI94jNtLT/BR9nkfa/PR2IU6d7qaEV8VVC3AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABUpTWpkpIQZNJOhxYNo4fHw1td28kruB5B+oQEEFRI3jMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQICAgABDAIAAABgGCMAAAAAAAMAbntcIlByZXBhcmVGb3JSZXZva2VcIjp7XCJ1c2VyXCI6XCI1aHI1ZmlzUGk2RFhOdXVScG01WFVienBpRW5tZHl4WHVCRFR3endaajVQZX1cIixcImFtb3VudFwiOlwiNTAwMDAwMDAwMDAwXCJ9';
+
 export const STAKING_DEACTIVATE_SIGNED_TX_single =
   'AUfyWtl4IUxhH21qX/H03hJZer1XxQaxL2r/uDTM/u1GzBIyePCHu78O2SkWGEYP6eDdiY3OLfJmUM1jiy8NCAoBAAIEReV5vPklPPaLR9/x+zo6XCwhusWyPAmuEqbgVWvwi0Fiey+6ASdh+bkZvPlMu0ydyAUdnwkymTFNOUkjMmi96Qah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxjHdMkoVmOYaR1etoteuKObS21cc1VbIQAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQECAwEDAAQFAAAA';