@bitgo/sdk-coin-polyx 1.7.2 → 1.8.0

package/dist/src/polyx.js

@@ -0,0 +1,287 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polyx = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const api_1 = require("@polkadot/api");
+const statics_1 = require("@bitgo/statics");
+const abstract_substrate_1 = require("@bitgo/abstract-substrate");
+const constants_1 = require("./lib/constants");
+const sdk_lib_mpc_1 = require("@bitgo/sdk-lib-mpc");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const lib_1 = require("./lib");
+class Polyx extends abstract_substrate_1.SubstrateCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo, staticsCoin);
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Polyx(bitgo, staticsCoin);
+    }
+    getBuilder() {
+        return new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+    }
+    /**
+     * Factor between the coin's base unit and its smallest subdivison
+     */
+    getBaseFactor() {
+        return 1e6;
+    }
+    getChain() {
+        return 'polyx';
+    }
+    getFullName() {
+        return 'Polymesh';
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ publicKey, prv, multiSigType }) {
+        super.auditDecryptedKey({ publicKey, prv, multiSigType });
+    }
+    stakingBatch() {
+        return this.getBuilder().getBatchBuilder();
+    }
+    bondExtra() {
+        return this.getBuilder().getBondExtraBuilder();
+    }
+    /**
+     * Retrieves the address format for Polyx.
+     *
+     * @returns {number} The address format as a number for Polyx.
+     * @override
+     */
+    getAddressFormat() {
+        return constants_1.POLYX_ADDRESS_FORMAT;
+    }
+    async getInitializedNodeAPI() {
+        if (!Polyx.nodeApiInitialized) {
+            const wsProvider = new api_1.WsProvider(sdk_core_1.Environments[this.bitgo.getEnv()].polymeshNodeUrls);
+            Polyx.API = await api_1.ApiPromise.create({ provider: wsProvider });
+            Polyx.nodeApiInitialized = true;
+        }
+        return Polyx.API;
+    }
+    async getAccountInfo(walletAddr) {
+        const api = await this.getInitializedNodeAPI();
+        const { nonce, data: balance } = await api.query.system.account(walletAddr);
+        return { nonce: nonce.toNumber(), freeBalance: balance.free.toNumber() };
+    }
+    async getFee(destAddr, srcAddr, amount) {
+        const api = await this.getInitializedNodeAPI();
+        const info = await api.tx.balances.transfer(destAddr, amount).paymentInfo(srcAddr);
+        return info.partialFee.toNumber();
+    }
+    async getHeaderInfo() {
+        const api = await this.getInitializedNodeAPI();
+        const { number, hash } = await api.rpc.chain.getHeader();
+        return { headerNumber: number.toNumber(), headerHash: hash.toString() };
+    }
+    async getMaterial() {
+        const api = await this.getInitializedNodeAPI();
+        return {
+            genesisHash: api.genesisHash.toString(),
+            chainName: api.runtimeChain.toString(),
+            specName: api.runtimeVersion.specName.toString(),
+            specVersion: api.runtimeVersion.specVersion.toNumber(),
+            txVersion: api.runtimeVersion.transactionVersion.toNumber(),
+            metadata: api.runtimeMetadata.toHex(),
+        };
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param {MPCRecoveryOptions} params parameters needed to construct and
+     * (maybe) sign the transaction
+     *
+     * @returns {MPCTx} the serialized transaction hex string and index
+     * of the address being swept
+     */
+    async recover(params) {
+        if (!params.bitgoKey) {
+            throw new Error('Missing bitgoKey');
+        }
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('Invalid recovery destination address');
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const index = params.index || 0;
+        const currPath = params.seed ? (0, sdk_lib_mpc_1.getDerivationPath)(params.seed) + `/${index}` : `m/${index}`;
+        const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+        const senderAddr = this.getAddressFromPublicKey(accountId);
+        const { nonce, freeBalance } = await this.getAccountInfo(senderAddr);
+        const destAddr = params.recoveryDestination;
+        const amount = freeBalance;
+        const partialFee = await this.getFee(destAddr, senderAddr, amount);
+        const paddedFee = new bignumber_js_1.default(partialFee).times(10).toNumber();
+        const amountToSend = new bignumber_js_1.default(amount).minus(new bignumber_js_1.default(paddedFee));
+        const value = new bignumber_js_1.default(freeBalance).minus(new bignumber_js_1.default(partialFee));
+        if (value.isLessThanOrEqualTo(0)) {
+            throw new Error('Did not find address with funds to recover');
+        }
+        const { headerNumber, headerHash } = await this.getHeaderInfo();
+        const material = await this.getMaterial();
+        const validityWindow = { firstValid: headerNumber, maxDuration: this.MAX_VALIDITY_DURATION };
+        const txBuilder = this.getBuilder().getTransferBuilder().material(material);
+        txBuilder
+            .amount(amountToSend.toString())
+            .to({ address: params.recoveryDestination })
+            .sender({ address: senderAddr })
+            .memo('0')
+            .validity(validityWindow)
+            .referenceBlock(headerHash)
+            .sequenceId({ name: 'Nonce', keyword: 'nonce', value: nonce })
+            .fee({ amount: 0, type: 'tip' });
+        const unsignedTransaction = (await txBuilder.build());
+        let serializedTx = unsignedTransaction.toBroadcastFormat();
+        if (!isUnsignedSweep) {
+            if (!params.userKey) {
+                throw new Error('missing userKey');
+            }
+            if (!params.backupKey) {
+                throw new Error('missing backupKey');
+            }
+            if (!params.walletPassphrase) {
+                throw new Error('missing wallet passphrase');
+            }
+            const userKey = params.userKey.replace(/\s/g, '');
+            const backupKey = params.backupKey.replace(/\s/g, '');
+            // Decrypt private keys from KeyCard values
+            let userPrv;
+            try {
+                userPrv = this.bitgo.decrypt({
+                    input: userKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting user keychain: ${e.message}`);
+            }
+            const userSigningMaterial = JSON.parse(userPrv);
+            let backupPrv;
+            try {
+                backupPrv = this.bitgo.decrypt({
+                    input: backupKey,
+                    password: params.walletPassphrase,
+                });
+            }
+            catch (e) {
+                throw new Error(`Error decrypting backup keychain: ${e.message}`);
+            }
+            const backupSigningMaterial = JSON.parse(backupPrv);
+            // add signature
+            const signatureHex = await sdk_core_1.EDDSAMethods.getTSSSignature(userSigningMaterial, backupSigningMaterial, currPath, unsignedTransaction);
+            const substrateKeyPair = new abstract_substrate_1.KeyPair({ pub: accountId });
+            txBuilder.addSignature({ pub: substrateKeyPair.getKeys().pub }, signatureHex);
+            const signedTransaction = await txBuilder.build();
+            serializedTx = signedTransaction.toBroadcastFormat();
+        }
+        else {
+            const walletCoin = this.getChain();
+            const inputs = [
+                {
+                    address: unsignedTransaction.inputs[0].address,
+                    valueString: amountToSend.toString(),
+                    value: amountToSend.toNumber(),
+                },
+            ];
+            const outputs = [
+                {
+                    address: unsignedTransaction.outputs[0].address,
+                    valueString: amountToSend.toString(),
+                    coinName: walletCoin,
+                },
+            ];
+            const spendAmount = amountToSend.toString();
+            const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
+            const feeInfo = { fee: 0, feeString: '0' };
+            const transaction = {
+                serializedTx: serializedTx,
+                scanIndex: index,
+                coin: walletCoin,
+                signableHex: unsignedTransaction.signablePayload.toString('hex'),
+                derivationPath: currPath,
+                parsedTx: parsedTx,
+                feeInfo: feeInfo,
+                coinSpecific: { ...validityWindow, commonKeychain: bitgoKey },
+            };
+            const unsignedTx = { unsignedTx: transaction, signatureShares: [] };
+            const transactions = [unsignedTx];
+            const txRequest = {
+                transactions: transactions,
+                walletCoin: walletCoin,
+            };
+            const txRequests = { txRequests: [txRequest] };
+            return txRequests;
+        }
+        const transaction = { serializedTx: serializedTx, scanIndex: index };
+        return transaction;
+    }
+    /** inherited doc */
+    async createBroadcastableSweepTransaction(params) {
+        const req = params.signatureShares;
+        const broadcastableTransactions = [];
+        let lastScanIndex = 0;
+        for (let i = 0; i < req.length; i++) {
+            const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            const transaction = req[i].txRequest.transactions[0].unsignedTx;
+            if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {
+                throw new Error('Missing signature(s)');
+            }
+            const signature = req[i].ovc[0].eddsaSignature;
+            if (!transaction.signableHex) {
+                throw new Error('Missing signable hex');
+            }
+            const messageBuffer = Buffer.from(transaction.signableHex, 'hex');
+            const result = MPC.verify(messageBuffer, signature);
+            if (!result) {
+                throw new Error('Invalid signature');
+            }
+            const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);
+            if (!transaction.coinSpecific ||
+                !transaction.coinSpecific?.firstValid ||
+                !transaction.coinSpecific?.maxDuration) {
+                throw new Error('missing validity window');
+            }
+            const validityWindow = {
+                firstValid: transaction.coinSpecific?.firstValid,
+                maxDuration: transaction.coinSpecific?.maxDuration,
+            };
+            const material = await this.getMaterial();
+            if (!transaction.coinSpecific?.commonKeychain) {
+                throw new Error('Missing common keychain');
+            }
+            const commonKeychain = transaction.coinSpecific.commonKeychain;
+            if (!transaction.derivationPath) {
+                throw new Error('Missing derivation path');
+            }
+            const derivationPath = transaction.derivationPath;
+            const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+            const senderAddr = this.getAddressFromPublicKey(accountId);
+            const txnBuilder = this.getBuilder()
+                .material(material)
+                .from(transaction.serializedTx)
+                .sender({ address: senderAddr })
+                .validity(validityWindow);
+            const substrateKeyPair = new abstract_substrate_1.KeyPair({ pub: accountId });
+            txnBuilder.addSignature({ pub: substrateKeyPair.getKeys().pub }, signatureHex);
+            const signedTransaction = await txnBuilder.build();
+            const serializedTx = signedTransaction.toBroadcastFormat();
+            broadcastableTransactions.push({
+                serializedTx: serializedTx,
+                scanIndex: transaction.scanIndex,
+            });
+            if (i === req.length - 1 && transaction.coinSpecific.lastScanIndex) {
+                lastScanIndex = transaction.coinSpecific.lastScanIndex;
+            }
+        }
+        return { transactions: broadcastableTransactions, lastScanIndex };
+    }
+}
+exports.Polyx = Polyx;
+Polyx.nodeApiInitialized = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polyx.js","sourceRoot":"","sources":["../../src/polyx.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  EDDSAMethods,\n  EDDSAMethodTypes,\n  MPCRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCUnsignedTx,\n  RecoveryTxRequest,\n  Environments,\n  MPCSweepRecoveryOptions,\n  MPCTxs,\n} from '@bitgo/sdk-core';\nimport { ApiPromise, WsProvider } from '@polkadot/api';\nimport { BaseCoin as StaticsBaseCoin, coins, SubstrateSpecNameType } from '@bitgo/statics';\nimport { KeyPair as SubstrateKeyPair, SubstrateCoin, Transaction, Interface } from '@bitgo/abstract-substrate';\nimport { BatchStakingBuilder } from './lib/batchStakingBuilder';\nimport { BondExtraBuilder } from './lib/bondExtraBuilder';\nimport { POLYX_ADDRESS_FORMAT } from './lib/constants';\nimport { getDerivationPath } from '@bitgo/sdk-lib-mpc';\nimport BigNumber from 'bignumber.js';\nimport { TransactionBuilderFactory, TransferBuilder } from './lib';\n\nexport class Polyx extends SubstrateCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo, staticsCoin);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  protected static nodeApiInitialized = false;\n  protected static API: ApiPromise;\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Polyx(bitgo, staticsCoin);\n  }\n\n  getBuilder(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /**\n   * Factor between the coin's base unit and its smallest subdivison\n   */\n  public getBaseFactor(): number {\n    return 1e6;\n  }\n\n  public getChain(): string {\n    return 'polyx';\n  }\n\n  public getFullName(): string {\n    return 'Polymesh';\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ publicKey, prv, multiSigType }: AuditDecryptedKeyParams) {\n    super.auditDecryptedKey({ publicKey, prv, multiSigType });\n  }\n\n  stakingBatch(): BatchStakingBuilder {\n    return this.getBuilder().getBatchBuilder();\n  }\n\n  bondExtra(): BondExtraBuilder {\n    return this.getBuilder().getBondExtraBuilder();\n  }\n\n  /**\n   * Retrieves the address format for Polyx.\n   *\n   * @returns {number} The address format as a number for Polyx.\n   * @override\n   */\n  protected getAddressFormat(): number {\n    return POLYX_ADDRESS_FORMAT;\n  }\n\n  protected async getInitializedNodeAPI(): Promise<ApiPromise> {\n    if (!Polyx.nodeApiInitialized) {\n      const wsProvider = new WsProvider(Environments[this.bitgo.getEnv()].polymeshNodeUrls);\n      Polyx.API = await ApiPromise.create({ provider: wsProvider });\n      Polyx.nodeApiInitialized = true;\n    }\n    return Polyx.API;\n  }\n\n  protected async getAccountInfo(walletAddr: string): Promise<{ nonce: number; freeBalance: number }> {\n    const api = await this.getInitializedNodeAPI();\n    const { nonce, data: balance } = await api.query.system.account(walletAddr);\n\n    return { nonce: nonce.toNumber(), freeBalance: balance.free.toNumber() };\n  }\n\n  protected async getFee(destAddr: string, srcAddr: string, amount: number): Promise<number> {\n    const api = await this.getInitializedNodeAPI();\n    const info = await api.tx.balances.transfer(destAddr, amount).paymentInfo(srcAddr);\n    return info.partialFee.toNumber();\n  }\n\n  protected async getHeaderInfo(): Promise<{ headerNumber: number; headerHash: string }> {\n    const api = await this.getInitializedNodeAPI();\n    const { number, hash } = await api.rpc.chain.getHeader();\n    return { headerNumber: number.toNumber(), headerHash: hash.toString() };\n  }\n\n  protected async getMaterial(): Promise<Interface.Material> {\n    const api = await this.getInitializedNodeAPI();\n    return {\n      genesisHash: api.genesisHash.toString(),\n      chainName: api.runtimeChain.toString(),\n      specName: api.runtimeVersion.specName.toString() as SubstrateSpecNameType,\n      specVersion: api.runtimeVersion.specVersion.toNumber(),\n      txVersion: api.runtimeVersion.transactionVersion.toNumber(),\n      metadata: api.runtimeMetadata.toHex(),\n    };\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param {MPCRecoveryOptions} params parameters needed to construct and\n   * (maybe) sign the transaction\n   *\n   * @returns {MPCTx} the serialized transaction hex string and index\n   * of the address being swept\n   */\n  async recover(params: MPCRecoveryOptions): Promise<MPCTx | MPCSweepTxs> {\n    if (!params.bitgoKey) {\n      throw new Error('Missing bitgoKey');\n    }\n\n    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('Invalid recovery destination address');\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n\n    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n    const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);\n    const senderAddr = this.getAddressFromPublicKey(accountId);\n\n    const { nonce, freeBalance } = await this.getAccountInfo(senderAddr);\n\n    const destAddr = params.recoveryDestination;\n    const amount = freeBalance;\n    const partialFee = await this.getFee(destAddr, senderAddr, amount);\n    const paddedFee = new BigNumber(partialFee).times(10).toNumber();\n    const amountToSend = new BigNumber(amount).minus(new BigNumber(paddedFee));\n\n    const value = new BigNumber(freeBalance).minus(new BigNumber(partialFee));\n    if (value.isLessThanOrEqualTo(0)) {\n      throw new Error('Did not find address with funds to recover');\n    }\n\n    const { headerNumber, headerHash } = await this.getHeaderInfo();\n    const material = await this.getMaterial();\n    const validityWindow = { firstValid: headerNumber, maxDuration: this.MAX_VALIDITY_DURATION };\n\n    const txBuilder = this.getBuilder().getTransferBuilder().material(material) as TransferBuilder;\n\n    txBuilder\n      .amount(amountToSend.toString())\n      .to({ address: params.recoveryDestination })\n      .sender({ address: senderAddr })\n      .memo('0')\n      .validity(validityWindow)\n      .referenceBlock(headerHash)\n      .sequenceId({ name: 'Nonce', keyword: 'nonce', value: nonce })\n      .fee({ amount: 0, type: 'tip' });\n\n    const unsignedTransaction = (await txBuilder.build()) as Transaction;\n\n    let serializedTx = unsignedTransaction.toBroadcastFormat();\n    if (!isUnsignedSweep) {\n      if (!params.userKey) {\n        throw new Error('missing userKey');\n      }\n      if (!params.backupKey) {\n        throw new Error('missing backupKey');\n      }\n      if (!params.walletPassphrase) {\n        throw new Error('missing wallet passphrase');\n      }\n\n      const userKey = params.userKey.replace(/\\s/g, '');\n      const backupKey = params.backupKey.replace(/\\s/g, '');\n\n      // Decrypt private keys from KeyCard values\n      let userPrv;\n      try {\n        userPrv = this.bitgo.decrypt({\n          input: userKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting user keychain: ${e.message}`);\n      }\n      const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n\n      let backupPrv;\n      try {\n        backupPrv = this.bitgo.decrypt({\n          input: backupKey,\n          password: params.walletPassphrase,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting backup keychain: ${e.message}`);\n      }\n      const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;\n\n      // add signature\n      const signatureHex = await EDDSAMethods.getTSSSignature(\n        userSigningMaterial,\n        backupSigningMaterial,\n        currPath,\n        unsignedTransaction\n      );\n\n      const substrateKeyPair = new SubstrateKeyPair({ pub: accountId });\n      txBuilder.addSignature({ pub: substrateKeyPair.getKeys().pub }, signatureHex);\n      const signedTransaction = await txBuilder.build();\n      serializedTx = signedTransaction.toBroadcastFormat();\n    } else {\n      const walletCoin = this.getChain();\n      const inputs = [\n        {\n          address: unsignedTransaction.inputs[0].address,\n          valueString: amountToSend.toString(),\n          value: amountToSend.toNumber(),\n        },\n      ];\n      const outputs = [\n        {\n          address: unsignedTransaction.outputs[0].address,\n          valueString: amountToSend.toString(),\n          coinName: walletCoin,\n        },\n      ];\n      const spendAmount = amountToSend.toString();\n      const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };\n      const feeInfo = { fee: 0, feeString: '0' };\n      const transaction: MPCTx = {\n        serializedTx: serializedTx,\n        scanIndex: index,\n        coin: walletCoin,\n        signableHex: unsignedTransaction.signablePayload.toString('hex'),\n        derivationPath: currPath,\n        parsedTx: parsedTx,\n        feeInfo: feeInfo,\n        coinSpecific: { ...validityWindow, commonKeychain: bitgoKey },\n      };\n\n      const unsignedTx: MPCUnsignedTx = { unsignedTx: transaction, signatureShares: [] };\n      const transactions: MPCUnsignedTx[] = [unsignedTx];\n      const txRequest: RecoveryTxRequest = {\n        transactions: transactions,\n        walletCoin: walletCoin,\n      };\n      const txRequests: MPCSweepTxs = { txRequests: [txRequest] };\n      return txRequests;\n    }\n\n    const transaction: MPCTx = { serializedTx: serializedTx, scanIndex: index };\n    return transaction;\n  }\n\n  /** inherited doc */\n  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {\n    const req = params.signatureShares;\n    const broadcastableTransactions: MPCTx[] = [];\n    let lastScanIndex = 0;\n\n    for (let i = 0; i < req.length; i++) {\n      const MPC = await EDDSAMethods.getInitializedMpcInstance();\n      const transaction = req[i].txRequest.transactions[0].unsignedTx;\n      if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {\n        throw new Error('Missing signature(s)');\n      }\n      const signature = req[i].ovc[0].eddsaSignature;\n      if (!transaction.signableHex) {\n        throw new Error('Missing signable hex');\n      }\n      const messageBuffer = Buffer.from(transaction.signableHex!, 'hex');\n      const result = MPC.verify(messageBuffer, signature);\n      if (!result) {\n        throw new Error('Invalid signature');\n      }\n      const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);\n      if (\n        !transaction.coinSpecific ||\n        !transaction.coinSpecific?.firstValid ||\n        !transaction.coinSpecific?.maxDuration\n      ) {\n        throw new Error('missing validity window');\n      }\n      const validityWindow = {\n        firstValid: transaction.coinSpecific?.firstValid,\n        maxDuration: transaction.coinSpecific?.maxDuration,\n      };\n      const material = await this.getMaterial();\n      if (!transaction.coinSpecific?.commonKeychain) {\n        throw new Error('Missing common keychain');\n      }\n      const commonKeychain = transaction.coinSpecific!.commonKeychain! as string;\n      if (!transaction.derivationPath) {\n        throw new Error('Missing derivation path');\n      }\n      const derivationPath = transaction.derivationPath as string;\n      const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);\n      const senderAddr = this.getAddressFromPublicKey(accountId);\n\n      const txnBuilder = this.getBuilder()\n        .material(material)\n        .from(transaction.serializedTx as string)\n        .sender({ address: senderAddr })\n        .validity(validityWindow);\n\n      const substrateKeyPair = new SubstrateKeyPair({ pub: accountId });\n      txnBuilder.addSignature({ pub: substrateKeyPair.getKeys().pub }, signatureHex);\n      const signedTransaction = await txnBuilder.build();\n      const serializedTx = signedTransaction.toBroadcastFormat();\n\n      broadcastableTransactions.push({\n        serializedTx: serializedTx,\n        scanIndex: transaction.scanIndex,\n      });\n\n      if (i === req.length - 1 && transaction.coinSpecific!.lastScanIndex) {\n        lastScanIndex = transaction.coinSpecific!.lastScanIndex as number;\n      }\n    }\n    return { transactions: broadcastableTransactions, lastScanIndex };\n  }\n}\n"]}

package/dist/src/polyxToken.d.ts

@@ -0,0 +1,20 @@
+import { PolyxTokenConfig } from '@bitgo/statics';
+import { Polyx } from './polyx';
+import { BitGoBase, CoinConstructor, NamedCoinConstructor } from '@bitgo/sdk-core';
+export declare class PolyxToken extends Polyx {
+    readonly tokenConfig: PolyxTokenConfig;
+    constructor(bitgo: BitGoBase, tokenConfig: PolyxTokenConfig);
+    static createTokenConstructor(config: PolyxTokenConfig): CoinConstructor;
+    static createTokenConstructors(tokenConfigs?: PolyxTokenConfig[]): NamedCoinConstructor[];
+    get name(): string;
+    get coin(): string;
+    get network(): string;
+    get ticker(): string;
+    get assetId(): string;
+    get decimalPlaces(): number;
+    getChain(): string;
+    getBaseChain(): string;
+    getFullName(): string;
+    getBaseFactor(): number;
+}
+//# sourceMappingURL=polyxToken.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polyxToken.d.ts","sourceRoot":"","sources":["../../src/polyxToken.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,gBAAgB,EAAU,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAEnF,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,WAAW,EAAE,gBAAgB,CAAC;gBAElC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB;IAM3D,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe;IAIxE,MAAM,CAAC,uBAAuB,CAC5B,YAAY,GAAE,gBAAgB,EAAqE,GAClG,oBAAoB,EAAE;IASzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM;IAItB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;CAGxB"}

package/dist/src/polyxToken.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolyxToken = void 0;
+const statics_1 = require("@bitgo/statics");
+const polyx_1 = require("./polyx");
+class PolyxToken extends polyx_1.Polyx {
+    constructor(bitgo, tokenConfig) {
+        const staticsCoin = tokenConfig.network === 'Mainnet' ? statics_1.coins.get('polyx') : statics_1.coins.get('tpolyx');
+        super(bitgo, staticsCoin);
+        this.tokenConfig = tokenConfig;
+    }
+    static createTokenConstructor(config) {
+        return (bitgo) => new PolyxToken(bitgo, config);
+    }
+    static createTokenConstructors(tokenConfigs = [...statics_1.tokens.bitcoin.polyx.tokens, ...statics_1.tokens.testnet.polyx.tokens]) {
+        const tokensCtors = [];
+        for (const token of tokenConfigs) {
+            const tokenConstructor = PolyxToken.createTokenConstructor(token);
+            tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });
+        }
+        return tokensCtors;
+    }
+    get name() {
+        return this.tokenConfig.name;
+    }
+    get coin() {
+        return this.tokenConfig.coin;
+    }
+    get network() {
+        return this.tokenConfig.network;
+    }
+    get ticker() {
+        return this.tokenConfig.ticker;
+    }
+    get assetId() {
+        return this.tokenConfig.assetId;
+    }
+    get decimalPlaces() {
+        return this.tokenConfig.decimalPlaces;
+    }
+    getChain() {
+        return this.tokenConfig.type;
+    }
+    getBaseChain() {
+        return this.coin;
+    }
+    getFullName() {
+        return this._staticsCoin.fullName;
+    }
+    getBaseFactor() {
+        return Math.pow(10, this.tokenConfig.decimalPlaces);
+    }
+}
+exports.PolyxToken = PolyxToken;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/register.d.ts

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAK5C,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAMzC,CAAC"}

package/dist/src/register.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const polyx_1 = require("./polyx");
+const tpolyx_1 = require("./tpolyx");
+const polyxToken_1 = require("./polyxToken");
+const register = (sdk) => {
+    sdk.register('polyx', polyx_1.Polyx.createInstance);
+    sdk.register('tpolyx', tpolyx_1.Tpolyx.createInstance);
+    polyxToken_1.PolyxToken.createTokenConstructors().forEach(({ name, coinConstructor }) => {
+        sdk.register(name, coinConstructor);
+    });
+};
+exports.register = register;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsbUNBQWdDO0FBQ2hDLHFDQUFrQztBQUNsQyw2Q0FBMEM7QUFFbkMsTUFBTSxRQUFRLEdBQUcsQ0FBQyxHQUFjLEVBQVEsRUFBRTtJQUMvQyxHQUFHLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxhQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDNUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxRQUFRLEVBQUUsZUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0lBQzlDLHVCQUFVLENBQUMsdUJBQXVCLEVBQUUsQ0FBQyxPQUFPLENBQUMsQ0FBQyxFQUFFLElBQUksRUFBRSxlQUFlLEVBQUUsRUFBRSxFQUFFO1FBQ3pFLEdBQUcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLGVBQWUsQ0FBQyxDQUFDO0lBQ3RDLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDO0FBTlcsUUFBQSxRQUFRLFlBTW5CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQml0R29CYXNlIH0gZnJvbSAnQGJpdGdvL3Nkay1jb3JlJztcbmltcG9ydCB7IFBvbHl4IH0gZnJvbSAnLi9wb2x5eCc7XG5pbXBvcnQgeyBUcG9seXggfSBmcm9tICcuL3Rwb2x5eCc7XG5pbXBvcnQgeyBQb2x5eFRva2VuIH0gZnJvbSAnLi9wb2x5eFRva2VuJztcblxuZXhwb3J0IGNvbnN0IHJlZ2lzdGVyID0gKHNkazogQml0R29CYXNlKTogdm9pZCA9PiB7XG4gIHNkay5yZWdpc3RlcigncG9seXgnLCBQb2x5eC5jcmVhdGVJbnN0YW5jZSk7XG4gIHNkay5yZWdpc3RlcigndHBvbHl4JywgVHBvbHl4LmNyZWF0ZUluc3RhbmNlKTtcbiAgUG9seXhUb2tlbi5jcmVhdGVUb2tlbkNvbnN0cnVjdG9ycygpLmZvckVhY2goKHsgbmFtZSwgY29pbkNvbnN0cnVjdG9yIH0pID0+IHtcbiAgICBzZGsucmVnaXN0ZXIobmFtZSwgY29pbkNvbnN0cnVjdG9yKTtcbiAgfSk7XG59O1xuIl19

package/dist/src/resources/index.d.ts

@@ -0,0 +1,3 @@
+export * from './mainnet';
+export * from './testnet';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/resources/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/resources/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC"}

package/dist/src/resources/index.js

@@ -0,0 +1,19 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mainnet"), exports);
+__exportStar(require("./testnet"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmVzb3VyY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSw0Q0FBMEI7QUFDMUIsNENBQTBCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9tYWlubmV0JztcbmV4cG9ydCAqIGZyb20gJy4vdGVzdG5ldCc7XG4iXX0=

package/dist/src/resources/mainnet.d.ts

@@ -0,0 +1,13 @@
+export declare const mainnetMaterial: {
+    at: {
+        hash: string;
+        height: string;
+    };
+    genesisHash: string;
+    chainName: string;
+    specName: string;
+    specVersion: number;
+    txVersion: number;
+    metadata: string;
+};
+//# sourceMappingURL=mainnet.d.ts.map

package/dist/src/resources/mainnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mainnet.d.ts","sourceRoot":"","sources":["../../../src/resources/mainnet.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,eAAe;;;;;;;;;;;CAY3B,CAAC"}