@bitgo-beta/sdk-coin-polyx 1.0.0-alpha.7 → 1.0.0-alpha.70

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

@@ -0,0 +1,49 @@
+import joi from 'joi';
+export type BatchValidationObject = {
+    amount: string;
+    controller: string;
+    payee: string | {
+        Account: string;
+    };
+    validators: string[];
+};
+export type BondValidationObject = {
+    value: string;
+    controller: string;
+    payee: string | {
+        Account: string;
+    };
+};
+export type NominateValidationObject = {
+    validators: string[];
+};
+export type BondExtraValidationObject = {
+    value: string;
+};
+export declare const RegisterDidWithCDDTransactionSchema: joi.ObjectSchema<any>;
+export declare const PreApproveAssetTransactionSchema: joi.ObjectSchema<any>;
+export declare const AddAndAffirmWithMediatorsTransactionSchema: joi.ObjectSchema<any>;
+export declare const BondExtraTransactionSchema: joi.ObjectSchema<any>;
+export declare const NominateTransactionSchema: joi.ObjectSchema<any>;
+export declare const BatchTransactionSchema: {
+    validate: (value: BatchValidationObject) => joi.ValidationResult;
+    validateBond: (value: BondValidationObject) => joi.ValidationResult;
+    validateNominate: (value: NominateValidationObject) => joi.ValidationResult;
+};
+export declare const bondSchema: joi.ObjectSchema<any>;
+export declare const BatchUnstakingTransactionSchema: {
+    validate: (value: {
+        value: string;
+    }) => joi.ValidationResult;
+};
+export declare const UnbondTransactionSchema: {
+    validate: (value: {
+        value: string;
+    }) => joi.ValidationResult;
+};
+export declare const WithdrawUnbondedTransactionSchema: {
+    validate: (value: {
+        slashingSpans: number;
+    }) => joi.ValidationResult;
+};
+//# sourceMappingURL=txnSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"txnSchema.d.ts","sourceRoot":"","sources":["../../../src/lib/txnSchema.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAGtB,MAAM,MAAM,qBAAqB,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACpC,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAIF,eAAO,MAAM,mCAAmC,uBAI9C,CAAC;AAEH,eAAO,MAAM,gCAAgC,uBAE3C,CAAC;AAEH,eAAO,MAAM,0CAA0C,uBAyCrD,CAAC;AAGH,eAAO,MAAM,0BAA0B,uBAErC,CAAC;AAGH,eAAO,MAAM,yBAAyB,uBAEpC,CAAC;AAGH,eAAO,MAAM,sBAAsB;sBACf,qBAAqB,KAAG,GAAG,CAAC,gBAAgB;0BAmBxC,oBAAoB,KAAG,GAAG,CAAC,gBAAgB;8BAiBvC,wBAAwB,KAAG,GAAG,CAAC,gBAAgB;CAM1E,CAAC;AAEF,eAAO,MAAM,UAAU,uBAYrB,CAAC;AAEH,eAAO,MAAM,+BAA+B;sBACxB;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,GAAG,CAAC,gBAAgB;CAM3D,CAAC;AAEF,eAAO,MAAM,uBAAuB;sBAChB;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,KAAG,GAAG,CAAC,gBAAgB;CAM3D,CAAC;AAEF,eAAO,MAAM,iCAAiC;sBAC1B;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE,KAAG,GAAG,CAAC,gBAAgB;CAMnE,CAAC"}

