@bitgo-beta/sdk-coin-dot 2.2.8-beta.167 → 2.2.8-beta.1670

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

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyPair = void 0;
+const keyring_1 = require("@polkadot/keyring");
+const pair_1 = require("@polkadot/keyring/pair");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const bs58_1 = __importDefault(require("bs58"));
+const utils_1 = __importDefault(require("./utils"));
+const nacl = __importStar(require("tweetnacl"));
+const TYPE = 'ed25519';
+const keyring = new keyring_1.Keyring({ type: TYPE });
+class KeyPair extends sdk_core_1.Ed25519KeyPair {
+    /**
+     * Public constructor. By default, creates a key pair with a random master seed.
+     *
+     * @param { KeyPairOptions } source Either a master seed, a private key, or a public key
+     */
+    constructor(source) {
+        super(source);
+    }
+    /**
+     * Helper function to create the KeyringPair for signing a dot transaction.
+     *
+     * @returns {KeyringPair} dot KeyringPair
+     *
+     * @see https://polkadot.js.org/docs/api/start/keyring
+     */
+    createPolkadotPair() {
+        const secretKey = this.keyPair.prv ? new Uint8Array(Buffer.from(this.keyPair.prv, 'hex')) : undefined;
+        const publicKey = new Uint8Array(Buffer.from(this.keyPair.pub, 'hex'));
+        return (0, pair_1.createPair)({ toSS58: keyring.encodeAddress, type: TYPE }, { secretKey, publicKey });
+    }
+    /**
+     // https://wiki.polkadot.network/docs/learn-accounts#address-format
+     * Returns the address in either mainnet polkadot format (starts with 1)
+     * or substrate format used for westend (starts with 5)
+     */
+    getAddress(format) {
+        let encodedAddress = this.createPolkadotPair().address;
+        encodedAddress = keyring.encodeAddress(encodedAddress, format);
+        return encodedAddress;
+    }
+    /** @inheritdoc */
+    getKeys() {
+        const result = { pub: this.keyPair.pub };
+        if (this.keyPair.prv) {
+            result.prv = this.keyPair.prv;
+        }
+        return result;
+    }
+    /** @inheritdoc */
+    recordKeysFromPrivateKeyInProtocolFormat(prv) {
+        const decodedSeed = utils_1.default.decodeSeed(prv);
+        const bufferFromSeed = Buffer.from(decodedSeed.seed);
+        return utils_1.default.keyPairFromSeed(bufferFromSeed).keyPair;
+    }
+    /** @inheritdoc */
+    recordKeysFromPublicKeyInProtocolFormat(pub) {
+        const publicKey = keyring.addFromPair({
+            // tss common pub is in base58 format and decodes to length of 32
+            publicKey: (0, sdk_core_1.isBase58)(pub, 32) ? new Uint8Array(bs58_1.default.decode(pub)) : new Uint8Array(Buffer.from(pub, 'hex')),
+            secretKey: new Uint8Array(),
+        }).publicKey;
+        return { pub: (0, sdk_core_1.toHex)(publicKey) };
+    }
+    /**
+     *  Sign the message in Uint8Array
+     *
+     * @param {Uint8Array} message to be signed
+     * @returns {Uint8Array} signed message
+     */
+    signMessageinUint8Array(message) {
+        const { prv } = this.keyPair;
+        if (!prv) {
+            throw new Error('Missing private key');
+        }
+        return nacl.sign.detached(message, nacl.sign.keyPair.fromSeed((0, sdk_core_1.toUint8Array)(prv)).secretKey);
+    }
+}
+exports.KeyPair = KeyPair;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"nativeTransferBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/nativeTransferBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA0C,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAExG,OAAO,EAA0B,SAAS,EAAiC,MAAM,SAAS,CAAC;AAG3F,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAI1D,8BAAsB,qBAAsB,SAAQ,kBAAkB;IACpE,SAAS,CAAC,iBAAiB,UAAS;IACpC,SAAS,CAAC,iBAAiB,UAAQ;IACnC,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;IACzB,SAAS,CAAC,eAAe,EAAE,SAAS,CAAC;gBAEzB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;;;;OAOG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAqCjD,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,SAAS,CAAC,EAAE,OAAO,GAAG,IAAI;IAQhC;;;;;;;;OAQG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B;;;;;;;;OAQG;IACH,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,WAAW,GAAG,IAAI;IAMlC;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAM/B;;;;;;;;OAQG;IACH,cAAc,CAAC,cAAc,EAAE,SAAS,GAAG,IAAI;IAK/C,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,EAAE,cAAc,EAAE,MAAM,GAAG,IAAI;IA0B7G,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAsDjE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAKzC,OAAO,CAAC,cAAc;CAgBvB"}

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

