@bitgo-beta/sdk-coin-tao 1.0.1-alpha.17 → 1.0.1-alpha.171

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"]}

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

@@ -0,0 +1,74 @@
+import { Transaction, TransactionBuilder } from '@bitgo-beta/abstract-substrate';
+import { TransactionType } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';
+export declare class TokenTransferBuilder extends TransactionBuilder {
+    protected _destinationColdkey: string;
+    protected _hotkey: string;
+    protected _originNetuid: string;
+    protected _destinationNetuid: string;
+    protected _alphaAmount: string;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Construct a transaction to transfer stake
+     * @returns {UnsignedTransaction} an unsigned transfer stake transaction
+     */
+    protected buildTransaction(): UnsignedTransaction;
+    /** @inheritdoc */
+    protected get transactionType(): TransactionType;
+    /**
+     * Set the amount to transfer
+     * @param {string} amount to transfer
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    amount(amount: string): this;
+    /**
+     * Set the validator hot key address
+     * @param {string} hotkey address of validator
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    hotkey(address: string): this;
+    /**
+     * Set the destination cold key address
+     * @param {string} address of the destination cold key
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    destinationColdkey(address: string): this;
+    /**
+     * Set the origin netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    originNetuid(netuid: string): this;
+    /**
+     * Set the destination netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    destinationNetuid(netuid: string): this;
+    /** @inheritdoc */
+    protected fromImplementation(rawTransaction: string): Transaction;
+    /** @inheritdoc */
+    validateTransaction(_: Transaction): void;
+    /**
+     * Helper method to validate whether tx params have the correct type and format
+     * @param {string} destinationColdkey destination cold key address
+     * @param {string} hotkey hotkey address of the validator
+     * @param {string} originNetuid netuid of the origin subnet
+     * @param {string} destinationNetuid netuid of the destination subnet
+     * @param {string} alphaAmount amount to transfer
+     * @throws {InvalidTransactionError} if validation fails
+     */
+    private validateFields;
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction: string): void;
+    /**
+     * Construct a transaction to transfer stake
+     *
+     * @param {Interface.TransferStakeArgs} args arguments to be passed to the transferStake method
+     * @param {Interface.CreateBaseTxInfo} info txn info required to construct the transferStake txn
+     * @returns {UnsignedTransaction} an unsigned stake transaction
+     */
+    private transferStake;
+}
+//# sourceMappingURL=tokenTransferBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenTransferBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/tokenTransferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,WAAW,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpG,OAAO,EAA2B,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAgB,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAItH,qBAAa,oBAAqB,SAAQ,kBAAkB;IAC1D,SAAS,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACtC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,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;IAM5B;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAM7B;;;;OAIG;IAEH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAMzC;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKlC;;;;OAIG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAKvC,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAiBjE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAWzC;;;;;;;;OAQG;IACH,OAAO,CAAC,cAAc;IAoBtB,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IAW7G;;;;;;OAMG;IAEH,OAAO,CAAC,aAAa;CAatB"}

