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

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

@@ -0,0 +1,84 @@
+import { Transaction, TransactionBuilder } from '@bitgo-beta/abstract-substrate';
+import { TransactionType, BaseAddress } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';
+export declare class MoveStakeBuilder extends TransactionBuilder {
+    protected _originHotkey: string;
+    protected _destinationHotkey: string;
+    protected _originNetuid: string;
+    protected _destinationNetuid: string;
+    protected _alphaAmount: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Construct a transaction to move stake
+     * @returns {UnsignedTransaction} an unsigned move stake transaction
+     */
+    protected buildTransaction(): UnsignedTransaction;
+    /** @inheritdoc */
+    protected get transactionType(): TransactionType;
+    /**
+     * Set the amount to move
+     * @param {string} amount to move
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    amount(amount: string): this;
+    /**
+     * Set the origin hot key address
+     * @param {string} address of origin hotkey
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    originHotkey({ address }: BaseAddress): this;
+    /**
+     * Set the destination hot key address
+     * @param {string} address of destination hotkey
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    destinationHotkey({ address }: BaseAddress): this;
+    /**
+     * Set the origin netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    originNetuid(netuid: string): this;
+    /**
+     * Set the destination netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    destinationNetuid(netuid: string): this;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    validateTransaction(_: Transaction): void;
+    /**
+     * @param {BigNumber} amount amount to validate
+     * @throws {InvalidTransactionError} if amount is less than or equal to zero
+     */
+    private validateAmount;
+    /**
+     * @param {string} netuid netuid to validate
+     * @throws {InvalidTransactionError} if netuid is out of range
+     */
+    private validateNetuid;
+    /**
+     * Helper method to validate whether tx params have the correct type and format
+     * @param {string} originHotkey origin hotkey address
+     * @param {string} destinationHotkey destination hotkey address
+     * @param {string} originNetuid netuid of the origin subnet
+     * @param {string} destinationNetuid netuid of the destination subnet
+     * @param {string} alphaAmount amount to move
+     * @throws {InvalidTransactionError} if validation fails
+     */
+    private validateFields;
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction: string): void;
+    /**
+     * Construct a transaction to move stake
+     *
+     * @param {Interface.MoveStakeArgs} args arguments to be passed to the moveStake method
+     * @param {Interface.CreateBaseTxInfo} info txn info required to construct the moveStake txn
+     * @returns {UnsignedTransaction} an unsigned move stake transaction
+     */
+    private moveStake;
+}
+//# sourceMappingURL=moveStakeBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moveStakeBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/moveStakeBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,WAAW,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpG,OAAO,EAA2B,eAAe,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAgB,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAKtH,qBAAa,gBAAiB,SAAQ,kBAAkB;IACtD,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,aAAa,EAAE,MAAM,CAAC;IAChC,SAAS,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACrC,SAAS,CAAC,YAAY,EAAE,MAAM,CAAC;gBAEnB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C;;;OAGG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAcjD,kBAAkB;IAClB,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAO5B;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,IAAI;IAM5C;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,IAAI;IAMjD;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMlC;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAMvC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAgBjE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAWzC;;;OAGG;IACH,OAAO,CAAC,cAAc;IAMtB;;;OAGG;IACH,OAAO,CAAC,cAAc;IAetB;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAwBtB,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAa7G;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;CAalB"}

package/dist/src/lib/moveStakeBuilder.js

