@bitgo-beta/sdk-coin-avaxp 0.0.0-semantic-release-managed

package/dist/src/lib/transactionBuilderFactory.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilderFactory = void 0;
+const avalanchejs_1 = require("@bitgo-forks/avalanchejs");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const avalanche_1 = require("avalanche");
+const evm_1 = require("avalanche/dist/apis/evm");
+const platformvm_1 = require("avalanche/dist/apis/platformvm");
+const exportInCTxBuilder_1 = require("./exportInCTxBuilder");
+const exportTxBuilder_1 = require("./exportTxBuilder");
+const importInCTxBuilder_1 = require("./importInCTxBuilder");
+const importTxBuilder_1 = require("./importTxBuilder");
+const permissionlessValidatorTxBuilder_1 = require("./permissionlessValidatorTxBuilder");
+const utils_1 = __importDefault(require("./utils"));
+const validatorTxBuilder_1 = require("./validatorTxBuilder");
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.recoverSigner = false;
+    }
+    /** @inheritdoc */
+    from(raw) {
+        utils_1.default.validateRawTransaction(raw);
+        let txSource = 'PVM';
+        let transactionBuilder = undefined;
+        let tx;
+        const rawNoHex = utils_1.default.removeHexPrefix(raw);
+        try {
+            tx = new platformvm_1.Tx();
+            // could throw an error if a txType doesn't match.
+            tx.fromBuffer(avalanche_1.Buffer.from(rawNoHex, 'hex'));
+            if (!utils_1.default.isTransactionOf(tx, this._coinConfig.network.blockchainID)) {
+                throw new Error('It is not a transaction of this platformvm old flow');
+            }
+        }
+        catch (e) {
+            try {
+                txSource = 'EVM';
+                tx = new evm_1.Tx();
+                tx.fromBuffer(avalanche_1.Buffer.from(rawNoHex, 'hex'));
+                if (!utils_1.default.isTransactionOf(tx, this._coinConfig.network.cChainBlockchainID)) {
+                    throw new Error('It is not a transaction of this network or C chain EVM');
+                }
+            }
+            catch (e) {
+                try {
+                    txSource = 'PVM';
+                    // this should be the last because other PVM functions are still being detected in the new SDK
+                    const manager = avalanchejs_1.utils.getManagerForVM('PVM');
+                    const [codec, txBytes] = manager.getCodecFromBuffer(avalanchejs_1.utils.hexToBuffer(raw));
+                    const unpackedTx = codec.UnpackPrefix(txBytes);
+                    // A signed transaction includes 4 bytes for the number of credentials as an Int type that is not known by the codec
+                    // We'll skip those 4 bytes, instead we'll loop until we've parsed all credentials
+                    // @see https://docs.avax.network/reference/avalanchego/p-chain/txn-format#signed-transaction-example
+                    const credentials = [];
+                    let credentialBytes = unpackedTx[1].slice(4);
+                    let moreCredentials = true;
+                    do {
+                        try {
+                            const [credential, rest] = codec.UnpackPrefix(credentialBytes);
+                            credentials.push(credential);
+                            credentialBytes = rest;
+                        }
+                        catch (e) {
+                            moreCredentials = false;
+                        }
+                    } while (credentialBytes.length > 0 && moreCredentials);
+                    const unpacked = codec.UnpackPrefix(txBytes);
+                    const permissionlessValidatorTx = unpacked[0];
+                    const outputs = permissionlessValidatorTx.baseTx.outputs;
+                    const output = outputs[0].output;
+                    if (outputs[0].getAssetId() !== this._coinConfig.network.avaxAssetID) {
+                        throw new Error('The Asset ID of the output does not match the transaction');
+                    }
+                    const fromAddresses = output.outputOwners.addrs.map((a) => avalanchejs_1.utils.hexToBuffer(a.toHex()));
+                    const addressMaps = fromAddresses.map((a) => new avalanchejs_1.utils.AddressMap([[new avalanchejs_1.Address(a), 0]]));
+                    tx = new avalanchejs_1.UnsignedTx(unpacked[0], [], new avalanchejs_1.utils.AddressMaps(addressMaps), credentials);
+                }
+                catch (e) {
+                    throw new Error(`The transaction type is not recognized as an old PVM or old EVM transaction. Additionally, parsing of the new PVM AddPermissionlessValidatorTx type failed: ${e.message}`);
+                }
+            }
+        }
+        if (txSource === 'PVM') {
+            if (tx?.tx?._type && permissionlessValidatorTxBuilder_1.PermissionlessValidatorTxBuilder.verifyTxType(tx.tx._type)) {
+                transactionBuilder = this.getPermissionlessValidatorTxBuilder();
+                transactionBuilder.initBuilder(tx);
+            }
+            else if (validatorTxBuilder_1.ValidatorTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getValidatorBuilder();
+                transactionBuilder.initBuilder(tx);
+            }
+            else if (exportTxBuilder_1.ExportTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getExportBuilder();
+                transactionBuilder.initBuilder(tx);
+            }
+            else if (importTxBuilder_1.ImportTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getImportBuilder();
+                transactionBuilder.initBuilder(tx);
+            }
+        }
+        else if (txSource === 'EVM') {
+            if (importInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getImportInCBuilder();
+                transactionBuilder.initBuilder(tx);
+            }
+            else if (exportInCTxBuilder_1.ExportInCTxBuilder.verifyTxType(tx.getUnsignedTx().getTransaction())) {
+                transactionBuilder = this.getExportInCBuilder();
+                transactionBuilder.initBuilder(tx);
+            }
+        }
+        if (transactionBuilder === undefined) {
+            throw new sdk_core_1.NotSupported('Transaction cannot be parsed or has an unsupported transaction type');
+        }
+        return transactionBuilder;
+    }
+    /** @inheritdoc */
+    getTransferBuilder() {
+        throw new sdk_core_1.NotSupported('Transfer is not supported in P Chain');
+    }
+    /**
+     * Initialize Validator builder
+     *
+     * @returns {ValidatorTxBuilder} the builder initialized
+     */
+    getValidatorBuilder() {
+        return new validatorTxBuilder_1.ValidatorTxBuilder(this._coinConfig);
+    }
+    /**
+     * Initialize Permissionless Validator builder
+     *
+     * @returns {PermissionlessValidatorTxBuilder} the builder initialized
+     */
+    getPermissionlessValidatorTxBuilder() {
+        return new permissionlessValidatorTxBuilder_1.PermissionlessValidatorTxBuilder(this._coinConfig);
+    }
+    /**
+     * Export Cross chain transfer
+     *
+     * @returns {ExportTxBuilder} the builder initialized
+     */
+    getExportBuilder() {
+        return new exportTxBuilder_1.ExportTxBuilder(this._coinConfig);
+    }
+    /**
+     * Import Cross chain transfer
+     *
+     * @returns {ImportTxBuilder} the builder initialized
+     */
+    getImportBuilder() {
+        return new importTxBuilder_1.ImportTxBuilder(this._coinConfig);
+    }
+    /**
+     * Import in C chain Cross chain transfer
+     *
+     * @returns {ImportInCTxBuilder} the builder initialized
+     */
+    getImportInCBuilder() {
+        return new importInCTxBuilder_1.ImportInCTxBuilder(this._coinConfig);
+    }
+    /**
+     * Export in C chain Cross chain transfer
+     *
+     * @returns {ExportInCTxBuilder} the builder initialized
+     */
+    getExportInCBuilder() {
+        return new exportInCTxBuilder_1.ExportInCTxBuilder(this._coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder() {
+        throw new sdk_core_1.NotSupported('Wallet initialization is not needed');
+    }
+}
+exports.TransactionBuilderFactory = TransactionBuilderFactory;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Address,\n  utils as AvaxUtils,\n  Credential,\n  pvmSerial,\n  TransferOutput,\n  UnsignedTx,\n} from '@bitgo-forks/avalanchejs';\nimport { BaseTransactionBuilderFactory, NotSupported } from '@bitgo-beta/sdk-core';\nimport { AvalancheNetwork, BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Buffer as BufferAvax } from 'avalanche';\nimport { Tx as EVMTx } from 'avalanche/dist/apis/evm';\nimport { Tx as PVMTx } from 'avalanche/dist/apis/platformvm';\nimport { DeprecatedTransactionBuilder } from './deprecatedTransactionBuilder';\nimport { ExportInCTxBuilder } from './exportInCTxBuilder';\nimport { ExportTxBuilder } from './exportTxBuilder';\nimport { ImportInCTxBuilder } from './importInCTxBuilder';\nimport { ImportTxBuilder } from './importTxBuilder';\nimport { PermissionlessValidatorTxBuilder } from './permissionlessValidatorTxBuilder';\nimport { TransactionBuilder } from './transactionBuilder';\nimport utils from './utils';\nimport { ValidatorTxBuilder } from './validatorTxBuilder';\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  protected recoverSigner = false;\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /** @inheritdoc */\n  from(raw: string): TransactionBuilder | DeprecatedTransactionBuilder {\n    utils.validateRawTransaction(raw);\n    let txSource: 'EVM' | 'PVM' = 'PVM';\n    let transactionBuilder: TransactionBuilder | DeprecatedTransactionBuilder | undefined = undefined;\n    let tx: PVMTx | EVMTx | UnsignedTx;\n    const rawNoHex = utils.removeHexPrefix(raw);\n    try {\n      tx = new PVMTx();\n      // could throw an error if a txType doesn't match.\n      tx.fromBuffer(BufferAvax.from(rawNoHex, 'hex'));\n\n      if (!utils.isTransactionOf(tx, (this._coinConfig.network as AvalancheNetwork).blockchainID)) {\n        throw new Error('It is not a transaction of this platformvm old flow');\n      }\n    } catch (e) {\n      try {\n        txSource = 'EVM';\n        tx = new EVMTx();\n        tx.fromBuffer(BufferAvax.from(rawNoHex, 'hex'));\n\n        if (!utils.isTransactionOf(tx, (this._coinConfig.network as AvalancheNetwork).cChainBlockchainID)) {\n          throw new Error('It is not a transaction of this network or C chain EVM');\n        }\n      } catch (e) {\n        try {\n          txSource = 'PVM';\n          // this should be the last because other PVM functions are still being detected in the new SDK\n          const manager = AvaxUtils.getManagerForVM('PVM');\n          const [codec, txBytes] = manager.getCodecFromBuffer(AvaxUtils.hexToBuffer(raw));\n          const unpackedTx = codec.UnpackPrefix<pvmSerial.AddPermissionlessValidatorTx>(txBytes);\n          // A signed transaction includes 4 bytes for the number of credentials as an Int type that is not known by the codec\n          // We'll skip those 4 bytes, instead we'll loop until we've parsed all credentials\n          // @see https://docs.avax.network/reference/avalanchego/p-chain/txn-format#signed-transaction-example\n          const credentials: Credential[] = [];\n          let credentialBytes = unpackedTx[1].slice(4);\n          let moreCredentials = true;\n          do {\n            try {\n              const [credential, rest] = codec.UnpackPrefix<Credential>(credentialBytes);\n              credentials.push(credential);\n              credentialBytes = rest;\n            } catch (e) {\n              moreCredentials = false;\n            }\n          } while (credentialBytes.length > 0 && moreCredentials);\n\n          const unpacked = codec.UnpackPrefix<pvmSerial.AddPermissionlessValidatorTx>(txBytes);\n          const permissionlessValidatorTx = unpacked[0] as pvmSerial.AddPermissionlessValidatorTx;\n          const outputs = permissionlessValidatorTx.baseTx.outputs;\n          const output = outputs[0].output as TransferOutput;\n          if (outputs[0].getAssetId() !== (this._coinConfig.network as AvalancheNetwork).avaxAssetID) {\n            throw new Error('The Asset ID of the output does not match the transaction');\n          }\n          const fromAddresses = output.outputOwners.addrs.map((a) => AvaxUtils.hexToBuffer(a.toHex()));\n          const addressMaps = fromAddresses.map((a) => new AvaxUtils.AddressMap([[new Address(a), 0]]));\n          tx = new UnsignedTx(unpacked[0], [], new AvaxUtils.AddressMaps(addressMaps), credentials);\n        } catch (e) {\n          throw new Error(\n            `The transaction type is not recognized as an old PVM or old EVM transaction. Additionally, parsing of the new PVM AddPermissionlessValidatorTx type failed: ${e.message}`\n          );\n        }\n      }\n    }\n\n    if (txSource === 'PVM') {\n      if ((tx as UnsignedTx)?.tx?._type && PermissionlessValidatorTxBuilder.verifyTxType((tx as UnsignedTx).tx._type)) {\n        transactionBuilder = this.getPermissionlessValidatorTxBuilder();\n        transactionBuilder.initBuilder(tx);\n      } else if (ValidatorTxBuilder.verifyTxType((tx as PVMTx).getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getValidatorBuilder();\n        transactionBuilder.initBuilder(tx as PVMTx);\n      } else if (ExportTxBuilder.verifyTxType((tx as PVMTx).getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getExportBuilder();\n        transactionBuilder.initBuilder(tx as PVMTx);\n      } else if (ImportTxBuilder.verifyTxType((tx as PVMTx).getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getImportBuilder();\n        transactionBuilder.initBuilder(tx as PVMTx);\n      }\n    } else if (txSource === 'EVM') {\n      if (ImportInCTxBuilder.verifyTxType((tx as EVMTx).getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getImportInCBuilder();\n        transactionBuilder.initBuilder(tx as EVMTx);\n      } else if (ExportInCTxBuilder.verifyTxType((tx as EVMTx).getUnsignedTx().getTransaction())) {\n        transactionBuilder = this.getExportInCBuilder();\n        transactionBuilder.initBuilder(tx as EVMTx);\n      }\n    }\n    if (transactionBuilder === undefined) {\n      throw new NotSupported('Transaction cannot be parsed or has an unsupported transaction type');\n    }\n    return transactionBuilder;\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(): DeprecatedTransactionBuilder {\n    throw new NotSupported('Transfer is not supported in P Chain');\n  }\n\n  /**\n   * Initialize Validator builder\n   *\n   * @returns {ValidatorTxBuilder} the builder initialized\n   */\n  getValidatorBuilder(): ValidatorTxBuilder {\n    return new ValidatorTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Initialize Permissionless Validator builder\n   *\n   * @returns {PermissionlessValidatorTxBuilder} the builder initialized\n   */\n  getPermissionlessValidatorTxBuilder(): PermissionlessValidatorTxBuilder {\n    return new PermissionlessValidatorTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Export Cross chain transfer\n   *\n   * @returns {ExportTxBuilder} the builder initialized\n   */\n  getExportBuilder(): ExportTxBuilder {\n    return new ExportTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import Cross chain transfer\n   *\n   * @returns {ImportTxBuilder} the builder initialized\n   */\n  getImportBuilder(): ImportTxBuilder {\n    return new ImportTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import in C chain Cross chain transfer\n   *\n   * @returns {ImportInCTxBuilder} the builder initialized\n   */\n  getImportInCBuilder(): ImportInCTxBuilder {\n    return new ImportInCTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Export in C chain Cross chain transfer\n   *\n   * @returns {ExportInCTxBuilder} the builder initialized\n   */\n  getExportInCBuilder(): ExportInCTxBuilder {\n    return new ExportInCTxBuilder(this._coinConfig);\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): DeprecatedTransactionBuilder {\n    throw new NotSupported('Wallet initialization is not needed');\n  }\n}\n"]}

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

@@ -0,0 +1,184 @@
+import { Signature as AvaxSignature, TransferableOutput } from '@bitgo-forks/avalanchejs';
+import { BaseUtils, Entry } from '@bitgo-beta/sdk-core';
+import { AvalancheNetwork } from '@bitgo-beta/statics';
+import { Buffer as BufferAvax } from 'avalanche';
+import { BaseTx, TransferableOutput as DeprecatedTransferableOutput } from 'avalanche/dist/apis/platformvm';
+import { Signature } from 'avalanche/dist/common';
+import { Credential } from 'avalanche/dist/common/credentials';
+import { NodeIDStringToBuffer } from 'avalanche/dist/utils';
+import { DeprecatedOutput, DeprecatedTx, Output } from './iface';
+export declare class Utils implements BaseUtils {
+    private binTools;
+    cb58Decode: (bytes: BufferAvax | string) => 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;
+    createNewSig(sigHex: string): AvaxSignature;
+    /**
+     * 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 {DeprecatedTx} tx
+     * @param {string} blockchainId
+     * @returns true if tx is for blockchainId
+     */
+    isTransactionOf(tx: DeprecatedTx, blockchainId: string): boolean;
+    /**
+     * Check if Output is from PVM.
+     * Output could be EVM or PVM output.
+     * @param {DeprecatedOutput} output
+     * @returns {boolean} output is DeprecatedTransferableOutput
+     */
+    deprecatedIsTransferableOutput(output: DeprecatedOutput): output is DeprecatedTransferableOutput;
+    /**
+     * 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
+     */
+    deprecatedMapOutputToEntry(network: AvalancheNetwork): (DeprecatedOutput: any) => Entry;
+    /**
+     * Return a mapper function to that network address representation.
+     * @param network required to stringify addresses
+     * @return mapper function
+     */
+    mapOutputToEntry(network: AvalancheNetwork): (Output: any) => Entry;
+    /**
+     * remove hex prefix (0x)
+     * @param hex string
+     * @returns hex without 0x
+     */
+    removeHexPrefix(hex: string): string;
+    /**
+     * Outputidx convert from number (as string) to buffer.
+     * @param {string} outputidx number
+     * @return {BufferAvax} buffer of size 4 with that number value
+     */
+    outputidxNumberToBuffer(outputidx: string): BufferAvax;
+    /**
+     * Outputidx buffer to number (as string)
+     * @param {BufferAvax} outputidx
+     * @return {string} outputidx number
+     */
+    outputidxBufferToNumber(outputidx: BufferAvax): string;
+}
+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":"AAAA,OAAO,EAAE,SAAS,IAAI,aAAa,EAAE,kBAAkB,EAA+B,MAAM,0BAA0B,CAAC;AACvH,OAAO,EACL,SAAS,EACT,KAAK,EAMN,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAgB,MAAM,IAAI,UAAU,EAAE,MAAM,WAAW,CAAC;AAE/D,OAAO,EAEL,MAAM,EACN,kBAAkB,IAAI,4BAA4B,EAEnD,MAAM,gCAAgC,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAC;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,OAAO,EAAqB,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEpF,qBAAa,KAAM,YAAW,SAAS;IACrC,OAAO,CAAC,QAAQ,CAA0B;IACnC,UAAU,6CAA4B;IACtC,UAAU,gCAA4B;IACtC,cAAc,8BAAgC;IAC9C,cAAc,+BAAgC;IAC9C,oBAAoB,8BAAwB;IAC5C,eAAe,8DAAiC;IAEhD,SAAS,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,mBAAmB,EAAE,MAAM,EAAE,GAAG,OAAO;IAInF;;;;;OAKG;IACH,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO;IAYnD,OAAO,CAAC,mBAAmB;IAI3B;;;;;OAKG;IACH,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIrC;;;;;;OAMG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAiC/B,YAAY,QAAS,MAAM,KAAG,UAAU,CAAuC;IAEtF;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAUvC;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,EAAE;IAIxC;;;;;;OAMG;IACH,yBAAyB,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,UAAU;IAMtG;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAIhF;;;;;;;OAOG;IACH,yBAAyB,CACvB,OAAO,EAAE,gBAAgB,EACzB,OAAO,EAAE,UAAU,EACnB,SAAS,EAAE,UAAU,EACrB,GAAG,EAAE,UAAU,GACd,OAAO;IAMV;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO;IASpG,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;IAMpC,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa;IAK3C;;;;;;OAMG;IACH,2BAA2B,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,GAAG,UAAU;IAK9G;;;;;;OAMG;IACH,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAIxF,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IAI/B;;;;;OAKG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IASpD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAIhE;;;;;OAKG;IACH,8BAA8B,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,IAAI,4BAA4B;IAIhG;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,kBAAkB;IAIlE;;;;OAIG;IACH,0BAA0B,CAAC,OAAO,EAAE,gBAAgB,GAAG,CAAC,gBAAgB,KAAA,KAAK,KAAK;IAyBlF;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,gBAAgB,GAAG,CAAC,MAAM,KAAA,KAAK,KAAK;IAmB9D;;;;OAIG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOpC;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,UAAU;IAItD;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;CAGvD;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}