@@ -0,0 +1,219 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeTransferBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const iface_1 = require("./iface");
+const iface_utils_1 = require("./iface_utils");
+const singletonRegistry_1 = require("./singletonRegistry");
+const transactionBuilder_1 = require("./transactionBuilder");
+const txnSchema_1 = require("./txnSchema");
+const utils_1 = __importDefault(require("./utils"));
+class NativeTransferBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._sweepFreeBalance = false;
+        this._keepAddressAlive = true;
+    }
+    /**
+     *
+     * Dispatch the given call from an account that the sender is authorised for through add_proxy.
+     *
+     * @returns {UnsignedTransaction} an unsigned Dot transaction
+     *
+     * @see https://polkadot.js.org/docs/substrate/extrinsics/#proxy
+     */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        let transferTx;
+        if (this._sweepFreeBalance) {
+            transferTx = txwrapper_polkadot_1.methods.balances.transferAll({
+                dest: { id: this._to },
+                keepAlive: this._keepAddressAlive,
+            }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        }
+        else {
+            transferTx = txwrapper_polkadot_1.methods.balances.transferKeepAlive({
+                value: this._amount,
+                dest: { id: this._to },
+            }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+        }
+        if (!this._owner) {
+            return transferTx;
+        }
+        return txwrapper_polkadot_1.methods.proxy.proxy({
+            real: this._owner,
+            forceProxyType: this._forceProxyType,
+            call: transferTx.method,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.Send;
+    }
+    /**
+     *
+     * Set this to be a sweep transaction, using TransferAll with keepAlive set to true by default.
+     * If keepAlive is false, the entire address will be swept (including the 1 DOT minimum).
+     *
+     * @param {boolean} keepAlive - keep the address alive after this sweep
+     * @returns {TransferBuilder} This transfer builder.
+     *
+     * @see https://github.com/paritytech/txwrapper-core/blob/main/docs/modules/txwrapper_substrate_src.methods.balances.md#transferall
+     */
+    sweep(keepAlive) {
+        this._sweepFreeBalance = true;
+        if (keepAlive !== undefined) {
+            this._keepAddressAlive = keepAlive;
+        }
+        return this;
+    }
+    /**
+     *
+     * The amount for transfer transaction.
+     *
+     * @param {string} amount
+     * @returns {TransferBuilder} This transfer builder.
+     *
+     * @see https://wiki.polkadot.network/docs/build-protocol-info
+     */
+    amount(amount) {
+        this.validateValue(new bignumber_js_1.default(amount));
+        this._amount = amount;
+        return this;
+    }
+    /**
+     *
+     * The destination address for transfer transaction.
+     *
+     * @param {string} dest
+     * @returns {TransferBuilder} This transfer builder.
+     *
+     * @see https://wiki.polkadot.network/docs/build-protocol-info
+     */
+    to({ address }) {
+        this.validateAddress({ address });
+        this._to = address;
+        return this;
+    }
+    /**
+     *
+     * The real address of the original tx
+     *
+     * @param {BaseAddress} real
+     * @returns {TransferBuilder} This builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-proxies#why-use-a-proxy
+     */
+    owner(owner) {
+        this.validateAddress({ address: owner.address });
+        this._owner = owner.address;
+        return this;
+    }
+    /**
+     *
+     * The proxy type to execute
+     *
+     * @param {proxyType} forceProxyType
+     * @returns {TransferBuilder} This builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-proxies#proxy-types
+     */
+    forceProxyType(forceProxyType) {
+        this._forceProxyType = forceProxyType;
+        return this;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn, rawTransaction) {
+        if (decodedTxn.method?.name === iface_1.MethodNames.TransferKeepAlive) {
+            const txMethod = decodedTxn.method.args;
+            const amount = `${txMethod.value}`;
+            const to = txMethod.dest.id;
+            const validationResult = txnSchema_1.TransferTransactionSchema.validate({ amount, to });
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Transfer Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+        else if (decodedTxn.method?.name === iface_1.MethodNames.Proxy) {
+            const txMethod = decodedTxn.method.args;
+            const real = (0, iface_utils_1.getAddress)(txMethod);
+            const forceProxyType = txMethod.forceProxyType;
+            const decodedCall = utils_1.default.decodeCallMethod(rawTransaction, {
+                registry: singletonRegistry_1.SingletonRegistry.getInstance(this._material),
+                metadataRpc: this._material.metadata,
+            });
+            const amount = `${decodedCall.value}`;
+            const to = decodedCall.dest.id;
+            const validationResult = txnSchema_1.ProxyTransactionSchema.validate({ real, forceProxyType, amount, to });
+            if (validationResult.error) {
+                throw new sdk_core_1.InvalidTransactionError(`Proxy Transaction validation failed: ${validationResult.error.message}`);
+            }
+        }
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name === iface_1.MethodNames.TransferKeepAlive) {
+            const txMethod = this._method.args;
+            this.amount(txMethod.value);
+            this.to({
+                address: utils_1.default.decodeDotAddress(txMethod.dest.id, utils_1.default.getAddressFormat(this._coinConfig.name)),
+            });
+        }
+        else if (this._method?.name === iface_1.MethodNames.TransferAll) {
+            this._sweepFreeBalance = true;
+            const txMethod = this._method.args;
+            this.sweep(txMethod.keepAlive);
+            this.to({
+                address: utils_1.default.decodeDotAddress(txMethod.dest.id, utils_1.default.getAddressFormat(this._coinConfig.name)),
+            });
+        }
+        else if (this._method?.name === iface_1.MethodNames.Proxy) {
+            const txMethod = this._method.args;
+            this.owner({
+                address: utils_1.default.decodeDotAddress((0, iface_utils_1.getAddress)(txMethod), utils_1.default.getAddressFormat(this._coinConfig.name)),
+            });
+            this.forceProxyType(txMethod.forceProxyType);
+            const decodedCall = utils_1.default.decodeCallMethod(rawTransaction, {
+                registry: singletonRegistry_1.SingletonRegistry.getInstance(this._material),
+                metadataRpc: this._material.metadata,
+            });
+            if (!decodedCall.value || !decodedCall.dest) {
+                throw new sdk_core_1.InvalidTransactionError(`Invalid Proxy Transaction Method: ${this._method?.name}. Expected transferKeepAlive`);
+            }
+            this.amount(`${decodedCall.value}`);
+            this.to({
+                address: utils_1.default.decodeDotAddress(decodedCall.dest.id, utils_1.default.getAddressFormat(this._coinConfig.name)),
+            });
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected a transferKeepAlive or a proxy transferKeepAlive transaction`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields(this._to, this._amount, this._owner, this._forceProxyType);
+    }
+    validateFields(to, amount, real, forceProxyType) {
+        let validationResult;
+        if (forceProxyType) {
+            validationResult = txnSchema_1.ProxyTransactionSchema.validate({ to, amount, real, forceProxyType });
+        }
+        else if (this._sweepFreeBalance) {
+            validationResult = txnSchema_1.TransferAllTransactionSchema.validate({ to });
+        }
+        else {
+            validationResult = txnSchema_1.TransferTransactionSchema.validate({ amount, to });
+        }
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`Proxy/TransferAll/TransferKeepAlive Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+}
+exports.NativeTransferBuilder = NativeTransferBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nativeTransferBuilder.js","sourceRoot":"","sources":["../../../../src/lib/nativeTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAddress, DotAssetTypes, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { methods } from '@substrate/txwrapper-polkadot';\nimport { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';\nimport BigNumber from 'bignumber.js';\nimport { MethodNames, ProxyArgs, ProxyType, TransferAllArgs, TransferArgs } from './iface';\nimport { getAddress } from './iface_utils';\nimport { SingletonRegistry } from './singletonRegistry';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { ProxyTransactionSchema, TransferAllTransactionSchema, TransferTransactionSchema } from './txnSchema';\nimport utils from './utils';\n\nexport abstract class NativeTransferBuilder extends TransactionBuilder {\n  protected _sweepFreeBalance = false;\n  protected _keepAddressAlive = true;\n  protected _amount: string;\n  protected _to: string;\n  protected _owner: string;\n  protected _forceProxyType: ProxyType;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   *\n   * Dispatch the given call from an account that the sender is authorised for through add_proxy.\n   *\n   * @returns {UnsignedTransaction} an unsigned Dot transaction\n   *\n   * @see https://polkadot.js.org/docs/substrate/extrinsics/#proxy\n   */\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    let transferTx;\n    if (this._sweepFreeBalance) {\n      transferTx = methods.balances.transferAll(\n        {\n          dest: { id: this._to },\n          keepAlive: this._keepAddressAlive,\n        },\n        baseTxInfo.baseTxInfo,\n        baseTxInfo.options\n      );\n    } else {\n      transferTx = methods.balances.transferKeepAlive(\n        {\n          value: this._amount,\n          dest: { id: this._to },\n        },\n        baseTxInfo.baseTxInfo,\n        baseTxInfo.options\n      );\n    }\n\n    if (!this._owner) {\n      return transferTx;\n    }\n    return methods.proxy.proxy(\n      {\n        real: this._owner,\n        forceProxyType: this._forceProxyType,\n        call: transferTx.method,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.Send;\n  }\n\n  /**\n   *\n   * Set this to be a sweep transaction, using TransferAll with keepAlive set to true by default.\n   * If keepAlive is false, the entire address will be swept (including the 1 DOT minimum).\n   *\n   * @param {boolean} keepAlive - keep the address alive after this sweep\n   * @returns {TransferBuilder} This transfer builder.\n   *\n   * @see https://github.com/paritytech/txwrapper-core/blob/main/docs/modules/txwrapper_substrate_src.methods.balances.md#transferall\n   */\n  sweep(keepAlive?: boolean): this {\n    this._sweepFreeBalance = true;\n    if (keepAlive !== undefined) {\n      this._keepAddressAlive = keepAlive;\n    }\n    return this;\n  }\n\n  /**\n   *\n   * The amount for transfer transaction.\n   *\n   * @param {string} amount\n   * @returns {TransferBuilder} This transfer builder.\n   *\n   * @see https://wiki.polkadot.network/docs/build-protocol-info\n   */\n  amount(amount: string): this {\n    this.validateValue(new BigNumber(amount));\n    this._amount = amount;\n    return this;\n  }\n\n  /**\n   *\n   * The destination address for transfer transaction.\n   *\n   * @param {string} dest\n   * @returns {TransferBuilder} This transfer builder.\n   *\n   * @see https://wiki.polkadot.network/docs/build-protocol-info\n   */\n  to({ address }: BaseAddress): this {\n    this.validateAddress({ address });\n    this._to = address;\n    return this;\n  }\n\n  /**\n   *\n   * The real address of the original tx\n   *\n   * @param {BaseAddress} real\n   * @returns {TransferBuilder} This builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-proxies#why-use-a-proxy\n   */\n  owner(owner: BaseAddress): this {\n    this.validateAddress({ address: owner.address });\n    this._owner = owner.address;\n    return this;\n  }\n\n  /**\n   *\n   * The proxy type to execute\n   *\n   * @param {proxyType} forceProxyType\n   * @returns {TransferBuilder} This builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-proxies#proxy-types\n   */\n  forceProxyType(forceProxyType: ProxyType): this {\n    this._forceProxyType = forceProxyType;\n    return this;\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction: string): void {\n    if (decodedTxn.method?.name === MethodNames.TransferKeepAlive) {\n      const txMethod = decodedTxn.method.args as unknown as TransferArgs;\n      const amount = `${txMethod.value}`;\n      const to = txMethod.dest.id;\n      const validationResult = TransferTransactionSchema.validate({ amount, to });\n      if (validationResult.error) {\n        throw new InvalidTransactionError(`Transfer Transaction validation failed: ${validationResult.error.message}`);\n      }\n    } else if (decodedTxn.method?.name === MethodNames.Proxy) {\n      const txMethod = decodedTxn.method.args as unknown as ProxyArgs;\n      const real = getAddress(txMethod);\n      const forceProxyType = txMethod.forceProxyType;\n      const decodedCall = utils.decodeCallMethod(rawTransaction, {\n        registry: SingletonRegistry.getInstance(this._material),\n        metadataRpc: this._material.metadata,\n      });\n      const amount = `${decodedCall.value}`;\n      const to = decodedCall.dest.id;\n      const validationResult = ProxyTransactionSchema.validate({ real, forceProxyType, amount, to });\n      if (validationResult.error) {\n        throw new InvalidTransactionError(`Proxy 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.TransferKeepAlive) {\n      const txMethod = this._method.args as TransferArgs;\n      this.amount(txMethod.value);\n      this.to({\n        address: utils.decodeDotAddress(\n          txMethod.dest.id,\n          utils.getAddressFormat(this._coinConfig.name as DotAssetTypes)\n        ),\n      });\n    } else if (this._method?.name === MethodNames.TransferAll) {\n      this._sweepFreeBalance = true;\n      const txMethod = this._method.args as TransferAllArgs;\n      this.sweep(txMethod.keepAlive);\n      this.to({\n        address: utils.decodeDotAddress(\n          txMethod.dest.id,\n          utils.getAddressFormat(this._coinConfig.name as DotAssetTypes)\n        ),\n      });\n    } else if (this._method?.name === MethodNames.Proxy) {\n      const txMethod = this._method.args as ProxyArgs;\n      this.owner({\n        address: utils.decodeDotAddress(\n          getAddress(txMethod),\n          utils.getAddressFormat(this._coinConfig.name as DotAssetTypes)\n        ),\n      });\n      this.forceProxyType(txMethod.forceProxyType);\n      const decodedCall = utils.decodeCallMethod(rawTransaction, {\n        registry: SingletonRegistry.getInstance(this._material),\n        metadataRpc: this._material.metadata,\n      });\n      if (!decodedCall.value || !decodedCall.dest) {\n        throw new InvalidTransactionError(\n          `Invalid Proxy Transaction Method: ${this._method?.name}. Expected transferKeepAlive`\n        );\n      }\n      this.amount(`${decodedCall.value}`);\n      this.to({\n        address: utils.decodeDotAddress(\n          decodedCall.dest.id,\n          utils.getAddressFormat(this._coinConfig.name as DotAssetTypes)\n        ),\n      });\n    } else {\n      throw new InvalidTransactionError(\n        `Invalid Transaction Type: ${this._method?.name}. Expected a transferKeepAlive or a proxy transferKeepAlive transaction`\n      );\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields(this._to, this._amount, this._owner, this._forceProxyType);\n  }\n\n  private validateFields(to: string, amount: string, real?: string, forceProxyType?: string): void {\n    let validationResult;\n    if (forceProxyType) {\n      validationResult = ProxyTransactionSchema.validate({ to, amount, real, forceProxyType });\n    } else if (this._sweepFreeBalance) {\n      validationResult = TransferAllTransactionSchema.validate({ to });\n    } else {\n      validationResult = TransferTransactionSchema.validate({ amount, to });\n    }\n\n    if (validationResult.error) {\n      throw new InvalidTransactionError(\n        `Proxy/TransferAll/TransferKeepAlive Transaction validation failed: ${validationResult.error.message}`\n      );\n    }\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"proxyBuilder.d.ts","sourceRoot":"","sources":["../../../../src/lib/proxyBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA2B,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIxG,OAAO,EAA6B,SAAS,EAAE,MAAM,SAAS,CAAC;AAE/D,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,kBAAmB,SAAQ,kBAAkB;IACxD,SAAS,CAAC,SAAS,EAAE,MAAM,CAAC;IAC5B,SAAS,CAAC,UAAU,EAAE,SAAS,CAAC;IAChC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEb,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C,kBAAkB;IAClB,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAajD,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAM/B;;;;;;;OAOG;IACH,IAAI,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI;IAKhC;;;;;;;;;;OAUG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM1B,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,GAAG,IAAI;IAerF,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IAejE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAKzC,OAAO,CAAC,cAAc;IAWtB,OAAO,CAAC,yBAAyB;CAOlC"}

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

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveProxyBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const iface_1 = require("./iface");
+const iface_utils_1 = require("./iface_utils");
+const transactionBuilder_1 = require("./transactionBuilder");
+const txnSchema_1 = require("./txnSchema");
+class RemoveProxyBuilder extends transactionBuilder_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+    }
+    /** @inheritDoc */
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return txwrapper_polkadot_1.methods.proxy.removeProxy({
+            delegate: this._delegate,
+            proxyType: this._proxyType,
+            delay: this._delay,
+        }, baseTxInfo.baseTxInfo, baseTxInfo.options);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.AddressInitialization;
+    }
+    /**
+     * The proxy account to remove.
+     *
+     * @param {BaseAddress} owner
+     * @returns {AddressInitializationBuilder} This builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-proxies#why-use-a-proxy
+     */
+    owner(owner) {
+        this.validateAddress({ address: owner.address });
+        this._delegate = owner.address;
+        return this;
+    }
+    /**
+     * The proxy type to remove.
+     *
+     * @param {proxyType} proxyType
+     * @returns {AddressInitializationBuilder} This builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-proxies#proxy-types
+     */
+    type(proxyType) {
+        this._proxyType = proxyType;
+        return this;
+    }
+    /**
+     * The number of blocks that an announcement must be in place for.
+     * before the corresponding call may be dispatched.
+     * If zero, then no announcement is needed.
+     * TODO: move to the validity window method once it has been standardized
+     *
+     * @param {string} delay
+     * @returns {AddressInitializationBuilder} This transfer builder.
+     *
+     * @see https://wiki.polkadot.network/docs/learn-proxies#time-delayed-proxies
+     */
+    delay(delay) {
+        this.validateValue(new bignumber_js_1.default(parseInt(delay, 10)));
+        this._delay = delay;
+        return this;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn) {
+        let validationResult;
+        if (decodedTxn.method?.name === iface_1.MethodNames.RemoveProxy) {
+            const txMethod = decodedTxn.method.args;
+            validationResult = this.validateRemoveProxyFields((0, iface_utils_1.getDelegateAddress)(txMethod), txMethod.proxyType, txMethod.delay);
+            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.RemoveProxy) {
+            const txMethod = this._method.args;
+            this.owner({ address: (0, iface_utils_1.getDelegateAddress)(txMethod) });
+            this.type(txMethod.proxyType);
+            this.delay(new bignumber_js_1.default(txMethod.delay).toString());
+        }
+        else {
+            throw new sdk_core_1.InvalidTransactionError(`Invalid Transaction Type: ${this._method?.name}. Expected ${iface_1.MethodNames.RemoveProxy}`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateTransaction(_) {
+        super.validateTransaction(_);
+        this.validateFields();
+    }
+    validateFields() {
+        const validationResult = this.validateRemoveProxyFields(this._delegate, this._proxyType, this._delay);
+        if (validationResult.error) {
+            throw new sdk_core_1.InvalidTransactionError(`RemoveProxy Transaction validation failed: ${validationResult.error.message}`);
+        }
+    }
+    validateRemoveProxyFields(delegate, proxyType, delay) {
+        return txnSchema_1.AddressInitializationSchema.validate({
+            delegate,
+            proxyType,
+            delay,
+        });
+    }
+}
+exports.RemoveProxyBuilder = RemoveProxyBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxyBuilder.js","sourceRoot":"","sources":["../../../../src/lib/proxyBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAddress, InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { DecodedSignedTx, DecodedSigningPayload, UnsignedTransaction } from '@substrate/txwrapper-core';\nimport { methods } from '@substrate/txwrapper-polkadot';\nimport BigNumber from 'bignumber.js';\nimport { ValidationResult } from 'joi';\nimport { AddProxyArgs, MethodNames, ProxyType } from './iface';\nimport { getDelegateAddress } from './iface_utils';\nimport { Transaction } from './transaction';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { AddressInitializationSchema } from './txnSchema';\n\nexport class RemoveProxyBuilder extends TransactionBuilder {\n  protected _delegate: string;\n  protected _proxyType: ProxyType;\n  protected _delay: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritDoc */\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    return methods.proxy.removeProxy(\n      {\n        delegate: this._delegate,\n        proxyType: this._proxyType,\n        delay: this._delay,\n      },\n      baseTxInfo.baseTxInfo,\n      baseTxInfo.options\n    );\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.AddressInitialization;\n  }\n\n  /**\n   * The proxy account to remove.\n   *\n   * @param {BaseAddress} owner\n   * @returns {AddressInitializationBuilder} This builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-proxies#why-use-a-proxy\n   */\n  owner(owner: BaseAddress): this {\n    this.validateAddress({ address: owner.address });\n    this._delegate = owner.address;\n    return this;\n  }\n\n  /**\n   * The proxy type to remove.\n   *\n   * @param {proxyType} proxyType\n   * @returns {AddressInitializationBuilder} This builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-proxies#proxy-types\n   */\n  type(proxyType: ProxyType): this {\n    this._proxyType = proxyType;\n    return this;\n  }\n\n  /**\n   * The number of blocks that an announcement must be in place for.\n   * before the corresponding call may be dispatched.\n   * If zero, then no announcement is needed.\n   * TODO: move to the validity window method once it has been standardized\n   *\n   * @param {string} delay\n   * @returns {AddressInitializationBuilder} This transfer builder.\n   *\n   * @see https://wiki.polkadot.network/docs/learn-proxies#time-delayed-proxies\n   */\n  delay(delay: string): this {\n    this.validateValue(new BigNumber(parseInt(delay, 10)));\n    this._delay = delay;\n    return this;\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx): void {\n    let validationResult;\n    if (decodedTxn.method?.name === MethodNames.RemoveProxy) {\n      const txMethod = decodedTxn.method.args as unknown as AddProxyArgs;\n      validationResult = this.validateRemoveProxyFields(\n        getDelegateAddress(txMethod),\n        txMethod.proxyType,\n        txMethod.delay\n      );\n      if (validationResult.error) {\n        throw new InvalidTransactionError(`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.RemoveProxy) {\n      const txMethod = this._method.args as AddProxyArgs;\n      this.owner({ address: getDelegateAddress(txMethod) });\n      this.type(txMethod.proxyType);\n      this.delay(new BigNumber(txMethod.delay).toString());\n    } else {\n      throw new InvalidTransactionError(\n        `Invalid Transaction Type: ${this._method?.name}. Expected ${MethodNames.RemoveProxy}`\n      );\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateTransaction(_: Transaction): void {\n    super.validateTransaction(_);\n    this.validateFields();\n  }\n\n  private validateFields(): void {\n    const validationResult: ValidationResult = this.validateRemoveProxyFields(\n      this._delegate,\n      this._proxyType,\n      this._delay\n    );\n    if (validationResult.error) {\n      throw new InvalidTransactionError(`RemoveProxy Transaction validation failed: ${validationResult.error.message}`);\n    }\n  }\n\n  private validateRemoveProxyFields(delegate: string, proxyType: string, delay: string): ValidationResult {\n    return AddressInitializationSchema.validate({\n      delegate,\n      proxyType,\n      delay,\n    });\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"singletonRegistry.d.ts","sourceRoot":"","sources":["../../../../src/lib/singletonRegistry.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AAInE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAe;IACtC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAW;IAElC,MAAM,CAAC,WAAW,CAAC,QAAQ,KAAA,GAAG,YAAY;CAY3C"}

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SingletonRegistry = void 0;
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+class SingletonRegistry {
+    static getInstance(material) {
+        if (material !== SingletonRegistry.material) {
+            SingletonRegistry.material = material;
+            SingletonRegistry.instance = (0, txwrapper_polkadot_1.getRegistry)({
+                chainName: material.chainName,
+                specName: material.specName,
+                specVersion: material.specVersion,
+                metadataRpc: material.metadata,
+            });
+        }
+        return SingletonRegistry.instance;
+    }
+}
+exports.SingletonRegistry = SingletonRegistry;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2luZ2xldG9uUmVnaXN0cnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL3NpbmdsZXRvblJlZ2lzdHJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBLHNFQUE0RDtBQUc1RCxNQUFhLGlCQUFpQjtJQUk1QixNQUFNLENBQUMsV0FBVyxDQUFDLFFBQVE7UUFDekIsSUFBSSxRQUFRLEtBQUssaUJBQWlCLENBQUMsUUFBUSxFQUFFLENBQUM7WUFDNUMsaUJBQWlCLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQztZQUN0QyxpQkFBaUIsQ0FBQyxRQUFRLEdBQUcsSUFBQSxnQ0FBVyxFQUFDO2dCQUN2QyxTQUFTLEVBQUUsUUFBUSxDQUFDLFNBQVM7Z0JBQzdCLFFBQVEsRUFBRSxRQUFRLENBQUMsUUFBZ0M7Z0JBQ25ELFdBQVcsRUFBRSxRQUFRLENBQUMsV0FBVztnQkFDakMsV0FBVyxFQUFFLFFBQVEsQ0FBQyxRQUF5QjthQUNoRCxDQUFDLENBQUM7UUFDTCxDQUFDO1FBQ0QsT0FBTyxpQkFBaUIsQ0FBQyxRQUFRLENBQUM7SUFDcEMsQ0FBQztDQUNGO0FBaEJELDhDQWdCQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBvbGthZG90U3BlY05hbWVUeXBlIH0gZnJvbSAnQGJpdGdvLWJldGEvc3RhdGljcyc7XG5pbXBvcnQgeyBUeXBlUmVnaXN0cnkgfSBmcm9tICdAc3Vic3RyYXRlL3R4d3JhcHBlci1jb3JlL2xpYi90eXBlcyc7XG5pbXBvcnQgeyBnZXRSZWdpc3RyeSB9IGZyb20gJ0BzdWJzdHJhdGUvdHh3cmFwcGVyLXBvbGthZG90JztcbmltcG9ydCB7IE1hdGVyaWFsIH0gZnJvbSAnLi9pZmFjZSc7XG5cbmV4cG9ydCBjbGFzcyBTaW5nbGV0b25SZWdpc3RyeSB7XG4gIHByaXZhdGUgc3RhdGljIGluc3RhbmNlOiBUeXBlUmVnaXN0cnk7XG4gIHByaXZhdGUgc3RhdGljIG1hdGVyaWFsOiBNYXRlcmlhbDtcblxuICBzdGF0aWMgZ2V0SW5zdGFuY2UobWF0ZXJpYWwpOiBUeXBlUmVnaXN0cnkge1xuICAgIGlmIChtYXRlcmlhbCAhPT0gU2luZ2xldG9uUmVnaXN0cnkubWF0ZXJpYWwpIHtcbiAgICAgIFNpbmdsZXRvblJlZ2lzdHJ5Lm1hdGVyaWFsID0gbWF0ZXJpYWw7XG4gICAgICBTaW5nbGV0b25SZWdpc3RyeS5pbnN0YW5jZSA9IGdldFJlZ2lzdHJ5KHtcbiAgICAgICAgY2hhaW5OYW1lOiBtYXRlcmlhbC5jaGFpbk5hbWUsXG4gICAgICAgIHNwZWNOYW1lOiBtYXRlcmlhbC5zcGVjTmFtZSBhcyBQb2xrYWRvdFNwZWNOYW1lVHlwZSxcbiAgICAgICAgc3BlY1ZlcnNpb246IG1hdGVyaWFsLnNwZWNWZXJzaW9uLFxuICAgICAgICBtZXRhZGF0YVJwYzogbWF0ZXJpYWwubWV0YWRhdGEgYXMgYDB4JHtzdHJpbmd9YCxcbiAgICAgIH0pO1xuICAgIH1cbiAgICByZXR1cm4gU2luZ2xldG9uUmVnaXN0cnkuaW5zdGFuY2U7XG4gIH1cbn1cbiJdfQ==

package/dist/cjs/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,EAAE,eAAe,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAIxG,OAAO,EAAE,WAAW,EAA0C,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5G,OAAO,EAA0B,cAAc,EAAoC,MAAM,SAAS,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAG1D,qBAAa,cAAe,SAAQ,kBAAkB;IACpD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,WAAW,EAAE,MAAM,CAAC;IAC9B,SAAS,CAAC,MAAM,EAAE,cAAc,CAAC;IACjC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC;gBAEnB,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;;;;;OAOG;IACH,SAAS,CAAC,gBAAgB,IAAI,mBAAmB;IAsBjD,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAM5B;;;;;OAKG;IACH,UAAU,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI;IAKrC;;;;;;;OAOG;IACH,KAAK,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI;IAMpC;;;;;;;;OAQG;IACH,KAAK,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAUlC,kBAAkB;IAClB,0BAA0B,CAAC,UAAU,EAAE,qBAAqB,GAAG,eAAe,GAAG,IAAI;IAoBrF,kBAAkB;IAClB,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,WAAW;IA+BjE,kBAAkB;IAClB,mBAAmB,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAKzC,OAAO,CAAC,cAAc;CAcvB"}