package/dist/src/lib/txnSchema.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithdrawUnbondedTransactionSchema = exports.UnbondTransactionSchema = exports.BatchUnstakingTransactionSchema = exports.bondSchema = exports.BatchTransactionSchema = exports.NominateTransactionSchema = exports.BondExtraTransactionSchema = exports.AddAndAffirmWithMediatorsTransactionSchema = exports.PreApproveAssetTransactionSchema = 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));
+exports.RegisterDidWithCDDTransactionSchema = joi_1.default.object({
+    targetAccount: addressSchema.required(),
+    secondaryKeys: joi_1.default.array().length(0).required(),
+    expiry: joi_1.default.valid(null).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.string().valid('SettleOnAffirmation').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.string().valid('Default').required(),
+            })
+                .required(),
+            receiver: joi_1.default
+                .object({
+                did: addressSchema.required(),
+                kind: joi_1.default.string().valid('Default').required(),
+            })
+                .required(),
+            assetId: joi_1.default.string().required(),
+            amount: joi_1.default.string().required(),
+        })
+            .required(),
+    }))
+        .required(),
+    portfolios: joi_1.default
+        .array()
+        .items(joi_1.default.object({
+        did: addressSchema.required(),
+        kind: joi_1.default.string().valid('Default').required(),
+    }))
+        .required(),
+    instructionMemo: joi_1.default.string().required(),
+    mediators: joi_1.default.array().length(0).required(),
+});
+// For standalone bondExtra transactions
+exports.BondExtraTransactionSchema = joi_1.default.object({
+    value: joi_1.default.string().required(),
+});
+// For nominate transactions in batch
+exports.NominateTransactionSchema = joi_1.default.object({
+    validators: joi_1.default.array().items(addressSchema).min(1).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).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).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\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\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.string().valid('SettleOnAffirmation').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.string().valid('Default').required(),\n              })\n              .required(),\n            receiver: joi\n              .object({\n                did: addressSchema.required(),\n                kind: joi.string().valid('Default').required(),\n              })\n              .required(),\n            assetId: joi.string().required(),\n            amount: joi.string().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.string().valid('Default').required(),\n      })\n    )\n    .required(),\n  instructionMemo: joi.string().required(),\n  mediators: joi.array().length(0).required(),\n});\n\n// For standalone bondExtra transactions\nexport const BondExtraTransactionSchema = joi.object({\n  value: joi.string().required(),\n});\n\n// For nominate transactions in batch\nexport const NominateTransactionSchema = joi.object({\n  validators: joi.array().items(addressSchema).min(1).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).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).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;AAMhF,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,98 @@
+"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"));
+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,17 +1,18 @@
-import { BaseUtils } from '@bitgo-beta/sdk-core';
-export declare class Utils implements BaseUtils {
-    /** @inheritdoc */
-    isValidAddress(address: string): boolean;
-    /** @inheritdoc */
-    isValidBlockId(hash: string): boolean;
-    /** @inheritdoc */
-    isValidPrivateKey(key: string): boolean;
-    /** @inheritdoc */
-    isValidPublicKey(key: string): boolean;
-    /** @inheritdoc */
-    isValidSignature(signature: string): boolean;
-    /** @inheritdoc */
-    isValidTransactionId(txId: string): boolean;
+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;
+    getMaterial(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,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,qBAAa,KAAM,YAAW,SAAS;IACrC,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC,kBAAkB;IAClB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC,kBAAkB;IAClB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAItC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;CAG5C;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,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;AAE1C,qBAAa,KAAM,SAAQ,cAAc;IACvC;;;;;;OAMG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAK1C,WAAW,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC,QAAQ;IAIzD,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

@@ -1,33 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Utils = void 0;
-class Utils {
-    /** @inheritdoc */
-    isValidAddress(address) {
-        throw new Error('Method not implemented.');
+const abstract_substrate_1 = require("@bitgo-beta/abstract-substrate");
+const statics_1 = require("@bitgo-beta/statics");
+const resources_1 = require("../resources");
+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;
     }
-    /** @inheritdoc */
-    isValidBlockId(hash) {
-        throw new Error('Method not implemented.');
+    getMaterial(networkType) {
+        return (networkType === statics_1.NetworkType.MAINNET ? resources_1.mainnetMaterial : resources_1.testnetMaterial);
     }
-    /** @inheritdoc */
-    isValidPrivateKey(key) {
-        throw new Error('Method not implemented.');
-    }
-    /** @inheritdoc */
-    isValidPublicKey(key) {
-        throw new Error('Method not implemented.');
-    }
-    /** @inheritdoc */
-    isValidSignature(signature) {
-        throw new Error('Method not implemented.');
-    }
-    /** @inheritdoc */
-    isValidTransactionId(txId) {
-        throw new Error('Method not implemented.');
+    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,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,35 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { UnsignedTransaction, DecodedSigningPayload, DecodedSignedTx } from '@substrate/txwrapper-core';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { Transaction } from './transaction';
+import { PolyxBaseBuilder } from './baseBuilder';
+export declare class WithdrawUnbondedBuilder extends PolyxBaseBuilder {
+    protected _slashingSpans: number;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Withdraw unbonded tokens after the unbonding period has passed
+     *
+     * @returns {UnsignedTransaction} an unsigned Polyx transaction
+     */
+    protected buildTransaction(): UnsignedTransaction;
+    protected get transactionType(): TransactionType;
+    /**
+     * The number of slashing spans, typically 0 for most users
+     *
+     * @param {number} slashingSpans
+     * @returns {WithdrawUnbondedBuilder} This withdrawUnbonded builder.
+     */
+    slashingSpans(slashingSpans: number): this;
+    /**
+     * Get the slashing spans
+     */
+    getSlashingSpans(): number;
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx): void;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    validateTransaction(_: Transaction): void;
+    private validateFields;
+}
+//# sourceMappingURL=withdrawUnbondedBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawUnbondedBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/withdrawUnbondedBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACxG,OAAO,EAA2B,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEhF,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAIjD,qBAAa,uBAAwB,SAAQ,gBAAgB;IAC3D,SAAS,CAAC,cAAc,SAAK;gBAEjB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;OAIG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAYjD,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;OAKG;IACH,aAAa,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI;IAM1C;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,GAAG,IAAI;IAkBrF,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAajE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAKzC,OAAO,CAAC,cAAc;CAWvB"}

package/dist/src/lib/withdrawUnbondedBuilder.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WithdrawUnbondedBuilder = void 0;
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const baseBuilder_1 = require("./baseBuilder");
+const txnSchema_1 = require("./txnSchema");
+class WithdrawUnbondedBuilder extends baseBuilder_1.PolyxBaseBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._slashingSpans = 0;
+    }
+    /**
+     * Withdraw unbonded tokens after the unbonding period has passed
+     *
+     * @returns {UnsignedTransaction} an unsigned Polyx transaction
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return txwrapper_polkadot_1.methods.staking.withdrawUnbonded({
+            numSlashingSpans: this._slashingSpans,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingWithdraw;
+    }
+    /**
+     * The number of slashing spans, typically 0 for most users
+     *
+     * @param {number} slashingSpans
+     * @returns {WithdrawUnbondedBuilder} This withdrawUnbonded builder.
+     */
+    slashingSpans(slashingSpans) {
+        this.validateValue(new bignumber_js_1.default(slashingSpans));
+        this._slashingSpans = slashingSpans;
+        return this;
+    }
+    /**
+     * Get the slashing spans
+     */
+    getSlashingSpans() {
+        return this._slashingSpans;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn) {
+        if (decodedTxn.method?.name === 'withdrawUnbonded') {
+            const txMethod = decodedTxn.method.args;
+            const slashingSpans = txMethod.numSlashingSpans;
+            const validationResult = txnSchema_1.WithdrawUnbondedTransactionSchema.validate({ slashingSpans });
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`WithdrawUnbonded Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid transaction type: ${decodedTxn.method?.name}. Expected withdrawUnbonded`);
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method && this._method.name === 'withdrawUnbonded') {
+            const txMethod = this._method.args;
+            this.slashingSpans(txMethod.numSlashingSpans);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected withdrawUnbonded`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields(this._slashingSpans);
+    }
+    validateFields(slashingSpans) {
+        const validationResult = txnSchema_1.WithdrawUnbondedTransactionSchema.validate({
+            slashingSpans,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`WithdrawUnbonded Builder Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+}
+exports.WithdrawUnbondedBuilder = WithdrawUnbondedBuilder;
+//# sourceMappingURL=data:application/json;base64,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