@bitgo-beta/sdk-coin-polyx 1.0.0-alpha.21 → 1.0.0-alpha.211

package/dist/src/lib/txnSchema.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RegisterDidWithCDDTransactionSchema = void 0;
+exports.WithdrawUnbondedTransactionSchema = exports.UnbondTransactionSchema = exports.BatchUnstakingTransactionSchema = exports.bondSchema = exports.V8BatchTransactionSchema = exports.BatchTransactionSchema = exports.NominateTransactionSchema = exports.BondExtraTransactionSchema = exports.RejectInstructionTransactionSchema = exports.V8AddAndAffirmWithMediatorsTransactionSchema = exports.AddAndAffirmWithMediatorsTransactionSchema = exports.PreApproveAssetTransactionSchema = exports.RegisterDidTransactionSchema = exports.RegisterDidWithCDDTransactionSchema = void 0;
 const joi_1 = __importDefault(require("joi"));
 const utils_1 = __importDefault(require("./utils"));
 const addressSchema = joi_1.default.string().custom((addr) => utils_1.default.isValidAddress(addr));
@@ -12,4 +12,233 @@ exports.RegisterDidWithCDDTransactionSchema = joi_1.default.object({
     secondaryKeys: joi_1.default.array().length(0).required(),
     expiry: joi_1.default.valid(null).required(),
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHhuU2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi90eG5TY2hlbWEudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7O0FBQUEsOENBQXNCO0FBQ3RCLG9EQUE0QjtBQUU1QixNQUFNLGFBQWEsR0FBRyxhQUFHLENBQUMsTUFBTSxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQyxlQUFLLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7QUFFbkUsUUFBQSxtQ0FBbUMsR0FBRyxhQUFHLENBQUMsTUFBTSxDQUFDO0lBQzVELGFBQWEsRUFBRSxhQUFhLENBQUMsUUFBUSxFQUFFO0lBQ3ZDLGFBQWEsRUFBRSxhQUFHLENBQUMsS0FBSyxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLFFBQVEsRUFBRTtJQUMvQyxNQUFNLEVBQUUsYUFBRyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLEVBQUU7Q0FDbkMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IGpvaSBmcm9tICdqb2knO1xuaW1wb3J0IFV0aWxzIGZyb20gJy4vdXRpbHMnO1xuXG5jb25zdCBhZGRyZXNzU2NoZW1hID0gam9pLnN0cmluZygpLmN1c3RvbSgoYWRkcikgPT4gVXRpbHMuaXNWYWxpZEFkZHJlc3MoYWRkcikpO1xuXG5leHBvcnQgY29uc3QgUmVnaXN0ZXJEaWRXaXRoQ0REVHJhbnNhY3Rpb25TY2hlbWEgPSBqb2kub2JqZWN0KHtcbiAgdGFyZ2V0QWNjb3VudDogYWRkcmVzc1NjaGVtYS5yZXF1aXJlZCgpLFxuICBzZWNvbmRhcnlLZXlzOiBqb2kuYXJyYXkoKS5sZW5ndGgoMCkucmVxdWlyZWQoKSxcbiAgZXhwaXJ5OiBqb2kudmFsaWQobnVsbCkucmVxdWlyZWQoKSxcbn0pO1xuIl19
+// v8 identity.registerDid — unlike the v7 CDD path, this call only carries targetAccount
+// (verified against the real testnetV8Material metadata; no secondaryKeys/expiry fields).
+exports.RegisterDidTransactionSchema = joi_1.default.object({
+    targetAccount: addressSchema.required(),
+});
+exports.PreApproveAssetTransactionSchema = joi_1.default.object({
+    assetId: joi_1.default.string().required(),
+});
+exports.AddAndAffirmWithMediatorsTransactionSchema = joi_1.default.object({
+    venueId: joi_1.default.valid(null).required(),
+    settlementType: joi_1.default
+        .object({
+        settleOnAffirmation: joi_1.default.valid(null),
+    })
+        .required(),
+    tradeDate: joi_1.default.valid(null).required(),
+    valueDate: joi_1.default.valid(null).required(),
+    legs: joi_1.default
+        .array()
+        .items(joi_1.default.object({
+        fungible: joi_1.default
+            .object({
+            sender: joi_1.default
+                .object({
+                did: addressSchema.required(),
+                kind: joi_1.default
+                    .object({
+                    default: joi_1.default.valid(null),
+                })
+                    .required(),
+            })
+                .required(),
+            receiver: joi_1.default
+                .object({
+                did: addressSchema.required(),
+                kind: joi_1.default
+                    .object({
+                    default: joi_1.default.valid(null),
+                })
+                    .required(),
+            })
+                .required(),
+            assetId: joi_1.default.string().required(),
+            amount: joi_1.default.number().required(),
+        })
+            .required(),
+    }))
+        .required(),
+    portfolios: joi_1.default
+        .array()
+        .items(joi_1.default.object({
+        did: addressSchema.required(),
+        kind: joi_1.default
+            .object({
+            default: joi_1.default.valid(null),
+        })
+            .required(),
+    }))
+        .required(),
+    instructionMemo: joi_1.default.string().required(),
+    mediators: joi_1.default.array().length(0).required(),
+});
+// v8 settlement.addAndAffirmWithMediators — legs/holderSet wrap the DID+kind in an AssetHolder
+// enum. Decoded shape lowercases the variant name (`portfolio`, not `Portfolio`) — verified by
+// round-tripping a sample value through the real v8 testnet metadata registry.
+const assetHolderSchema = joi_1.default.object({
+    portfolio: joi_1.default
+        .object({
+        did: addressSchema.required(),
+        kind: joi_1.default
+            .object({
+            default: joi_1.default.valid(null),
+        })
+            .required(),
+    })
+        .required(),
+});
+exports.V8AddAndAffirmWithMediatorsTransactionSchema = joi_1.default.object({
+    venueId: joi_1.default.valid(null).required(),
+    settlementType: joi_1.default
+        .object({
+        settleOnAffirmation: joi_1.default.valid(null),
+    })
+        .required(),
+    tradeDate: joi_1.default.valid(null).required(),
+    valueDate: joi_1.default.valid(null).required(),
+    legs: joi_1.default
+        .array()
+        .items(joi_1.default.object({
+        fungible: joi_1.default
+            .object({
+            sender: assetHolderSchema.required(),
+            receiver: assetHolderSchema.required(),
+            assetId: joi_1.default.string().required(),
+            amount: joi_1.default.number().required(),
+        })
+            .required(),
+    }))
+        .required(),
+    holderSet: joi_1.default.array().items(assetHolderSchema).required(),
+    instructionMemo: joi_1.default.string().required(),
+    mediators: joi_1.default.array().length(0).required(),
+});
+exports.RejectInstructionTransactionSchema = joi_1.default.object({
+    id: joi_1.default.string().required(),
+    portfolio: joi_1.default
+        .object({
+        did: addressSchema.required(),
+        kind: joi_1.default
+            .object({
+            default: joi_1.default.valid(null),
+        })
+            .required(),
+    })
+        .required(),
+    numberOfAssets: joi_1.default
+        .object({
+        fungible: joi_1.default.number().required(),
+        nonFungible: joi_1.default.number().required(),
+        offChain: joi_1.default.number().required(),
+    })
+        .optional(),
+});
+// For standalone bondExtra transactions
+exports.BondExtraTransactionSchema = joi_1.default.object({
+    value: joi_1.default.string().required(),
+});
+// For nominate transactions (standalone or in batch)
+exports.NominateTransactionSchema = joi_1.default.object({
+    validators: joi_1.default.array().items(addressSchema).min(1).max(16).required(),
+});
+// For batch validation
+exports.BatchTransactionSchema = {
+    validate: (value) => joi_1.default
+        .object({
+        amount: joi_1.default.string().required(),
+        controller: addressSchema.required(),
+        // Payee can be a string or an object with Account property
+        payee: joi_1.default
+            .alternatives()
+            .try(joi_1.default.string(), joi_1.default.object({
+            Account: addressSchema,
+        }))
+            .required(),
+        validators: joi_1.default.array().items(addressSchema).min(1).max(16).required(),
+    })
+        .validate(value),
+    validateBond: (value) => joi_1.default
+        .object({
+        value: joi_1.default.string().required(),
+        controller: addressSchema.required(),
+        payee: joi_1.default
+            .alternatives()
+            .try(joi_1.default.string(), joi_1.default.object({
+            Account: addressSchema,
+        }))
+            .required(),
+    })
+        .validate(value),
+    validateNominate: (value) => joi_1.default
+        .object({
+        validators: joi_1.default.array().items(addressSchema).min(1).max(16).required(),
+    })
+        .validate(value),
+};
+// v8 batch validation — mirrors BatchTransactionSchema but drops the `controller` field, which
+// v8 staking.bond no longer encodes.
+exports.V8BatchTransactionSchema = {
+    validate: (value) => joi_1.default
+        .object({
+        amount: joi_1.default.string().required(),
+        // Payee can be a string or an object with Account property
+        payee: joi_1.default
+            .alternatives()
+            .try(joi_1.default.string(), joi_1.default.object({
+            Account: addressSchema,
+        }))
+            .required(),
+        validators: joi_1.default.array().items(addressSchema).min(1).max(16).required(),
+    })
+        .validate(value),
+    validateBond: (value) => joi_1.default
+        .object({
+        value: joi_1.default.string().required(),
+        payee: joi_1.default
+            .alternatives()
+            .try(joi_1.default.string(), joi_1.default.object({
+            Account: addressSchema,
+        }))
+            .required(),
+    })
+        .validate(value),
+    validateNominate: (value) => joi_1.default
+        .object({
+        validators: joi_1.default.array().items(addressSchema).min(1).max(16).required(),
+    })
+        .validate(value),
+};
+exports.bondSchema = joi_1.default.object({
+    value: joi_1.default.string().required(),
+    controller: addressSchema.required(),
+    payee: joi_1.default
+        .alternatives()
+        .try(joi_1.default.string().valid('Staked', 'Stash', 'Controller'), joi_1.default.object({
+        Account: addressSchema.required(),
+    }))
+        .required(),
+});
+exports.BatchUnstakingTransactionSchema = {
+    validate: (value) => joi_1.default
+        .object({
+        value: joi_1.default.string().required(),
+    })
+        .validate(value),
+};
+exports.UnbondTransactionSchema = {
+    validate: (value) => joi_1.default
+        .object({
+        value: joi_1.default.string().required(),
+    })
+        .validate(value),
+};
+exports.WithdrawUnbondedTransactionSchema = {
+    validate: (value) => joi_1.default
+        .object({
+        slashingSpans: joi_1.default.number().min(0).required(),
+    })
+        .validate(value),
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"txnSchema.js","sourceRoot":"","sources":["../../../src/lib/txnSchema.ts"],"names":[],"mappings":"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","sourcesContent":["import joi from 'joi';\nimport Utils from './utils';\n\nexport type BatchValidationObject = {\n  amount: string;\n  controller: string;\n  payee: string | { Account: string };\n  validators: string[];\n};\n\nexport type BondValidationObject = {\n  value: string;\n  controller: string;\n  payee: string | { Account: string };\n};\n\nexport type NominateValidationObject = {\n  validators: string[];\n};\n\n// v8 bond/batch validation objects — no `controller` (stash is its own controller in v8).\nexport type V8BatchValidationObject = {\n  amount: string;\n  payee: string | { Account: string };\n  validators: string[];\n};\n\nexport type V8BondValidationObject = {\n  value: string;\n  payee: string | { Account: string };\n};\n\nexport type BondExtraValidationObject = {\n  value: string;\n};\n\nconst addressSchema = joi.string().custom((addr) => Utils.isValidAddress(addr));\n\nexport const RegisterDidWithCDDTransactionSchema = joi.object({\n  targetAccount: addressSchema.required(),\n  secondaryKeys: joi.array().length(0).required(),\n  expiry: joi.valid(null).required(),\n});\n\n// v8 identity.registerDid — unlike the v7 CDD path, this call only carries targetAccount\n// (verified against the real testnetV8Material metadata; no secondaryKeys/expiry fields).\nexport const RegisterDidTransactionSchema = joi.object({\n  targetAccount: addressSchema.required(),\n});\n\nexport const PreApproveAssetTransactionSchema = joi.object({\n  assetId: joi.string().required(),\n});\n\nexport const AddAndAffirmWithMediatorsTransactionSchema = joi.object({\n  venueId: joi.valid(null).required(),\n  settlementType: joi\n    .object({\n      settleOnAffirmation: joi.valid(null),\n    })\n    .required(),\n  tradeDate: joi.valid(null).required(),\n  valueDate: joi.valid(null).required(),\n  legs: joi\n    .array()\n    .items(\n      joi.object({\n        fungible: joi\n          .object({\n            sender: joi\n              .object({\n                did: addressSchema.required(),\n                kind: joi\n                  .object({\n                    default: joi.valid(null),\n                  })\n                  .required(),\n              })\n              .required(),\n            receiver: joi\n              .object({\n                did: addressSchema.required(),\n                kind: joi\n                  .object({\n                    default: joi.valid(null),\n                  })\n                  .required(),\n              })\n              .required(),\n            assetId: joi.string().required(),\n            amount: joi.number().required(),\n          })\n          .required(),\n      })\n    )\n    .required(),\n  portfolios: joi\n    .array()\n    .items(\n      joi.object({\n        did: addressSchema.required(),\n        kind: joi\n          .object({\n            default: joi.valid(null),\n          })\n          .required(),\n      })\n    )\n    .required(),\n  instructionMemo: joi.string().required(),\n  mediators: joi.array().length(0).required(),\n});\n\n// v8 settlement.addAndAffirmWithMediators — legs/holderSet wrap the DID+kind in an AssetHolder\n// enum. Decoded shape lowercases the variant name (`portfolio`, not `Portfolio`) — verified by\n// round-tripping a sample value through the real v8 testnet metadata registry.\nconst assetHolderSchema = joi.object({\n  portfolio: joi\n    .object({\n      did: addressSchema.required(),\n      kind: joi\n        .object({\n          default: joi.valid(null),\n        })\n        .required(),\n    })\n    .required(),\n});\n\nexport const V8AddAndAffirmWithMediatorsTransactionSchema = joi.object({\n  venueId: joi.valid(null).required(),\n  settlementType: joi\n    .object({\n      settleOnAffirmation: joi.valid(null),\n    })\n    .required(),\n  tradeDate: joi.valid(null).required(),\n  valueDate: joi.valid(null).required(),\n  legs: joi\n    .array()\n    .items(\n      joi.object({\n        fungible: joi\n          .object({\n            sender: assetHolderSchema.required(),\n            receiver: assetHolderSchema.required(),\n            assetId: joi.string().required(),\n            amount: joi.number().required(),\n          })\n          .required(),\n      })\n    )\n    .required(),\n  holderSet: joi.array().items(assetHolderSchema).required(),\n  instructionMemo: joi.string().required(),\n  mediators: joi.array().length(0).required(),\n});\n\nexport const RejectInstructionTransactionSchema = joi.object({\n  id: joi.string().required(),\n  portfolio: joi\n    .object({\n      did: addressSchema.required(),\n      kind: joi\n        .object({\n          default: joi.valid(null),\n        })\n        .required(),\n    })\n    .required(),\n  numberOfAssets: joi\n    .object({\n      fungible: joi.number().required(),\n      nonFungible: joi.number().required(),\n      offChain: joi.number().required(),\n    })\n    .optional(),\n});\n\n// For standalone bondExtra transactions\nexport const BondExtraTransactionSchema = joi.object({\n  value: joi.string().required(),\n});\n\n// For nominate transactions (standalone or in batch)\nexport const NominateTransactionSchema = joi.object({\n  validators: joi.array().items(addressSchema).min(1).max(16).required(),\n});\n\n// For batch validation\nexport const BatchTransactionSchema = {\n  validate: (value: BatchValidationObject): joi.ValidationResult =>\n    joi\n      .object({\n        amount: joi.string().required(),\n        controller: addressSchema.required(),\n        // Payee can be a string or an object with Account property\n        payee: joi\n          .alternatives()\n          .try(\n            joi.string(),\n            joi.object({\n              Account: addressSchema,\n            })\n          )\n          .required(),\n        validators: joi.array().items(addressSchema).min(1).max(16).required(),\n      })\n      .validate(value),\n\n  validateBond: (value: BondValidationObject): joi.ValidationResult =>\n    joi\n      .object({\n        value: joi.string().required(),\n        controller: addressSchema.required(),\n        payee: joi\n          .alternatives()\n          .try(\n            joi.string(),\n            joi.object({\n              Account: addressSchema,\n            })\n          )\n          .required(),\n      })\n      .validate(value),\n\n  validateNominate: (value: NominateValidationObject): joi.ValidationResult =>\n    joi\n      .object({\n        validators: joi.array().items(addressSchema).min(1).max(16).required(),\n      })\n      .validate(value),\n};\n\n// v8 batch validation — mirrors BatchTransactionSchema but drops the `controller` field, which\n// v8 staking.bond no longer encodes.\nexport const V8BatchTransactionSchema = {\n  validate: (value: V8BatchValidationObject): joi.ValidationResult =>\n    joi\n      .object({\n        amount: joi.string().required(),\n        // Payee can be a string or an object with Account property\n        payee: joi\n          .alternatives()\n          .try(\n            joi.string(),\n            joi.object({\n              Account: addressSchema,\n            })\n          )\n          .required(),\n        validators: joi.array().items(addressSchema).min(1).max(16).required(),\n      })\n      .validate(value),\n\n  validateBond: (value: V8BondValidationObject): joi.ValidationResult =>\n    joi\n      .object({\n        value: joi.string().required(),\n        payee: joi\n          .alternatives()\n          .try(\n            joi.string(),\n            joi.object({\n              Account: addressSchema,\n            })\n          )\n          .required(),\n      })\n      .validate(value),\n\n  validateNominate: (value: NominateValidationObject): joi.ValidationResult =>\n    joi\n      .object({\n        validators: joi.array().items(addressSchema).min(1).max(16).required(),\n      })\n      .validate(value),\n};\n\nexport const bondSchema = joi.object({\n  value: joi.string().required(),\n  controller: addressSchema.required(),\n  payee: joi\n    .alternatives()\n    .try(\n      joi.string().valid('Staked', 'Stash', 'Controller'),\n      joi.object({\n        Account: addressSchema.required(),\n      })\n    )\n    .required(),\n});\n\nexport const BatchUnstakingTransactionSchema = {\n  validate: (value: { value: string }): joi.ValidationResult =>\n    joi\n      .object({\n        value: joi.string().required(),\n      })\n      .validate(value),\n};\n\nexport const UnbondTransactionSchema = {\n  validate: (value: { value: string }): joi.ValidationResult =>\n    joi\n      .object({\n        value: joi.string().required(),\n      })\n      .validate(value),\n};\n\nexport const WithdrawUnbondedTransactionSchema = {\n  validate: (value: { slashingSpans: number }): joi.ValidationResult =>\n    joi\n      .object({\n        slashingSpans: joi.number().min(0).required(),\n      })\n      .validate(value),\n};\n"]}

package/dist/src/lib/unbondBuilder.d.ts

@@ -0,0 +1,37 @@
+import { Transaction } from './transaction';
+import { PolyxBaseBuilder } from './baseBuilder';
+import { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+export declare class UnbondBuilder extends PolyxBaseBuilder {
+    protected _amount: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    protected get transactionType(): TransactionType;
+    /**
+     * Build the unbond transaction
+     */
+    protected buildTransaction(): UnsignedTransaction;
+    /**
+     * Set the amount to unbond
+     */
+    amount(amount: string): this;
+    /**
+     * Get the amount to unbond
+     */
+    getAmount(): string;
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx): void;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    validateTransaction(tx: Transaction): void;
+    /**
+     * Validate the unbond fields
+     */
+    private validateFields;
+    /**
+     * Validates fields for testing
+     */
+    testValidateFields(): void;
+}
+//# sourceMappingURL=unbondBuilder.d.ts.map

package/dist/src/lib/unbondBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unbondBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/unbondBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAExG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAA2B,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAQhF,qBAAa,aAAc,SAAQ,gBAAgB;IACjD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;OAEG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAYjD;;OAEG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,GAAG,IAAI;IAmBrF,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAcjE,kBAAkB;IAClB,mBAAmB,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI;IAK1C;;OAEG;IACH,OAAO,CAAC,cAAc;IAUtB;;OAEG;IACH,kBAAkB,IAAI,IAAI;CAG3B"}

package/dist/src/lib/unbondBuilder.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnbondBuilder = void 0;
+const baseBuilder_1 = require("./baseBuilder");
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const txnSchema_1 = require("./txnSchema");
+const utils_1 = __importDefault(require("./utils"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+// [CLEANUP-V8-OLD] v7 path — v7 metadata material. Retained as the Flipt rollback path alongside
+// V8UnbondBuilder (same logic, v8 material).
+class UnbondBuilder extends baseBuilder_1.PolyxBaseBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.material(utils_1.default.getMaterial(_coinConfig.network.type));
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingDeactivate;
+    }
+    /**
+     * Build the unbond transaction
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return txwrapper_polkadot_1.methods.staking.unbond({
+            value: this._amount,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+    }
+    /**
+     * Set the amount to unbond
+     */
+    amount(amount) {
+        this.validateValue(new bignumber_js_1.default(amount));
+        this._amount = amount;
+        return this;
+    }
+    /**
+     * Get the amount to unbond
+     */
+    getAmount() {
+        return this._amount;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn) {
+        const methodName = decodedTxn.method?.name;
+        if (methodName === 'unbond') {
+            const txMethod = decodedTxn.method.args;
+            const value = txMethod.value;
+            const validationResult = txnSchema_1.UnbondTransactionSchema.validate({
+                value,
+            });
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Invalid unbond transaction: ${validationResult.error.message}`);
+            }
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid transaction type: ${methodName}. Expected unbond`);
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        const methodName = this._method?.name;
+        if (methodName === 'unbond' && this._method) {
+            const txMethod = this._method.args;
+            this.amount(txMethod.value);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${methodName}. Expected unbond`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(tx) {
+        super.validateTransaction(tx);
+        this.validateFields();
+    }
+    /**
+     * Validate the unbond fields
+     */
+    validateFields() {
+        const validationResult = txnSchema_1.UnbondTransactionSchema.validate({
+            value: this._amount,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid unbond transaction: ${validationResult.error.message}`);
+        }
+    }
+    /**
+     * Validates fields for testing
+     */
+    testValidateFields() {
+        this.validateFields();
+    }
+}
+exports.UnbondBuilder = UnbondBuilder;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/lib/utils.d.ts

@@ -1,7 +1,47 @@
 import { Utils as SubstrateUtils, Interface } from '@bitgo-beta/abstract-substrate';
 import { NetworkType } from '@bitgo-beta/statics';
+import { TypeRegistry } from '@substrate/txwrapper-core/lib/types';
+import { BatchCallObject } from './iface';
 export declare class Utils extends SubstrateUtils {
+    /**
+     * Get the appropriate address format based on network type
+     * Returns 12 for mainnet and 42 for testnet
+     *
+     * @param coinName The name of the coin
+     * @returns The address format to use
+     */
+    getAddressFormat(coinName: string): number;
+    /**
+     * Checks if a string is a valid Polymesh DID (Decentralized Identifier)
+     * DIDs are 32-byte hex strings (0x prefix + 64 hex characters)
+     *
+     * @param {string} did - The string to validate
+     * @returns {boolean} true if valid DID format, false otherwise
+     */
+    isValidDid(did: string): boolean;
+    /**
+     * Encode a memo string using the NEW Polymesh format:
+     * UTF-8 bytes right-padded with 0x00 to 32 bytes, returned as a 0x-prefixed hex string.
+     *
+     * @param text The intended memo string
+     * @returns 0x-prefixed 66-character hex string representing the 32-byte encoded memo
+     */
+    encodeMemoNew(text: string): string;
+    /**
+     * Detect whether a decoded 32-byte memo (0x-prefixed hex from txwrapper decode()) uses NEW encoding.
+     *
+     * Detection rules (see problem.md):
+     * - Any 0x00 byte → NEW (null right-padding)
+     * - All 0x30 bytes → OLD (memo "0" in ASCII-left-padded form)
+     * - Leading 0x30 bytes then non-0x30 content → OLD (ASCII '0' left-padding)
+     * - Otherwise → NEW (content at byte 0, full 32-byte memo, or no ASCII pad)
+     *
+     * @param memo 0x-prefixed 66-char hex string as returned by txwrapper decode()
+     */
+    isNewMemoEncoding(memo: string): boolean;
     getMaterial(networkType: NetworkType): Interface.Material;
+    getV8Material(networkType: NetworkType): Interface.Material;
+    decodeMethodName(call: BatchCallObject, registry: TypeRegistry): string;
 }
 declare const utils: Utils;
 export default utils;

package/dist/src/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,cAAc,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAGlD,qBAAa,KAAM,SAAQ,cAAc;IACvC,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC,QAAQ;CAG1D;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAC1B,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,IAAI,cAAc,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAC;AACpF,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C,qBAAa,KAAM,SAAQ,cAAc;IACvC;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK1C;;;;;;OAMG;IACH,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC;;;;;;OAMG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IASnC;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAiBxC,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC,QAAQ;IAIzD,aAAa,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC,QAAQ;IAM3D,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,MAAM;CA0BxE;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAC1B,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -4,12 +4,105 @@ exports.Utils = void 0;
 const abstract_substrate_1 = require("@bitgo-beta/abstract-substrate");
 const statics_1 = require("@bitgo-beta/statics");
 const resources_1 = require("../resources");
+const constants_1 = require("./constants");
 class Utils extends abstract_substrate_1.Utils {
+    /**
+     * Get the appropriate address format based on network type
+     * Returns 12 for mainnet and 42 for testnet
+     *
+     * @param coinName The name of the coin
+     * @returns The address format to use
+     */
+    getAddressFormat(coinName) {
+        const isMainnet = coinName.toLowerCase() === 'polyx';
+        return isMainnet ? 12 : 42;
+    }
+    /**
+     * Checks if a string is a valid Polymesh DID (Decentralized Identifier)
+     * DIDs are 32-byte hex strings (0x prefix + 64 hex characters)
+     *
+     * @param {string} did - The string to validate
+     * @returns {boolean} true if valid DID format, false otherwise
+     */
+    isValidDid(did) {
+        return constants_1.POLYX_DID_REGEX.test(did);
+    }
+    /**
+     * Encode a memo string using the NEW Polymesh format:
+     * UTF-8 bytes right-padded with 0x00 to 32 bytes, returned as a 0x-prefixed hex string.
+     *
+     * @param text The intended memo string
+     * @returns 0x-prefixed 66-character hex string representing the 32-byte encoded memo
+     */
+    encodeMemoNew(text) {
+        const bytes = Buffer.from(text, 'utf8');
+        if (bytes.length > constants_1.MEMO_MAX_BYTES) {
+            throw new Error(`Memo exceeds maximum length of ${constants_1.MEMO_MAX_BYTES} bytes (got ${bytes.length} bytes)`);
+        }
+        const textHex = bytes.toString('hex');
+        return `0x${textHex.padEnd(64, '0')}`;
+    }
+    /**
+     * Detect whether a decoded 32-byte memo (0x-prefixed hex from txwrapper decode()) uses NEW encoding.
+     *
+     * Detection rules (see problem.md):
+     * - Any 0x00 byte → NEW (null right-padding)
+     * - All 0x30 bytes → OLD (memo "0" in ASCII-left-padded form)
+     * - Leading 0x30 bytes then non-0x30 content → OLD (ASCII '0' left-padding)
+     * - Otherwise → NEW (content at byte 0, full 32-byte memo, or no ASCII pad)
+     *
+     * @param memo 0x-prefixed 66-char hex string as returned by txwrapper decode()
+     */
+    isNewMemoEncoding(memo) {
+        if (!constants_1.MEMO_HEX_REGEX.test(memo))
+            return false;
+        const bytes = Buffer.from(memo.slice(2), 'hex');
+        if (bytes.some((b) => b === 0x00))
+            return true;
+        if (bytes.every((b) => b === 0x30))
+            return false;
+        let leadingAsciiZeros = 0;
+        while (leadingAsciiZeros < bytes.length && bytes[leadingAsciiZeros] === 0x30) {
+            leadingAsciiZeros++;
+        }
+        if (leadingAsciiZeros > 0 && leadingAsciiZeros < bytes.length)
+            return false;
+        return true;
+    }
     getMaterial(networkType) {
         return (networkType === statics_1.NetworkType.MAINNET ? resources_1.mainnetMaterial : resources_1.testnetMaterial);
     }
+    getV8Material(networkType) {
+        return (networkType === statics_1.NetworkType.MAINNET
+            ? resources_1.mainnetV8Material
+            : resources_1.testnetV8Material);
+    }
+    decodeMethodName(call, registry) {
+        // Handle both callIndex and method formats
+        const callWithIndex = call;
+        const methodIdentifier = callWithIndex.callIndex || call.method;
+        if (typeof methodIdentifier === 'string') {
+            // Check if it looks like a hex callIndex
+            if (methodIdentifier.startsWith('0x') && methodIdentifier.length > 2) {
+                try {
+                    const decodedCall = registry.findMetaCall(new Uint8Array(Buffer.from(methodIdentifier.replace('0x', ''), 'hex')));
+                    return decodedCall.method;
+                }
+                catch (e) {
+                    // Fallback: assume it's already the method name
+                    return methodIdentifier;
+                }
+            }
+            else {
+                // Already a simple method name
+                return methodIdentifier;
+            }
+        }
+        // Fallback
+        return String(methodIdentifier);
+    }
 }
 exports.Utils = Utils;
 const utils = new Utils();
 exports.default = utils;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHVFQUFvRjtBQUNwRixpREFBa0Q7QUFDbEQsNENBQWdFO0FBRWhFLE1BQWEsS0FBTSxTQUFRLDBCQUFjO0lBQ3ZDLFdBQVcsQ0FBQyxXQUF3QjtRQUNsQyxPQUFPLENBQUMsV0FBVyxLQUFLLHFCQUFXLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQywyQkFBZSxDQUFDLENBQUMsQ0FBQywyQkFBZSxDQUFrQyxDQUFDO0lBQ3BILENBQUM7Q0FDRjtBQUpELHNCQUlDO0FBRUQsTUFBTSxLQUFLLEdBQUcsSUFBSSxLQUFLLEVBQUUsQ0FBQztBQUMxQixrQkFBZSxLQUFLLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBVdGlscyBhcyBTdWJzdHJhdGVVdGlscywgSW50ZXJmYWNlIH0gZnJvbSAnQGJpdGdvLWJldGEvYWJzdHJhY3Qtc3Vic3RyYXRlJztcbmltcG9ydCB7IE5ldHdvcmtUeXBlIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5pbXBvcnQgeyBtYWlubmV0TWF0ZXJpYWwsIHRlc3RuZXRNYXRlcmlhbCB9IGZyb20gJy4uL3Jlc291cmNlcyc7XG5cbmV4cG9ydCBjbGFzcyBVdGlscyBleHRlbmRzIFN1YnN0cmF0ZVV0aWxzIHtcbiAgZ2V0TWF0ZXJpYWwobmV0d29ya1R5cGU6IE5ldHdvcmtUeXBlKTogSW50ZXJmYWNlLk1hdGVyaWFsIHtcbiAgICByZXR1cm4gKG5ldHdvcmtUeXBlID09PSBOZXR3b3JrVHlwZS5NQUlOTkVUID8gbWFpbm5ldE1hdGVyaWFsIDogdGVzdG5ldE1hdGVyaWFsKSBhcyB1bmtub3duIGFzIEludGVyZmFjZS5NYXRlcmlhbDtcbiAgfVxufVxuXG5jb25zdCB1dGlscyA9IG5ldyBVdGlscygpO1xuZXhwb3J0IGRlZmF1bHQgdXRpbHM7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { Utils as SubstrateUtils, Interface } from '@bitgo-beta/abstract-substrate';\nimport { NetworkType } from '@bitgo-beta/statics';\nimport { TypeRegistry } from '@substrate/txwrapper-core/lib/types';\nimport { mainnetMaterial, testnetMaterial, mainnetV8Material, testnetV8Material } from '../resources';\nimport { BatchCallObject } from './iface';\nimport { MEMO_HEX_REGEX, MEMO_MAX_BYTES, POLYX_DID_REGEX } from './constants';\n\nexport class Utils extends SubstrateUtils {\n  /**\n   * Get the appropriate address format based on network type\n   * Returns 12 for mainnet and 42 for testnet\n   *\n   * @param coinName The name of the coin\n   * @returns The address format to use\n   */\n  getAddressFormat(coinName: string): number {\n    const isMainnet = coinName.toLowerCase() === 'polyx';\n    return isMainnet ? 12 : 42;\n  }\n\n  /**\n   * Checks if a string is a valid Polymesh DID (Decentralized Identifier)\n   * DIDs are 32-byte hex strings (0x prefix + 64 hex characters)\n   *\n   * @param {string} did - The string to validate\n   * @returns {boolean} true if valid DID format, false otherwise\n   */\n  isValidDid(did: string): boolean {\n    return POLYX_DID_REGEX.test(did);\n  }\n\n  /**\n   * Encode a memo string using the NEW Polymesh format:\n   * UTF-8 bytes right-padded with 0x00 to 32 bytes, returned as a 0x-prefixed hex string.\n   *\n   * @param text The intended memo string\n   * @returns 0x-prefixed 66-character hex string representing the 32-byte encoded memo\n   */\n  encodeMemoNew(text: string): string {\n    const bytes = Buffer.from(text, 'utf8');\n    if (bytes.length > MEMO_MAX_BYTES) {\n      throw new Error(`Memo exceeds maximum length of ${MEMO_MAX_BYTES} bytes (got ${bytes.length} bytes)`);\n    }\n    const textHex = bytes.toString('hex');\n    return `0x${textHex.padEnd(64, '0')}`;\n  }\n\n  /**\n   * Detect whether a decoded 32-byte memo (0x-prefixed hex from txwrapper decode()) uses NEW encoding.\n   *\n   * Detection rules (see problem.md):\n   * - Any 0x00 byte → NEW (null right-padding)\n   * - All 0x30 bytes → OLD (memo \"0\" in ASCII-left-padded form)\n   * - Leading 0x30 bytes then non-0x30 content → OLD (ASCII '0' left-padding)\n   * - Otherwise → NEW (content at byte 0, full 32-byte memo, or no ASCII pad)\n   *\n   * @param memo 0x-prefixed 66-char hex string as returned by txwrapper decode()\n   */\n  isNewMemoEncoding(memo: string): boolean {\n    if (!MEMO_HEX_REGEX.test(memo)) return false;\n\n    const bytes = Buffer.from(memo.slice(2), 'hex');\n\n    if (bytes.some((b) => b === 0x00)) return true;\n    if (bytes.every((b) => b === 0x30)) return false;\n\n    let leadingAsciiZeros = 0;\n    while (leadingAsciiZeros < bytes.length && bytes[leadingAsciiZeros] === 0x30) {\n      leadingAsciiZeros++;\n    }\n    if (leadingAsciiZeros > 0 && leadingAsciiZeros < bytes.length) return false;\n\n    return true;\n  }\n\n  getMaterial(networkType: NetworkType): Interface.Material {\n    return (networkType === NetworkType.MAINNET ? mainnetMaterial : testnetMaterial) as unknown as Interface.Material;\n  }\n\n  getV8Material(networkType: NetworkType): Interface.Material {\n    return (networkType === NetworkType.MAINNET\n      ? mainnetV8Material\n      : testnetV8Material) as unknown as Interface.Material;\n  }\n\n  decodeMethodName(call: BatchCallObject, registry: TypeRegistry): string {\n    // Handle both callIndex and method formats\n    const callWithIndex = call as BatchCallObject & { callIndex?: string };\n    const methodIdentifier = callWithIndex.callIndex || call.method;\n\n    if (typeof methodIdentifier === 'string') {\n      // Check if it looks like a hex callIndex\n      if (methodIdentifier.startsWith('0x') && methodIdentifier.length > 2) {\n        try {\n          const decodedCall = registry.findMetaCall(\n            new Uint8Array(Buffer.from(methodIdentifier.replace('0x', ''), 'hex'))\n          );\n          return decodedCall.method;\n        } catch (e) {\n          // Fallback: assume it's already the method name\n          return methodIdentifier;\n        }\n      } else {\n        // Already a simple method name\n        return methodIdentifier;\n      }\n    }\n\n    // Fallback\n    return String(methodIdentifier);\n  }\n}\n\nconst utils = new Utils();\nexport default utils;\n"]}