@bitgo-beta/sdk-coin-avaxp 2.0.0

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

@@ -0,0 +1,152 @@
+/// <reference types="node" />
+import { BaseUtils, Entry } from '@bitgo-beta/sdk-core';
+import { Buffer as BufferAvax } from 'avalanche';
+import { NodeIDStringToBuffer } from 'avalanche/dist/utils';
+import { BaseTx, TransferableOutput } from 'avalanche/dist/apis/platformvm';
+import { Credential } from 'avalanche/dist/common/credentials';
+import { AvalancheNetwork } from '@bitgo-beta/statics';
+import { Signature } from 'avalanche/dist/common';
+import { Output, Tx } from './iface';
+export declare class Utils implements BaseUtils {
+    private binTools;
+    cb58Decode: (bytes: string | BufferAvax) => BufferAvax;
+    cb58Encode: (bytes: BufferAvax) => string;
+    stringToBuffer: (str: string) => BufferAvax;
+    bufferToString: (buff: BufferAvax) => string;
+    NodeIDStringToBuffer: typeof NodeIDStringToBuffer;
+    addressToString: (hrp: string, chainid: string, bytes: BufferAvax) => string;
+    includeIn(walletAddresses: string[], otxoOutputAddresses: string[]): boolean;
+    /**
+     * Checks if it is a valid address no illegal characters
+     *
+     * @param {string} address - address to be validated
+     * @returns {boolean} - the validation result
+     */
+    /** @inheritdoc */
+    isValidAddress(address: string | string[]): boolean;
+    private isValidAddressRegex;
+    /**
+     * Checks if it is a valid blockId with length 66 including 0x
+     *
+     * @param {string} hash - blockId to be validated
+     * @returns {boolean} - the validation result
+     */
+    /** @inheritdoc */
+    isValidBlockId(hash: string): boolean;
+    /**
+     * Checks if the string is a valid protocol public key or
+     * extended public key.
+     *
+     * @param {string} pub - the  public key to be validated
+     * @returns {boolean} - the validation result
+     */
+    isValidPublicKey(pub: string): boolean;
+    parseAddress: (pub: string) => BufferAvax;
+    /**
+     * Returns whether or not the string is a valid protocol private key, or extended
+     * private key.
+     *
+     * The protocol key format is described in the @stacks/transactions npm package, in the
+     * createStacksPrivateKey function:
+     * https://github.com/blockstack/stacks.js/blob/master/packages/transactions/src/keys.ts#L125
+     *
+     * @param {string} prv - the private key (or extended private key) to be validated
+     * @returns {boolean} - the validation result
+     */
+    isValidPrivateKey(prv: string): boolean;
+    /**
+     * Returns whether or not the string is a composed of hex chars only
+     *
+     * @param {string} maybe - the  string to be validated
+     * @returns {boolean} - the validation result
+     */
+    allHexChars(maybe: string): boolean;
+    /** @inheritdoc */
+    isValidSignature(signature: string): boolean;
+    /** @inheritdoc */
+    isValidTransactionId(txId: string): boolean;
+    getCredentials(tx: BaseTx): Credential[];
+    /**
+     * Avaxp wrapper to create signature and return it for credentials using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param prv
+     * @return signature
+     */
+    createSignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, prv: BufferAvax): BufferAvax;
+    /**
+     * Avaxp wrapper to create signature and return it for credentials
+     * @param network
+     * @param message
+     * @param prv
+     * @return signature
+     */
+    createSignature(network: AvalancheNetwork, message: Buffer, prv: Buffer): Buffer;
+    /**
+     * Avaxp wrapper to verify signature using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param signature
+     * @param prv
+     * @return true if it's verify successful
+     */
+    verifySignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, signature: BufferAvax, prv: BufferAvax): boolean;
+    /**
+     * Avaxp wrapper to verify signature
+     * @param network
+     * @param message
+     * @param signature
+     * @param prv
+     * @return true if it's verify successful
+     */
+    verifySignature(network: AvalancheNetwork, message: Buffer, signature: Buffer, prv: Buffer): boolean;
+    createSig(sigHex: string): Signature;
+    /**
+     * Avaxp wrapper to recovery signature using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param signature
+     * @return
+     */
+    recoverySignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, signature: BufferAvax): BufferAvax;
+    /**
+     * Avaxp wrapper to verify signature
+     * @param network
+     * @param message
+     * @param signature
+     * @return true if it's verify successful
+     */
+    recoverySignature(network: AvalancheNetwork, message: Buffer, signature: Buffer): Buffer;
+    sha256(buf: Uint8Array): Buffer;
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     * It's to reuse in TransactionBuilder and TransactionBuilderFactory
+     *
+     * @param rawTransaction Transaction as hex string
+     */
+    validateRawTransaction(rawTransaction: string): void;
+    /**
+     * Check if tx is for the blockchainId
+     *
+     * @param {Tx} tx
+     * @param {string} blockchainId
+     * @returns true if tx is for blockchainId
+     */
+    isTransactionOf(tx: Tx, blockchainId: string): boolean;
+    /**
+     * Check if Output is from PVM.
+     * Output could be EVM or PVM output.
+     * @param {Output} output
+     * @returns {boolean} output is TransferableOutput
+     */
+    isTransferableOutput(output: Output): output is TransferableOutput;
+    /**
+     * Return a mapper function to that network address representation.
+     * @param network required to stringify addresses
+     * @return mapper function
+     */
+    mapOutputToEntry(network: AvalancheNetwork): (Output: any) => Entry;
+}
+declare const utils: Utils;
+export default utils;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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"}

