feat: add stakingBuilder (bond and bondExtra) for polyx

abhijit0943 · abhijit0943 · commit 06912364d3ce · 2025-05-14T16:27:43.000+05:30
TICKET: SC-1826
diff --git a/modules/sdk-coin-polyx/src/lib/iface.ts b/modules/sdk-coin-polyx/src/lib/iface.ts
@@ -5,3 +5,13 @@ export interface RegisterDidWithCDDArgs extends Args {
   secondaryKeys: [];
   expiry: null;
 }
+
+export interface BondArgs extends Args {
+  controller: string;
+  value: string;
+  payee: string;
+}
+
+export interface BondExtraArgs extends Args {
+  maxAdditional: string;
+}
diff --git a/modules/sdk-coin-polyx/src/lib/index.ts b/modules/sdk-coin-polyx/src/lib/index.ts
@@ -11,4 +11,5 @@ export {
 export { TransactionBuilderFactory } from './transactionBuilderFactory';
 export { TransferBuilder } from './transferBuilder';
 export { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
+export { StakingBuilder } from './stakingBuilder';
 export { Utils, default as utils } from './utils';
diff --git a/modules/sdk-coin-polyx/src/lib/stakingBuilder.ts b/modules/sdk-coin-polyx/src/lib/stakingBuilder.ts
@@ -0,0 +1,192 @@
+import BigNumber from 'bignumber.js';
+import { TransactionBuilder, Transaction } from '@bitgo/abstract-substrate';
+import { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';
+import { methods } from '@substrate/txwrapper-polkadot';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { BaseAddress, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';
+import { StakingTransactionSchema } from './txnSchema';
+import utils from './utils';
+import { BondArgs, BondExtraArgs } from './iface';
+
+export interface StakingParams {
+  amount: string;
+  controller?: string;
+  payee?: string;
+  addToStake?: boolean;
+}
+
+export class StakingBuilder extends TransactionBuilder {
+  protected _amount: string;
+  protected _controller: string;
+  protected _payee: string;
+  protected _addToStake: boolean;
+
+  constructor(_coinConfig: Readonly<CoinConfig>) {
+    super(_coinConfig);
+    this.material(utils.getMaterial(_coinConfig.network.type));
+  }
+
+  protected get transactionType(): TransactionType {
+    return TransactionType.StakingActivate;
+  }
+
+  /**
+   * Build the appropriate staking transaction based on whether we're doing
+   * initial bonding or adding to an existing stake.
+   *
+   * @returns {UnsignedTransaction} The constructed unsigned staking transaction
+   */
+  protected buildTransaction(): UnsignedTransaction {
+    const baseTxInfo = this.createBaseTxInfo();
+
+    if (this._addToStake) {
+      return methods.staking.bondExtra(
+        {
+          maxAdditional: this._amount,
+        },
+        baseTxInfo.baseTxInfo,
+        baseTxInfo.options
+      );
+    } else {
+      return methods.staking.bond(
+        {
+          controller: this._controller || this._sender,
+          value: this._amount,
+          payee: this._payee || 'Staked',
+        },
+        baseTxInfo.baseTxInfo,
+        baseTxInfo.options
+      );
+    }
+  }
+
+  /**
+   * Set the staking amount.
+   *
+   * @param {string} amount - Amount to stake in smallest unit
+   * @returns {StakingBuilder} This staking builder
+   */
+  amount(amount: string): this {
+    this.validateValue(new BigNumber(amount));
+    this._amount = amount;
+    return this;
+  }
+
+  /**
+   * Set whether this is adding to an existing stake.
+   *
+   * @param {boolean} addToStake - true for bondExtra, false for initial bond
+   * @returns {StakingBuilder} This staking builder
+   */
+  addToStake(addToStake: boolean): this {
+    this._addToStake = addToStake;
+    return this;
+  }
+
+  /**
+   * The controller of the staked amount.
+   * Only applies to initial bonding.
+   *
+   * @param {BaseAddress} controller - Controller account address
+   * @returns {StakingBuilder} This staking builder
+   */
+  controller(controller: BaseAddress): this {
+    this.validateAddress(controller);
+    this._controller = controller.address;
+    return this;
+  }
+
+  /**
+   * The rewards destination of the staked amount.
+   * Only applies to initial bonding.
+   *
+   * @param {string} payee - Where rewards should be directed (e.g. 'Staked')
+   * @returns {StakingBuilder} This staking builder
+   */
+  payee(payee: string): this {
+    this._payee = payee;
+    return this;
+  }
+
+  /** @inheritdoc */
+  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx): void {
+    const methodName = decodedTxn.method?.name as string;
+
+    if (methodName === 'staking.bond') {
+      const txMethod = decodedTxn.method.args as unknown as BondArgs;
+      const value = txMethod.value;
+      const controller = txMethod.controller;
+      const payee = txMethod.payee;
+
+      const validationResult = StakingTransactionSchema.validate({
+        value,
+        controller,
+        payee,
+      });
+
+      if (validationResult.error) {
+        throw new InvalidTransactionError(`Invalid transaction: ${validationResult.error.message}`);
+      }
+    } else if (methodName === 'staking.bondExtra') {
+      const txMethod = decodedTxn.method.args as unknown as BondExtraArgs;
+      const value = txMethod.maxAdditional;
+
+      const validationResult = StakingTransactionSchema.validate({
+        value,
+        addToStake: true,
+      });
+
+      if (validationResult.error) {
+        throw new InvalidTransactionError(`Invalid transaction: ${validationResult.error.message}`);
+      }
+    } else {
+      throw new InvalidTransactionError(`Invalid transaction type: ${methodName}`);
+    }
+  }
+
+  /** @inheritdoc */
+  protected fromImplementation(rawTransaction: string): Transaction {
+    const tx = super.fromImplementation(rawTransaction);
+
+    const methodName = this._method?.name as string;
+
+    if (methodName === 'staking.bond' && this._method) {
+      const txMethod = this._method.args as unknown as BondArgs;
+      this.amount(txMethod.value);
+      this.controller({ address: txMethod.controller });
+      this.payee(txMethod.payee);
+    } else if (methodName === 'staking.bondExtra' && this._method) {
+      const txMethod = this._method.args as unknown as BondExtraArgs;
+      this.amount(txMethod.maxAdditional);
+      this.addToStake(true);
+    } else {
+      throw new InvalidTransactionError(
+        `Invalid Transaction Type: ${methodName}. Expected staking.bond or staking.bondExtra`
+      );
+    }
+
+    return tx;
+  }
+
+  /** @inheritdoc */
+  validateTransaction(tx: Transaction): void {
+    super.validateTransaction(tx);
+    this.validateFields();
+  }
+
+  /**
+   * Validate the builder fields.
+   */
+  private validateFields(): void {
+    const validationResult = StakingTransactionSchema.validate({
+      value: this._amount,
+      controller: this._controller,
+      payee: this._payee,
+      addToStake: this._addToStake,
+    });
+
+    if (validationResult.error) {
+      throw new InvalidTransactionError(`Invalid transaction: ${validationResult.error.message}`);
+    }
+  }
+}
diff --git a/modules/sdk-coin-polyx/src/lib/transactionBuilderFactory.ts b/modules/sdk-coin-polyx/src/lib/transactionBuilderFactory.ts
@@ -3,6 +3,7 @@ import { BaseCoin as CoinConfig } from '@bitgo/statics';
 import { decode } from '@substrate/txwrapper-polkadot';
 import { TransferBuilder } from './transferBuilder';
 import { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
+import { StakingBuilder } from './stakingBuilder';
 import utils from './utils';
 import { Interface, SingletonRegistry, TransactionBuilder } from './';
 
@@ -22,6 +23,10 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return new RegisterDidWithCDDBuilder(this._coinConfig).material(this._material);
   }
 
+  getStakingBuilder(): StakingBuilder {
+    return new StakingBuilder(this._coinConfig).material(this._material);
+  }
+
   getWalletInitializationBuilder(): void {
     throw new NotImplementedError(`walletInitialization for ${this._coinConfig.name} not implemented`);
   }
@@ -49,6 +54,8 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
       return this.getTransferBuilder();
     } else if (methodName === Interface.MethodNames.RegisterDidWithCDD) {
       return this.getRegisterDidWithCDDBuilder();
+    } else if (methodName === 'staking.bond' || methodName === 'staking.bondExtra') {
+      return this.getStakingBuilder();
     } else {
       throw new Error('Transaction cannot be parsed or has an unsupported transaction type');
     }
diff --git a/modules/sdk-coin-polyx/src/lib/txnSchema.ts b/modules/sdk-coin-polyx/src/lib/txnSchema.ts
@@ -8,3 +8,18 @@ export const RegisterDidWithCDDTransactionSchema = joi.object({
   secondaryKeys: joi.array().length(0).required(),
   expiry: joi.valid(null).required(),
 });
+
+export const StakingTransactionSchema = joi.object({
+  value: joi.string().required(),
+  controller: joi.alternatives().conditional('addToStake', {
+    is: true,
+    then: joi.optional(),
+    otherwise: addressSchema.required(),
+  }),
+  payee: joi.alternatives().conditional('addToStake', {
+    is: true,
+    then: joi.optional(),
+    otherwise: joi.string().required(),
+  }),
+  addToStake: joi.boolean().optional(),
+});
diff --git a/modules/sdk-coin-polyx/src/polyx.ts b/modules/sdk-coin-polyx/src/polyx.ts
@@ -11,6 +11,7 @@ import {
 } from '@bitgo/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo/statics';
 import { SubstrateCoin } from '@bitgo/abstract-substrate';
+import { StakingBuilder } from './lib/stakingBuilder';
 
 export class Polyx extends SubstrateCoin {
   protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
@@ -70,4 +71,8 @@ export class Polyx extends SubstrateCoin {
   signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {
     throw new Error('Method not implemented.');
   }
+
+  stake(): StakingBuilder {
+    return this.getBuilder().getStakingBuilder();
+  }
 }
diff --git a/modules/sdk-coin-polyx/test/resources/index.ts b/modules/sdk-coin-polyx/test/resources/index.ts
@@ -40,4 +40,18 @@ export const rawTx = {
   },
 };
 
+export const stakingTx = {
+  bond: {
+    unsigned: '0x9c04110000bec110eab4d327d3b2b6bb68e888654a474694d3935ce35bd3926e4bc7ebd538419c00',
+    signed:
+      '0x35028400bec110eab4d327d3b2b6bb68e888654a474694d3935ce35bd3926e4bc7ebd5380100066429bde7f75f50a792dba137a524611debd57018c908f8daa6f94a6e246ac60d839b69f0f7df6f916913d9dccb709ad56857f866c3775d7ffcb5d764f38fe5020c00110000bec110eab4d327d3b2b6bb68e888654a474694d3935ce35bd3926e4bc7ebd538419c00',
+  },
+  bondExtra: {
+    unsigned:
+      '0xad018400bec110eab4d327d3b2b6bb68e888654a474694d3935ce35bd3926e4bc7ebd53801201199a43e8ee9fec776ac0045120e54b61edd4da8b949993772c7d0184e682a5fd3e2f64e0164a10b9ff837928c8b658398b292012bab5b7a377e654a302b81750108001101a10f',
+    signed:
+      '0xad018400bec110eab4d327d3b2b6bb68e888654a474694d3935ce35bd3926e4bc7ebd53801201199a43e8ee9fec776ac0045120e54b61edd4da8b949993772c7d0184e682a5fd3e2f64e0164a10b9ff837928c8b658398b292012bab5b7a377e654a302b81750108001101a10f',
+  },
+};
+
 export const { txVersion, specVersion, genesisHash, chainName, specName } = Networks.test.polyx;
diff --git a/modules/sdk-coin-polyx/test/unit/transactionBuilder/stakingBuilder.ts b/modules/sdk-coin-polyx/test/unit/transactionBuilder/stakingBuilder.ts
