@bitgo-beta/sdk-coin-polyx 0.0.0-semantic-release-managed

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

@@ -0,0 +1,19 @@
+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;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +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;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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+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;
+    }
+    getMaterial(networkType) {
+        return (networkType === statics_1.NetworkType.MAINNET ? resources_1.mainnetMaterial : resources_1.testnetMaterial);
+    }
+    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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

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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

package/dist/src/polyx.d.ts

@@ -0,0 +1,63 @@
+import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, MPCRecoveryOptions, MPCSweepTxs, MPCTx, MPCSweepRecoveryOptions, MPCTxs, TokenEnablementConfig } from '@bitgo-beta/sdk-core';
+import { ApiPromise } from '@polkadot/api';
+import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { SubstrateCoin, Interface } from '@bitgo-beta/abstract-substrate';
+import { BatchStakingBuilder } from './lib/batchStakingBuilder';
+import { BondExtraBuilder } from './lib/bondExtraBuilder';
+import { TransactionBuilderFactory } from './lib';
+export declare class Polyx extends SubstrateCoin {
+    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
+    protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    protected static nodeApiInitialized: boolean;
+    protected static API: ApiPromise;
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
+    getBuilder(): TransactionBuilderFactory;
+    /**
+     * Factor between the coin's base unit and its smallest subdivison
+     */
+    getBaseFactor(): number;
+    getChain(): string;
+    getFullName(): string;
+    /** @inheritDoc */
+    auditDecryptedKey({ publicKey, prv, multiSigType }: AuditDecryptedKeyParams): void;
+    stakingBatch(): BatchStakingBuilder;
+    bondExtra(): BondExtraBuilder;
+    /**
+     * Retrieves the address format for Polyx.
+     *
+     * @returns {number} The address format as a number for Polyx.
+     * @override
+     */
+    protected getAddressFormat(): number;
+    protected getInitializedNodeAPI(): Promise<ApiPromise>;
+    protected getAccountInfo(walletAddr: string): Promise<{
+        nonce: number;
+        freeBalance: number;
+    }>;
+    protected getFee(destAddr: string, srcAddr: string, amount: number): Promise<number>;
+    protected getHeaderInfo(): Promise<{
+        headerNumber: number;
+        headerHash: string;
+    }>;
+    protected getMaterial(): Promise<Interface.Material>;
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param {MPCRecoveryOptions} params parameters needed to construct and
+     * (maybe) sign the transaction
+     *
+     * @returns {MPCTx} the serialized transaction hex string and index
+     * of the address being swept
+     */
+    recover(params: MPCRecoveryOptions): Promise<MPCTx | MPCSweepTxs>;
+    /** inherited doc */
+    createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs>;
+    /**
+     * Gets config for how token enablements work for this coin
+     * @returns
+     *    requiresTokenEnablement: True if tokens need to be enabled for this coin
+     *    supportsMultipleTokenEnablements: True if multiple tokens can be enabled in one transaction
+     *    validateWallet: Function to validate wallet type for token enablement
+     */
+    getTokenEnablementConfig(): TokenEnablementConfig;
+}
+//# sourceMappingURL=polyx.d.ts.map

package/dist/src/polyx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyx.d.ts","sourceRoot":"","sources":["../../src/polyx.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,SAAS,EAGT,kBAAkB,EAClB,WAAW,EACX,KAAK,EAIL,uBAAuB,EACvB,MAAM,EACN,qBAAqB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,UAAU,EAAc,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAgC,MAAM,qBAAqB,CAAC;AAChG,OAAO,EAA+B,aAAa,EAAe,SAAS,EAAE,MAAM,gCAAgC,CAAC;AACpH,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAI1D,OAAO,EAAE,yBAAyB,EAAmB,MAAM,OAAO,CAAC;AAEnE,qBAAa,KAAM,SAAQ,aAAa;IACtC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,SAAS,CAAC,MAAM,CAAC,kBAAkB,UAAS;IAC5C,SAAS,CAAC,MAAM,CAAC,GAAG,EAAE,UAAU,CAAC;IAEjC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,UAAU,IAAI,yBAAyB;IAIvC;;OAEG;IACI,aAAa,IAAI,MAAM;IAIvB,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,MAAM;IAI5B,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,YAAY,EAAE,EAAE,uBAAuB;IAI3E,YAAY,IAAI,mBAAmB;IAInC,SAAS,IAAI,gBAAgB;IAI7B;;;;;OAKG;IACH,SAAS,CAAC,gBAAgB,IAAI,MAAM;cAIpB,qBAAqB,IAAI,OAAO,CAAC,UAAU,CAAC;cAS5C,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;cAOnF,MAAM,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;cAM1E,aAAa,IAAI,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC;cAMtE,WAAW,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC;IAY1D;;;;;;;OAOG;IACG,OAAO,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,KAAK,GAAG,WAAW,CAAC;IAgJvE,oBAAoB;IACd,mCAAmC,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,MAAM,CAAC;IAmE3F;;;;;;OAMG;IACH,wBAAwB,IAAI,qBAAqB;CAWlD"}