Merge pull request #6282 from BitGo/SC-2108

feat: add decoding support for polyx staking related txns

Author: noel-bitgo

modules/abstract-substrate/src/lib/iface.ts

@@ -41,6 +41,39 @@ export enum MethodNames {
   AddStake = 'addStake',
   RemoveStake = 'removeStake',
 
+  /**
+   * Take the origin account as a stash and lock up value of its balance.
+   */
+  Bond = 'bond',
+  /**
+   * Add some extra amount that have appeared in the stash free_balance into the balance up for staking.
+   */
+  BondExtra = 'bondExtra',
+  /**
+   * Declare the desire to nominate targets for the origin controller.
+   */
+  Nominate = 'nominate',
+  /**
+   * Declare no desire to either validate or nominate.
+   */
+  Chill = 'chill',
+  /**
+   * Schedule a portion of the stash to be unlocked ready for transfer out after the bond period ends.
+   */
+  Unbond = 'unbond',
+  /**
+   * Remove any unlocked chunks from the unlocking queue from our management.
+   */
+  WithdrawUnbonded = 'withdrawUnbonded',
+  /**
+   * Send a batch of dispatch calls.
+   */
+  Batch = 'batch',
+  /**
+   * Send a batch of dispatch calls and atomically execute them.
+   */
+  BatchAll = 'batchAll',
+
   /**
    * Registers a Decentralized Identifier (DID) along with Customer Due Diligence (CDD) information.
    *
@@ -71,6 +104,8 @@ export interface TxData {
   payee?: string;
   keepAlive?: boolean;
   netuid?: string;
+  numSlashingSpans?: number;
+  batchCalls?: BatchCallObject[];
 }
 
 /**
@@ -107,11 +142,57 @@ export interface RemoveStakeArgs extends Args {
   netuid: string;
 }
 
+export interface BondArgs extends Args {
+  value: string;
+  controller: string;
+  payee: string | { Account: string };
+}
+
+export interface BondExtraArgs extends Args {
+  maxAdditional: string;
+}
+
+export interface NominateArgs extends Args {
+  targets: string[];
+}
+
+export interface ChillArgs extends Args {
+  [key: string]: never; // Chill has no arguments
+}
+
+export interface UnbondArgs extends Args {
+  value: string;
+}
+
+export interface WithdrawUnbondedArgs extends Args {
+  numSlashingSpans: number;
+}
+
+export interface BatchCallObject {
+  method: string;
+  args: Record<string, unknown>;
+}
+
+export interface BatchArgs {
+  calls: BatchCallObject[];
+}
+
 /**
  * Decoded TxMethod from a transaction hex
  */
 export interface TxMethod {
-  args: TransferArgs | TransferAllArgs | AddStakeArgs | RemoveStakeArgs;
+  args:
+    | TransferArgs
+    | TransferAllArgs
+    | AddStakeArgs
+    | RemoveStakeArgs
+    | BondArgs
+    | BondExtraArgs
+    | NominateArgs
+    | ChillArgs
+    | UnbondArgs
+    | WithdrawUnbondedArgs
+    | BatchArgs;
   name: MethodNames;
   pallet: string;
 }

modules/abstract-substrate/src/lib/transaction.ts

@@ -26,7 +26,7 @@ export class Transaction extends BaseTransaction {
   protected _chainName: string;
   protected _sender: string;
 
-  private static FAKE_SIGNATURE = `0x${Buffer.from(new Uint8Array(256).fill(1)).toString('hex')}`;
+  private static FAKE_SIGNATURE = `0x${Buffer.from(new Uint8Array(256).fill(1)).toString('hex')}` as HexString;
 
   constructor(coinConfig: Readonly<CoinConfig>) {
     super(coinConfig);
@@ -77,7 +77,7 @@ export class Transaction extends BaseTransaction {
   addSignature(signature: string): void {
     this._signedTransaction = utils.serializeSignedTransaction(
       this._substrateTransaction,
-      signature,
+      signature as HexString,
       this._substrateTransaction.metadataRpc,
       this._registry
     );
@@ -177,6 +177,11 @@ export class Transaction extends BaseTransaction {
         result.to = keypairDest.getAddress(this.getAddressFormat());
         result.amount = txMethod.amountStaked.toString();
         result.netuid = txMethod.netuid;
+      } else if (utils.isBond(txMethod)) {
+        result.amount = txMethod.value;
+        result.payee = typeof txMethod.payee === 'string' ? txMethod.payee : txMethod.payee.Account;
+      } else if (utils.isBondExtra(txMethod)) {
+        result.amount = txMethod.maxAdditional;
       }
     } else if (this.type === TransactionType.StakingDeactivate) {
       if (utils.isRemoveStake(txMethod)) {
@@ -187,6 +192,28 @@ export class Transaction extends BaseTransaction {
         result.to = keypairDest.getAddress(this.getAddressFormat());
         result.amount = txMethod.amountUnstaked.toString();
         result.netuid = txMethod.netuid;
+      } else if (utils.isUnbond(txMethod)) {
+        result.amount = txMethod.value;
+      } else if (utils.isWithdrawUnbonded(txMethod)) {
+        result.numSlashingSpans = txMethod.numSlashingSpans;
+      }
+    } else if (this.type === TransactionType.Batch) {
+      if (utils.isBatch(txMethod)) {
+        result.batchCalls = txMethod.calls;
+        // Extract amount from batch calls for display
+        if (txMethod.calls && txMethod.calls.length === 2) {
+          const firstCall = txMethod.calls[0];
+          const secondCall = txMethod.calls[1];
+          if (firstCall.method === 'bond' && secondCall.method === 'nominate') {
+            // Staking batch: bond + nominate
+            const bondArgs = firstCall.args as Record<string, unknown>;
+            result.amount = bondArgs.value as string;
+          } else if (firstCall.method === 'chill' && secondCall.method === 'unbond') {
+            // Unstaking batch: chill + unbond
+            const unbondArgs = secondCall.args as Record<string, unknown>;
+            result.amount = unbondArgs.value as string;
+          }
+        }
       }
     }
 
@@ -277,6 +304,8 @@ export class Transaction extends BaseTransaction {
       this.decodeInputsAndOutputsForStakingActivate(decodedTx);
     } else if (this.type === TransactionType.StakingDeactivate) {
       this.decodeInputsAndOutputsForStakingDeactivate(decodedTx);
+    } else if (this.type === TransactionType.Batch) {
+      this.decodeInputsAndOutputsForBatch(decodedTx);
     }
   }
 
@@ -331,6 +360,14 @@ export class Transaction extends BaseTransaction {
       to = keypairDest.getAddress(this.getAddressFormat());
       value = txMethod.amountStaked.toString();
       from = decodedTx.address;
+    } else if (utils.isBond(txMethod)) {
+      to = decodedTx.address; // For bond, funds are locked in the same account
+      value = txMethod.value;
+      from = decodedTx.address;
+    } else if (utils.isBondExtra(txMethod)) {
+      to = decodedTx.address; // For bond extra, funds are locked in the same account
+      value = txMethod.maxAdditional;
+      from = decodedTx.address;
     } else {
       throw new ParseTransactionError(`Loading inputs of unknown StakingActivate type parameters`);
     }
@@ -363,6 +400,14 @@ export class Transaction extends BaseTransaction {
       to = keypairDest.getAddress(this.getAddressFormat());
       value = txMethod.amountUnstaked.toString();
       from = decodedTx.address;
+    } else if (utils.isUnbond(txMethod)) {
+      to = decodedTx.address; // For unbond, funds are unlocked from the same account
+      value = txMethod.value;
+      from = decodedTx.address;
+    } else if (utils.isWithdrawUnbonded(txMethod)) {
+      to = decodedTx.address; // For withdraw unbonded, funds are returned to the same account
+      value = '0'; // Amount is not specified in withdraw unbonded
+      from = decodedTx.address;
     } else {
       throw new ParseTransactionError(`Loading inputs of unknown StakingDeactivate type parameters`);
     }
@@ -383,6 +428,83 @@ export class Transaction extends BaseTransaction {
     ];
   }
 
+  private decodeInputsAndOutputsForBatch(decodedTx: DecodedTx) {
+    const txMethod = decodedTx.method.args;
+    const sender = decodedTx.address;
+    this._inputs = [];
+    this._outputs = [];
+
+    if (utils.isBatch(txMethod)) {
+      if (!txMethod.calls) {
+        throw new InvalidTransactionError('failed to decode calls from batch transaction');
+      }
+      // Handle different types of batch operations
+      let totalStakingValue = '0';
+      let hasStakingOperations = false;
+      let hasUnstakingOperations = false;
+
+      for (const call of txMethod.calls) {
+        // Handle both possible formats: simple method names or callIndex with registry lookup
+        let methodName: string;
+
+        if (typeof call.method === 'string') {
+          methodName = call.method;
+        } else {
+          try {
+            const callIndex = call.method as string;
+            const decodedCall = this._registry.findMetaCall(
+              new Uint8Array(Buffer.from(callIndex.replace('0x', ''), 'hex'))
+            );
+            methodName = decodedCall.method;
+          } catch (e) {
+            methodName = call.method as string;
+          }
+        }
+
+        if (methodName === 'bond') {
+          const args = call.args as Record<string, unknown>;
+          const value = (args.value as string) || '0';
+          totalStakingValue = value;
+          hasStakingOperations = true;
+        } else if (methodName === 'chill') {
+          hasUnstakingOperations = true;
+        } else if (methodName === 'unbond') {
+          const args = call.args as Record<string, unknown>;
+          const value = (args.value as string) || '0';
+          totalStakingValue = value;
+          hasUnstakingOperations = true;
+        }
+      }
+
+      // For staking batch operations (bond + nominate or bondExtra + nominate)
+      if (hasStakingOperations && !hasUnstakingOperations) {
+        this._inputs.push({
+          address: sender,
+          value: totalStakingValue,
+          coin: this._coinConfig.name,
+        });
+        this._outputs.push({
+          address: sender, // For staking, funds are locked in the same account
+          value: totalStakingValue,
+          coin: this._coinConfig.name,
+        });
+      }
+      // For unstaking batch operations (chill + unbond)
+      else if (hasUnstakingOperations && !hasStakingOperations) {
+        this._inputs.push({
+          address: sender,
+          value: totalStakingValue,
+          coin: this._coinConfig.name,
+        });
+        this._outputs.push({
+          address: sender, // For unstaking, funds are unlocked from the same account
+          value: totalStakingValue,
+          coin: this._coinConfig.name,
+        });
+      }
+    }
+  }
+
   /**
    * Constructs a signed payload using construct.signTx
    * This method will be called during the build step if a TSS signature

modules/abstract-substrate/src/lib/utils.ts

@@ -13,7 +13,22 @@ import bs58 from 'bs58';
 import base32 from 'hi-base32';
 import nacl from 'tweetnacl';
 import { KeyPair } from '.';
-import { HexString, Material, TransferAllArgs, TransferArgs, TxMethod, AddStakeArgs, RemoveStakeArgs } from './iface';
+import {
+  HexString,
+  Material,
+  TransferAllArgs,
+  TransferArgs,
+  TxMethod,
+  AddStakeArgs,
+  RemoveStakeArgs,
+  BondArgs,
+  BondExtraArgs,
+  NominateArgs,
+  ChillArgs,
+  UnbondArgs,
+  WithdrawUnbondedArgs,
+  BatchArgs,
+} from './iface';
 
 export class Utils implements BaseUtils {
   /** @inheritdoc */
@@ -143,7 +158,12 @@ export class Utils implements BaseUtils {
    * @param registry Transaction registry
    * @returns string Serialized transaction
    */
-  serializeSignedTransaction(transaction, signature, metadataRpc: `0x${string}`, registry): string {
+  serializeSignedTransaction(
+    transaction: UnsignedTransaction,
+    signature: HexString,
+    metadataRpc: `0x${string}`,
+    registry: TypeRegistry
+  ): string {
     return construct.signedTx(transaction, signature, {
       metadataRpc,
       registry,
@@ -211,6 +231,38 @@ export class Utils implements BaseUtils {
     );
   }
 
+  isBond(arg: TxMethod['args']): arg is BondArgs {
+    return (
+      (arg as BondArgs).value !== undefined &&
+      (arg as BondArgs).controller !== undefined &&
+      (arg as BondArgs).payee !== undefined
+    );
+  }
+
+  isBondExtra(arg: TxMethod['args']): arg is BondExtraArgs {
+    return (arg as BondExtraArgs).maxAdditional !== undefined;
+  }
+
+  isNominate(arg: TxMethod['args']): arg is NominateArgs {
+    return (arg as NominateArgs).targets !== undefined;
+  }
+
+  isChill(arg: TxMethod['args']): arg is ChillArgs {
+    return true; // Chill has no arguments, so any object can be considered ChillArgs
+  }
+
+  isUnbond(arg: TxMethod['args']): arg is UnbondArgs {
+    return (arg as UnbondArgs).value !== undefined;
+  }
+
+  isWithdrawUnbonded(arg: TxMethod['args']): arg is WithdrawUnbondedArgs {
+    return (arg as WithdrawUnbondedArgs).numSlashingSpans !== undefined;
+  }
+
+  isBatch(arg: TxMethod['args']): arg is BatchArgs {
+    return (arg as BatchArgs).calls !== undefined && Array.isArray((arg as BatchArgs).calls);
+  }
+
   /**
    * extracts and returns the signature in hex format given a raw signed transaction
    *