feat(sdk-coin-polyx): add v8 staking builders

modules/sdk-coin-polyx/src/lib/batchStakingBuilder.ts

@@ -25,6 +25,9 @@ type ControllerValue = string | DecodedController;
 type PayeeValue = string | DecodedPayee;
 type AmountValue = string | number;
 
+// [CLEANUP-V8-OLD] v7 path — builds `utility.batchAll([bond, nominate])` with the 3-arg
+// `bond(controller, value, payee)` against v7 metadata. Retained as the Flipt rollback path
+// alongside V8BatchStakingBuilder (v8 2-arg `bond(value, payee)`).
 export class BatchStakingBuilder extends PolyxBaseBuilder {
   // For bond operation
   protected _amount: string;

modules/sdk-coin-polyx/src/lib/batchUnstakingBuilder.ts

@@ -9,6 +9,8 @@ import { BatchArgs } from './iface';
 import { BatchUnstakingTransactionSchema } from './txnSchema';
 import utils from './utils';
 
+// [CLEANUP-V8-OLD] v7 path — v7 metadata material. Retained as the Flipt rollback path alongside
+// V8BatchUnstakingBuilder (same logic, v8 material).
 export class BatchUnstakingBuilder extends PolyxBaseBuilder {
   protected _amount: string;
 

modules/sdk-coin-polyx/src/lib/bondExtraBuilder.ts

@@ -9,6 +9,8 @@ import utils from './utils';
 import { BondExtraArgs } from './iface';
 import BigNumber from 'bignumber.js';
 
+// [CLEANUP-V8-OLD] v7 path — v7 metadata material. Retained as the Flipt rollback path alongside
+// V8BondExtraBuilder (same logic, v8 material).
 export class BondExtraBuilder extends PolyxBaseBuilder {
   protected _amount: string;
 

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

@@ -215,12 +215,25 @@ export interface DecodedTx extends Omit<DecodedUnsignedTx, 'method'> {
   method: TxMethod;
 }
 
+// [CLEANUP-V8-OLD] v7 staking.bond args carry `controller` (bond(controller, value, payee)).
+// v8 drops the controller leg (stash is its own controller) — see V8BondArgs below. Kept for the
+// v7 BatchStakingBuilder rollback path.
 export interface BondArgs extends Args {
   value: string;
   controller: string;
   payee: string | { Account: string };
 }
 
+/**
+ * v8 staking.bond args. Polymesh v8 changed `bond(controller, value, payee)` to
+ * `bond(value, payee)` — the stash account is its own controller, so no `controller` field is
+ * encoded. Used by V8BatchStakingBuilder.
+ */
+export interface V8BondArgs extends Args {
+  value: string;
+  payee: string | { Account: string };
+}
+
 export interface BondExtraArgs extends Args {
   maxAdditional: string;
 }

modules/sdk-coin-polyx/src/lib/index.ts

@@ -31,11 +31,17 @@ export { V8RegisterDidBuilder } from './v8RegisterDidBuilder';
 export { V8TokenTransferBuilder } from './v8TokenTransferBuilder';
 export { V8HexTokenTransferBuilder } from './v8HexTokenTransferBuilder';
 export { V8PreApproveAssetBuilder } from './v8PreApproveAssetBuilder';
+export { V8BatchStakingBuilder } from './v8BatchStakingBuilder';
+export { V8BondExtraBuilder } from './v8BondExtraBuilder';
+export { V8UnbondBuilder } from './v8UnbondBuilder';
+export { V8BatchUnstakingBuilder } from './v8BatchUnstakingBuilder';
+export { V8WithdrawUnbondedBuilder } from './v8WithdrawUnbondedBuilder';
+export { V8NominateBuilder } from './v8NominateBuilder';
 import polyxUtils from './utils';
 export { Utils, default as utils } from './utils';
 export * from './iface';
 
-export { BondArgs, NominateArgs, BatchCallObject, BatchArgs } from './iface';
+export { BondArgs, V8BondArgs, NominateArgs, BatchCallObject, BatchArgs } from './iface';
 
 /**
  * Checks if a string is a valid Polymesh DID (Decentralized Identifier)

modules/sdk-coin-polyx/src/lib/nominateBuilder.ts

@@ -8,6 +8,8 @@ import { NominateTransactionSchema } from './txnSchema';
 import utils from './utils';
 import { NominateArgs } from './iface';
 
+// [CLEANUP-V8-OLD] v7 path — v7 metadata material. Retained as the Flipt rollback path alongside
+// V8NominateBuilder (same logic, v8 material).
 export class NominateBuilder extends PolyxBaseBuilder {
   protected _validators: string[] = [];
 

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

@@ -26,6 +26,12 @@ import { V8RegisterDidBuilder } from './v8RegisterDidBuilder';
 import { V8TokenTransferBuilder } from './v8TokenTransferBuilder';
 import { V8HexTokenTransferBuilder } from './v8HexTokenTransferBuilder';
 import { V8PreApproveAssetBuilder } from './v8PreApproveAssetBuilder';
+import { V8BatchStakingBuilder } from './v8BatchStakingBuilder';
+import { V8BondExtraBuilder } from './v8BondExtraBuilder';
+import { V8UnbondBuilder } from './v8UnbondBuilder';
+import { V8BatchUnstakingBuilder } from './v8BatchUnstakingBuilder';
+import { V8WithdrawUnbondedBuilder } from './v8WithdrawUnbondedBuilder';
+import { V8NominateBuilder } from './v8NominateBuilder';
 
 export type SupportedTransaction = BaseTransaction | PolyxTransaction;
 
@@ -117,6 +123,30 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
     return new V8PreApproveAssetBuilder(this._coinConfig);
   }
 
+  getV8BatchStakingBuilder(): V8BatchStakingBuilder {
+    return new V8BatchStakingBuilder(this._coinConfig);
+  }
+
+  getV8BondExtraBuilder(): V8BondExtraBuilder {
+    return new V8BondExtraBuilder(this._coinConfig);
+  }
+
+  getV8UnbondBuilder(): V8UnbondBuilder {
+    return new V8UnbondBuilder(this._coinConfig);
+  }
+
+  getV8BatchUnstakingBuilder(): V8BatchUnstakingBuilder {
+    return new V8BatchUnstakingBuilder(this._coinConfig);
+  }
+
+  getV8WithdrawUnbondedBuilder(): V8WithdrawUnbondedBuilder {
+    return new V8WithdrawUnbondedBuilder(this._coinConfig);
+  }
+
+  getV8NominateBuilder(): V8NominateBuilder {
+    return new V8NominateBuilder(this._coinConfig);
+  }
+
   getWalletInitializationBuilder(): void {
     throw new NotImplementedError(`walletInitialization for ${this._coinConfig.name} not implemented`);
   }
@@ -134,10 +164,24 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
 
   private getBuilder(rawTxn: string): TransactionBuilder<TxMethod, SupportedTransaction> {
     const registry = SingletonRegistry.getInstance(this._material);
-    const decodedTxn = decode(rawTxn, {
-      metadataRpc: this._material.metadata,
-      registry: registry,
-    });
+    let decodedTxn;
+    try {
+      decodedTxn = decode(rawTxn, {
+        metadataRpc: this._material.metadata,
+        registry: registry,
+      });
+    } catch (err) {
+      // v8-encoded transactions use different chain metadata and signed extensions, so they
+      // cannot be decoded with v7 material. Retry against v8 material and route to the matching
+      // v8 staking builder (e.g. batchAll([bond, nominate]) with the 2-arg v8 bond → no
+      // controller). Falls back to re-throwing the original v7 decode error if the transaction is
+      // not a recognized v8 staking transaction.
+      const v8Builder = this.tryGetV8Builder(rawTxn);
+      if (v8Builder) {
+        return v8Builder;
+      }
+      throw err;
+    }
 
     const methodName = decodedTxn.method?.name;
     if (methodName === Interface.MethodNames.TransferWithMemo) {
@@ -193,4 +237,53 @@ export class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
 
     throw new Error('Transaction cannot be parsed or has an unsupported transaction type');
   }
+
+  /**
+   * Attempt to decode a transaction against v8 chain metadata and return the matching v8 staking
+   * builder. Returns undefined when the transaction cannot be decoded with v8 material or is not a
+   * recognized v8 staking transaction, so the caller can surface the original v7 decode error.
+   */
+  private tryGetV8Builder(rawTxn: string): TransactionBuilder<TxMethod, SupportedTransaction> | undefined {
+    const v8Material = utils.getV8Material(this._coinConfig.network.type);
+    const registry = SingletonRegistry.getInstance(v8Material);
+    let decodedTxn;
+    try {
+      decodedTxn = decode(rawTxn, {
+        metadataRpc: v8Material.metadata,
+        registry: registry,
+      });
+    } catch (e) {
+      return undefined;
+    }
+
+    const methodName = decodedTxn.method?.name;
+    if (methodName === 'batchAll') {
+      const args = decodedTxn.method.args as { calls?: BatchCallObject[] };
+
+      if (args.calls && args.calls.length === 2) {
+        const firstCallMethod = utils.decodeMethodName(args.calls[0], registry);
+        const secondCallMethod = utils.decodeMethodName(args.calls[1], registry);
+
+        // v8 batch staking pattern: bond (2-arg, no controller) + nominate
+        if (firstCallMethod === 'bond' && secondCallMethod === 'nominate') {
+          return this.getV8BatchStakingBuilder();
+        }
+        // v8 batch unstaking pattern: chill + unbond
+        if (firstCallMethod === 'chill' && secondCallMethod === 'unbond') {
+          return this.getV8BatchUnstakingBuilder();
+        }
+      }
+      return this.getV8BatchStakingBuilder();
+    } else if (methodName === 'bondExtra') {
+      return this.getV8BondExtraBuilder();
+    } else if (methodName === 'nominate') {
+      return this.getV8NominateBuilder();
+    } else if (methodName === 'unbond') {
+      return this.getV8UnbondBuilder();
+    } else if (methodName === 'withdrawUnbonded') {
+      return this.getV8WithdrawUnbondedBuilder();
+    }
+
+    return undefined;
+  }
 }

modules/sdk-coin-polyx/src/lib/txnSchema.ts

@@ -18,6 +18,18 @@ export type NominateValidationObject = {
   validators: string[];
 };
 
+// v8 bond/batch validation objects — no `controller` (stash is its own controller in v8).
+export type V8BatchValidationObject = {
+  amount: string;
+  payee: string | { Account: string };
+  validators: string[];
+};
+
+export type V8BondValidationObject = {
+  value: string;
+  payee: string | { Account: string };
+};
+
 export type BondExtraValidationObject = {
   value: string;
 };
@@ -221,6 +233,51 @@ export const BatchTransactionSchema = {
       .validate(value),
 };
 
+// v8 batch validation — mirrors BatchTransactionSchema but drops the `controller` field, which
+// v8 staking.bond no longer encodes.
+export const V8BatchTransactionSchema = {
+  validate: (value: V8BatchValidationObject): joi.ValidationResult =>
+    joi
+      .object({
+        amount: joi.string().required(),
+        // Payee can be a string or an object with Account property
+        payee: joi
+          .alternatives()
+          .try(
+            joi.string(),
+            joi.object({
+              Account: addressSchema,
+            })
+          )
+          .required(),
+        validators: joi.array().items(addressSchema).min(1).max(16).required(),
+      })
+      .validate(value),
+
+  validateBond: (value: V8BondValidationObject): joi.ValidationResult =>
+    joi
+      .object({
+        value: joi.string().required(),
+        payee: joi
+          .alternatives()
+          .try(
+            joi.string(),
+            joi.object({
+              Account: addressSchema,
+            })
+          )
+          .required(),
+      })
+      .validate(value),
+
+  validateNominate: (value: NominateValidationObject): joi.ValidationResult =>
+    joi
+      .object({
+        validators: joi.array().items(addressSchema).min(1).max(16).required(),
+      })
+      .validate(value),
+};
+
 export const bondSchema = joi.object({
   value: joi.string().required(),
   controller: addressSchema.required(),

modules/sdk-coin-polyx/src/lib/unbondBuilder.ts

@@ -9,6 +9,8 @@ import utils from './utils';
 import { UnbondArgs } from './iface';
 import BigNumber from 'bignumber.js';
 
+// [CLEANUP-V8-OLD] v7 path — v7 metadata material. Retained as the Flipt rollback path alongside
+// V8UnbondBuilder (same logic, v8 material).
 export class UnbondBuilder extends PolyxBaseBuilder {
   protected _amount: string;