package/dist/src/lib/utils.js

@@ -0,0 +1,300 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utils = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const avalanche_1 = require("avalanche");
+const utils_1 = require("avalanche/dist/utils");
+const elliptic_1 = require("elliptic");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const keychain_1 = require("avalanche/dist/apis/platformvm/keychain");
+const common_1 = require("avalanche/dist/common");
+const createHash = __importStar(require("create-hash"));
+class Utils {
+    constructor() {
+        this.binTools = avalanche_1.BinTools.getInstance();
+        this.cb58Decode = this.binTools.cb58Decode;
+        this.cb58Encode = this.binTools.cb58Encode;
+        this.stringToBuffer = this.binTools.stringToBuffer;
+        this.bufferToString = this.binTools.bufferToString;
+        this.NodeIDStringToBuffer = utils_1.NodeIDStringToBuffer;
+        this.addressToString = this.binTools.addressToString;
+        this.parseAddress = (pub) => this.binTools.stringToAddress(pub);
+    }
+    includeIn(walletAddresses, otxoOutputAddresses) {
+        return walletAddresses.map((a) => otxoOutputAddresses.includes(a)).reduce((a, b) => a && b, true);
+    }
+    /**
+     * Checks if it is a valid address no illegal characters
+     *
+     * @param {string} address - address to be validated
+     * @returns {boolean} - the validation result
+     */
+    /** @inheritdoc */
+    isValidAddress(address) {
+        const addressArr = Array.isArray(address) ? address : address.split('~');
+        for (const address of addressArr) {
+            if (!this.isValidAddressRegex(address)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isValidAddressRegex(address) {
+        return /^(^P||NodeID)-[a-zA-Z0-9]+$/.test(address);
+    }
+    /**
+     * Checks if it is a valid blockId with length 66 including 0x
+     *
+     * @param {string} hash - blockId to be validated
+     * @returns {boolean} - the validation result
+     */
+    /** @inheritdoc */
+    isValidBlockId(hash) {
+        return this.binTools.isCB58(hash) && this.binTools.b58ToBuffer(hash).length === 36;
+    }
+    /**
+     * Checks if the string is a valid protocol public key or
+     * extended public key.
+     *
+     * @param {string} pub - the  public key to be validated
+     * @returns {boolean} - the validation result
+     */
+    isValidPublicKey(pub) {
+        if (sdk_core_1.isValidXpub(pub))
+            return true;
+        let pubBuf;
+        if (pub.length === 50) {
+            try {
+                pubBuf = utils.cb58Decode(pub);
+            }
+            catch {
+                return false;
+            }
+        }
+        else {
+            if (pub.length !== 66 && pub.length !== 130)
+                return false;
+            const firstByte = pub.slice(0, 2);
+            // uncompressed public key
+            if (pub.length === 130 && firstByte !== '04')
+                return false;
+            // compressed public key
+            if (pub.length === 66 && firstByte !== '02' && firstByte !== '03')
+                return false;
+            if (!this.allHexChars(pub))
+                return false;
+            pubBuf = avalanche_1.Buffer.from(pub, 'hex');
+        }
+        // validate the public key
+        const secp256k1 = new elliptic_1.ec('secp256k1');
+        try {
+            const keyPair = secp256k1.keyFromPublic(pubBuf);
+            const { result } = keyPair.validate();
+            return result;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+    /**
+     * Returns whether or not the string is a valid protocol private key, or extended
+     * private key.
+     *
+     * The protocol key format is described in the @stacks/transactions npm package, in the
+     * createStacksPrivateKey function:
+     * https://github.com/blockstack/stacks.js/blob/master/packages/transactions/src/keys.ts#L125
+     *
+     * @param {string} prv - the private key (or extended private key) to be validated
+     * @returns {boolean} - the validation result
+     */
+    isValidPrivateKey(prv) {
+        if (sdk_core_1.isValidXprv(prv))
+            return true;
+        if (prv.length !== 64 && prv.length !== 66)
+            return false;
+        if (prv.length === 66 && prv.slice(64) !== '01')
+            return false;
+        return this.allHexChars(prv);
+    }
+    /**
+     * Returns whether or not the string is a composed of hex chars only
+     *
+     * @param {string} maybe - the  string to be validated
+     * @returns {boolean} - the validation result
+     */
+    allHexChars(maybe) {
+        return /^([0-9a-f])+$/i.test(maybe);
+    }
+    /** @inheritdoc */
+    isValidSignature(signature) {
+        throw new sdk_core_1.NotImplementedError('isValidSignature not implemented');
+    }
+    /** @inheritdoc */
+    isValidTransactionId(txId) {
+        throw new sdk_core_1.NotImplementedError('isValidTransactionId not implemented');
+    }
+    getCredentials(tx) {
+        return tx.getIns().map((ins) => platformvm_1.SelectCredentialClass(ins.getInput().getCredentialID()));
+    }
+    /**
+     * Avaxp wrapper to create signature and return it for credentials using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param prv
+     * @return signature
+     */
+    createSignatureAvaxBuffer(network, message, prv) {
+        const ky = new keychain_1.KeyPair(network.hrp, network.networkID.toString());
+        ky.importKey(prv);
+        return ky.sign(message);
+    }
+    /**
+     * Avaxp wrapper to create signature and return it for credentials
+     * @param network
+     * @param message
+     * @param prv
+     * @return signature
+     */
+    createSignature(network, message, prv) {
+        return Buffer.from(this.createSignatureAvaxBuffer(network, avalanche_1.Buffer.from(message), avalanche_1.Buffer.from(prv)));
+    }
+    /**
+     * Avaxp wrapper to verify signature using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param signature
+     * @param prv
+     * @return true if it's verify successful
+     */
+    verifySignatureAvaxBuffer(network, message, signature, prv) {
+        const ky = new keychain_1.KeyPair(network.hrp, network.networkID.toString());
+        ky.importKey(prv);
+        return ky.verify(message, signature);
+    }
+    /**
+     * Avaxp wrapper to verify signature
+     * @param network
+     * @param message
+     * @param signature
+     * @param prv
+     * @return true if it's verify successful
+     */
+    verifySignature(network, message, signature, prv) {
+        return this.verifySignatureAvaxBuffer(network, avalanche_1.Buffer.from(message), avalanche_1.Buffer.from(signature), avalanche_1.Buffer.from(prv));
+    }
+    createSig(sigHex) {
+        const sig = new common_1.Signature();
+        sig.fromBuffer(avalanche_1.Buffer.from(sigHex.padStart(130, '0'), 'hex'));
+        return sig;
+    }
+    /**
+     * Avaxp wrapper to recovery signature using Avalanche's buffer
+     * @param network
+     * @param message
+     * @param signature
+     * @return
+     */
+    recoverySignatureAvaxBuffer(network, message, signature) {
+        const ky = new keychain_1.KeyPair(network.hrp, network.networkID.toString());
+        return ky.recover(message, signature);
+    }
+    /**
+     * Avaxp wrapper to verify signature
+     * @param network
+     * @param message
+     * @param signature
+     * @return true if it's verify successful
+     */
+    recoverySignature(network, message, signature) {
+        return Buffer.from(this.recoverySignatureAvaxBuffer(network, avalanche_1.Buffer.from(message), avalanche_1.Buffer.from(signature)));
+    }
+    sha256(buf) {
+        return createHash.default('sha256').update(buf).digest();
+    }
+    /**
+     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+     * It's to reuse in TransactionBuilder and TransactionBuilderFactory
+     *
+     * @param rawTransaction Transaction as hex string
+     */
+    validateRawTransaction(rawTransaction) {
+        if (!rawTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Raw transaction is empty');
+        }
+        if (!utils.allHexChars(rawTransaction)) {
+            throw new sdk_core_1.ParseTransactionError('Raw transaction is not hex string');
+        }
+    }
+    /**
+     * Check if tx is for the blockchainId
+     *
+     * @param {Tx} tx
+     * @param {string} blockchainId
+     * @returns true if tx is for blockchainId
+     */
+    isTransactionOf(tx, blockchainId) {
+        return utils.cb58Encode(tx.getUnsignedTx().getTransaction().getBlockchainID()) === blockchainId;
+    }
+    /**
+     * Check if Output is from PVM.
+     * Output could be EVM or PVM output.
+     * @param {Output} output
+     * @returns {boolean} output is TransferableOutput
+     */
+    isTransferableOutput(output) {
+        return 'getOutput' in output;
+    }
+    /**
+     * Return a mapper function to that network address representation.
+     * @param network required to stringify addresses
+     * @return mapper function
+     */
+    mapOutputToEntry(network) {
+        return (output) => {
+            if (this.isTransferableOutput(output)) {
+                const amountOutput = output.getOutput();
+                const address = amountOutput
+                    .getAddresses()
+                    .map((a) => this.addressToString(network.hrp, network.alias, a))
+                    .sort()
+                    .join('~');
+                return {
+                    value: amountOutput.getAmount().toString(),
+                    address,
+                };
+            }
+            else {
+                const evmOutput = output;
+                return {
+                    // it should be evmOuput.getAmount(), but it returns a 0.
+                    value: new avalanche_1.BN(evmOutput.amount).toString(),
+                    // C-Chain address.
+                    address: '0x' + evmOutput.getAddressString(),
+                };
+            }
+        };
+    }
+}
+exports.Utils = Utils;
+const utils = new Utils();
+exports.default = utils;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  isValidXpub,\n  isValidXprv,\n  NotImplementedError,\n  BaseUtils,\n  InvalidTransactionError,\n  ParseTransactionError,\n  Entry,\n} from '@bitgo-beta/sdk-core';\nimport { BinTools, BN, Buffer as BufferAvax } from 'avalanche';\nimport { NodeIDStringToBuffer } from 'avalanche/dist/utils';\nimport { ec } from 'elliptic';\nimport { AmountOutput, BaseTx, SelectCredentialClass, TransferableOutput } from 'avalanche/dist/apis/platformvm';\nimport { Credential } from 'avalanche/dist/common/credentials';\nimport { KeyPair as KeyPairAvax } from 'avalanche/dist/apis/platformvm/keychain';\nimport { AvalancheNetwork } from '@bitgo-beta/statics';\nimport { Signature } from 'avalanche/dist/common';\nimport * as createHash from 'create-hash';\nimport { EVMOutput } from 'avalanche/dist/apis/evm';\nimport { Output, Tx } from './iface';\n\nexport class Utils implements BaseUtils {\n  private binTools = BinTools.getInstance();\n  public cb58Decode = this.binTools.cb58Decode;\n  public cb58Encode = this.binTools.cb58Encode;\n  public stringToBuffer = this.binTools.stringToBuffer;\n  public bufferToString = this.binTools.bufferToString;\n  public NodeIDStringToBuffer = NodeIDStringToBuffer;\n  public addressToString = this.binTools.addressToString;\n\n  public includeIn(walletAddresses: string[], otxoOutputAddresses: string[]): boolean {\n    return walletAddresses.map((a) => otxoOutputAddresses.includes(a)).reduce((a, b) => a && b, true);\n  }\n\n  /**\n   * Checks if it is a valid address no illegal characters\n   *\n   * @param {string} address - address to be validated\n   * @returns {boolean} - the validation result\n   */\n  /** @inheritdoc */\n  isValidAddress(address: string | string[]): boolean {\n    const addressArr: string[] = Array.isArray(address) ? address : address.split('~');\n\n    for (const address of addressArr) {\n      if (!this.isValidAddressRegex(address)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private isValidAddressRegex(address: string): boolean {\n    return /^(^P||NodeID)-[a-zA-Z0-9]+$/.test(address);\n  }\n\n  /**\n   * Checks if it is a valid blockId with length 66 including 0x\n   *\n   * @param {string} hash - blockId to be validated\n   * @returns {boolean} - the validation result\n   */\n  /** @inheritdoc */\n  isValidBlockId(hash: string): boolean {\n    return this.binTools.isCB58(hash) && this.binTools.b58ToBuffer(hash).length === 36;\n  }\n\n  /**\n   * Checks if the string is a valid protocol public key or\n   * extended public key.\n   *\n   * @param {string} pub - the  public key to be validated\n   * @returns {boolean} - the validation result\n   */\n  isValidPublicKey(pub: string): boolean {\n    if (isValidXpub(pub)) return true;\n\n    let pubBuf;\n    if (pub.length === 50) {\n      try {\n        pubBuf = utils.cb58Decode(pub);\n      } catch {\n        return false;\n      }\n    } else {\n      if (pub.length !== 66 && pub.length !== 130) return false;\n\n      const firstByte = pub.slice(0, 2);\n\n      // uncompressed public key\n      if (pub.length === 130 && firstByte !== '04') return false;\n\n      // compressed public key\n      if (pub.length === 66 && firstByte !== '02' && firstByte !== '03') return false;\n\n      if (!this.allHexChars(pub)) return false;\n\n      pubBuf = BufferAvax.from(pub, 'hex');\n    }\n    // validate the public key\n    const secp256k1 = new ec('secp256k1');\n    try {\n      const keyPair = secp256k1.keyFromPublic(pubBuf);\n      const { result } = keyPair.validate();\n      return result;\n    } catch (e) {\n      return false;\n    }\n  }\n\n  public parseAddress = (pub: string): BufferAvax => this.binTools.stringToAddress(pub);\n\n  /**\n   * Returns whether or not the string is a valid protocol private key, or extended\n   * private key.\n   *\n   * The protocol key format is described in the @stacks/transactions npm package, in the\n   * createStacksPrivateKey function:\n   * https://github.com/blockstack/stacks.js/blob/master/packages/transactions/src/keys.ts#L125\n   *\n   * @param {string} prv - the private key (or extended private key) to be validated\n   * @returns {boolean} - the validation result\n   */\n  isValidPrivateKey(prv: string): boolean {\n    if (isValidXprv(prv)) return true;\n\n    if (prv.length !== 64 && prv.length !== 66) return false;\n\n    if (prv.length === 66 && prv.slice(64) !== '01') return false;\n\n    return this.allHexChars(prv);\n  }\n\n  /**\n   * Returns whether or not the string is a composed of hex chars only\n   *\n   * @param {string} maybe - the  string to be validated\n   * @returns {boolean} - the validation result\n   */\n  allHexChars(maybe: string): boolean {\n    return /^([0-9a-f])+$/i.test(maybe);\n  }\n\n  /** @inheritdoc */\n  isValidSignature(signature: string): boolean {\n    throw new NotImplementedError('isValidSignature not implemented');\n  }\n\n  /** @inheritdoc */\n  isValidTransactionId(txId: string): boolean {\n    throw new NotImplementedError('isValidTransactionId not implemented');\n  }\n\n  getCredentials(tx: BaseTx): Credential[] {\n    return tx.getIns().map((ins) => SelectCredentialClass(ins.getInput().getCredentialID()));\n  }\n\n  /**\n   * Avaxp wrapper to create signature and return it for credentials using Avalanche's buffer\n   * @param network\n   * @param message\n   * @param prv\n   * @return signature\n   */\n  createSignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, prv: BufferAvax): BufferAvax {\n    const ky = new KeyPairAvax(network.hrp, network.networkID.toString());\n    ky.importKey(prv);\n    return ky.sign(message);\n  }\n\n  /**\n   * Avaxp wrapper to create signature and return it for credentials\n   * @param network\n   * @param message\n   * @param prv\n   * @return signature\n   */\n  createSignature(network: AvalancheNetwork, message: Buffer, prv: Buffer): Buffer {\n    return Buffer.from(this.createSignatureAvaxBuffer(network, BufferAvax.from(message), BufferAvax.from(prv)));\n  }\n\n  /**\n   * Avaxp wrapper to verify signature using Avalanche's buffer\n   * @param network\n   * @param message\n   * @param signature\n   * @param prv\n   * @return true if it's verify successful\n   */\n  verifySignatureAvaxBuffer(\n    network: AvalancheNetwork,\n    message: BufferAvax,\n    signature: BufferAvax,\n    prv: BufferAvax\n  ): boolean {\n    const ky = new KeyPairAvax(network.hrp, network.networkID.toString());\n    ky.importKey(prv);\n    return ky.verify(message, signature);\n  }\n\n  /**\n   * Avaxp wrapper to verify signature\n   * @param network\n   * @param message\n   * @param signature\n   * @param prv\n   * @return true if it's verify successful\n   */\n  verifySignature(network: AvalancheNetwork, message: Buffer, signature: Buffer, prv: Buffer): boolean {\n    return this.verifySignatureAvaxBuffer(\n      network,\n      BufferAvax.from(message),\n      BufferAvax.from(signature),\n      BufferAvax.from(prv)\n    );\n  }\n\n  createSig(sigHex: string): Signature {\n    const sig = new Signature();\n    sig.fromBuffer(BufferAvax.from(sigHex.padStart(130, '0'), 'hex'));\n    return sig;\n  }\n\n  /**\n   * Avaxp wrapper to recovery signature using Avalanche's buffer\n   * @param network\n   * @param message\n   * @param signature\n   * @return\n   */\n  recoverySignatureAvaxBuffer(network: AvalancheNetwork, message: BufferAvax, signature: BufferAvax): BufferAvax {\n    const ky = new KeyPairAvax(network.hrp, network.networkID.toString());\n    return ky.recover(message, signature);\n  }\n\n  /**\n   * Avaxp wrapper to verify signature\n   * @param network\n   * @param message\n   * @param signature\n   * @return true if it's verify successful\n   */\n  recoverySignature(network: AvalancheNetwork, message: Buffer, signature: Buffer): Buffer {\n    return Buffer.from(this.recoverySignatureAvaxBuffer(network, BufferAvax.from(message), BufferAvax.from(signature)));\n  }\n\n  sha256(buf: Uint8Array): Buffer {\n    return createHash.default('sha256').update(buf).digest();\n  }\n\n  /**\n   * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n   * It's to reuse in TransactionBuilder and TransactionBuilderFactory\n   *\n   * @param rawTransaction Transaction as hex string\n   */\n  validateRawTransaction(rawTransaction: string): void {\n    if (!rawTransaction) {\n      throw new InvalidTransactionError('Raw transaction is empty');\n    }\n    if (!utils.allHexChars(rawTransaction)) {\n      throw new ParseTransactionError('Raw transaction is not hex string');\n    }\n  }\n\n  /**\n   * Check if tx is for the blockchainId\n   *\n   * @param {Tx} tx\n   * @param {string} blockchainId\n   * @returns true if tx is for blockchainId\n   */\n  isTransactionOf(tx: Tx, blockchainId: string): boolean {\n    return utils.cb58Encode(tx.getUnsignedTx().getTransaction().getBlockchainID()) === blockchainId;\n  }\n\n  /**\n   * Check if Output is from PVM.\n   * Output could be EVM or PVM output.\n   * @param {Output} output\n   * @returns {boolean} output is TransferableOutput\n   */\n  isTransferableOutput(output: Output): output is TransferableOutput {\n    return 'getOutput' in output;\n  }\n\n  /**\n   * Return a mapper function to that network address representation.\n   * @param network required to stringify addresses\n   * @return mapper function\n   */\n  mapOutputToEntry(network: AvalancheNetwork): (Output) => Entry {\n    return (output: Output) => {\n      if (this.isTransferableOutput(output)) {\n        const amountOutput = output.getOutput() as AmountOutput;\n        const address = amountOutput\n          .getAddresses()\n          .map((a) => this.addressToString(network.hrp, network.alias, a))\n          .sort()\n          .join('~');\n        return {\n          value: amountOutput.getAmount().toString(),\n          address,\n        };\n      } else {\n        const evmOutput = output as EVMOutput;\n        return {\n          // it should be evmOuput.getAmount(), but it returns a 0.\n          value: new BN((evmOutput as any).amount).toString(),\n          // C-Chain address.\n          address: '0x' + evmOutput.getAddressString(),\n        };\n      }\n    };\n  }\n}\n\nconst utils = new Utils();\n\nexport default utils;\n"]}

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

@@ -0,0 +1,45 @@
+/// <reference types="bn.js" />
+import { DecodedUtxoObj } from './iface';
+import { BN, Buffer as BufferAvax } from 'avalanche';
+import { Signature } from 'avalanche/dist/common';
+import { StandardTransferableInput } from 'avalanche/dist/common/input';
+export interface InputData {
+    amount: BN;
+    txidBuf: BufferAvax;
+    outputIdx: BufferAvax;
+    signaturesIdx: number[];
+    signatures: Signature[];
+}
+/**
+ * Inputs can be controlled but outputs get reordered in transactions
+ * In order to make sure that the mapping is always correct we create an addressIndex which matches to the appropriate
+ * signatureIdx
+ * @param {StandardTransferableInput[]} utxos as transaction ins.
+ * @returns the list of UTXOs
+ */
+export declare function recoverUtxos(utxos: StandardTransferableInput[]): DecodedUtxoObj[];
+/**
+ * Convert Utxos into inputs data. Input Objects changes regarding chains. This method return a plain object to be mapped late in chain input.
+ * Sender is a list of owners address and utxo address must contains all of them.
+ * Signers is a list of sender cut it in threshold size. Firsts senders are the signers.
+ *
+ * Output always get reordered we want to make sure we can always add signatures in the correct location.
+ * Signatures array store signers address of the expected signature. Tx sign replace the address for the signature.
+ * So the location of the signatures is guaranteed.
+ *
+ * To find the correct location for the signature, we use the output's addresses to create the signatureIdx in the order that we desire
+ * 0: user key, 1: hsm key, 2: recovery key
+ *
+ * @param utxos
+ * @param sender array of addresses
+ * @param threshold number of signatures required
+ * @return {
+ *   inputs: InputData[];
+ *   amount: BN;
+ * } as total amount and inputs with signatures as signers address to be replaced.
+ */
+export declare function utxoToInput(utxos: DecodedUtxoObj[], sender: BufferAvax[], threshold?: number): {
+    inputs: InputData[];
+    amount: BN;
+};
+//# sourceMappingURL=utxoEngine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utxoEngine.d.ts","sourceRoot":"","sources":["../../../src/lib/utxoEngine.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,cAAc,EAA6B,MAAM,SAAS,CAAC;AACpE,OAAO,EAAE,EAAE,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGlD,OAAO,EAAuB,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAE7F,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,EAAE,CAAC;IACX,OAAO,EAAE,UAAU,CAAC;IACpB,SAAS,EAAE,UAAU,CAAC;IACtB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,yBAAyB,EAAE,GAAG,cAAc,EAAE,CAiBjF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,cAAc,EAAE,EACvB,MAAM,EAAE,UAAU,EAAE,EACpB,SAAS,SAAI,GACZ;IACD,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,MAAM,EAAE,EAAE,CAAC;CACZ,CAuCA"}

package/dist/src/lib/utxoEngine.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utxoToInput = exports.recoverUtxos = void 0;
+const iface_1 = require("./iface");
+const avalanche_1 = require("avalanche");
+const utils_1 = __importDefault(require("./utils"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+/**
+ * Inputs can be controlled but outputs get reordered in transactions
+ * In order to make sure that the mapping is always correct we create an addressIndex which matches to the appropriate
+ * signatureIdx
+ * @param {StandardTransferableInput[]} utxos as transaction ins.
+ * @returns the list of UTXOs
+ */
+function recoverUtxos(utxos) {
+    return utxos.map((utxo) => {
+        const secpInput = utxo.getInput();
+        // use the same addressesIndex as existing ones in the inputs
+        const addressesIndex = secpInput.getSigIdxs().map((s) => s.toBuffer().readUInt32BE(0));
+        return {
+            outputID: iface_1.SECP256K1_Transfer_Output,
+            outputidx: utils_1.default.cb58Encode(utxo.getOutputIdx()),
+            txid: utils_1.default.cb58Encode(utxo.getTxID()),
+            amount: secpInput.getAmount().toString(),
+            threshold: addressesIndex.length,
+            addresses: [],
+            addressesIndex,
+        };
+    });
+}
+exports.recoverUtxos = recoverUtxos;
+/**
+ * Convert Utxos into inputs data. Input Objects changes regarding chains. This method return a plain object to be mapped late in chain input.
+ * Sender is a list of owners address and utxo address must contains all of them.
+ * Signers is a list of sender cut it in threshold size. Firsts senders are the signers.
+ *
+ * Output always get reordered we want to make sure we can always add signatures in the correct location.
+ * Signatures array store signers address of the expected signature. Tx sign replace the address for the signature.
+ * So the location of the signatures is guaranteed.
+ *
+ * To find the correct location for the signature, we use the output's addresses to create the signatureIdx in the order that we desire
+ * 0: user key, 1: hsm key, 2: recovery key
+ *
+ * @param utxos
+ * @param sender array of addresses
+ * @param threshold number of signatures required
+ * @return {
+ *   inputs: InputData[];
+ *   amount: BN;
+ * } as total amount and inputs with signatures as signers address to be replaced.
+ */
+function utxoToInput(utxos, sender, threshold = 2) {
+    // amount spent so far
+    let currentTotal = new avalanche_1.BN(0);
+    const inputs = utxos
+        .filter((utxo) => utxo && utxo.outputID === iface_1.SECP256K1_Transfer_Output)
+        .map((utxo) => {
+        // validate the utxos
+        const utxoAddresses = utxo.addresses.map((a) => utils_1.default.parseAddress(a));
+        const addressesIndex = sender.map((a) => utxoAddresses.findIndex((u) => a.equals(u)));
+        // addressesIndex should never have a mismatch
+        if (addressesIndex.includes(-1)) {
+            throw new sdk_core_1.BuildTransactionError('Addresses are inconsistent: ' + utxo.txid);
+        }
+        if (utxo.threshold !== threshold) {
+            throw new sdk_core_1.BuildTransactionError('Threshold is inconsistent');
+        }
+        const txidBuf = utils_1.default.cb58Decode(utxo.txid);
+        const amount = new avalanche_1.BN(utxo.amount);
+        const outputIdx = utils_1.default.cb58Decode(utxo.outputidx);
+        currentTotal = currentTotal.add(amount);
+        const signers = addressesIndex
+            .slice(0, threshold)
+            .map((utxoIndex, senderIndex) => ({ utxoIndex, senderIndex }))
+            .sort((a, b) => a.utxoIndex - b.utxoIndex);
+        const signatures = signers.map(({ senderIndex }) => 
+        // TODO(BG-56700):  Improve canSign by check in addresses in empty credentials match signer
+        // HSM require empty signature.
+        utils_1.default.createSig(senderIndex == 1 ? '' : sender[senderIndex].toString('hex')));
+        const signaturesIdx = signers.map(({ utxoIndex }) => utxoIndex);
+        return { amount, txidBuf, outputIdx, signaturesIdx, signatures };
+    });
+    return { inputs, amount: currentTotal };
+}
+exports.utxoToInput = utxoToInput;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utxoEngine.js","sourceRoot":"","sources":["../../../src/lib/utxoEngine.ts"],"names":[],"mappings":"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","sourcesContent":["import { DecodedUtxoObj, SECP256K1_Transfer_Output } from './iface';\nimport { BN, Buffer as BufferAvax } from 'avalanche';\nimport { Signature } from 'avalanche/dist/common';\nimport utils from './utils';\nimport { BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { StandardAmountInput, StandardTransferableInput } from 'avalanche/dist/common/input';\n\nexport interface InputData {\n  amount: BN;\n  txidBuf: BufferAvax;\n  outputIdx: BufferAvax;\n  signaturesIdx: number[];\n  signatures: Signature[];\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 addressIndex which matches to the appropriate\n * signatureIdx\n * @param {StandardTransferableInput[]} utxos as transaction ins.\n * @returns the list of UTXOs\n */\nexport function recoverUtxos(utxos: StandardTransferableInput[]): DecodedUtxoObj[] {\n  return utxos.map((utxo) => {\n    const secpInput = utxo.getInput() as StandardAmountInput;\n\n    // use the same addressesIndex as existing ones in the inputs\n    const addressesIndex: number[] = secpInput.getSigIdxs().map((s) => s.toBuffer().readUInt32BE(0));\n\n    return {\n      outputID: SECP256K1_Transfer_Output,\n      outputidx: utils.cb58Encode(utxo.getOutputIdx()),\n      txid: utils.cb58Encode(utxo.getTxID()),\n      amount: secpInput.getAmount().toString(),\n      threshold: addressesIndex.length,\n      addresses: [], // this is empty since the inputs from deserialized transaction don't contain addresses\n      addressesIndex,\n    };\n  });\n}\n\n/**\n * Convert Utxos into inputs data. Input Objects changes regarding chains. This method return a plain object to be mapped late in chain input.\n * Sender is a list of owners address and utxo address must contains all of them.\n * Signers is a list of sender cut it in threshold size. Firsts senders are the signers.\n *\n * Output always get reordered we want to make sure we can always add signatures in the correct location.\n * Signatures array store signers address of the expected signature. Tx sign replace the address for the signature.\n * So the location of the signatures is guaranteed.\n *\n * To find the correct location for the signature, we use the output's addresses to create the signatureIdx in the order that we desire\n * 0: user key, 1: hsm key, 2: recovery key\n *\n * @param utxos\n * @param sender array of addresses\n * @param threshold number of signatures required\n * @return {\n *   inputs: InputData[];\n *   amount: BN;\n * } as total amount and inputs with signatures as signers address to be replaced.\n */\nexport function utxoToInput(\n  utxos: DecodedUtxoObj[],\n  sender: BufferAvax[],\n  threshold = 2\n): {\n  inputs: InputData[];\n  amount: BN;\n} {\n  // amount spent so far\n  let currentTotal: BN = new BN(0);\n\n  const inputs = utxos\n    .filter((utxo) => utxo && utxo.outputID === SECP256K1_Transfer_Output)\n    .map((utxo) => {\n      // validate the utxos\n      const utxoAddresses: BufferAvax[] = utxo.addresses.map((a) => utils.parseAddress(a));\n      const addressesIndex = sender.map((a) => utxoAddresses.findIndex((u) => a.equals(u)));\n      // addressesIndex should never have a mismatch\n      if (addressesIndex.includes(-1)) {\n        throw new BuildTransactionError('Addresses are inconsistent: ' + utxo.txid);\n      }\n      if (utxo.threshold !== threshold) {\n        throw new BuildTransactionError('Threshold is inconsistent');\n      }\n\n      const txidBuf: BufferAvax = utils.cb58Decode(utxo.txid);\n      const amount: BN = new BN(utxo.amount);\n      const outputIdx: BufferAvax = utils.cb58Decode(utxo.outputidx);\n\n      currentTotal = currentTotal.add(amount);\n\n      const signers = addressesIndex\n        .slice(0, threshold)\n        .map((utxoIndex, senderIndex) => ({ utxoIndex, senderIndex }))\n        .sort((a, b) => a.utxoIndex - b.utxoIndex);\n      const signatures = signers.map(({ senderIndex }) =>\n        // TODO(BG-56700):  Improve canSign by check in addresses in empty credentials match signer\n        // HSM require empty signature.\n        utils.createSig(senderIndex == 1 ? '' : sender[senderIndex].toString('hex'))\n      );\n      const signaturesIdx = signers.map(({ utxoIndex }) => utxoIndex);\n\n      return { amount, txidBuf, outputIdx, signaturesIdx, signatures };\n    });\n\n  return { inputs, amount: currentTotal };\n}\n"]}