@@ -0,0 +1,182 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveStakeBuilder = void 0;
+const abstract_substrate_1 = require("@bitgo-beta/abstract-substrate");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const txwrapper_core_1 = require("@substrate/txwrapper-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const constants_1 = require("./constants");
+const moveStakeTransaction_1 = require("./moveStakeTransaction");
+class MoveStakeBuilder extends abstract_substrate_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new moveStakeTransaction_1.MoveStakeTransaction(_coinConfig);
+    }
+    /**
+     * Construct a transaction to move stake
+     * @returns {UnsignedTransaction} an unsigned move stake transaction
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return this.moveStake({
+            originHotkey: this._originHotkey,
+            destinationHotkey: this._destinationHotkey,
+            originNetuid: this._originNetuid,
+            destinationNetuid: this._destinationNetuid,
+            alphaAmount: this._alphaAmount,
+        }, baseTxInfo);
+    }
+    /** @inheritdoc */
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingRedelegate;
+    }
+    /**
+     * Set the amount to move
+     * @param {string} amount to move
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    amount(amount) {
+        const value = new bignumber_js_1.default(amount);
+        this.validateAmount(value);
+        this._alphaAmount = amount;
+        return this;
+    }
+    /**
+     * Set the origin hot key address
+     * @param {string} address of origin hotkey
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    originHotkey({ address }) {
+        this.validateAddress({ address });
+        this._originHotkey = address;
+        return this;
+    }
+    /**
+     * Set the destination hot key address
+     * @param {string} address of destination hotkey
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    destinationHotkey({ address }) {
+        this.validateAddress({ address });
+        this._destinationHotkey = address;
+        return this;
+    }
+    /**
+     * Set the origin netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    originNetuid(netuid) {
+        this.validateNetuid(netuid);
+        this._originNetuid = netuid;
+        return this;
+    }
+    /**
+     * Set the destination netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {MoveStakeBuilder} This builder.
+     */
+    destinationNetuid(netuid) {
+        this.validateNetuid(netuid);
+        this._destinationNetuid = netuid;
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name !== abstract_substrate_1.Interface.MethodNames.MoveStake) {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected ${abstract_substrate_1.Interface.MethodNames.MoveStake}`);
+        }
+        const txMethod = this._method.args;
+        this.amount(txMethod.alphaAmount);
+        this.originHotkey({ address: txMethod.originHotkey });
+        this.destinationHotkey({ address: txMethod.destinationHotkey });
+        this.originNetuid(txMethod.originNetuid);
+        this.destinationNetuid(txMethod.destinationNetuid);
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields(this._originHotkey, this._destinationHotkey, this._originNetuid, this._destinationNetuid, this._alphaAmount);
+    }
+    /**
+     * @param {BigNumber} amount amount to validate
+     * @throws {InvalidTransactionError} if amount is less than or equal to zero
+     */
+    validateAmount(amount) {
+        if (amount.isLessThanOrEqualTo(0)) {
+            throw new sdk_core_1.InvalidTransactionError('Amount must be greater than zero');
+        }
+    }
+    /**
+     * @param {string} netuid netuid to validate
+     * @throws {InvalidTransactionError} if netuid is out of range
+     */
+    validateNetuid(netuid) {
+        const trimmed = netuid.trim();
+        if (!/^\d+$/.test(trimmed)) {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid netuid: ${netuid}. Must be a non-negative integer.`);
+        }
+        const num = Number(trimmed);
+        if (num < 0 || num > constants_1.TAO_CONSTANTS.MAX_NETUID) {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid netuid: ${netuid}. Netuid must be between 0 and ${constants_1.TAO_CONSTANTS.MAX_NETUID}.`);
+        }
+    }
+    /**
+     * Helper method to validate whether tx params have the correct type and format
+     * @param {string} originHotkey origin hotkey address
+     * @param {string} destinationHotkey destination hotkey address
+     * @param {string} originNetuid netuid of the origin subnet
+     * @param {string} destinationNetuid netuid of the destination subnet
+     * @param {string} alphaAmount amount to move
+     * @throws {InvalidTransactionError} if validation fails
+     */
+    validateFields(originHotkey, destinationHotkey, originNetuid, destinationNetuid, alphaAmount) {
+        // Validate netuid ranges
+        this.validateNetuid(originNetuid);
+        this.validateNetuid(destinationNetuid);
+        const validationResult = abstract_substrate_1.Schema.MoveStakeTransactionSchema.validate({
+            originHotkey,
+            destinationHotkey,
+            originNetuid,
+            destinationNetuid,
+            alphaAmount,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn, rawTransaction) {
+        if (decodedTxn.method?.name === abstract_substrate_1.Interface.MethodNames.MoveStake) {
+            const txMethod = decodedTxn.method.args;
+            const validationResult = abstract_substrate_1.Schema.MoveStakeTransactionSchema.validate(txMethod);
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Move Stake Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+    }
+    /**
+     * Construct a transaction to move stake
+     *
+     * @param {Interface.MoveStakeArgs} args arguments to be passed to the moveStake method
+     * @param {Interface.CreateBaseTxInfo} info txn info required to construct the moveStake txn
+     * @returns {UnsignedTransaction} an unsigned move stake transaction
+     */
+    moveStake(args, info) {
+        return (0, txwrapper_core_1.defineMethod)({
+            method: {
+                args,
+                name: 'moveStake',
+                pallet: 'subtensorModule',
+            },
+            ...info.baseTxInfo,
+        }, info.options);
+    }
+}
+exports.MoveStakeBuilder = MoveStakeBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"moveStakeBuilder.js","sourceRoot":"","sources":["../../../src/lib/moveStakeBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Interface, Schema, Transaction, TransactionBuilder } from '@bitgo-beta/abstract-substrate';\nimport { InvalidTransactionError, TransactionType, BaseAddress } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { DecodedSignedTx, DecodedSigningPayload, defineMethod, UnsignedTransaction } from '@substrate/txwrapper-core';\nimport BigNumber from 'bignumber.js';\nimport { TAO_CONSTANTS } from './constants';\nimport { MoveStakeTransaction } from './moveStakeTransaction';\n\nexport class MoveStakeBuilder extends TransactionBuilder {\n  protected _originHotkey: string;\n  protected _destinationHotkey: string;\n  protected _originNetuid: string;\n  protected _destinationNetuid: string;\n  protected _alphaAmount: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new MoveStakeTransaction(_coinConfig);\n  }\n\n  /**\n   * Construct a transaction to move stake\n   * @returns {UnsignedTransaction} an unsigned move stake transaction\n   */\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    return this.moveStake(\n      {\n        originHotkey: this._originHotkey,\n        destinationHotkey: this._destinationHotkey,\n        originNetuid: this._originNetuid,\n        destinationNetuid: this._destinationNetuid,\n        alphaAmount: this._alphaAmount,\n      },\n      baseTxInfo\n    );\n  }\n\n  /** @inheritdoc */\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingRedelegate;\n  }\n\n  /**\n   * Set the amount to move\n   * @param {string} amount to move\n   * @returns {MoveStakeBuilder} This builder.\n   */\n  amount(amount: string): this {\n    const value = new BigNumber(amount);\n    this.validateAmount(value);\n    this._alphaAmount = amount;\n    return this;\n  }\n\n  /**\n   * Set the origin hot key address\n   * @param {string} address of origin hotkey\n   * @returns {MoveStakeBuilder} This builder.\n   */\n  originHotkey({ address }: BaseAddress): this {\n    this.validateAddress({ address });\n    this._originHotkey = address;\n    return this;\n  }\n\n  /**\n   * Set the destination hot key address\n   * @param {string} address of destination hotkey\n   * @returns {MoveStakeBuilder} This builder.\n   */\n  destinationHotkey({ address }: BaseAddress): this {\n    this.validateAddress({ address });\n    this._destinationHotkey = address;\n    return this;\n  }\n\n  /**\n   * Set the origin netuid of the subnet (root network is 0)\n   * @param {string} netuid of subnet\n   * @returns {MoveStakeBuilder} This builder.\n   */\n  originNetuid(netuid: string): this {\n    this.validateNetuid(netuid);\n    this._originNetuid = netuid;\n    return this;\n  }\n\n  /**\n   * Set the destination netuid of the subnet (root network is 0)\n   * @param {string} netuid of subnet\n   * @returns {MoveStakeBuilder} This builder.\n   */\n  destinationNetuid(netuid: string): this {\n    this.validateNetuid(netuid);\n    this._destinationNetuid = netuid;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = super.fromImplementation(rawTransaction);\n    if (this._method?.name !== Interface.MethodNames.MoveStake) {\n      throw new InvalidTransactionError(\n        `Invalid Transaction Type: ${this._method?.name}. Expected ${Interface.MethodNames.MoveStake}`\n      );\n    }\n    const txMethod = this._method.args as Interface.MoveStakeArgs;\n    this.amount(txMethod.alphaAmount);\n    this.originHotkey({ address: txMethod.originHotkey });\n    this.destinationHotkey({ address: txMethod.destinationHotkey });\n    this.originNetuid(txMethod.originNetuid);\n    this.destinationNetuid(txMethod.destinationNetuid);\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields(\n      this._originHotkey,\n      this._destinationHotkey,\n      this._originNetuid,\n      this._destinationNetuid,\n      this._alphaAmount\n    );\n  }\n\n  /**\n   * @param {BigNumber} amount amount to validate\n   * @throws {InvalidTransactionError} if amount is less than or equal to zero\n   */\n  private validateAmount(amount: BigNumber): void {\n    if (amount.isLessThanOrEqualTo(0)) {\n      throw new InvalidTransactionError('Amount must be greater than zero');\n    }\n  }\n\n  /**\n   * @param {string} netuid netuid to validate\n   * @throws {InvalidTransactionError} if netuid is out of range\n   */\n  private validateNetuid(netuid: string): void {\n    const trimmed = netuid.trim();\n\n    if (!/^\\d+$/.test(trimmed)) {\n      throw new InvalidTransactionError(`Invalid netuid: ${netuid}. Must be a non-negative integer.`);\n    }\n\n    const num = Number(trimmed);\n    if (num < 0 || num > TAO_CONSTANTS.MAX_NETUID) {\n      throw new InvalidTransactionError(\n        `Invalid netuid: ${netuid}. Netuid must be between 0 and ${TAO_CONSTANTS.MAX_NETUID}.`\n      );\n    }\n  }\n\n  /**\n   * Helper method to validate whether tx params have the correct type and format\n   * @param {string} originHotkey origin hotkey address\n   * @param {string} destinationHotkey destination hotkey address\n   * @param {string} originNetuid netuid of the origin subnet\n   * @param {string} destinationNetuid netuid of the destination subnet\n   * @param {string} alphaAmount amount to move\n   * @throws {InvalidTransactionError} if validation fails\n   */\n  private validateFields(\n    originHotkey: string,\n    destinationHotkey: string,\n    originNetuid: string,\n    destinationNetuid: string,\n    alphaAmount: string\n  ): void {\n    // Validate netuid ranges\n    this.validateNetuid(originNetuid);\n    this.validateNetuid(destinationNetuid);\n\n    const validationResult = Schema.MoveStakeTransactionSchema.validate({\n      originHotkey,\n      destinationHotkey,\n      originNetuid,\n      destinationNetuid,\n      alphaAmount,\n    });\n\n    if (validationResult.error) {\n      throw new InvalidTransactionError(`Transaction validation failed: ${validationResult.error.message}`);\n    }\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction: string): void {\n    if (decodedTxn.method?.name === Interface.MethodNames.MoveStake) {\n      const txMethod = decodedTxn.method.args as unknown as Interface.MoveStakeArgs;\n\n      const validationResult = Schema.MoveStakeTransactionSchema.validate(txMethod);\n      if (validationResult.error) {\n        throw new InvalidTransactionError(\n          `Move Stake Transaction validation failed: ${validationResult.error.message}`\n        );\n      }\n    }\n  }\n\n  /**\n   * Construct a transaction to move stake\n   *\n   * @param {Interface.MoveStakeArgs} args arguments to be passed to the moveStake method\n   * @param {Interface.CreateBaseTxInfo} info txn info required to construct the moveStake txn\n   * @returns {UnsignedTransaction} an unsigned move stake transaction\n   */\n  private moveStake(args: Interface.MoveStakeArgs, info: Interface.CreateBaseTxInfo): UnsignedTransaction {\n    return defineMethod(\n      {\n        method: {\n          args,\n          name: 'moveStake',\n          pallet: 'subtensorModule',\n        },\n        ...info.baseTxInfo,\n      },\n      info.options\n    );\n  }\n}\n"]}

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

@@ -0,0 +1,10 @@
+import { Interface as SubstrateInterface, Transaction as SubstrateTransaction } from '@bitgo-beta/abstract-substrate';
+export declare class MoveStakeTransaction extends SubstrateTransaction {
+    /** @inheritdoc */
+    toJson(): SubstrateInterface.TxData;
+    /** @inheritdoc */
+    loadInputsAndOutputs(): void;
+    /** @inheritdoc */
+    explainTransaction(): SubstrateInterface.TransactionExplanation;
+}
+//# sourceMappingURL=moveStakeTransaction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"moveStakeTransaction.d.ts","sourceRoot":"","sources":["../../../src/lib/moveStakeTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,kBAAkB,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAMtH,qBAAa,oBAAqB,SAAQ,oBAAoB;IAC5D,kBAAkB;IAClB,MAAM,IAAI,kBAAkB,CAAC,MAAM;IAsBnC,kBAAkB;IAClB,oBAAoB,IAAI,IAAI;IAuB5B,kBAAkB;IAClB,kBAAkB,IAAI,kBAAkB,CAAC,sBAAsB;CAwBhE"}

package/dist/src/lib/moveStakeTransaction.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveStakeTransaction = void 0;
+const abstract_substrate_1 = require("@bitgo-beta/abstract-substrate");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const utils_1 = __importDefault(require("./utils"));
+class MoveStakeTransaction extends abstract_substrate_1.Transaction {
+    /** @inheritdoc */
+    toJson() {
+        if (!this._substrateTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        const decodedTx = (0, txwrapper_polkadot_1.decode)(this._substrateTransaction, {
+            metadataRpc: this._substrateTransaction.metadataRpc,
+            registry: this._registry,
+            isImmortalEra: utils_1.default.isZeroHex(this._substrateTransaction.era),
+        });
+        const txMethod = decodedTx.method.args;
+        const result = super.toJson();
+        result.originHotkey = txMethod.originHotkey;
+        result.destinationHotkey = txMethod.destinationHotkey;
+        result.originNetuid = txMethod.originNetuid;
+        result.destinationNetuid = txMethod.destinationNetuid;
+        result.alphaAmount = txMethod.alphaAmount;
+        return result;
+    }
+    /** @inheritdoc */
+    loadInputsAndOutputs() {
+        super.loadInputsAndOutputs();
+        const decodedTx = (0, txwrapper_polkadot_1.decode)(this._substrateTransaction, {
+            metadataRpc: this._substrateTransaction.metadataRpc,
+            registry: this._registry,
+            isImmortalEra: utils_1.default.isZeroHex(this._substrateTransaction.era),
+        });
+        const txMethod = decodedTx.method.args;
+        this._inputs.push({
+            address: txMethod.originHotkey,
+            value: txMethod.alphaAmount,
+            coin: utils_1.default.getTaoTokenBySubnetId(txMethod.originNetuid).name,
+        });
+        this._outputs.push({
+            address: txMethod.destinationHotkey,
+            value: txMethod.alphaAmount,
+            coin: utils_1.default.getTaoTokenBySubnetId(txMethod.destinationNetuid).name,
+        });
+    }
+    /** @inheritdoc */
+    explainTransaction() {
+        const result = this.toJson();
+        const outputs = this._outputs.map((output) => {
+            return {
+                address: output.address,
+                amount: output.value,
+                tokenName: output.coin,
+            };
+        });
+        const explanationResult = {
+            id: result.id,
+            outputAmount: result.amount?.toString() || '0',
+            changeAmount: '0',
+            changeOutputs: [],
+            outputs,
+            fee: {
+                fee: result.tip?.toString() || '',
+                type: 'tip',
+            },
+            type: this.type,
+        };
+        return explanationResult;
+    }
+}
+exports.MoveStakeTransaction = MoveStakeTransaction;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,63 @@
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { UnsignedTransaction, DecodedSignedTx, DecodedSigningPayload } from '@substrate/txwrapper-core';
+import { TransactionType, BaseAddress } from '@bitgo-beta/sdk-core';
+import { Transaction, TransactionBuilder } from '@bitgo-beta/abstract-substrate';
+export declare class StakingBuilder extends TransactionBuilder {
+    protected _amount: string;
+    protected _hotkey: string;
+    protected _netuid: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Construct a transaction to stake
+     * @returns {UnsignedTransaction} an unsigned stake TAO transaction
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#staking
+     */
+    protected buildTransaction(): UnsignedTransaction;
+    /** @inheritdoc */
+    protected get transactionType(): TransactionType;
+    /**
+     * Set the amount to stake
+     * @param {string} amount to stake
+     * @returns {StakingBuilder} This staking builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-nominator#required-minimum-stake
+     */
+    amount(amount: string): this;
+    /**
+     * Set the validator hot key address
+     * @param {string} hotkey address of validator
+     * @returns {StakingBuilder} This staking builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-staking#accounts
+     */
+    hotkey({ address }: BaseAddress): this;
+    /**
+     * Set netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {StakingBuilder} This staking builder.
+     */
+    netuid(netuid: string): this;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    validateTransaction(_: Transaction): void;
+    /**
+     * Helper method to validate whether stake params have the correct type and format
+     * @param {string} amountStaked amount to stake
+     * @param {string} hotkey hotkey address of the validator
+     * @param {string} netuid netuid of the subnet
+     */
+    private validateFields;
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction: string): void;
+    /**
+     * Construct a transaction to stake
+     *
+     * @param {Interface.AddStakeArgs} Stake arguments to be passed to the addStake method
+     * @param {Interface.CreateBaseTxInfo} Base txn info required to construct the addStake txn
+     * @returns {UnsignedTransaction} an unsigned stake TAO transaction
+     */
+    private addStake;
+}
+//# sourceMappingURL=stakingBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stakingBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/stakingBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAgB,mBAAmB,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAEtH,OAAO,EAA2B,eAAe,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAqB,MAAM,gCAAgC,CAAC;AAEpG,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEd,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;;OAKG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAYjD,kBAAkB;IAClB,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,IAAI;IAMtC;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK5B,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAajE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAKzC;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IActB,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAa7G;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ;CAajB"}

package/dist/src/lib/stakingBuilder.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingBuilder = void 0;
+const txwrapper_core_1 = require("@substrate/txwrapper-core");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const abstract_substrate_1 = require("@bitgo-beta/abstract-substrate");
+class StakingBuilder extends abstract_substrate_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /**
+     * Construct a transaction to stake
+     * @returns {UnsignedTransaction} an unsigned stake TAO transaction
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#staking
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return this.addStake({
+            amountStaked: this._amount,
+            hotkey: this._hotkey,
+            netuid: this._netuid,
+        }, baseTxInfo);
+    }
+    /** @inheritdoc */
+    get transactionType() {
+        return sdk_core_1.TransactionType.StakingActivate;
+    }
+    /**
+     * Set the amount to stake
+     * @param {string} amount to stake
+     * @returns {StakingBuilder} This staking builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-nominator#required-minimum-stake
+     */
+    amount(amount) {
+        this.validateValue(new bignumber_js_1.default(amount));
+        this._amount = amount;
+        return this;
+    }
+    /**
+     * Set the validator hot key address
+     * @param {string} hotkey address of validator
+     * @returns {StakingBuilder} This staking builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-staking#accounts
+     */
+    hotkey({ address }) {
+        this.validateAddress({ address });
+        this._hotkey = address;
+        return this;
+    }
+    /**
+     * Set netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {StakingBuilder} This staking builder.
+     */
+    netuid(netuid) {
+        this._netuid = netuid;
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name === abstract_substrate_1.Interface.MethodNames.AddStake) {
+            const txMethod = this._method.args;
+            this.amount(txMethod.amountStaked);
+            this.hotkey({ address: txMethod.hotkey });
+            this.netuid(txMethod.netuid);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected addStake`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields(this._amount, this._hotkey, this._netuid);
+    }
+    /**
+     * Helper method to validate whether stake params have the correct type and format
+     * @param {string} amountStaked amount to stake
+     * @param {string} hotkey hotkey address of the validator
+     * @param {string} netuid netuid of the subnet
+     */
+    validateFields(amountStaked, hotkey, netuid) {
+        const validationResult = abstract_substrate_1.Schema.StakeTransactionSchema.validate({
+            amountStaked,
+            hotkey,
+            netuid,
+        });
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Stake Builder Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn, rawTransaction) {
+        if (decodedTxn.method?.name === abstract_substrate_1.Interface.MethodNames.AddStake) {
+            const txMethod = decodedTxn.method.args;
+            const amountStaked = txMethod.amountStaked;
+            const hotkey = txMethod.hotkey;
+            const netuid = txMethod.netuid;
+            const validationResult = abstract_substrate_1.Schema.StakeTransactionSchema.validate({ amountStaked, hotkey, netuid });
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Transfer Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+    }
+    /**
+     * Construct a transaction to stake
+     *
+     * @param {Interface.AddStakeArgs} Stake arguments to be passed to the addStake method
+     * @param {Interface.CreateBaseTxInfo} Base txn info required to construct the addStake txn
+     * @returns {UnsignedTransaction} an unsigned stake TAO transaction
+     */
+    addStake(args, info) {
+        return (0, txwrapper_core_1.defineMethod)({
+            method: {
+                args,
+                name: 'addStake',
+                pallet: 'subtensorModule',
+            },
+            ...info.baseTxInfo,
+        }, info.options);
+    }
+}
+exports.StakingBuilder = StakingBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"stakingBuilder.js","sourceRoot":"","sources":["../../../src/lib/stakingBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { defineMethod, UnsignedTransaction, DecodedSignedTx, DecodedSigningPayload } from '@substrate/txwrapper-core';\nimport BigNumber from 'bignumber.js';\nimport { InvalidTransactionError, TransactionType, BaseAddress } from '@bitgo-beta/sdk-core';\nimport { Transaction, TransactionBuilder, Interface, Schema } from '@bitgo-beta/abstract-substrate';\n\nexport class StakingBuilder extends TransactionBuilder {\n  protected _amount: string;\n  protected _hotkey: string;\n  protected _netuid: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Construct a transaction to stake\n   * @returns {UnsignedTransaction} an unsigned stake TAO transaction\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#staking\n   */\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    return this.addStake(\n      {\n        amountStaked: this._amount,\n        hotkey: this._hotkey,\n        netuid: this._netuid,\n      },\n      baseTxInfo\n    );\n  }\n\n  /** @inheritdoc */\n  protected get transactionType(): TransactionType {\n    return TransactionType.StakingActivate;\n  }\n\n  /**\n   * Set the amount to stake\n   * @param {string} amount to stake\n   * @returns {StakingBuilder} This staking builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-nominator#required-minimum-stake\n   */\n  amount(amount: string): this {\n    this.validateValue(new BigNumber(amount));\n    this._amount = amount;\n    return this;\n  }\n\n  /**\n   * Set the validator hot key address\n   * @param {string} hotkey address of validator\n   * @returns {StakingBuilder} This staking builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-staking#accounts\n   */\n  hotkey({ address }: BaseAddress): this {\n    this.validateAddress({ address });\n    this._hotkey = address;\n    return this;\n  }\n\n  /**\n   * Set netuid of the subnet (root network is 0)\n   * @param {string} netuid of subnet\n   * @returns {StakingBuilder} This staking builder.\n   */\n  netuid(netuid: string): this {\n    this._netuid = netuid;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = super.fromImplementation(rawTransaction);\n    if (this._method?.name === Interface.MethodNames.AddStake) {\n      const txMethod = this._method.args as Interface.AddStakeArgs;\n      this.amount(txMethod.amountStaked);\n      this.hotkey({ address: txMethod.hotkey });\n      this.netuid(txMethod.netuid);\n    } else {\n      throw new InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected addStake`);\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields(this._amount, this._hotkey, this._netuid);\n  }\n\n  /**\n   * Helper method to validate whether stake params have the correct type and format\n   * @param {string} amountStaked amount to stake\n   * @param {string} hotkey hotkey address of the validator\n   * @param {string} netuid netuid of the subnet\n   */\n  private validateFields(amountStaked: string, hotkey: string, netuid: string): void {\n    const validationResult = Schema.StakeTransactionSchema.validate({\n      amountStaked,\n      hotkey,\n      netuid,\n    });\n\n    if (validationResult.error) {\n      throw new InvalidTransactionError(\n        `Stake Builder Transaction validation failed: ${validationResult.error.message}`\n      );\n    }\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction: string): void {\n    if (decodedTxn.method?.name === Interface.MethodNames.AddStake) {\n      const txMethod = decodedTxn.method.args as unknown as Interface.AddStakeArgs;\n      const amountStaked = txMethod.amountStaked;\n      const hotkey = txMethod.hotkey;\n      const netuid = txMethod.netuid;\n      const validationResult = Schema.StakeTransactionSchema.validate({ amountStaked, hotkey, netuid });\n      if (validationResult.error) {\n        throw new InvalidTransactionError(`Transfer Transaction validation failed: ${validationResult.error.message}`);\n      }\n    }\n  }\n\n  /**\n   * Construct a transaction to stake\n   *\n   * @param {Interface.AddStakeArgs} Stake arguments to be passed to the addStake method\n   * @param {Interface.CreateBaseTxInfo} Base txn info required to construct the addStake txn\n   * @returns {UnsignedTransaction} an unsigned stake TAO transaction\n   */\n  private addStake(args: Interface.AddStakeArgs, info: Interface.CreateBaseTxInfo): UnsignedTransaction {\n    return defineMethod(\n      {\n        method: {\n          args,\n          name: 'addStake',\n          pallet: 'subtensorModule',\n        },\n        ...info.baseTxInfo,\n      },\n      info.options\n    );\n  }\n}\n"]}