feat(sdk-coin-sui): walrus unstaking tx support

TICKET: SC-1098

Author: benkelcher-bitgo

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

@@ -20,6 +20,8 @@ export enum SuiTransactionType {
   CustomTx = 'CustomTx',
   TokenTransfer = 'TokenTransfer',
   WalrusStakeWithPool = 'WalrusStakeWithPool',
+  WalrusRequestWithdrawStake = 'WalrusRequestWithdrawStake',
+  WalrusWithdrawStake = 'WalrusWithdrawStake',
 }
 
 export interface TransactionExplanation extends BaseTransactionExplanation {
@@ -32,7 +34,8 @@ export type SuiProgrammableTransaction =
   | UnstakingProgrammableTransaction
   | CustomProgrammableTransaction
   | TokenTransferProgrammableTransaction
-  | WalrusStakingProgrammableTransaction;
+  | WalrusStakingProgrammableTransaction
+  | WalrusWithdrawStakeProgrammableTransaction;
 
 export interface TxData {
   id?: string;
@@ -87,6 +90,13 @@ export type WalrusStakingProgrammableTransaction =
       transactions: TransactionType[];
     };
 
+export type WalrusWithdrawStakeProgrammableTransaction =
+  | ProgrammableTransaction
+  | {
+      inputs: CallArg[] | TransactionBlockInput[];
+      transactions: TransactionType[];
+    };
+
 export interface SuiTransaction<T = SuiProgrammableTransaction> {
   id?: string;
   type: SuiTransactionType;
@@ -110,6 +120,11 @@ export interface RequestWalrusStakeWithPool {
   validatorAddress: SuiAddress;
 }
 
+export interface RequestWalrusWithdrawStake {
+  amount?: number;
+  stakedWal: SuiObjectRef;
+}
+
 /**
  * Method names for the transaction method. Names change based on the type of transaction e.g 'request_add_delegation_mul_coin' for the staking transaction
  */
@@ -119,13 +134,13 @@ export enum MethodNames {
    *
    * @see https://github.com/MystenLabs/sui/blob/main/crates/sui-framework/docs/sui_system.md#function-request_add_stake
    */
-  RequestAddStake = 'request_add_stake',
+  RequestAddStake = '::sui_system::request_add_stake',
   /**
    * Withdraw some portion of a stake from a validator's staking pool.
    *
    * @see https://github.com/MystenLabs/sui/blob/main/crates/sui-framework/docs/sui_system.md#function-request_withdraw_stake
    */
-  RequestWithdrawStake = 'request_withdraw_stake',
+  RequestWithdrawStake = '::sui_system::request_withdraw_stake',
   /**
    * Split StakedSui self to two parts, one with principal split_amount, and the remaining principal is left in self.
    *
@@ -143,7 +158,19 @@ export enum MethodNames {
    *
    * @see https://github.com/MystenLabs/walrus-docs/blob/8ba15d67d7ed0e728077e1600866fddd46fd113b/contracts/walrus/sources/staking.move#L289
    */
-  WalrusStakeWithPool = 'stake_with_pool',
+  WalrusStakeWithPool = '::staking::stake_with_pool',
+  /**
+   * @see https://github.com/MystenLabs/walrus-docs/blob/9307e66df0ea3f6555cdef78d46aefa62737e216/contracts/walrus/sources/staking.move#L221
+   */
+  WalrusRequestWithdrawStake = '::staking::request_withdraw_stake',
+  /**
+   * @see https://github.com/MystenLabs/walrus-docs/blob/9307e66df0ea3f6555cdef78d46aefa62737e216/contracts/walrus/sources/staking.move#L231
+   */
+  WalrusWithdrawStake = '::staking::withdraw_stake',
+  /**
+   * @see https://github.com/MystenLabs/walrus-docs/blob/9307e66df0ea3f6555cdef78d46aefa62737e216/contracts/walrus/sources/staking/staked_wal.move#L143
+   */
+  WalrusSplitStakedWal = '::staked_wal::split',
 }
 
 export interface SuiObjectInfo extends SuiObjectRef {

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

@@ -190,6 +190,12 @@ export abstract class Transaction<T> extends BaseTransaction {
     if (transactions.some((tx) => utils.getSuiTransactionType(tx) === SuiTransactionType.WalrusStakeWithPool)) {
       return SuiTransactionType.WalrusStakeWithPool;
     }
+    if (transactions.some((tx) => utils.getSuiTransactionType(tx) === SuiTransactionType.WalrusRequestWithdrawStake)) {
+      return SuiTransactionType.WalrusRequestWithdrawStake;
+    }
+    if (transactions.some((tx) => utils.getSuiTransactionType(tx) === SuiTransactionType.WalrusWithdrawStake)) {
+      return SuiTransactionType.WalrusWithdrawStake;
+    }
     if (transactions.some((tx) => utils.getSuiTransactionType(tx) === SuiTransactionType.AddStake)) {
       return SuiTransactionType.AddStake;
     }

modules/sdk-coin-sui/src/lib/transactionBuilderFactory.ts

@@ -13,6 +13,7 @@ import {
   SuiProgrammableTransaction,
   TokenTransferProgrammableTransaction,
   WalrusStakingProgrammableTransaction,
+  WalrusWithdrawStakeProgrammableTransaction,
 } from './iface';
 import { StakingTransaction } from './stakingTransaction';
 import { TransferTransaction } from './transferTransaction';
@@ -26,6 +27,8 @@ import { TokenTransferBuilder } from './tokenTransferBuilder';
 import { TokenTransferTransaction } from './tokenTransferTransaction';
 import { WalrusStakingBuilder } from './walrusStakingBuilder';
 import { WalrusStakingTransaction } from './walrusStakingTransaction';
+import { WalrusWithdrawStakeBuilder } from './walrusWithdrawStakeBuilder';
+import { WalrusWithdrawStakeTransaction } from './walrusWithdrawStakeTransaction';
 
 export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
   constructor(_coinConfig: Readonly<CoinConfig>) {
@@ -62,6 +65,11 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
           const walrusStakeTx = new WalrusStakingTransaction(this._coinConfig);
           walrusStakeTx.fromRawTransaction(raw);
           return this.getWalrusStakingBuilder(walrusStakeTx);
+        case SuiTransactionType.WalrusRequestWithdrawStake:
+        case SuiTransactionType.WalrusWithdrawStake:
+          const walrusRequestWithdrawStakeTransaction = new WalrusWithdrawStakeTransaction(this._coinConfig);
+          walrusRequestWithdrawStakeTransaction.fromRawTransaction(raw);
+          return this.getWalrusRequestWithdrawStakeBuilder(walrusRequestWithdrawStakeTransaction);
         default:
           throw new InvalidTransactionError('Invalid transaction');
       }
@@ -100,6 +108,13 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return this.initializeBuilder(tx, new WalrusStakingBuilder(this._coinConfig));
   }
 
+  /** @inheritdoc */
+  getWalrusRequestWithdrawStakeBuilder(
+    tx?: Transaction<WalrusWithdrawStakeProgrammableTransaction>
+  ): WalrusWithdrawStakeBuilder {
+    return this.initializeBuilder(tx, new WalrusWithdrawStakeBuilder(this._coinConfig));
+  }
+
   /** @inheritdoc */
   getWalletInitializationBuilder(): void {
     throw new Error('Method not implemented.');

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

@@ -15,8 +15,10 @@ import {
   MethodNames,
   RequestAddStake,
   RequestWalrusStakeWithPool,
+  RequestWalrusWithdrawStake,
   StakingProgrammableTransaction,
   WalrusStakingProgrammableTransaction,
+  WalrusWithdrawStakeProgrammableTransaction,
   SuiObjectInfo,
   SuiProgrammableTransaction,
   SuiTransaction,
@@ -199,7 +201,10 @@ export class Utils implements BaseUtils {
       case SuiTransactionType.AddStake:
       case SuiTransactionType.WalrusStakeWithPool:
         return TransactionType.StakingAdd;
+      case SuiTransactionType.WalrusRequestWithdrawStake:
+        return TransactionType.StakingDeactivate;
       case SuiTransactionType.WithdrawStake:
+      case SuiTransactionType.WalrusWithdrawStake:
         return TransactionType.StakingWithdraw;
       case SuiTransactionType.CustomTx:
         return TransactionType.CustomTx;
@@ -238,6 +243,13 @@ export class Utils implements BaseUtils {
           return SuiTransactionType.CustomTx;
         } else if (command.target.endsWith(MethodNames.WalrusStakeWithPool)) {
           return SuiTransactionType.WalrusStakeWithPool;
+        } else if (
+          command.target.endsWith(MethodNames.WalrusRequestWithdrawStake) ||
+          command.target.endsWith(MethodNames.WalrusSplitStakedWal)
+        ) {
+          return SuiTransactionType.WalrusRequestWithdrawStake;
+        } else if (command.target.endsWith(MethodNames.WalrusWithdrawStake)) {
+          return SuiTransactionType.WalrusWithdrawStake;
         } else {
           throw new InvalidTransactionError(`unsupported target method ${command.target}`);
         }
@@ -355,6 +367,47 @@ export class Utils implements BaseUtils {
     });
   }
 
+  getWalrusWithdrawStakeRequests(tx: WalrusWithdrawStakeProgrammableTransaction): RequestWalrusWithdrawStake {
+    let amount: number | undefined = undefined;
+    let stakedWal: SuiObjectRef;
+    let stakedWalInputIdx = -1;
+
+    // TS won't let us use filter
+    const moveCalls: MoveCallTransaction[] = [];
+    tx.transactions.forEach((transaction) => {
+      if (transaction.kind === 'MoveCall') {
+        moveCalls.push(transaction);
+      }
+    });
+
+    if (moveCalls.length === 1) {
+      // This is either request_withdraw full or withdraw full (either way, no amount)
+      stakedWalInputIdx = ((moveCalls[0] as MoveCallTransaction).arguments[1] as TransactionBlockInput).index;
+    } else if (moveCalls.length === 2) {
+      // This is request_withdraw partial
+      const amountInputIdx = ((moveCalls[0] as MoveCallTransaction).arguments[1] as TransactionBlockInput).index;
+      amount = utils.getAmount(tx.inputs[amountInputIdx] as TransactionBlockInput);
+
+      stakedWalInputIdx = ((moveCalls[0] as MoveCallTransaction).arguments[0] as TransactionBlockInput).index;
+    } else {
+      throw new InvalidTransactionError('Invalid number of MoveCall transactions');
+    }
+
+    let input = tx.inputs[stakedWalInputIdx];
+    if ('value' in input) {
+      input = input.value;
+    }
+    if ('Object' in input && isImmOrOwnedObj(input.Object)) {
+      stakedWal = utils.normalizeSuiObjectRef(input.Object.ImmOrOwned as SuiObjectRef);
+    } else {
+      throw new InvalidTransactionError(
+        `Expected StakedWal object at input index ${stakedWalInputIdx}, found ${input}`
+      );
+    }
+
+    return { amount, stakedWal };
+  }
+
   getAmount(input: SuiJsonValue | TransactionBlockInput): number {
     return isPureArg(input)
       ? builder.de(BCS.U64, Buffer.from(new Uint16Array(input.Pure)).toString('base64'), 'base64')