package/dist/src/lib/tokenTransferBuilder.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTransferBuilder = 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 tokenTransferTransaction_1 = require("./tokenTransferTransaction");
+class TokenTransferBuilder extends abstract_substrate_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new tokenTransferTransaction_1.TokenTransferTransaction(_coinConfig);
+    }
+    /**
+     * Construct a transaction to transfer stake
+     * @returns {UnsignedTransaction} an unsigned transfer stake transaction
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return this.transferStake({
+            destinationColdkey: this._destinationColdkey,
+            hotkey: this._hotkey,
+            originNetuid: this._originNetuid,
+            destinationNetuid: this._destinationNetuid,
+            alphaAmount: this._alphaAmount,
+        }, baseTxInfo);
+    }
+    /** @inheritdoc */
+    get transactionType() {
+        return sdk_core_1.TransactionType.SendToken;
+    }
+    /**
+     * Set the amount to transfer
+     * @param {string} amount to transfer
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    amount(amount) {
+        this.validateValue(new bignumber_js_1.default(amount));
+        this._alphaAmount = amount;
+        return this;
+    }
+    /**
+     * Set the validator hot key address
+     * @param {string} hotkey address of validator
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    hotkey(address) {
+        this.validateAddress({ address });
+        this._hotkey = address;
+        return this;
+    }
+    /**
+     * Set the destination cold key address
+     * @param {string} address of the destination cold key
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    destinationColdkey(address) {
+        this.validateAddress({ address });
+        this._destinationColdkey = address;
+        return this;
+    }
+    /**
+     * Set the origin netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    originNetuid(netuid) {
+        this._originNetuid = netuid;
+        return this;
+    }
+    /**
+     * Set the destination netuid of the subnet (root network is 0)
+     * @param {string} netuid of subnet
+     * @returns {TokenTransferBuilder} This builder.
+     */
+    destinationNetuid(netuid) {
+        this._destinationNetuid = netuid;
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name === abstract_substrate_1.Interface.MethodNames.TransferStake) {
+            const txMethod = this._method.args;
+            this.amount(txMethod.alphaAmount);
+            this.hotkey(txMethod.hotkey);
+            this.destinationColdkey(txMethod.destinationColdkey);
+            this.originNetuid(txMethod.originNetuid);
+            this.destinationNetuid(txMethod.destinationNetuid);
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected ${abstract_substrate_1.Interface.MethodNames.TransferStake}`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields(this._destinationColdkey, this._hotkey, this._originNetuid, this._destinationNetuid, this._alphaAmount);
+    }
+    /**
+     * Helper method to validate whether tx params have the correct type and format
+     * @param {string} destinationColdkey destination cold key address
+     * @param {string} hotkey hotkey address of the validator
+     * @param {string} originNetuid netuid of the origin subnet
+     * @param {string} destinationNetuid netuid of the destination subnet
+     * @param {string} alphaAmount amount to transfer
+     * @throws {InvalidTransactionError} if validation fails
+     */
+    validateFields(destinationColdkey, hotkey, originNetuid, destinationNetuid, alphaAmount) {
+        const validationResult = abstract_substrate_1.Schema.TransferStakeTransactionSchema.validate({
+            destinationColdkey,
+            hotkey,
+            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.TransferStake) {
+            const txMethod = decodedTxn.method.args;
+            const validationResult = abstract_substrate_1.Schema.TransferStakeTransactionSchema.validate(txMethod);
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Transfer Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+    }
+    /**
+     * Construct a transaction to transfer stake
+     *
+     * @param {Interface.TransferStakeArgs} args arguments to be passed to the transferStake method
+     * @param {Interface.CreateBaseTxInfo} info txn info required to construct the transferStake txn
+     * @returns {UnsignedTransaction} an unsigned stake transaction
+     */
+    transferStake(args, info) {
+        return (0, txwrapper_core_1.defineMethod)({
+            method: {
+                args,
+                name: 'transferStake',
+                pallet: 'subtensorModule',
+            },
+            ...info.baseTxInfo,
+        }, info.options);
+    }
+}
+exports.TokenTransferBuilder = TokenTransferBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenTransferBuilder.js","sourceRoot":"","sources":["../../../src/lib/tokenTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { Interface, Schema, Transaction, TransactionBuilder } from '@bitgo-beta/abstract-substrate';\nimport { InvalidTransactionError, TransactionType } 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 { TokenTransferTransaction } from './tokenTransferTransaction';\n\nexport class TokenTransferBuilder extends TransactionBuilder {\n  protected _destinationColdkey: string;\n  protected _hotkey: 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 TokenTransferTransaction(_coinConfig);\n  }\n\n  /**\n   * Construct a transaction to transfer stake\n   * @returns {UnsignedTransaction} an unsigned transfer stake transaction\n   */\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    return this.transferStake(\n      {\n        destinationColdkey: this._destinationColdkey,\n        hotkey: this._hotkey,\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.SendToken;\n  }\n\n  /**\n   * Set the amount to transfer\n   * @param {string} amount to transfer\n   * @returns {TokenTransferBuilder} This builder.\n   */\n  amount(amount: string): this {\n    this.validateValue(new BigNumber(amount));\n    this._alphaAmount = amount;\n    return this;\n  }\n\n  /**\n   * Set the validator hot key address\n   * @param {string} hotkey address of validator\n   * @returns {TokenTransferBuilder} This builder.\n   */\n  hotkey(address: string): this {\n    this.validateAddress({ address });\n    this._hotkey = address;\n    return this;\n  }\n\n  /**\n   * Set the destination cold key address\n   * @param {string} address of the destination cold key\n   * @returns {TokenTransferBuilder} This builder.\n   */\n\n  destinationColdkey(address: string): this {\n    this.validateAddress({ address });\n    this._destinationColdkey = 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 {TokenTransferBuilder} This builder.\n   */\n  originNetuid(netuid: string): this {\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 {TokenTransferBuilder} This builder.\n   */\n  destinationNetuid(netuid: string): this {\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.TransferStake) {\n      const txMethod = this._method.args as Interface.TransferStakeArgs;\n      this.amount(txMethod.alphaAmount);\n      this.hotkey(txMethod.hotkey);\n      this.destinationColdkey(txMethod.destinationColdkey);\n      this.originNetuid(txMethod.originNetuid);\n      this.destinationNetuid(txMethod.destinationNetuid);\n    } else {\n      throw new InvalidTransactionError(\n        `Invalid Transaction Type: ${this._method?.name}. Expected ${Interface.MethodNames.TransferStake}`\n      );\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields(\n      this._destinationColdkey,\n      this._hotkey,\n      this._originNetuid,\n      this._destinationNetuid,\n      this._alphaAmount\n    );\n  }\n\n  /**\n   * Helper method to validate whether tx params have the correct type and format\n   * @param {string} destinationColdkey destination cold key address\n   * @param {string} hotkey hotkey address of the validator\n   * @param {string} originNetuid netuid of the origin subnet\n   * @param {string} destinationNetuid netuid of the destination subnet\n   * @param {string} alphaAmount amount to transfer\n   * @throws {InvalidTransactionError} if validation fails\n   */\n  private validateFields(\n    destinationColdkey: string,\n    hotkey: string,\n    originNetuid: string,\n    destinationNetuid: string,\n    alphaAmount: string\n  ): void {\n    const validationResult = Schema.TransferStakeTransactionSchema.validate({\n      destinationColdkey,\n      hotkey,\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.TransferStake) {\n      const txMethod = decodedTxn.method.args as unknown as Interface.TransferStakeArgs;\n\n      const validationResult = Schema.TransferStakeTransactionSchema.validate(txMethod);\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 transfer stake\n   *\n   * @param {Interface.TransferStakeArgs} args arguments to be passed to the transferStake method\n   * @param {Interface.CreateBaseTxInfo} info txn info required to construct the transferStake txn\n   * @returns {UnsignedTransaction} an unsigned stake transaction\n   */\n\n  private transferStake(args: Interface.TransferStakeArgs, info: Interface.CreateBaseTxInfo): UnsignedTransaction {\n    return defineMethod(\n      {\n        method: {\n          args,\n          name: 'transferStake',\n          pallet: 'subtensorModule',\n        },\n        ...info.baseTxInfo,\n      },\n      info.options\n    );\n  }\n}\n"]}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokenTransferTransaction.d.ts","sourceRoot":"","sources":["../../../src/lib/tokenTransferTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,kBAAkB,EAAE,WAAW,IAAI,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAMtH,qBAAa,wBAAyB,SAAQ,oBAAoB;IAChE,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/tokenTransferTransaction.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.TokenTransferTransaction = 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 TokenTransferTransaction 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.destinationColdkey = txMethod.destinationColdkey;
+        result.hotkey = txMethod.hotkey;
+        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: this._sender,
+            value: txMethod.alphaAmount,
+            coin: utils_1.default.getTaoTokenBySubnetId(txMethod.originNetuid).name,
+        });
+        this._outputs.push({
+            address: txMethod.destinationColdkey,
+            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.TokenTransferTransaction = TokenTransferTransaction;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,15 +1,21 @@
 import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
 import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
-import { Material } from './iface';
+import { TransactionBuilder, Interface } from './';
 import { TransferBuilder } from './transferBuilder';
-import { TransactionBuilder } from './transactionBuilder';
+import { StakingBuilder } from './stakingBuilder';
+import { UnstakeBuilder } from './unstakeBuilder';
+import { MoveStakeBuilder } from './moveStakeBuilder';
 export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
-    protected _material: Material;
+    protected _material: Interface.Material;
     constructor(_coinConfig: Readonly<CoinConfig>);
     getTransferBuilder(): TransferBuilder;
+    getStakingBuilder(): StakingBuilder;
+    getUnstakingBuilder(): UnstakeBuilder;
+    getTokenTransferBuilder(): TransactionBuilder;
+    getMoveStakeBuilder(): MoveStakeBuilder;
     getWalletInitializationBuilder(): void;
     from(rawTxn: string): TransactionBuilder;
-    material(material: Material): this;
+    material(material: Interface.Material): this;
     private getBuilder;
 }
 //# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAqC,MAAM,sBAAsB,CAAC;AACxG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,QAAQ,EAAe,MAAM,SAAS,CAAC;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,yBAA0B,SAAQ,6BAA6B;IAC1E,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC;gBAElB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,kBAAkB,IAAI,eAAe;IAIrC,8BAA8B,IAAI,IAAI;IAItC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB;IAMxC,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAKlC,OAAO,CAAC,UAAU;CAkBnB"}
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAqC,MAAM,sBAAsB,CAAC;AACxG,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAqB,kBAAkB,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,qBAAa,yBAA0B,SAAQ,6BAA6B;IAC1E,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;gBAE5B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,kBAAkB,IAAI,eAAe;IAIrC,iBAAiB,IAAI,cAAc;IAInC,mBAAmB,IAAI,cAAc;IAIrC,uBAAuB,IAAI,kBAAkB;IAI7C,mBAAmB,IAAI,gBAAgB;IAIvC,8BAA8B,IAAI,IAAI;IAItC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB;IAMxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,IAAI;IAK5C,OAAO,CAAC,UAAU;CAsBnB"}

package/dist/src/lib/transactionBuilderFactory.js

@@ -6,18 +6,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionBuilderFactory = void 0;
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
 const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
-const iface_1 = require("./iface");
-const singletonRegistry_1 = require("./singletonRegistry");
+const _1 = require("./");
 const transferBuilder_1 = require("./transferBuilder");
 const utils_1 = __importDefault(require("./utils"));
+const stakingBuilder_1 = require("./stakingBuilder");
+const unstakeBuilder_1 = require("./unstakeBuilder");
+const tokenTransferBuilder_1 = require("./tokenTransferBuilder");
+const moveStakeBuilder_1 = require("./moveStakeBuilder");
 class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
     constructor(_coinConfig) {
         super(_coinConfig);
-        this._material = utils_1.default.getMaterial(_coinConfig);
+        this._material = utils_1.default.getMaterial(_coinConfig.network.type);
     }
     getTransferBuilder() {
         return new transferBuilder_1.TransferBuilder(this._coinConfig).material(this._material);
     }
+    getStakingBuilder() {
+        return new stakingBuilder_1.StakingBuilder(this._coinConfig).material(this._material);
+    }
+    getUnstakingBuilder() {
+        return new unstakeBuilder_1.UnstakeBuilder(this._coinConfig).material(this._material);
+    }
+    getTokenTransferBuilder() {
+        return new tokenTransferBuilder_1.TokenTransferBuilder(this._coinConfig).material(this._material);
+    }
+    getMoveStakeBuilder() {
+        return new moveStakeBuilder_1.MoveStakeBuilder(this._coinConfig).material(this._material);
+    }
     getWalletInitializationBuilder() {
         throw new sdk_core_1.NotImplementedError(`walletInitialization for ${this._coinConfig.name} not implemented`);
     }
@@ -31,21 +46,31 @@ class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory
         return this;
     }
     getBuilder(rawTxn) {
-        const registry = singletonRegistry_1.SingletonRegistry.getInstance(this._material);
+        const registry = _1.SingletonRegistry.getInstance(this._material);
         const decodedTxn = (0, txwrapper_polkadot_1.decode)(rawTxn, {
             metadataRpc: this._material.metadata,
             registry: registry,
         });
         const methodName = decodedTxn.method?.name;
-        if (methodName === iface_1.MethodNames.TransferKeepAlive ||
-            methodName === iface_1.MethodNames.TransferAll ||
-            methodName === iface_1.MethodNames.Proxy) {
+        if (methodName === _1.Interface.MethodNames.TransferKeepAlive || methodName === _1.Interface.MethodNames.TransferAll) {
             return this.getTransferBuilder();
         }
+        else if (methodName === _1.Interface.MethodNames.AddStake) {
+            return this.getStakingBuilder();
+        }
+        else if (methodName === _1.Interface.MethodNames.RemoveStake) {
+            return this.getUnstakingBuilder();
+        }
+        else if (methodName === _1.Interface.MethodNames.TransferStake) {
+            return this.getTokenTransferBuilder();
+        }
+        else if (methodName === _1.Interface.MethodNames.MoveStake) {
+            return this.getMoveStakeBuilder();
+        }
         else {
             throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
         }
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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