@bitgo/sdk-coin-dot 4.11.7 → 4.12.0

package/dist/cjs/src/lib/batchTransactionBuilder.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchTransactionBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const iface_1 = require("./iface");
+const iface_utils_1 = require("./iface_utils");
+const transactionBuilder_1 = require("./transactionBuilder");
+const txnSchema_1 = require("./txnSchema");
+const utils_1 = __importDefault(require("./utils"));
+class BatchTransactionBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._atomic = false;
+    }
+    /** @inheritDoc */
+    buildTransaction() {
+        return this.buildBatchTransaction();
+    }
+    /**
+     * Build a transaction which batches together multiple transactions.
+     * The transactions which are batched together are passed in as an array of hex strings
+     * which are composed of the method to call and the arguments to pass into the method.
+     *
+     * @returns {UnsignedTransaction}
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#batchcalls-veccall
+     */
+    buildBatchTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        if (this._atomic) {
+            return txwrapper_polkadot_1.methods.utility.batchAll({
+                calls: this._calls,
+            }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        }
+        else {
+            return txwrapper_polkadot_1.methods.utility.batch({
+                calls: this._calls,
+            }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        }
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Batch;
+    }
+    /**
+     * Set multiple unsigned transactions to be batched and broadcast as a single transaction
+     *
+     * @param {BatchCall[]} calls unsigned transactions
+     * @returns {BatchTransactionBuilder} This batch transaction builder.
+     */
+    calls(calls) {
+        this.validateCalls(calls);
+        this._calls = calls;
+        return this;
+    }
+    /**
+     * If true when a batched call fails the entire transactions is rolled back, if false no roll back
+     * is performed and the effects of any successful call prior to the error remain.
+     *
+     * @param atomic true if calls must succeed atomically, false otherwise.
+     */
+    atomic(atomic) {
+        this._atomic = atomic;
+        return this;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn) {
+        const txMethod = decodedTxn.method.args;
+        const validationResult = this.validateBatchTransactionFields(txMethod.calls);
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name === iface_1.MethodNames.Batch || this._method?.name === iface_1.MethodNames.BatchAll) {
+            if (this._method?.name === iface_1.MethodNames.BatchAll) {
+                this.atomic(true);
+            }
+            const txMethod = this._method.args;
+            if (!txMethod.calls) {
+                throw new sdk_core_1.InvalidTransactionError('failed to decode calls from batch transaction');
+            }
+            const callsToBatch = [];
+            txMethod.calls.forEach((call) => {
+                const method = call.callIndex;
+                const decodedMethod = (0, sdk_core_1.toUint8Array)(utils_1.default.stripHexPrefix(method));
+                const decodedCall = this._registry.findMetaCall(decodedMethod);
+                if (decodedCall.section === iface_1.SectionNames.Proxy &&
+                    (decodedCall.method === iface_1.MethodNames.Anonymous || decodedCall.method === iface_1.MethodNames.PureProxy)) {
+                    callsToBatch.push(this.getPureProxyCall(call.args));
+                }
+                else if (decodedCall.section === iface_1.SectionNames.Proxy && decodedCall.method === iface_1.MethodNames.AddProxy) {
+                    callsToBatch.push(this.getAddProxyCall(call.args));
+                }
+                else if (decodedCall.section === iface_1.SectionNames.Staking && decodedCall.method === iface_1.MethodNames.BondExtra) {
+                    callsToBatch.push(this.getBondExtraCall(call.args));
+                }
+                else if (decodedCall.section === iface_1.SectionNames.Staking && decodedCall.method === iface_1.MethodNames.Bond) {
+                    callsToBatch.push(this.getBondCall(call.args));
+                }
+                else if (decodedCall.section === iface_1.SectionNames.Staking && decodedCall.method === iface_1.MethodNames.Unbond) {
+                    callsToBatch.push(this.getUnbondCall(call.args));
+                }
+                else if (decodedCall.section === iface_1.SectionNames.Staking && decodedCall.method === iface_1.MethodNames.Chill) {
+                    callsToBatch.push(this.getChillCall());
+                }
+                else if (decodedCall.section === iface_1.SectionNames.Proxy && decodedCall.method === iface_1.MethodNames.RemoveProxy) {
+                    callsToBatch.push(this.getRemoveProxyCall(call.args));
+                }
+                else {
+                    throw new sdk_core_1.NotImplementedError(`batching of transaction with index ${method} unsupported`);
+                }
+            });
+            this.calls(callsToBatch);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected ${iface_1.MethodNames.Batch}`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields();
+    }
+    /**
+     * Validate list of unsigned transactions added to batch
+     *
+     * @param {string[]} calls
+     *
+     */
+    validateCalls(calls) {
+        calls.forEach((call) => {
+            if (call.slice(0, 2) !== '0x') {
+                // example: '0x160400000000000000'
+                throw new sdk_core_1.BuildTransactionError('call in string format must be hex format of a method and its arguments');
+            }
+        });
+    }
+    validateFields() {
+        const validationResult = this.validateBatchTransactionFields(this._calls);
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`AddressInitialization Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+    validateBatchTransactionFields(calls) {
+        return txnSchema_1.BatchTransactionSchema.validate({
+            calls,
+        });
+    }
+    getPureProxyCall(args) {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = utils_1.default.pureProxy({
+            proxyType: args.proxy_type,
+            index: args.index,
+            delay: args.delay,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+    getBondCall(args) {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = txwrapper_polkadot_1.methods.staking.bond({
+            value: args.value,
+            payee: this.getPayee(args.payee),
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+    getUnbondCall(args) {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = txwrapper_polkadot_1.methods.staking.unbond({
+            value: args.value,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+    getPayee(payee) {
+        if ((0, iface_utils_1.isStakeBatchCallPayeeStash)(payee)) {
+            return 'Stash';
+        }
+        else if ((0, iface_utils_1.isStakeBatchCallPayeeController)(payee)) {
+            return 'Controller';
+        }
+        else if ((0, iface_utils_1.isStakeBatchCallPayeeAccount)(payee)) {
+            return { Account: payee.account };
+        }
+        else if ((0, iface_utils_1.isStakeBatchCallPayeeStaked)(payee)) {
+            return 'Staked';
+        }
+        else {
+            throw new Error(`Invalid payee: ${payee}`);
+        }
+    }
+    getAddProxyCall(args) {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = txwrapper_polkadot_1.methods.proxy.addProxy({
+            delegate: (0, iface_utils_1.getDelegateAddress)(args),
+            proxyType: args.proxy_type,
+            delay: args.delay,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+    getBondExtraCall(args) {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = txwrapper_polkadot_1.methods.staking.bondExtra({
+            maxAdditional: args.max_additional,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+    getRemoveProxyCall(args) {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = txwrapper_polkadot_1.methods.proxy.removeProxy({
+            delegate: (0, iface_utils_1.getDelegateAddress)(args),
+            proxyType: args.proxy_type,
+            delay: args.delay,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+    getChillCall() {
+        const baseTxInfo = this.createBaseTxInfo();
+        const unsigned = txwrapper_polkadot_1.methods.staking.chill({}, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        return unsigned.method;
+    }
+}
+exports.BatchTransactionBuilder = BatchTransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batchTransactionBuilder.js","sourceRoot":"","sources":["../../../../src/lib/batchTransactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BuildTransactionError,\n  InvalidTransactionError,\n  NotImplementedError,\n  TransactionType,\n  toUint8Array,\n} from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';\nimport { methods } from '@substrate/txwrapper-polkadot';\nimport { ValidationResult } from 'joi';\nimport {\n  AddAnonymousProxyBatchCallArgs,\n  AddProxyBatchCallArgs,\n  BatchCallObject,\n  BatchArgs,\n  MethodNames,\n  SectionNames,\n  StakeArgsPayee,\n  StakeBatchCallArgs,\n  StakeBatchCallPayee,\n  UnbondCallArgs,\n  StakeMoreCallArgs,\n} from './iface';\nimport {\n  getDelegateAddress,\n  isStakeBatchCallPayeeStaked,\n  isStakeBatchCallPayeeStash,\n  isStakeBatchCallPayeeController,\n  isStakeBatchCallPayeeAccount,\n} from './iface_utils';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { BatchTransactionSchema } from './txnSchema';\nimport utils from './utils';\n\nexport class BatchTransactionBuilder extends TransactionBuilder {\n  protected _calls: string[];\n  protected _type: TransactionType;\n  private _atomic = false;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritDoc */\n  protected buildTransaction(): UnsignedTransaction {\n    return this.buildBatchTransaction();\n  }\n\n  /**\n   * Build a transaction which batches together multiple transactions.\n   * The transactions which are batched together are passed in as an array of hex strings\n   * which are composed of the method to call and the arguments to pass into the method.\n   *\n   * @returns {UnsignedTransaction}\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#batchcalls-veccall\n   */\n  protected buildBatchTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    if (this._atomic) {\n      return methods.utility.batchAll(\n        {\n          calls: this._calls,\n        },\n        baseTxInfo.baseTxInfo,\n        baseTxInfo.options\n      );\n    } else {\n      return methods.utility.batch(\n        {\n          calls: this._calls,\n        },\n        baseTxInfo.baseTxInfo,\n        baseTxInfo.options\n      );\n    }\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Batch;\n  }\n\n  /**\n   * Set multiple unsigned transactions to be batched and broadcast as a single transaction\n   *\n   * @param {BatchCall[]} calls unsigned transactions\n   * @returns {BatchTransactionBuilder} This batch transaction builder.\n   */\n  calls(calls: string[]): this {\n    this.validateCalls(calls);\n    this._calls = calls;\n    return this;\n  }\n\n  /**\n   * If true when a batched call fails the entire transactions is rolled back, if false no roll back\n   * is performed and the effects of any successful call prior to the error remain.\n   *\n   * @param atomic true if calls must succeed atomically, false otherwise.\n   */\n  atomic(atomic: boolean): this {\n    this._atomic = atomic;\n    return this;\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx): void {\n    const txMethod = decodedTxn.method.args as unknown as BatchArgs;\n    const validationResult = this.validateBatchTransactionFields(txMethod.calls);\n    if (validationResult.error) {\n      throw new InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);\n    }\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = super.fromImplementation(rawTransaction);\n    if (this._method?.name === MethodNames.Batch || this._method?.name === MethodNames.BatchAll) {\n      if (this._method?.name === MethodNames.BatchAll) {\n        this.atomic(true);\n      }\n      const txMethod = this._method.args as BatchArgs;\n      if (!txMethod.calls) {\n        throw new InvalidTransactionError('failed to decode calls from batch transaction');\n      }\n      const callsToBatch: string[] = [];\n      txMethod.calls.forEach((call) => {\n        const method = (call as BatchCallObject).callIndex;\n        const decodedMethod = toUint8Array(utils.stripHexPrefix(method));\n        const decodedCall = this._registry.findMetaCall(decodedMethod);\n        if (\n          decodedCall.section === SectionNames.Proxy &&\n          (decodedCall.method === MethodNames.Anonymous || decodedCall.method === MethodNames.PureProxy)\n        ) {\n          callsToBatch.push(this.getPureProxyCall(call.args as AddAnonymousProxyBatchCallArgs));\n        } else if (decodedCall.section === SectionNames.Proxy && decodedCall.method === MethodNames.AddProxy) {\n          callsToBatch.push(this.getAddProxyCall(call.args as AddProxyBatchCallArgs));\n        } else if (decodedCall.section === SectionNames.Staking && decodedCall.method === MethodNames.BondExtra) {\n          callsToBatch.push(this.getBondExtraCall(call.args as StakeMoreCallArgs));\n        } else if (decodedCall.section === SectionNames.Staking && decodedCall.method === MethodNames.Bond) {\n          callsToBatch.push(this.getBondCall(call.args as StakeBatchCallArgs));\n        } else if (decodedCall.section === SectionNames.Staking && decodedCall.method === MethodNames.Unbond) {\n          callsToBatch.push(this.getUnbondCall(call.args as UnbondCallArgs));\n        } else if (decodedCall.section === SectionNames.Staking && decodedCall.method === MethodNames.Chill) {\n          callsToBatch.push(this.getChillCall());\n        } else if (decodedCall.section === SectionNames.Proxy && decodedCall.method === MethodNames.RemoveProxy) {\n          callsToBatch.push(this.getRemoveProxyCall(call.args as AddProxyBatchCallArgs));\n        } else {\n          throw new NotImplementedError(`batching of transaction with index ${method} unsupported`);\n        }\n      });\n      this.calls(callsToBatch);\n    } else {\n      throw new InvalidTransactionError(\n        `Invalid Transaction Type: ${this._method?.name}. Expected ${MethodNames.Batch}`\n      );\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields();\n  }\n\n  /**\n   * Validate list of unsigned transactions added to batch\n   *\n   * @param {string[]} calls\n   *\n   */\n  validateCalls(calls: string[]): void {\n    calls.forEach((call) => {\n      if (call.slice(0, 2) !== '0x') {\n        // example: '0x160400000000000000'\n        throw new BuildTransactionError('call in string format must be hex format of a method and its arguments');\n      }\n    });\n  }\n\n  private validateFields(): void {\n    const validationResult = this.validateBatchTransactionFields(this._calls);\n    if (validationResult.error) {\n      throw new InvalidTransactionError(\n        `AddressInitialization Transaction validation failed: ${validationResult.error.message}`\n      );\n    }\n  }\n\n  private validateBatchTransactionFields(calls: (string | BatchCallObject)[]): ValidationResult {\n    return BatchTransactionSchema.validate({\n      calls,\n    });\n  }\n\n  private getPureProxyCall(args: AddAnonymousProxyBatchCallArgs): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = utils.pureProxy(\n      {\n        proxyType: args.proxy_type,\n        index: args.index,\n        delay: args.delay,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n    return unsigned.method;\n  }\n\n  private getBondCall(args: StakeBatchCallArgs): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = methods.staking.bond(\n      {\n        value: args.value,\n        payee: this.getPayee(args.payee),\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n    return unsigned.method;\n  }\n\n  private getUnbondCall(args: UnbondCallArgs): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = methods.staking.unbond(\n      {\n        value: args.value,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n    return unsigned.method;\n  }\n\n  private getPayee(payee: StakeBatchCallPayee): StakeArgsPayee {\n    if (isStakeBatchCallPayeeStash(payee)) {\n      return 'Stash';\n    } else if (isStakeBatchCallPayeeController(payee)) {\n      return 'Controller';\n    } else if (isStakeBatchCallPayeeAccount(payee)) {\n      return { Account: payee.account };\n    } else if (isStakeBatchCallPayeeStaked(payee)) {\n      return 'Staked';\n    } else {\n      throw new Error(`Invalid payee: ${payee}`);\n    }\n  }\n\n  private getAddProxyCall(args: AddProxyBatchCallArgs): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = methods.proxy.addProxy(\n      {\n        delegate: getDelegateAddress(args),\n        proxyType: args.proxy_type,\n        delay: args.delay,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n    return unsigned.method;\n  }\n\n  private getBondExtraCall(args: StakeMoreCallArgs): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = methods.staking.bondExtra(\n      {\n        maxAdditional: args.max_additional,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n    return unsigned.method;\n  }\n\n  private getRemoveProxyCall(args: AddProxyBatchCallArgs): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = methods.proxy.removeProxy(\n      {\n        delegate: getDelegateAddress(args),\n        proxyType: args.proxy_type,\n        delay: args.delay,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n    return unsigned.method;\n  }\n\n  private getChillCall(): string {\n    const baseTxInfo = this.createBaseTxInfo();\n    const unsigned = methods.staking.chill({}, baseTxInfo.baseTxInfo, baseTxInfo.options);\n    return unsigned.method;\n  }\n}\n"]}

package/dist/cjs/src/lib/claimBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claimBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/claimBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA0C,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIxG,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI1D,qBAAa,YAAa,SAAQ,kBAAkB;IAClD,SAAS,CAAC,eAAe,EAAE,MAAM,CAAC;IAClC,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;gBAEhB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;;;;;OAQG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAYjD;;OAEG;IACH,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,cAAc,EAAE,WAAW,GAAG,IAAI;IAMjD;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMhC,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,GAAG,IAAI;IAYrF,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAiBjE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAKzC;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;CAYvB"}

package/dist/cjs/src/lib/claimBuilder.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaimBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const iface_1 = require("./iface");
+const transactionBuilder_1 = require("./transactionBuilder");
+const txnSchema_1 = require("./txnSchema");
+const utils_1 = __importDefault(require("./utils"));
+class ClaimBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     *
+     * Pay out all the stakers behind a single validator for a single era.
+     * Any account can create this transaction.
+     *
+     * @returns {UnsignedTransaction} an unsigned Dot transaction
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#payoutstakersvalidator_stash-accountid32-era-u32
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return txwrapper_polkadot_1.methods.staking.payoutStakers({
+            validatorStash: this._validatorStash,
+            era: this._claimEra,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+    }
+    /**
+     * Get the transaction type.
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingClaim;
+    }
+    /**
+     *
+     * The stash account of the validator.
+     *
+     * @param {string} validatorStash
+     * @returns {ClaimBuilder} This claim builder.
+     *
+     */
+    validatorStash(validatorStash) {
+        this.validateAddress(validatorStash);
+        this._validatorStash = validatorStash.address;
+        return this;
+    }
+    /**
+     * The era to claim.
+     *
+     * @param {string} claimEra
+     * @returns {ClaimBuilder} This claim builder.
+     *
+     */
+    claimEra(claimEra) {
+        this.validateValue(new bignumber_js_1.default(claimEra));
+        this._claimEra = claimEra;
+        return this;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn) {
+        if (decodedTxn.method?.name === iface_1.MethodNames.PayoutStakers) {
+            const txMethod = decodedTxn.method.args;
+            const claimEra = txMethod.era;
+            const validatorStash = txMethod.validatorStash;
+            const validationResult = txnSchema_1.ClaimTransactionSchema.validate({ claimEra, validatorStash });
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Claim Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name === iface_1.MethodNames.PayoutStakers) {
+            const txMethod = this._method.args;
+            this.validatorStash({
+                address: utils_1.default.decodeDotAddress(txMethod.validatorStash, utils_1.default.getAddressFormat(this._coinConfig.name)),
+            });
+            this.claimEra(txMethod.era);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected payoutStakers`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields(this._claimEra, this._validatorStash);
+    }
+    /**
+     *
+     * The stash account of the validator.
+     *
+     * @param {string} claimEra
+     * @param {string} validatorStash
+     * @throws {Error} If the expected fields are not valid.
+     *
+     */
+    validateFields(claimEra, validatorStash) {
+        const validationResult = txnSchema_1.ClaimTransactionSchema.validate({
+            claimEra,
+            validatorStash,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Claim Builder Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+}
+exports.ClaimBuilder = ClaimBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"claimBuilder.js","sourceRoot":"","sources":["../../../../src/lib/claimBuilder.ts"],"names":[],"mappings":";;;;;;AAAA,8CAAuG;AAGvG,sEAAwD;AACxD,gEAAqC;AACrC,mCAAiD;AAEjD,6DAA0D;AAC1D,2CAAqD;AACrD,oDAA4B;AAE5B,MAAa,YAAa,SAAQ,uCAAkB;IAIlD,YAAY,WAAiC;QAC3C,KAAK,CAAC,WAAW,CAAC,CAAC;IACrB,CAAC;IAED;;;;;;;;OAQG;IACO,gBAAgB;QACxB,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAC3C,OAAO,4BAAO,CAAC,OAAO,CAAC,aAAa,CAClC;YACE,cAAc,EAAE,IAAI,CAAC,eAAe;YACpC,GAAG,EAAE,IAAI,CAAC,SAAS;SACpB,EACD,UAAU,CAAC,UAAU,EACrB,UAAU,CAAC,OAAO,CACnB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAc,eAAe;QAC3B,OAAO,0BAAe,CAAC,YAAY,CAAC;IACtC,CAAC;IAED;;;;;;;OAOG;IACH,cAAc,CAAC,cAA2B;QACxC,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,CAAC;QACrC,IAAI,CAAC,eAAe,GAAG,cAAc,CAAC,OAAO,CAAC;QAC9C,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;OAMG;IACH,QAAQ,CAAC,QAAgB;QACvB,IAAI,CAAC,aAAa,CAAC,IAAI,sBAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC5C,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IAClB,0BAA0B,CAAC,UAAmD;QAC5E,IAAI,UAAU,CAAC,MAAM,EAAE,IAAI,KAAK,mBAAW,CAAC,aAAa,EAAE,CAAC;YAC1D,MAAM,QAAQ,GAAG,UAAU,CAAC,MAAM,CAAC,IAA4B,CAAC;YAChE,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC;YAC9B,MAAM,cAAc,GAAG,QAAQ,CAAC,cAAc,CAAC;YAC/C,MAAM,gBAAgB,GAAG,kCAAsB,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC,CAAC;YACvF,IAAI,gBAAgB,CAAC,KAAK,EAAE,CAAC;gBAC3B,MAAM,IAAI,kCAAuB,CAAC,wCAAwC,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YAC9G,CAAC;QACH,CAAC;IACH,CAAC;IAED,kBAAkB;IACR,kBAAkB,CAAC,cAAsB;QACjD,MAAM,EAAE,GAAG,KAAK,CAAC,kBAAkB,CAAC,cAAc,CAAC,CAAC;QACpD,IAAI,IAAI,CAAC,OAAO,EAAE,IAAI,KAAK,mBAAW,CAAC,aAAa,EAAE,CAAC;YACrD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAiB,CAAC;YAChD,IAAI,CAAC,cAAc,CAAC;gBAClB,OAAO,EAAE,eAAK,CAAC,gBAAgB,CAC7B,QAAQ,CAAC,cAAc,EACvB,eAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,WAAW,CAAC,IAAqB,CAAC,CAC/D;aACF,CAAC,CAAC;YACH,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,kCAAuB,CAAC,6BAA6B,IAAI,CAAC,OAAO,EAAE,IAAI,0BAA0B,CAAC,CAAC;QAC/G,CAAC;QACD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,kBAAkB;IAClB,mBAAmB,CAAC,CAAc;QAChC,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IAC5D,CAAC;IAED;;;;;;;;OAQG;IACK,cAAc,CAAC,QAAgB,EAAE,cAAsB;QAC7D,MAAM,gBAAgB,GAAG,kCAAsB,CAAC,QAAQ,CAAC;YACvD,QAAQ;YACR,cAAc;SACf,CAAC,CAAC;QAEH,IAAI,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC3B,MAAM,IAAI,kCAAuB,CAC/B,gDAAgD,gBAAgB,CAAC,KAAK,CAAC,OAAO,EAAE,CACjF,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AAzHD,oCAyHC","sourcesContent":["import { BaseAddress, DotAssetTypes, InvalidTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';\nimport { methods } from '@substrate/txwrapper-polkadot';\nimport BigNumber from 'bignumber.js';\nimport { ClaimArgs, MethodNames } from './iface';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { ClaimTransactionSchema } from './txnSchema';\nimport utils from './utils';\n\nexport class ClaimBuilder extends TransactionBuilder {\n  protected _validatorStash: string;\n  protected _claimEra: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   *\n   * Pay out all the stakers behind a single validator for a single era.\n   * Any account can create this transaction.\n   *\n   * @returns {UnsignedTransaction} an unsigned Dot transaction\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#payoutstakersvalidator_stash-accountid32-era-u32\n   */\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    return methods.staking.payoutStakers(\n      {\n        validatorStash: this._validatorStash,\n        era: this._claimEra,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n  }\n\n  /**\n   * Get the transaction type.\n   */\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingClaim;\n  }\n\n  /**\n   *\n   * The stash account of the validator.\n   *\n   * @param {string} validatorStash\n   * @returns {ClaimBuilder} This claim builder.\n   *\n   */\n  validatorStash(validatorStash: BaseAddress): this {\n    this.validateAddress(validatorStash);\n    this._validatorStash = validatorStash.address;\n    return this;\n  }\n\n  /**\n   * The era to claim.\n   *\n   * @param {string} claimEra\n   * @returns {ClaimBuilder} This claim builder.\n   *\n   */\n  claimEra(claimEra: string): this {\n    this.validateValue(new BigNumber(claimEra));\n    this._claimEra = claimEra;\n    return this;\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx): void {\n    if (decodedTxn.method?.name === MethodNames.PayoutStakers) {\n      const txMethod = decodedTxn.method.args as unknown as ClaimArgs;\n      const claimEra = txMethod.era;\n      const validatorStash = txMethod.validatorStash;\n      const validationResult = ClaimTransactionSchema.validate({ claimEra, validatorStash });\n      if (validationResult.error) {\n        throw new InvalidTransactionError(`Claim Transaction validation failed: ${validationResult.error.message}`);\n      }\n    }\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = super.fromImplementation(rawTransaction);\n    if (this._method?.name === MethodNames.PayoutStakers) {\n      const txMethod = this._method.args as ClaimArgs;\n      this.validatorStash({\n        address: utils.decodeDotAddress(\n          txMethod.validatorStash,\n          utils.getAddressFormat(this._coinConfig.name as DotAssetTypes)\n        ),\n      });\n      this.claimEra(txMethod.era);\n    } else {\n      throw new InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected payoutStakers`);\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields(this._claimEra, this._validatorStash);\n  }\n\n  /**\n   *\n   * The stash account of the validator.\n   *\n   * @param {string} claimEra\n   * @param {string} validatorStash\n   * @throws {Error} If the expected fields are not valid.\n   *\n   */\n  private validateFields(claimEra: string, validatorStash: string): void {\n    const validationResult = ClaimTransactionSchema.validate({\n      claimEra,\n      validatorStash,\n    });\n\n    if (validationResult.error) {\n      throw new InvalidTransactionError(\n        `Claim Builder Transaction validation failed: ${validationResult.error.message}`\n      );\n    }\n  }\n}\n"]}

package/dist/cjs/src/lib/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/lib/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAExD,qBAAa,sBAAuB,SAAQ,qBAAqB;gBACnD,gBAAgB,EAAE,MAAM;CAIrC;AAED,qBAAa,eAAgB,SAAQ,qBAAqB;gBAC5C,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM;CAIjD"}

package/dist/cjs/src/lib/errors.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidFeeError = exports.AddressValidationError = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+class AddressValidationError extends sdk_core_1.BuildTransactionError {
+    constructor(malformedAddress) {
+        super(`The address '${malformedAddress}' is not a well-formed dot address`);
+        this.name = AddressValidationError.name;
+    }
+}
+exports.AddressValidationError = AddressValidationError;
+class InvalidFeeError extends sdk_core_1.BuildTransactionError {
+    constructor(type, expectedType) {
+        super(`The specified type: "${type}" is not valid. Please provide the type: "${expectedType}"`);
+        this.name = InvalidFeeError.name;
+    }
+}
+exports.InvalidFeeError = InvalidFeeError;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9lcnJvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsOENBQXdEO0FBRXhELE1BQWEsc0JBQXVCLFNBQVEsZ0NBQXFCO0lBQy9ELFlBQVksZ0JBQXdCO1FBQ2xDLEtBQUssQ0FBQyxnQkFBZ0IsZ0JBQWdCLG9DQUFvQyxDQUFDLENBQUM7UUFDNUUsSUFBSSxDQUFDLElBQUksR0FBRyxzQkFBc0IsQ0FBQyxJQUFJLENBQUM7SUFDMUMsQ0FBQztDQUNGO0FBTEQsd0RBS0M7QUFFRCxNQUFhLGVBQWdCLFNBQVEsZ0NBQXFCO0lBQ3hELFlBQVksSUFBYSxFQUFFLFlBQXFCO1FBQzlDLEtBQUssQ0FBQyx3QkFBd0IsSUFBSSw2Q0FBNkMsWUFBWSxHQUFHLENBQUMsQ0FBQztRQUNoRyxJQUFJLENBQUMsSUFBSSxHQUFHLGVBQWUsQ0FBQyxJQUFJLENBQUM7SUFDbkMsQ0FBQztDQUNGO0FBTEQsMENBS0MiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCdWlsZFRyYW5zYWN0aW9uRXJyb3IgfSBmcm9tICdAYml0Z28vc2RrLWNvcmUnO1xuXG5leHBvcnQgY2xhc3MgQWRkcmVzc1ZhbGlkYXRpb25FcnJvciBleHRlbmRzIEJ1aWxkVHJhbnNhY3Rpb25FcnJvciB7XG4gIGNvbnN0cnVjdG9yKG1hbGZvcm1lZEFkZHJlc3M6IHN0cmluZykge1xuICAgIHN1cGVyKGBUaGUgYWRkcmVzcyAnJHttYWxmb3JtZWRBZGRyZXNzfScgaXMgbm90IGEgd2VsbC1mb3JtZWQgZG90IGFkZHJlc3NgKTtcbiAgICB0aGlzLm5hbWUgPSBBZGRyZXNzVmFsaWRhdGlvbkVycm9yLm5hbWU7XG4gIH1cbn1cblxuZXhwb3J0IGNsYXNzIEludmFsaWRGZWVFcnJvciBleHRlbmRzIEJ1aWxkVHJhbnNhY3Rpb25FcnJvciB7XG4gIGNvbnN0cnVjdG9yKHR5cGU/OiBzdHJpbmcsIGV4cGVjdGVkVHlwZT86IHN0cmluZykge1xuICAgIHN1cGVyKGBUaGUgc3BlY2lmaWVkIHR5cGU6IFwiJHt0eXBlfVwiIGlzIG5vdCB2YWxpZC4gUGxlYXNlIHByb3ZpZGUgdGhlIHR5cGU6IFwiJHtleHBlY3RlZFR5cGV9XCJgKTtcbiAgICB0aGlzLm5hbWUgPSBJbnZhbGlkRmVlRXJyb3IubmFtZTtcbiAgfVxufVxuIl19

package/dist/cjs/src/lib/iface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iface.d.ts","sourceRoot":"","sources":["../../../../src/lib/iface.ts"],"names":[],"mappings":"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"}

package/dist/cjs/src/lib/iface.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionTypes = exports.ProxyType = exports.MethodNames = exports.SectionNames = void 0;
+/**
+ * Section names for the transaction methods.
+ */
+var SectionNames;
+(function (SectionNames) {
+    SectionNames["Proxy"] = "proxy";
+    SectionNames["Staking"] = "staking";
+})(SectionNames || (exports.SectionNames = SectionNames = {}));
+/**
+ * Method names for the transaction method. Names change based on the type of transaction e.g 'bond' for the staking transaction
+ */
+var MethodNames;
+(function (MethodNames) {
+    /**
+     * Register a proxy account for the sender that is able to make calls on its behalf.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#addproxydelegate-multiaddress-proxy_type-kitchensinkruntimeproxytype-delay-u32
+     */
+    MethodNames["AddProxy"] = "addProxy";
+    /**
+     * Unregister a proxy account for the sender.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#removeproxydelegate-multiaddress-proxy_type-kitchensinkruntimeproxytype-delay-u32
+     */
+    MethodNames["RemoveProxy"] = "removeProxy";
+    /**
+     * Dispatch the given call from an account that the sender is authorised for through add_proxy.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#proxyreal-multiaddress-force_proxy_type-optionkitchensinkruntimeproxytype-call-call
+     */
+    MethodNames["Proxy"] = "proxy";
+    /**
+     * Take the origin account as a stash and lock up value of its balance. controller will be the account that controls it.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#bondcontroller-multiaddress-value-compactu128-payee-palletstakingrewarddestination
+     */
+    MethodNames["Bond"] = "bond";
+    /**
+     * Add some extra amount that have appeared in the stash free_balance into the balance up for staking.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#bondextramax_additional-compactu128
+     */
+    MethodNames["BondExtra"] = "bondExtra";
+    /**
+     * Transfer the entire transferable balance from the caller account.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#transferalldest-multiaddress-keep_alive-bool
+     */
+    MethodNames["TransferAll"] = "transferAll";
+    /**
+     * Same as the transfer call, but with a check that the transfer will not kill the origin account.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#transferkeepalivedest-multiaddress-value-compactu128
+     */
+    MethodNames["TransferKeepAlive"] = "transferKeepAlive";
+    /**
+     * Schedule a portion of the stash to be unlocked ready for transfer out after the bond period ends.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#unbondvalue-compactu128
+     */
+    MethodNames["Unbond"] = "unbond";
+    /**
+     * @deprecated Anonymous proxies were renamed to pure proxies.
+     *
+     * @see PureProxy
+     * @see https://polkadot.polkassembly.io/referendum/84
+     */
+    MethodNames["Anonymous"] = "anonymous";
+    /**
+     * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and initialize it with a proxy of proxy_type for origin sender.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#createpureproxy_type-kitchensinkruntimeproxytype-delay-u32-index-u16
+     */
+    MethodNames["PureProxy"] = "createPure";
+    /**
+     * Send a batch of dispatch calls.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#batchcalls-veccall
+     */
+    MethodNames["Batch"] = "batch";
+    /**
+     * Send a batch of dispatch calls and atomically execute them. The whole transaction will rollback and fail if any of the calls failed.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#batchallcalls-veccall
+     */
+    MethodNames["BatchAll"] = "batchAll";
+    /**
+     * Declare no desire to either validate or nominate.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#chill
+     */
+    MethodNames["Chill"] = "chill";
+    /**
+     * Remove any unlocked chunks from the unlocking queue from our management.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#withdrawunbondednum_slashing_spans-u32
+     */
+    MethodNames["WithdrawUnbonded"] = "withdrawUnbonded";
+    /**
+     * Pay out all the stakers behind a single validator for a single era.
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#payoutstakersvalidator_stash-accountid32-era-u32
+     */
+    MethodNames["PayoutStakers"] = "payoutStakers";
+})(MethodNames || (exports.MethodNames = MethodNames = {}));
+/**
+ * The types of proxies that can be setup and used
+ * https://wiki.polkadot.network/docs/learn-proxies#proxy-types
+ */
+var ProxyType;
+(function (ProxyType) {
+    ProxyType["ANY"] = "Any";
+    ProxyType["NON_TRANSFER"] = "NonTransfer";
+    ProxyType["STAKING"] = "Staking";
+    ProxyType["IDENTTITY_JUDGEMENT"] = "IdentityJudgement";
+    ProxyType["CANCEL_PROXY"] = "CancelProxy";
+})(ProxyType || (exports.ProxyType = ProxyType = {}));
+var TransactionTypes;
+(function (TransactionTypes) {
+    TransactionTypes["TRANSFER"] = "transfer";
+    TransactionTypes["STAKING"] = "staking";
+    TransactionTypes["ADDR_INIT"] = "addressInitialization";
+    TransactionTypes["UNSTAKING"] = "unstaking";
+})(TransactionTypes || (exports.TransactionTypes = TransactionTypes = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"iface.js","sourceRoot":"","sources":["../../../../src/lib/iface.ts"],"names":[],"mappings":";;;AAMA;;GAEG;AACH,IAAY,YAGX;AAHD,WAAY,YAAY;IACtB,+BAAe,CAAA;IACf,mCAAmB,CAAA;AACrB,CAAC,EAHW,YAAY,4BAAZ,YAAY,QAGvB;AAED;;GAEG;AACH,IAAY,WA4FX;AA5FD,WAAY,WAAW;IACrB;;;;OAIG;IACH,oCAAqB,CAAA;IACrB;;;;OAIG;IACH,0CAA2B,CAAA;IAC3B;;;;OAIG;IACH,8BAAe,CAAA;IACf;;;;OAIG;IACH,4BAAa,CAAA;IACb;;;;OAIG;IACH,sCAAuB,CAAA;IACvB;;;;OAIG;IACH,0CAA2B,CAAA;IAC3B;;;;OAIG;IACH,sDAAuC,CAAA;IACvC;;;;OAIG;IACH,gCAAiB,CAAA;IACjB;;;;;OAKG;IACH,sCAAuB,CAAA;IACvB;;;;OAIG;IACH,uCAAwB,CAAA;IACxB;;;;OAIG;IACH,8BAAe,CAAA;IACf;;;;OAIG;IACH,oCAAqB,CAAA;IACrB;;;;OAIG;IACH,8BAAe,CAAA;IACf;;;;OAIG;IACH,oDAAqC,CAAA;IACrC;;;;OAIG;IACH,8CAA+B,CAAA;AACjC,CAAC,EA5FW,WAAW,2BAAX,WAAW,QA4FtB;AAiGD;;;GAGG;AACH,IAAY,SAMX;AAND,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,yCAA4B,CAAA;IAC5B,gCAAmB,CAAA;IACnB,sDAAyC,CAAA;IACzC,yCAA4B,CAAA;AAC9B,CAAC,EANW,SAAS,yBAAT,SAAS,QAMpB;AAgJD,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,yCAAqB,CAAA;IACrB,uCAAmB,CAAA;IACnB,uDAAmC,CAAA;IACnC,2CAAuB,CAAA;AACzB,CAAC,EALW,gBAAgB,gCAAhB,gBAAgB,QAK3B","sourcesContent":["import { TransactionType, TransactionExplanation as BaseTransactionExplanation } from '@bitgo/sdk-core';\nimport { PolkadotSpecNameType } from '@bitgo/statics';\nimport { BaseTxInfo, TypeRegistry, DecodedUnsignedTx } from '@substrate/txwrapper-core/lib/types';\n\nexport { HexString } from '@polkadot/util/types';\n\n/**\n * Section names for the transaction methods.\n */\nexport enum SectionNames {\n  Proxy = 'proxy',\n  Staking = 'staking',\n}\n\n/**\n * Method names for the transaction method. Names change based on the type of transaction e.g 'bond' for the staking transaction\n */\nexport enum MethodNames {\n  /**\n   * Register a proxy account for the sender that is able to make calls on its behalf.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#addproxydelegate-multiaddress-proxy_type-kitchensinkruntimeproxytype-delay-u32\n   */\n  AddProxy = 'addProxy',\n  /**\n   * Unregister a proxy account for the sender.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#removeproxydelegate-multiaddress-proxy_type-kitchensinkruntimeproxytype-delay-u32\n   */\n  RemoveProxy = 'removeProxy',\n  /**\n   * Dispatch the given call from an account that the sender is authorised for through add_proxy.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#proxyreal-multiaddress-force_proxy_type-optionkitchensinkruntimeproxytype-call-call\n   */\n  Proxy = 'proxy',\n  /**\n   * Take the origin account as a stash and lock up value of its balance. controller will be the account that controls it.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#bondcontroller-multiaddress-value-compactu128-payee-palletstakingrewarddestination\n   */\n  Bond = 'bond',\n  /**\n   * Add some extra amount that have appeared in the stash free_balance into the balance up for staking.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#bondextramax_additional-compactu128\n   */\n  BondExtra = 'bondExtra',\n  /**\n   * Transfer the entire transferable balance from the caller account.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#transferalldest-multiaddress-keep_alive-bool\n   */\n  TransferAll = 'transferAll',\n  /**\n   * Same as the transfer call, but with a check that the transfer will not kill the origin account.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#transferkeepalivedest-multiaddress-value-compactu128\n   */\n  TransferKeepAlive = 'transferKeepAlive',\n  /**\n   * Schedule a portion of the stash to be unlocked ready for transfer out after the bond period ends.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#unbondvalue-compactu128\n   */\n  Unbond = 'unbond',\n  /**\n   * @deprecated Anonymous proxies were renamed to pure proxies.\n   *\n   * @see PureProxy\n   * @see https://polkadot.polkassembly.io/referendum/84\n   */\n  Anonymous = 'anonymous',\n  /**\n   * Spawn a fresh new account that is guaranteed to be otherwise inaccessible, and initialize it with a proxy of proxy_type for origin sender.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#createpureproxy_type-kitchensinkruntimeproxytype-delay-u32-index-u16\n   */\n  PureProxy = 'createPure', // Anonymous proxies were renamed to pure proxies\n  /**\n   * Send a batch of dispatch calls.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#batchcalls-veccall\n   */\n  Batch = 'batch',\n  /**\n   * Send a batch of dispatch calls and atomically execute them. The whole transaction will rollback and fail if any of the calls failed.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#batchallcalls-veccall\n   */\n  BatchAll = 'batchAll',\n  /**\n   * Declare no desire to either validate or nominate.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#chill\n   */\n  Chill = 'chill',\n  /**\n   * Remove any unlocked chunks from the unlocking queue from our management.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#withdrawunbondednum_slashing_spans-u32\n   */\n  WithdrawUnbonded = 'withdrawUnbonded',\n  /**\n   * Pay out all the stakers behind a single validator for a single era.\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#payoutstakersvalidator_stash-accountid32-era-u32\n   */\n  PayoutStakers = 'payoutStakers',\n}\n\n/**\n * The transaction data returned from the toJson() function of a transaction\n */\nexport interface TxData {\n  id: string;\n  sender: string;\n  referenceBlock: string;\n  blockNumber: number;\n  genesisHash: string;\n  nonce: number;\n  specVersion: number;\n  transactionVersion: number;\n  chainName: string;\n  method?: string;\n  specName?: string;\n  amount?: string;\n  to?: string;\n  tip?: number;\n  eraPeriod?: number;\n  controller?: string;\n  payee?: string;\n  owner?: string;\n  proxyType?: string;\n  delay?: string;\n  forceProxyType?: ProxyType;\n  index?: string;\n  batchCalls?: BatchCallObject[];\n  numSlashingSpans?: number;\n  validatorStash?: string;\n  claimEra?: string;\n  keepAlive?: boolean;\n}\n\n/**\n * Transaction method specific args\n */\nexport interface TransferArgs {\n  dest: { id: string };\n  value: string;\n}\n\n/**\n * Transaction method specific args\n */\nexport interface TransferAllArgs {\n  dest: { id: string };\n  keepAlive: boolean;\n}\n\n/**\n * Transaction method specific args\n */\nexport type StakeArgsPayee =\n  | 'Staked'\n  | 'Stash'\n  | 'Controller'\n  | {\n      Account: string;\n    };\n\n/**\n * Transaction method specific args\n */\nexport type StakeArgsPayeeRaw = { controller?: null; stash?: null; staked?: null; account?: string };\n\n/**\n * Transaction method specific args\n */\nexport interface StakeArgs {\n  value: string;\n  controller: { id: string };\n  payee: StakeArgsPayee;\n}\n\nexport interface StakeMoreArgs {\n  maxAdditional: string;\n}\n\nexport interface StakeMoreCallArgs {\n  max_additional: string;\n}\n\nexport interface UnstakeArgs {\n  value: string;\n}\n\nexport interface WithdrawUnstakedArgs {\n  numSlashingSpans: number;\n}\n\nexport interface ClaimArgs {\n  validatorStash: string;\n  era: string;\n}\n\n/**\n * The types of proxies that can be setup and used\n * https://wiki.polkadot.network/docs/learn-proxies#proxy-types\n */\nexport enum ProxyType {\n  ANY = 'Any',\n  NON_TRANSFER = 'NonTransfer',\n  STAKING = 'Staking',\n  IDENTTITY_JUDGEMENT = 'IdentityJudgement',\n  CANCEL_PROXY = 'CancelProxy',\n}\n\n/**\n * Transaction method specific args\n */\nexport interface AddProxyArgs {\n  delegate: string | AccountId;\n  delay: string;\n  proxyType: ProxyType;\n}\n\n/**\n * Transaction method specific args\n */\nexport interface AddAnonymousProxyArgs {\n  proxyType: ProxyType;\n  index: string;\n  delay: string;\n}\n\n/**\n * Transaction method specific args\n */\nexport type BatchCallObject = {\n  callIndex: string;\n  args:\n    | Record<string, any>\n    | AddProxyBatchCallArgs\n    | AddAnonymousProxyBatchCallArgs\n    | StakeBatchCallArgs\n    | StakeMoreArgs\n    | StakeMoreCallArgs\n    | UnbondCallArgs;\n};\nexport interface BatchArgs {\n  calls: BatchCallObject[];\n}\n\nexport interface AddAnonymousProxyBatchCallArgs {\n  // Using snake_case here to be compatible with the library we use to decode\n  // polkadot transactions\n  proxy_type: ProxyType;\n  index: number;\n  delay: number;\n}\n\nexport interface AddProxyBatchCallArgs {\n  delegate: string | AccountId;\n  proxy_type: ProxyType;\n  delay: number;\n}\n\nexport type AccountId = { id: string };\n\nexport type StakeBatchCallPayeeStaked = { staked: null };\nexport type StakeBatchCallPayeeStash = { stash: null };\nexport type StakeBatchCallPayeeController = { controller: null };\nexport type StakeBatchCallPayeeAccount = { account: string };\n\nexport type StakeBatchCallPayee =\n  | StakeBatchCallPayeeStaked\n  | StakeBatchCallPayeeStash\n  | StakeBatchCallPayeeController\n  | StakeBatchCallPayeeAccount;\n\nexport interface StakeBatchCallArgs {\n  value: string;\n  controller?: { id: string };\n  payee: StakeBatchCallPayee;\n}\n\nexport interface UnstakeBatchCallArgs {\n  value: string;\n}\n\nexport interface UnbondCallArgs {\n  value: string;\n}\n\n/**\n * Transaction method specific args\n */\nexport type ProxyCallArgs = {\n  callIndex: string;\n  args: TransferArgs;\n};\n\n/**\n * Transaction method specific args\n */\nexport interface ProxyArgs {\n  real: string | AccountId;\n  forceProxyType: ProxyType;\n}\n\n/**\n * Decoded TxMethod from a transaction hex\n */\nexport interface TxMethod {\n  args:\n    | TransferArgs\n    | TransferAllArgs\n    | StakeArgs\n    | StakeMoreArgs\n    | AddProxyArgs\n    | ProxyArgs\n    | UnstakeArgs\n    | AddAnonymousProxyArgs\n    | BatchArgs\n    | WithdrawUnstakedArgs\n    | ClaimArgs;\n  name: MethodNames;\n  pallet: string;\n}\n\n/**\n * Modified unsigned transaction with a decoded method instead of a method hex\n */\nexport interface DecodedTx extends Omit<DecodedUnsignedTx, 'method'> {\n  method: TxMethod;\n}\n\n/**\n * Base transaction info shared across all types of transactions\n */\nexport interface CreateBaseTxInfo {\n  baseTxInfo: BaseTxInfo;\n  options: {\n    metadataRpc: `0x${string}`;\n    registry: TypeRegistry;\n    isImmortalEra?: boolean;\n  };\n}\n\nexport interface TransactionExplanation extends BaseTransactionExplanation {\n  type: TransactionType;\n  forceProxyType?: ProxyType;\n  controller?: string;\n  payee?: string;\n  owner?: string;\n  proxyType?: string;\n  delay?: string;\n}\n\nexport enum TransactionTypes {\n  TRANSFER = 'transfer',\n  STAKING = 'staking',\n  ADDR_INIT = 'addressInitialization',\n  UNSTAKING = 'unstaking',\n}\nexport interface Material {\n  genesisHash: string;\n  chainName: string;\n  specName: PolkadotSpecNameType;\n  specVersion: number;\n  txVersion: number;\n  metadata: `0x${string}`;\n}\n"]}

package/dist/cjs/src/lib/iface_utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iface_utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/iface_utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,YAAY,EACZ,qBAAqB,EACrB,mBAAmB,EACnB,0BAA0B,EAC1B,6BAA6B,EAC7B,yBAAyB,EACzB,wBAAwB,EACxB,SAAS,EACV,MAAM,SAAS,CAAC;AAEjB;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,IAAI,SAAS,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,qBAAqB,GAAG,YAAY,GAAG,MAAM,CAMrF;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,mBAAmB,GAAG,KAAK,IAAI,yBAAyB,CAE1G;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,mBAAmB,GAAG,KAAK,IAAI,wBAAwB,CAExG;AAED;;;;;;GAMG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE,mBAAmB,GAAG,KAAK,IAAI,6BAA6B,CAElH;AAED;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,mBAAmB,GAAG,KAAK,IAAI,0BAA0B,CAK5G;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAMlD"}