@bitgo/sdk-coin-avaxp 2.1.0 → 2.2.0-hotfix.0

package/dist/src/avaxp.js

@@ -27,7 +27,6 @@ const statics_1 = require("@bitgo/statics");
 const sdk_core_1 = require("@bitgo/sdk-core");
 const AvaxpLib = __importStar(require("./lib"));
 const lodash_1 = __importDefault(require("lodash"));
-const avalanche_1 = require("avalanche");
 class AvaxP extends sdk_core_1.BaseCoin {
     constructor(bitgo, staticsCoin) {
         super(bitgo);
@@ -55,42 +54,63 @@ class AvaxP extends sdk_core_1.BaseCoin {
         return true;
     }
     async verifyTransaction(params) {
-        var _a;
-        let totalAmount = new avalanche_1.BN(0);
-        const coinConfig = statics_1.coins.get(this.getChain());
-        const { txPrebuild: txPrebuild, txParams: txParams } = params;
-        const rawTx = txPrebuild.txHex;
-        if (!rawTx) {
+        const txHex = params.txPrebuild && params.txPrebuild.txHex;
+        if (!txHex) {
             throw new Error('missing required tx prebuild property txHex');
         }
-        const transactionBuilder = new AvaxpLib.TransactionBuilderFactory(coinConfig).from(rawTx);
-        const transaction = await transactionBuilder.build();
-        const explainedTx = transaction.explainTransaction();
-        if (txParams.recipients !== undefined) {
-            const filteredRecipients = (_a = txParams.recipients) === null || _a === void 0 ? void 0 : _a.map((recipient) => lodash_1.default.pick(recipient, ['address', 'amount']));
-            const filteredOutputs = explainedTx.outputs.map((output) => lodash_1.default.pick(output, ['address', 'amount']));
-            if (!lodash_1.default.isEqual(filteredOutputs, filteredRecipients)) {
-                throw new Error('Tx outputs does not match with expected txParams recipients');
-            }
-            for (const recipients of txParams.recipients) {
-                totalAmount = totalAmount.add(new avalanche_1.BN(recipients.amount));
-            }
-            if (!totalAmount.eq(new avalanche_1.BN(explainedTx.outputAmount))) {
-                throw new Error('Tx total amount does not match with expected total amount field');
-            }
+        let tx;
+        try {
+            const txBuilder = this.getBuilder().from(txHex);
+            tx = await txBuilder.build();
+        }
+        catch (error) {
+            throw new Error('Invalid transaction');
+        }
+        const explainedTx = tx.explainTransaction();
+        const { type, stakingOptions, memo } = params.txParams;
+        if (!type || explainedTx.type !== sdk_core_1.TransactionType[type]) {
+            throw new Error('Tx type does not match with expected txParams type');
+        }
+        if (memo && explainedTx.memo !== memo.value) {
+            throw new Error('Tx memo does not match with expected txParams memo');
+        }
+        switch (explainedTx.type) {
+            case sdk_core_1.TransactionType.addDelegator:
+            case sdk_core_1.TransactionType.addValidator:
+                if (!params.txParams.recipients || params.txParams.recipients.length === 0) {
+                    const filteredRecipients = [{ address: stakingOptions.nodeID, amount: stakingOptions.amount }];
+                    const filteredOutputs = explainedTx.outputs.map((output) => lodash_1.default.pick(output, ['address', 'amount']));
+                    if (!lodash_1.default.isEqual(filteredOutputs, filteredRecipients)) {
+                        throw new Error('Tx outputs does not match with expected txParams');
+                    }
+                    if (stakingOptions.amount !== explainedTx.outputAmount) {
+                        throw new Error('Tx total amount does not match with expected total amount field');
+                    }
+                }
+                break;
+            default:
+                throw new Error('Tx type is not supported yet');
         }
-        return true;
-    }
-    verifyAddress(params) {
-        // TODO(STLX-16574): verifyTransaction
         return true;
     }
     /**
      * Check if address is valid, then make sure it matches the root address.
      *
-     * @param {VerifyAddressOptions} params address and rootAddress to verify
+     * @param params.address address to validate
+     * @param params.keychains public keys to generate the wallet
      */
     isWalletAddress(params) {
+        const { address, keychains } = params;
+        if (!this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        if (!keychains || keychains.length !== 3) {
+            throw new Error('Invalid keychains');
+        }
+        const unlockAddresses = keychains.map((keychain) => new AvaxpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type));
+        if (!unlockAddresses.some((unlockAddress) => unlockAddress === address)) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);
+        }
         return true;
     }
     /**
@@ -162,7 +182,8 @@ class AvaxP extends sdk_core_1.BaseCoin {
             : { halfSigned: { txHex: transaction.toBroadcastFormat() } };
     }
     async feeEstimate(params) {
-        return { fee: this._staticsCoin.network.txFee };
+        // staking transactions are fee-less
+        return { fee: '0' };
     }
     parseTransaction(params) {
         throw new sdk_core_1.MethodNotImplementedError('parseTransaction method not implemented');
@@ -187,6 +208,9 @@ class AvaxP extends sdk_core_1.BaseCoin {
             throw new Error(`Invalid transaction: ${e.message}`);
         }
     }
+    recoverySignature(message, signature) {
+        return AvaxpLib.Utils.recoverySignature(this._staticsCoin.network, message, signature);
+    }
     async signMessage(key, message) {
         const prv = new AvaxpLib.KeyPair(key).getPrivateKey();
         if (!prv) {
@@ -202,4 +226,4 @@ class AvaxP extends sdk_core_1.BaseCoin {
     }
 }
 exports.AvaxP = AvaxP;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avaxp.js","sourceRoot":"","sources":["../../src/avaxp.ts"],"names":[],"mappings":"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","sourcesContent":["import { AvalancheNetwork, BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';\nimport {\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n  SignedTransaction,\n  ParseTransactionOptions,\n  MethodNotImplementedError,\n  BaseTransaction,\n  InvalidTransactionError,\n  FeeEstimateOptions,\n  SigningError,\n} from '@bitgo/sdk-core';\nimport * as AvaxpLib from './lib';\nimport { AvaxpSignTransactionOptions, TransactionFee, ExplainTransactionOptions } from './iface';\nimport _ from 'lodash';\nimport { BN } from 'avalanche';\n\nexport class AvaxP extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new AvaxP(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  supportsStaking(): boolean {\n    return true;\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    let totalAmount = new BN(0);\n    const coinConfig = coins.get(this.getChain());\n    const { txPrebuild: txPrebuild, txParams: txParams } = params;\n    const rawTx = txPrebuild.txHex;\n    if (!rawTx) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    const transactionBuilder = new AvaxpLib.TransactionBuilderFactory(coinConfig).from(rawTx);\n    const transaction = await transactionBuilder.build();\n    const explainedTx = transaction.explainTransaction();\n\n    if (txParams.recipients !== undefined) {\n      const filteredRecipients = txParams.recipients?.map((recipient) => _.pick(recipient, ['address', 'amount']));\n      const filteredOutputs = explainedTx.outputs.map((output: { address: string; amount: string; memo: string }) =>\n        _.pick(output, ['address', 'amount'])\n      );\n\n      if (!_.isEqual(filteredOutputs, filteredRecipients)) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n      for (const recipients of txParams.recipients) {\n        totalAmount = totalAmount.add(new BN(recipients.amount));\n      }\n      if (!totalAmount.eq(new BN(explainedTx.outputAmount))) {\n        throw new Error('Tx total amount does not match with expected total amount field');\n      }\n    }\n    return true;\n  }\n\n  verifyAddress(params: VerifyAddressOptions): boolean {\n    // TODO(STLX-16574): verifyTransaction\n    return true;\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the root address.\n   *\n   * @param {VerifyAddressOptions} params address and rootAddress to verify\n   */\n  isWalletAddress(params: VerifyAddressOptions): boolean {\n    return true;\n  }\n  /**\n   * Generate Avaxp key pair\n   *\n   * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new AvaxpLib.KeyPair({ seed }) : new AvaxpLib.KeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {string} pub the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    try {\n      new AvaxpLib.KeyPair({ pub });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param {string} prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    try {\n      new AvaxpLib.KeyPair({ prv });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string): boolean {\n    return AvaxpLib.Utils.isValidAddress(address);\n  }\n\n  /**\n   * Signs Avaxp transaction\n   */\n  async signTransaction(params: AvaxpSignTransactionOptions): Promise<SignedTransaction> {\n    // deserialize raw transaction (note: fromAddress has onchain order)\n    const txBuilder = this.getBuilder().from(params.txPrebuild.txHex);\n    const key = params.prv;\n\n    // push the keypair to signer array\n    txBuilder.sign({ key });\n\n    // build the transaction\n    const transaction: BaseTransaction = await txBuilder.build();\n    if (!transaction) {\n      throw new InvalidTransactionError('Error while trying to build transaction');\n    }\n    return transaction.signature.length >= 2\n      ? { txHex: transaction.toBroadcastFormat() }\n      : { halfSigned: { txHex: transaction.toBroadcastFormat() } };\n  }\n\n  async feeEstimate(params: FeeEstimateOptions): Promise<TransactionFee> {\n    return { fee: (this._staticsCoin.network as AvalancheNetwork).txFee };\n  }\n\n  parseTransaction(params: ParseTransactionOptions): Promise<ParseTransactionOptions> {\n    throw new MethodNotImplementedError('parseTransaction method not implemented');\n  }\n\n  /**\n   * Explain a Avaxp transaction from txHex\n   * @param params\n   * @param callback\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<AvaxpLib.TransactionExplanation> {\n    const txHex = params.txHex ?? params?.halfSigned?.txHex;\n    if (!txHex) {\n      throw new Error('missing transaction hex');\n    }\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      const tx = await txBuilder.build();\n      return tx.explainTransaction();\n    } catch (e) {\n      throw new Error(`Invalid transaction: ${e.message}`);\n    }\n  }\n\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const prv = new AvaxpLib.KeyPair(key).getPrivateKey();\n    if (!prv) {\n      throw new SigningError('Invalid key pair options');\n    }\n    if (typeof message === 'string') {\n      message = Buffer.from(message, 'hex');\n    }\n    return AvaxpLib.Utils.createSignature(this._staticsCoin.network as AvalancheNetwork, message, prv);\n  }\n\n  private getBuilder(): AvaxpLib.TransactionBuilderFactory {\n    return new AvaxpLib.TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"avaxp.js","sourceRoot":"","sources":["../../src/avaxp.ts"],"names":[],"mappings":"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","sourcesContent":["import { AvalancheNetwork, BaseCoin as StaticsBaseCoin, CoinFamily, coins } from '@bitgo/statics';\nimport {\n  BaseCoin,\n  BitGoBase,\n  KeyPair,\n  VerifyAddressOptions,\n  SignedTransaction,\n  ParseTransactionOptions,\n  MethodNotImplementedError,\n  BaseTransaction,\n  InvalidTransactionError,\n  FeeEstimateOptions,\n  SigningError,\n  TransactionType,\n  InvalidAddressError,\n  UnexpectedAddressError,\n} from '@bitgo/sdk-core';\nimport * as AvaxpLib from './lib';\nimport {\n  AvaxpSignTransactionOptions,\n  TransactionFee,\n  ExplainTransactionOptions,\n  AvaxpVerifyTransactionOptions,\n} from './iface';\nimport _ from 'lodash';\n\nexport class AvaxP extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new AvaxP(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  supportsStaking(): boolean {\n    return true;\n  }\n\n  async verifyTransaction(params: AvaxpVerifyTransactionOptions): Promise<boolean> {\n    const txHex = params.txPrebuild && params.txPrebuild.txHex;\n    if (!txHex) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n    let tx;\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      tx = await txBuilder.build();\n    } catch (error) {\n      throw new Error('Invalid transaction');\n    }\n    const explainedTx = tx.explainTransaction();\n\n    const { type, stakingOptions, memo } = params.txParams;\n    if (!type || explainedTx.type !== TransactionType[type]) {\n      throw new Error('Tx type does not match with expected txParams type');\n    }\n    if (memo && explainedTx.memo !== memo.value) {\n      throw new Error('Tx memo does not match with expected txParams memo');\n    }\n    switch (explainedTx.type) {\n      case TransactionType.addDelegator:\n      case TransactionType.addValidator:\n        if (!params.txParams.recipients || params.txParams.recipients.length === 0) {\n          const filteredRecipients = [{ address: stakingOptions.nodeID, amount: stakingOptions.amount }];\n          const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount']));\n\n          if (!_.isEqual(filteredOutputs, filteredRecipients)) {\n            throw new Error('Tx outputs does not match with expected txParams');\n          }\n          if (stakingOptions.amount !== explainedTx.outputAmount) {\n            throw new Error('Tx total amount does not match with expected total amount field');\n          }\n        }\n        break;\n      default:\n        throw new Error('Tx type is not supported yet');\n    }\n    return true;\n  }\n\n  /**\n   * Check if address is valid, then make sure it matches the root address.\n   *\n   * @param params.address address to validate\n   * @param params.keychains public keys to generate the wallet\n   */\n  isWalletAddress(params: VerifyAddressOptions): boolean {\n    const { address, keychains } = params;\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n    if (!keychains || keychains.length !== 3) {\n      throw new Error('Invalid keychains');\n    }\n    const unlockAddresses = keychains.map((keychain) =>\n      new AvaxpLib.KeyPair({ pub: keychain.pub }).getAddress(this._staticsCoin.network.type)\n    );\n\n    if (!unlockAddresses.some((unlockAddress) => unlockAddress === address)) {\n      throw new UnexpectedAddressError(`address validation failure: ${address} is not of this wallet`);\n    }\n    return true;\n  }\n  /**\n   * Generate Avaxp key pair\n   *\n   * @param {Buffer} seed - Seed from which the new keypair should be generated, otherwise a random seed is used\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? new AvaxpLib.KeyPair({ seed }) : new AvaxpLib.KeyPair();\n    const keys = keyPair.getKeys();\n\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {string} pub the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    try {\n      new AvaxpLib.KeyPair({ pub });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param {string} prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    try {\n      new AvaxpLib.KeyPair({ prv });\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  isValidAddress(address: string): boolean {\n    return AvaxpLib.Utils.isValidAddress(address);\n  }\n\n  /**\n   * Signs Avaxp transaction\n   */\n  async signTransaction(params: AvaxpSignTransactionOptions): Promise<SignedTransaction> {\n    // deserialize raw transaction (note: fromAddress has onchain order)\n    const txBuilder = this.getBuilder().from(params.txPrebuild.txHex);\n    const key = params.prv;\n\n    // push the keypair to signer array\n    txBuilder.sign({ key });\n\n    // build the transaction\n    const transaction: BaseTransaction = await txBuilder.build();\n    if (!transaction) {\n      throw new InvalidTransactionError('Error while trying to build transaction');\n    }\n    return transaction.signature.length >= 2\n      ? { txHex: transaction.toBroadcastFormat() }\n      : { halfSigned: { txHex: transaction.toBroadcastFormat() } };\n  }\n\n  async feeEstimate(params: FeeEstimateOptions): Promise<TransactionFee> {\n    // staking transactions are fee-less\n    return { fee: '0' };\n  }\n\n  parseTransaction(params: ParseTransactionOptions): Promise<ParseTransactionOptions> {\n    throw new MethodNotImplementedError('parseTransaction method not implemented');\n  }\n\n  /**\n   * Explain a Avaxp transaction from txHex\n   * @param params\n   * @param callback\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<AvaxpLib.TransactionExplanation> {\n    const txHex = params.txHex ?? params?.halfSigned?.txHex;\n    if (!txHex) {\n      throw new Error('missing transaction hex');\n    }\n    try {\n      const txBuilder = this.getBuilder().from(txHex);\n      const tx = await txBuilder.build();\n      return tx.explainTransaction();\n    } catch (e) {\n      throw new Error(`Invalid transaction: ${e.message}`);\n    }\n  }\n\n  recoverySignature(message: Buffer, signature: Buffer): Buffer {\n    return AvaxpLib.Utils.recoverySignature(this._staticsCoin.network as AvalancheNetwork, message, signature);\n  }\n\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const prv = new AvaxpLib.KeyPair(key).getPrivateKey();\n    if (!prv) {\n      throw new SigningError('Invalid key pair options');\n    }\n    if (typeof message === 'string') {\n      message = Buffer.from(message, 'hex');\n    }\n    return AvaxpLib.Utils.createSignature(this._staticsCoin.network as AvalancheNetwork, message, prv);\n  }\n\n  private getBuilder(): AvaxpLib.TransactionBuilderFactory {\n    return new AvaxpLib.TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n}\n"]}

package/dist/src/constants.d.ts

@@ -0,0 +1,10 @@
+import { SerializedType } from 'avalanche/dist/utils';
+export declare const DEFAULT_CHAIN_NAMES: {
+    testnet: string;
+    mainnet: string;
+};
+export declare const serializedType: SerializedType;
+export declare const chainID = "P";
+export declare const testnet = "fuji";
+export declare const mainnet = "avax";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,eAAO,MAAM,mBAAmB;;;CAG/B,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,cAAyB,CAAC;AACvD,eAAO,MAAM,OAAO,MAAM,CAAC;AAC3B,eAAO,MAAM,OAAO,SAAS,CAAC;AAC9B,eAAO,MAAM,OAAO,SAAS,CAAC"}

package/dist/src/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mainnet = exports.testnet = exports.chainID = exports.serializedType = exports.DEFAULT_CHAIN_NAMES = void 0;
+exports.DEFAULT_CHAIN_NAMES = {
+    testnet: 'tavaxp',
+    mainnet: 'avaxp',
+};
+exports.serializedType = 'bech32';
+exports.chainID = 'P';
+exports.testnet = 'fuji';
+exports.mainnet = 'avax';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFFYSxRQUFBLG1CQUFtQixHQUFHO0lBQ2pDLE9BQU8sRUFBRSxRQUFRO0lBQ2pCLE9BQU8sRUFBRSxPQUFPO0NBQ2pCLENBQUM7QUFFVyxRQUFBLGNBQWMsR0FBbUIsUUFBUSxDQUFDO0FBQzFDLFFBQUEsT0FBTyxHQUFHLEdBQUcsQ0FBQztBQUNkLFFBQUEsT0FBTyxHQUFHLE1BQU0sQ0FBQztBQUNqQixRQUFBLE9BQU8sR0FBRyxNQUFNLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZXJpYWxpemVkVHlwZSB9IGZyb20gJ2F2YWxhbmNoZS9kaXN0L3V0aWxzJztcblxuZXhwb3J0IGNvbnN0IERFRkFVTFRfQ0hBSU5fTkFNRVMgPSB7XG4gIHRlc3RuZXQ6ICd0YXZheHAnLFxuICBtYWlubmV0OiAnYXZheHAnLFxufTtcblxuZXhwb3J0IGNvbnN0IHNlcmlhbGl6ZWRUeXBlOiBTZXJpYWxpemVkVHlwZSA9ICdiZWNoMzInO1xuZXhwb3J0IGNvbnN0IGNoYWluSUQgPSAnUCc7XG5leHBvcnQgY29uc3QgdGVzdG5ldCA9ICdmdWppJztcbmV4cG9ydCBjb25zdCBtYWlubmV0ID0gJ2F2YXgnO1xuIl19

package/dist/src/delegatorTxBuilder.d.ts

@@ -0,0 +1,100 @@
+/// <reference types="bn.js" />
+import { BaseAddress, TransactionType } from '@bitgo/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo/statics';
+import { TransactionBuilder } from './transactionBuilder';
+import { AddDelegatorTx, BaseTx, ParseableOutput, TransferableInput, TransferableOutput } from 'avalanche/dist/apis/platformvm';
+import { BN } from 'avalanche';
+import { DecodedUtxoObj } from './iface';
+export declare class DelegatorTxBuilder extends TransactionBuilder {
+    protected _nodeID: string;
+    protected _startTime: BN;
+    protected _endTime: BN;
+    protected _stakeAmount: BN;
+    protected _rewardAddress: BaseAddress;
+    /**
+     *
+     * @param coinConfig
+     */
+    constructor(coinConfig: Readonly<CoinConfig>);
+    /**
+     * get transaction type
+     * @protected
+     */
+    protected get transactionType(): TransactionType;
+    /**
+     *
+     * @param nodeID
+     */
+    nodeID(value: string): this;
+    /**
+     *
+     * @param startTime
+     */
+    startTime(value: string | number): this;
+    /**
+     *
+     * @param endTime
+     */
+    endTime(value: string | number): this;
+    /**
+     *
+     * @param value
+     */
+    stakeAmount(value: BN | string): this;
+    /**
+     * Set the transaction source
+     *
+     * @param {BaseAddress} address The source account
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    rewardAddress(address: BaseAddress): this;
+    /**
+     * region Validators
+     */
+    /**
+     * validates a correct NodeID is used
+     * @param nodeID
+     */
+    validateNodeID(nodeID: string): void;
+    /**
+     *
+     *   protected _startTime: Date;
+     *   protected _endTime: Date;
+     *   2 weeks = 1209600
+     *   1 year = 31556926
+     *   unix time stamp based off seconds
+     */
+    validateStakeDuration(startTime: BN, endTime: BN): void;
+    /**
+     *
+     * @param amount
+     */
+    validateStakeAmount(amount: BN): void;
+    initBuilder(tx?: AddDelegatorTx): this;
+    /**
+     *
+     * @protected
+     */
+    protected buildAvaxpTransaction(): BaseTx;
+    protected stakeTransferOut(): TransferableOutput;
+    protected rewardOwnersOutput(): ParseableOutput;
+    /**
+     * Inputs can be controlled but outputs get reordered in transactions
+     * In order to make sure that the mapping is always correct we create an addressIndx which matches to the appropiate
+     * signatureIdx
+     * @param inputs
+     * @protected
+     */
+    protected recoverUtxos(inputs: TransferableInput[]): DecodedUtxoObj[];
+    /**
+     * Threshold must be 2 and since output always get reordered we want to make sure we can always add signatures in the correct location
+     * To find the correct location for the signature, we use the ouput's addresses to create the signatureIdx in the order that we desire
+     * 0: user key, 1: recovery key, 2: hsm key
+     * @protected
+     */
+    protected createInputOutput(): {
+        inputs: TransferableInput[];
+        outputs: TransferableOutput[];
+    };
+}
+//# sourceMappingURL=delegatorTxBuilder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delegatorTxBuilder.d.ts","sourceRoot":"","sources":["../../src/delegatorTxBuilder.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAyB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACtF,OAAO,EAAoB,QAAQ,IAAI,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC1E,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EACL,cAAc,EACd,MAAM,EACN,eAAe,EAIf,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGzC,qBAAa,kBAAmB,SAAQ,kBAAkB;IACxD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,UAAU,EAAE,EAAE,CAAC;IACzB,SAAS,CAAC,QAAQ,EAAE,EAAE,CAAC;IACvB,SAAS,CAAC,YAAY,EAAE,EAAE,CAAC;IAC3B,SAAS,CAAC,cAAc,EAAE,WAAW,CAAC;IAEtC;;;OAGG;gBACS,UAAU,EAAE,QAAQ,CAAC,UAAU,CAAC;IAM5C;;;OAGG;IACH,SAAS,KAAK,eAAe,IAAI,eAAe,CAE/C;IAED;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAM3B;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKvC;;;OAGG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAKrC;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,EAAE,GAAG,MAAM,GAAG,IAAI;IAOrC;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAMzC;;OAEG;IAEH;;;OAGG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAWpC;;;;;;;OAOG;IACH,qBAAqB,CAAC,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,GAAG,IAAI;IAYvD;;;OAGG;IACH,mBAAmB,CAAC,MAAM,EAAE,EAAE,GAAG,IAAI;IAQrC,WAAW,CAAC,EAAE,CAAC,EAAE,cAAc,GAAG,IAAI;IAYtC;;;OAGG;IACH,SAAS,CAAC,qBAAqB,IAAI,MAAM;IAiBzC,SAAS,CAAC,gBAAgB,IAAI,kBAAkB;IAYhD,SAAS,CAAC,kBAAkB,IAAI,eAAe;IAM/C;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,CAAC,MAAM,EAAE,iBAAiB,EAAE,GAAG,cAAc,EAAE;IAqCrE;;;;;OAKG;IACH,SAAS,CAAC,iBAAiB,IAAI;QAAE,MAAM,EAAE,iBAAiB,EAAE,CAAC;QAAC,OAAO,EAAE,kBAAkB,EAAE,CAAA;KAAE;CA8D9F"}

package/dist/src/delegatorTxBuilder.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatorTxBuilder = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const transactionBuilder_1 = require("./transactionBuilder");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const avalanche_1 = require("avalanche");
+const utils_1 = __importDefault(require("./utils"));
+class DelegatorTxBuilder extends transactionBuilder_1.TransactionBuilder {
+    /**
+     *
+     * @param coinConfig
+     */
+    constructor(coinConfig) {
+        super(coinConfig);
+        const network = coinConfig.network;
+        this._stakeAmount = new avalanche_1.BN(network.minStake.toString());
+    }
+    /**
+     * get transaction type
+     * @protected
+     */
+    get transactionType() {
+        return sdk_core_1.TransactionType.addDelegator;
+    }
+    /**
+     *
+     * @param nodeID
+     */
+    nodeID(value) {
+        this.validateNodeID(value);
+        this._nodeID = value;
+        return this;
+    }
+    /**
+     *
+     * @param startTime
+     */
+    startTime(value) {
+        this._startTime = new avalanche_1.BN(value);
+        return this;
+    }
+    /**
+     *
+     * @param endTime
+     */
+    endTime(value) {
+        this._endTime = new avalanche_1.BN(value);
+        return this;
+    }
+    /**
+     *
+     * @param value
+     */
+    stakeAmount(value) {
+        const valueBN = avalanche_1.BN.isBN(value) ? value : new avalanche_1.BN(value);
+        this.validateStakeAmount(valueBN);
+        this._stakeAmount = valueBN;
+        return this;
+    }
+    /**
+     * Set the transaction source
+     *
+     * @param {BaseAddress} address The source account
+     * @returns {TransactionBuilder} This transaction builder
+     */
+    rewardAddress(address) {
+        this.validateAddress(address);
+        this._rewardAddress = address;
+        return this;
+    }
+    /**
+     * region Validators
+     */
+    /**
+     * validates a correct NodeID is used
+     * @param nodeID
+     */
+    validateNodeID(nodeID) {
+        if (!nodeID) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: missing nodeID');
+        }
+        if (nodeID.slice(0, 6) !== 'NodeID') {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: invalid NodeID tag');
+        }
+        if (nodeID.length !== 40) {
+            throw new sdk_core_1.BuildTransactionError('Invalid transaction: NodeID has incorrect length');
+        }
+    }
+    /**
+     *
+     *   protected _startTime: Date;
+     *   protected _endTime: Date;
+     *   2 weeks = 1209600
+     *   1 year = 31556926
+     *   unix time stamp based off seconds
+     */
+    validateStakeDuration(startTime, endTime) {
+        if (endTime < startTime) {
+            throw new sdk_core_1.BuildTransactionError('End date cannot be less than start date');
+        }
+        if (startTime.add(new avalanche_1.BN(this.transaction._network.minStakeDuration)).gt(endTime)) {
+            throw new sdk_core_1.BuildTransactionError('End date must be greater than or equal to two weeks');
+        }
+        if (endTime.gt(startTime.add(new avalanche_1.BN(this.transaction._network.maxStakeDuration)))) {
+            throw new sdk_core_1.BuildTransactionError('End date must be less than or equal to one year');
+        }
+    }
+    /**
+     *
+     * @param amount
+     */
+    validateStakeAmount(amount) {
+        if (amount.lt(new avalanche_1.BN(this.transaction._network.minStake.toString()))) {
+            throw new sdk_core_1.BuildTransactionError('Minimum staking amount is 2,000 AVAX');
+        }
+    }
+    // endregion
+    initBuilder(tx) {
+        if (!tx)
+            return this;
+        super.initBuilder(tx);
+        this._nodeID = tx.getNodeIDString();
+        this._startTime = tx.getStartTime();
+        this._endTime = tx.getEndTime();
+        this._stakeAmount = tx.getStakeAmount();
+        this.transaction._utxos = this.recoverUtxos(tx.getIns());
+        return this;
+    }
+    /**
+     *
+     * @protected
+     */
+    buildAvaxpTransaction() {
+        const { inputs, outputs } = this.createInputOutput();
+        return new platformvm_1.AddDelegatorTx(this.transaction._networkID, this.transaction._blockchainID, outputs, inputs, this.transaction._memo, utils_1.default.NodeIDStringToBuffer(this._nodeID), this._startTime, this._endTime, this._stakeAmount, [this.stakeTransferOut()], this.rewardOwnersOutput());
+    }
+    stakeTransferOut() {
+        return new platformvm_1.TransferableOutput(this.transaction._assetId, new platformvm_1.SECPTransferOutput(this._stakeAmount, this.transaction._fromPubKeys, this.transaction._locktime, this.transaction._threshold));
+    }
+    rewardOwnersOutput() {
+        return new platformvm_1.ParseableOutput(new platformvm_1.SECPOwnerOutput(this.transaction._fromPubKeys, this.transaction._locktime, this.transaction._threshold));
+    }
+    /**
+     * Inputs can be controlled but outputs get reordered in transactions
+     * In order to make sure that the mapping is always correct we create an addressIndx which matches to the appropiate
+     * signatureIdx
+     * @param inputs
+     * @protected
+     */
+    recoverUtxos(inputs) {
+        return inputs.map((input) => {
+            const secpInput = input.getInput();
+            // Order Addresses as output was defined.
+            const addressesIndx = secpInput.getSigIdxs().map((s) => s.toBuffer().readUInt32BE(0));
+            addressesIndx.push([0, 1, 2].filter((i) => !addressesIndx.includes(i))[0]);
+            const addresses = [];
+            // first index address is user
+            addresses[addressesIndx[0]] = utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, this.transaction._fromPubKeys[0]);
+            // second index address is bigto
+            addresses[addressesIndx[1]] = utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, this.transaction._fromPubKeys[2]);
+            // Unindex address is recovery
+            addresses[addressesIndx[2]] = utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, this.transaction._fromPubKeys[1]);
+            return {
+                outputID: 7,
+                outputidx: utils_1.default.cb58Encode(input.getOutputIdx()),
+                txid: utils_1.default.cb58Encode(input.getTxID()),
+                amount: secpInput.getAmount().toString(),
+                threshold: this.transaction._threshold,
+                addresses,
+            };
+        });
+    }
+    /**
+     * Threshold must be 2 and since output always get reordered we want to make sure we can always add signatures in the correct location
+     * To find the correct location for the signature, we use the ouput's addresses to create the signatureIdx in the order that we desire
+     * 0: user key, 1: recovery key, 2: hsm key
+     * @protected
+     */
+    createInputOutput() {
+        const inputs = [];
+        const outputs = [];
+        const addresses = this.transaction._fromPubKeys.map((b) => utils_1.default.addressToString(this.transaction._network.hrp, this.transaction._network.alias, b));
+        let total = new avalanche_1.BN(0);
+        const totalTarget = this._stakeAmount.clone().add(this.transaction._txFee);
+        this.transaction._utxos
+            .filter((output) => output.threshold === this.transaction._threshold && utils_1.default.includeIn(addresses, output.addresses))
+            .forEach((output, i) => {
+            if (output.outputID === 7 && total.lte(totalTarget)) {
+                const txidBuf = utils_1.default.cb58Decode(output.txid);
+                const amt = new avalanche_1.BN(output.amount);
+                const outputidx = utils_1.default.cb58Decode(output.outputidx);
+                total = total.add(amt);
+                const secpTransferInput = new platformvm_1.SECPTransferInput(amt);
+                if (this.recoverSigner) {
+                    secpTransferInput.addSignatureIdx(output.addresses.findIndex((a) => a === addresses[1]), this.transaction._fromPubKeys[1]);
+                }
+                else {
+                    secpTransferInput.addSignatureIdx(output.addresses.findIndex((a) => a === addresses[0]), this.transaction._fromPubKeys[0]);
+                }
+                secpTransferInput.addSignatureIdx(output.addresses.findIndex((a) => a === addresses[2]), this.transaction._fromPubKeys[2]);
+                const input = new platformvm_1.TransferableInput(txidBuf, outputidx, this.transaction._assetId, secpTransferInput);
+                inputs.push(input);
+            }
+        });
+        if (total.lt(totalTarget)) {
+            throw new sdk_core_1.BuildTransactionError(`Utxo outputs get ${total.toString()} and ${totalTarget.toString()} is required`);
+        }
+        outputs.push(new platformvm_1.TransferableOutput(this.transaction._assetId, new platformvm_1.SECPTransferOutput(total.sub(totalTarget), this.transaction._fromPubKeys, this.transaction._locktime, this.transaction._threshold)));
+        return { inputs, outputs };
+    }
+}
+exports.DelegatorTxBuilder = DelegatorTxBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delegatorTxBuilder.js","sourceRoot":"","sources":["../../src/delegatorTxBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseAddress, BuildTransactionError, TransactionType } from '@bitgo/sdk-core';\nimport { AvalancheNetwork, BaseCoin as CoinConfig } from '@bitgo/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport {\n  AddDelegatorTx,\n  BaseTx,\n  ParseableOutput,\n  SECPOwnerOutput,\n  SECPTransferInput,\n  SECPTransferOutput,\n  TransferableInput,\n  TransferableOutput,\n} from 'avalanche/dist/apis/platformvm';\nimport { BN } from 'avalanche';\nimport { DecodedUtxoObj } from './iface';\nimport utils from './utils';\n\nexport class DelegatorTxBuilder extends TransactionBuilder {\n  protected _nodeID: string;\n  protected _startTime: BN;\n  protected _endTime: BN;\n  protected _stakeAmount: BN;\n  protected _rewardAddress: BaseAddress;\n\n  /**\n   *\n   * @param coinConfig\n   */\n  constructor(coinConfig: Readonly<CoinConfig>) {\n    super(coinConfig);\n    const network = coinConfig.network as AvalancheNetwork;\n    this._stakeAmount = new BN(network.minStake.toString());\n  }\n\n  /**\n   * get transaction type\n   * @protected\n   */\n  protected get transactionType(): TransactionType {\n    return TransactionType.addDelegator;\n  }\n\n  /**\n   *\n   * @param nodeID\n   */\n  nodeID(value: string): this {\n    this.validateNodeID(value);\n    this._nodeID = value;\n    return this;\n  }\n\n  /**\n   *\n   * @param startTime\n   */\n  startTime(value: string | number): this {\n    this._startTime = new BN(value);\n    return this;\n  }\n\n  /**\n   *\n   * @param endTime\n   */\n  endTime(value: string | number): this {\n    this._endTime = new BN(value);\n    return this;\n  }\n\n  /**\n   *\n   * @param value\n   */\n  stakeAmount(value: BN | string): this {\n    const valueBN = BN.isBN(value) ? value : new BN(value);\n    this.validateStakeAmount(valueBN);\n    this._stakeAmount = valueBN;\n    return this;\n  }\n\n  /**\n   * Set the transaction source\n   *\n   * @param {BaseAddress} address The source account\n   * @returns {TransactionBuilder} This transaction builder\n   */\n  rewardAddress(address: BaseAddress): this {\n    this.validateAddress(address);\n    this._rewardAddress = address;\n    return this;\n  }\n\n  /**\n   * region Validators\n   */\n\n  /**\n   * validates a correct NodeID is used\n   * @param nodeID\n   */\n  validateNodeID(nodeID: string): void {\n    if (!nodeID) {\n      throw new BuildTransactionError('Invalid transaction: missing nodeID');\n    }\n    if (nodeID.slice(0, 6) !== 'NodeID') {\n      throw new BuildTransactionError('Invalid transaction: invalid NodeID tag');\n    }\n    if (nodeID.length !== 40) {\n      throw new BuildTransactionError('Invalid transaction: NodeID has incorrect length');\n    }\n  }\n  /**\n   *\n   *   protected _startTime: Date;\n   *   protected _endTime: Date;\n   *   2 weeks = 1209600\n   *   1 year = 31556926\n   *   unix time stamp based off seconds\n   */\n  validateStakeDuration(startTime: BN, endTime: BN): void {\n    if (endTime < startTime) {\n      throw new BuildTransactionError('End date cannot be less than start date');\n    }\n    if (startTime.add(new BN(this.transaction._network.minStakeDuration)).gt(endTime)) {\n      throw new BuildTransactionError('End date must be greater than or equal to two weeks');\n    }\n    if (endTime.gt(startTime.add(new BN(this.transaction._network.maxStakeDuration)))) {\n      throw new BuildTransactionError('End date must be less than or equal to one year');\n    }\n  }\n\n  /**\n   *\n   * @param amount\n   */\n  validateStakeAmount(amount: BN): void {\n    if (amount.lt(new BN(this.transaction._network.minStake.toString()))) {\n      throw new BuildTransactionError('Minimum staking amount is 2,000 AVAX');\n    }\n  }\n\n  // endregion\n\n  initBuilder(tx?: AddDelegatorTx): this {\n    if (!tx) return this;\n    super.initBuilder(tx);\n    this._nodeID = tx.getNodeIDString();\n    this._startTime = tx.getStartTime();\n    this._endTime = tx.getEndTime();\n    this._stakeAmount = tx.getStakeAmount();\n    this.transaction._utxos = this.recoverUtxos(tx.getIns());\n\n    return this;\n  }\n\n  /**\n   *\n   * @protected\n   */\n  protected buildAvaxpTransaction(): BaseTx {\n    const { inputs, outputs } = this.createInputOutput();\n    return new AddDelegatorTx(\n      this.transaction._networkID,\n      this.transaction._blockchainID,\n      outputs,\n      inputs,\n      this.transaction._memo,\n      utils.NodeIDStringToBuffer(this._nodeID),\n      this._startTime,\n      this._endTime,\n      this._stakeAmount,\n      [this.stakeTransferOut()],\n      this.rewardOwnersOutput()\n    );\n  }\n\n  protected stakeTransferOut(): TransferableOutput {\n    return new TransferableOutput(\n      this.transaction._assetId,\n      new SECPTransferOutput(\n        this._stakeAmount,\n        this.transaction._fromPubKeys,\n        this.transaction._locktime,\n        this.transaction._threshold\n      )\n    );\n  }\n\n  protected rewardOwnersOutput(): ParseableOutput {\n    return new ParseableOutput(\n      new SECPOwnerOutput(this.transaction._fromPubKeys, this.transaction._locktime, this.transaction._threshold)\n    );\n  }\n\n  /**\n   * Inputs can be controlled but outputs get reordered in transactions\n   * In order to make sure that the mapping is always correct we create an addressIndx which matches to the appropiate\n   * signatureIdx\n   * @param inputs\n   * @protected\n   */\n  protected recoverUtxos(inputs: TransferableInput[]): DecodedUtxoObj[] {\n    return inputs.map((input) => {\n      const secpInput: SECPTransferInput = input.getInput() as SECPTransferInput;\n      // Order Addresses as output was defined.\n      const addressesIndx: number[] = secpInput.getSigIdxs().map((s) => s.toBuffer().readUInt32BE(0));\n      addressesIndx.push([0, 1, 2].filter((i) => !addressesIndx.includes(i))[0]);\n      const addresses: string[] = [];\n      // first index address is user\n      addresses[addressesIndx[0]] = utils.addressToString(\n        this.transaction._network.hrp,\n        this.transaction._network.alias,\n        this.transaction._fromPubKeys[0]\n      );\n      // second index address is bigto\n      addresses[addressesIndx[1]] = utils.addressToString(\n        this.transaction._network.hrp,\n        this.transaction._network.alias,\n        this.transaction._fromPubKeys[2]\n      );\n      // Unindex address is recovery\n      addresses[addressesIndx[2]] = utils.addressToString(\n        this.transaction._network.hrp,\n        this.transaction._network.alias,\n        this.transaction._fromPubKeys[1]\n      );\n\n      return {\n        outputID: 7,\n        outputidx: utils.cb58Encode(input.getOutputIdx()),\n        txid: utils.cb58Encode(input.getTxID()),\n        amount: secpInput.getAmount().toString(),\n        threshold: this.transaction._threshold,\n        addresses,\n      };\n    });\n  }\n\n  /**\n   * Threshold must be 2 and since output always get reordered we want to make sure we can always add signatures in the correct location\n   * To find the correct location for the signature, we use the ouput's addresses to create the signatureIdx in the order that we desire\n   * 0: user key, 1: recovery key, 2: hsm key\n   * @protected\n   */\n  protected createInputOutput(): { inputs: TransferableInput[]; outputs: TransferableOutput[] } {\n    const inputs: TransferableInput[] = [];\n    const outputs: TransferableOutput[] = [];\n    const addresses = this.transaction._fromPubKeys.map((b) =>\n      utils.addressToString(this.transaction._network.hrp, this.transaction._network.alias, b)\n    );\n    let total: BN = new BN(0);\n    const totalTarget = this._stakeAmount.clone().add(this.transaction._txFee);\n    this.transaction._utxos\n      .filter(\n        (output) => output.threshold === this.transaction._threshold && utils.includeIn(addresses, output.addresses)\n      )\n      .forEach((output, i) => {\n        if (output.outputID === 7 && total.lte(totalTarget)) {\n          const txidBuf = utils.cb58Decode(output.txid);\n          const amt: BN = new BN(output.amount);\n          const outputidx = utils.cb58Decode(output.outputidx);\n          total = total.add(amt);\n\n          const secpTransferInput = new SECPTransferInput(amt);\n          if (this.recoverSigner) {\n            secpTransferInput.addSignatureIdx(\n              output.addresses.findIndex((a) => a === addresses[1]),\n              this.transaction._fromPubKeys[1]\n            );\n          } else {\n            secpTransferInput.addSignatureIdx(\n              output.addresses.findIndex((a) => a === addresses[0]),\n              this.transaction._fromPubKeys[0]\n            );\n          }\n          secpTransferInput.addSignatureIdx(\n            output.addresses.findIndex((a) => a === addresses[2]),\n            this.transaction._fromPubKeys[2]\n          );\n\n          const input: TransferableInput = new TransferableInput(\n            txidBuf,\n            outputidx,\n            this.transaction._assetId,\n            secpTransferInput\n          );\n          inputs.push(input);\n        }\n      });\n    if (total.lt(totalTarget)) {\n      throw new BuildTransactionError(`Utxo outputs get ${total.toString()} and ${totalTarget.toString()} is required`);\n    }\n    outputs.push(\n      new TransferableOutput(\n        this.transaction._assetId,\n        new SECPTransferOutput(\n          total.sub(totalTarget),\n          this.transaction._fromPubKeys,\n          this.transaction._locktime,\n          this.transaction._threshold\n        )\n      )\n    );\n\n    return { inputs, outputs };\n  }\n}\n"]}

package/dist/src/errors.d.ts

@@ -0,0 +1,8 @@
+import { BuildTransactionError } from '@bitgo/sdk-core';
+export declare class AddressValidationError extends BuildTransactionError {
+    constructor(malformedAddress: string);
+}
+export declare class InvalidFeeError extends BuildTransactionError {
+    constructor(type?: string, expectedType?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

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

package/dist/src/errors.js

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