{"version":3,"file":"static/js/12.8f09ab00.js","mappings":"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","sources":["../node_modules/@shapeshiftoss/asset-service/dist/index.js","../node_modules/@shapeshiftoss/asset-service/dist/service/AssetService.js","../node_modules/@shapeshiftoss/asset-service/dist/service/GenerateAssetIcon.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/node_modules/big-integer/BigInteger.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/address.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/block.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/bufferutils.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/cashaddr/base32.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/cashaddr/convertBits.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/cashaddr/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/cashaddr/validation.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/classify.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/crypto.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/ecpair.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/networks.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/embed.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/lazy.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/p2ms.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/p2pk.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/p2pkh.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/p2sh.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/p2wpkh.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/payments/p2wsh.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/psbt.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/script.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/script_number.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/script_signature.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/multisig/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/multisig/input.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/multisig/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/nulldata.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/pubkey/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/pubkey/input.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/pubkey/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/pubkeyhash/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/pubkeyhash/input.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/pubkeyhash/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/scripthash/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/scripthash/input.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/scripthash/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnesscommitment/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnesscommitment/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnesspubkeyhash/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnesspubkeyhash/input.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnesspubkeyhash/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnessscripthash/index.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnessscripthash/input.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/templates/witnessscripthash/output.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/transaction.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/transaction_builder.js","../node_modules/@shapeshiftoss/bitcoinjs-lib/src/types.js","../node_modules/@shapeshiftoss/caip/dist/accountId/accountId.js","../node_modules/@shapeshiftoss/caip/dist/adapters/banxa/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/coincap/generated/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/coincap/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/coingecko/generated/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/coingecko/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/gem/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/osmosis/generated/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/osmosis/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/yearn/generated/index.js","../node_modules/@shapeshiftoss/caip/dist/adapters/yearn/index.js","../node_modules/@shapeshiftoss/caip/dist/assetId/assetId.js","../node_modules/@shapeshiftoss/caip/dist/chainId/chainId.js","../node_modules/@shapeshiftoss/caip/dist/index.js","../node_modules/sha.js/hash.js","../node_modules/sha.js/index.js","../node_modules/sha.js/sha.js","../node_modules/sha.js/sha1.js","../node_modules/sha.js/sha224.js","../node_modules/sha.js/sha256.js","../node_modules/sha.js/sha384.js","../node_modules/sha.js/sha512.js"],"sourcesContent":["\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./service/AssetService\"), exports);\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AssetService = exports.indexAssetData = exports.flattenAssetData = void 0;\nconst types_1 = require(\"@shapeshiftoss/types\");\nconst axios_1 = __importDefault(require(\"axios\"));\nconst descriptions_json_1 = __importDefault(require(\"./descriptions.json\"));\nconst GenerateAssetIcon_1 = require(\"./GenerateAssetIcon\");\nconst generatedAssetData_json_1 = __importDefault(require(\"./generatedAssetData.json\"));\nconst flattenAssetData = (assetData) => {\n    const flatAssetData = [];\n    for (const baseAsset of assetData) {\n        const newAsset = { ...baseAsset };\n        delete newAsset.tokens;\n        flatAssetData.push(newAsset);\n        if (baseAsset.tokens) {\n            for (const tokenAsset of baseAsset.tokens) {\n                flatAssetData.push({\n                    ...tokenAsset,\n                    chain: baseAsset.chain,\n                    network: baseAsset.network,\n                    slip44: baseAsset.slip44,\n                    explorer: baseAsset.explorer,\n                    explorerAddressLink: baseAsset.explorerAddressLink,\n                    explorerTxLink: baseAsset.explorerTxLink\n                });\n            }\n        }\n    }\n    return flatAssetData;\n};\nexports.flattenAssetData = flattenAssetData;\nconst getDataIndexKey = (chain, network, tokenId) => {\n    return chain + '_' + network + (tokenId ? '_' + tokenId : '');\n};\nconst indexAssetData = (flatAssetData) => {\n    return flatAssetData.reduce((acc, val) => {\n        acc[getDataIndexKey(val.chain, val.network, val.tokenId)] = val;\n        return acc;\n    }, {});\n};\nexports.indexAssetData = indexAssetData;\nclass AssetService {\n    constructor(assetFileUrl) {\n        this.assetFileUrl = assetFileUrl;\n    }\n    get isInitialized() {\n        return Array.isArray(this.assetData) && Array.isArray(this.flatAssetData);\n    }\n    checkInitialized() {\n        if (!this.isInitialized)\n            throw new Error('Asset service not initialized');\n    }\n    /**\n     * Get asset data from assetFileUrl and flatten it for easier use\n     */\n    async initialize() {\n        try {\n            if (!this.assetFileUrl)\n                throw new Error('No assetFileUrl');\n            const { data } = await axios_1.default.get(this.assetFileUrl);\n            if (!Array.isArray(data)) {\n                throw new Error(`Asset Initialize: Return value ${data} is not valid`);\n            }\n            this.assetData = data;\n        }\n        catch (err) {\n            this.assetData = generatedAssetData_json_1.default;\n        }\n        this.flatAssetData = (0, exports.flattenAssetData)(this.assetData);\n        this.indexedAssetData = (0, exports.indexAssetData)(this.flatAssetData);\n    }\n    /**\n     * Get list of all assets on a given network (mainnet, ropsten, etc) or all assets across all networks\n     * @param network mainnet, testnet, eth ropsten, etc\n     * @returns base coins (ETH, BNB, etc...) along with their supported tokens in a flattened list\n     */\n    byNetwork(network) {\n        this.checkInitialized();\n        return network\n            ? this.flatAssetData.filter((asset) => asset.network == network)\n            : this.flatAssetData;\n    }\n    /**\n     * Find an asset by chain, network and tokenId\n     * @param chain blockchain to look up by (btc, eth, etc...)\n     * @param network mainnet, testnet, eth ropsten, etc\n     * @param tokenId token identifier (contract address on eth)\n     * @returns First asset found\n     */\n    byTokenId({ chain, network, tokenId }) {\n        this.checkInitialized();\n        const index = getDataIndexKey(chain, network !== null && network !== void 0 ? network : types_1.NetworkTypes.MAINNET, tokenId);\n        const result = this.indexedAssetData[index];\n        if (!result) {\n            throw new Error(`AssetService:byTokenId: could not find tokenId ${tokenId}`);\n        }\n        return result;\n    }\n    async description({ asset }) {\n        var _a, _b, _c;\n        const descriptions = descriptions_json_1.default;\n        // Return overridden asset description if it exists and add isTrusted for description links\n        if (descriptions[asset.assetId]) {\n            return {\n                description: descriptions[asset.assetId],\n                isTrusted: true\n            };\n        }\n        if (asset.dataSource !== types_1.AssetDataSource.CoinGecko) {\n            return { description: '' };\n        }\n        const contractUrl = typeof asset.tokenId === 'string' ? `/contract/${(_a = asset.tokenId) === null || _a === void 0 ? void 0 : _a.toLowerCase()}` : '';\n        const errorMessage = `AssetService:description: no description availble for ${asset.tokenId} on chain ${asset.chain}`;\n        try {\n            const { data } = await axios_1.default.get(`https://api.coingecko.com/api/v3/coins/${asset.chain}${contractUrl}`);\n            return { description: (_c = (_b = data === null || data === void 0 ? void 0 : data.description) === null || _b === void 0 ? void 0 : _b.en) !== null && _c !== void 0 ? _c : '' };\n        }\n        catch (e) {\n            throw new Error(errorMessage);\n        }\n    }\n    async generateAssetIconBase64(identity, text, options) {\n        return (0, GenerateAssetIcon_1.getRenderedIdenticonBase64)(identity, text, options);\n    }\n}\nexports.AssetService = AssetService;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getRenderedIdenticonBase64 = void 0;\n/* eslint-disable */\nconst Identicon = require('identicon.js');\nconst { fonts, renderPixels } = require('js-pixel-fonts');\n// any is used here since a library without typings is used (identicon.js).\n// However, all functions that involved `any` are used internally (without export).\n// eslint-disable-next-line  @typescript-eslint/no-explicit-any\nconst identiconPNGtoBase64 = (pngObj) => {\n    return `data:image/png;base64,${pngObj.getBase64()}`;\n};\n// any is used here since a library without typings is used (identicon.js).\n// However, all functions that involved `any` are used internally (without export).\n// eslint-disable-next-line  @typescript-eslint/no-explicit-any\nconst paintPixel = (pngObj, x, y, color) => {\n    pngObj.buffer[pngObj.index(x + 1, y)] = pngObj.color(...color);\n};\nconst getRenderedIdenticonPNG = (tokenId, text, options\n// any is used here since a library without typings is used (identicon.js).\n// However, all functions that involved `any` are used internally (without export).\n// eslint-disable-next-line  @typescript-eslint/no-explicit-any\n) => {\n    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;\n    const identiconOptions = {\n        identiconImage: {\n            size: ((_a = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _a === void 0 ? void 0 : _a.size) || 128,\n            margin: ((_b = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _b === void 0 ? void 0 : _b.margin) || 0.08,\n            foreground: (_c = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _c === void 0 ? void 0 : _c.foreground,\n            background: ((_d = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _d === void 0 ? void 0 : _d.background) || [240, 240, 240, 255],\n            saturation: ((_e = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _e === void 0 ? void 0 : _e.saturation) || 0.7,\n            brightness: ((_f = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _f === void 0 ? void 0 : _f.brightness) || 0.5,\n            format: 'png'\n        },\n        identiconText: {\n            textColor: ((_g = options === null || options === void 0 ? void 0 : options.identiconText) === null || _g === void 0 ? void 0 : _g.textColor) || [255, 255, 255, 255],\n            // if no provided `symbolScale`, then `symbolScale` is automatically computed given image size and text length\n            symbolScale: ((_h = options === null || options === void 0 ? void 0 : options.identiconText) === null || _h === void 0 ? void 0 : _h.symbolScale) ||\n                Math.floor((((_j = options === null || options === void 0 ? void 0 : options.identiconImage) === null || _j === void 0 ? void 0 : _j.size) || 128) / (6 * ((text === null || text === void 0 ? void 0 : text.length) || 3))),\n            enableShadow: ((_k = options === null || options === void 0 ? void 0 : options.identiconText) === null || _k === void 0 ? void 0 : _k.enableShadow) || false,\n            shadowColor: ((_l = options === null || options === void 0 ? void 0 : options.identiconText) === null || _l === void 0 ? void 0 : _l.shadowColor) || [0, 0, 0, 255]\n        }\n    };\n    // In order to additionally render text, we acquire PNGLib object here which has some convenient png operator.\n    // https://github.com/stewartlord/identicon.js/blob/master/pnglib.js\n    const identiconImage = new Identicon(tokenId === null || tokenId === void 0 ? void 0 : tokenId.substring(2), identiconOptions.identiconImage).render();\n    // we just return if no symbol\n    if (!text)\n        return identiconImage;\n    if (text.length === 0)\n        return identiconImage;\n    // here we start to render the text\n    const symbolPixels = renderPixels(text, fonts.sevenPlus);\n    // get fonts width and height\n    // `pixelSymbolWidth` and `pixelSymbolHeight` are the original width and height of pixel fonts\n    // generated by 'js-pixel-fonts'. They can't be modified.\n    const pixelSymbolWidth = symbolPixels[0].length, // here `symbolPixels` is guaranteed to have at least one child.\n    pixelSymbolHeight = symbolPixels.length;\n    // calculate the offset in order for centering the text\n    const offsetX = Math.round((identiconOptions.identiconImage.size -\n        pixelSymbolWidth * identiconOptions.identiconText.symbolScale) /\n        2);\n    const offsetY = Math.round((identiconOptions.identiconImage.size -\n        pixelSymbolHeight * identiconOptions.identiconText.symbolScale) /\n        2);\n    // render pixel text\n    for (let x = 0; x < identiconOptions.identiconImage.size; x++) {\n        const offsettedX = Math.floor((x - offsetX) / identiconOptions.identiconText.symbolScale);\n        if (offsettedX < 0 || offsettedX >= pixelSymbolWidth)\n            continue;\n        for (let y = 0; y < identiconOptions.identiconImage.size; y++) {\n            const offsettedY = Math.floor((y - offsetY) / identiconOptions.identiconText.symbolScale);\n            if (offsettedY < 0 || offsettedY >= pixelSymbolHeight)\n                continue;\n            if (symbolPixels[offsettedY][offsettedX]) {\n                // make the pixel at current position white (RGBA: 255, 255, 255, 255)\n                paintPixel(identiconImage, x, y, identiconOptions.identiconText.textColor);\n                if (identiconOptions.identiconText.enableShadow) {\n                    // create shadow\n                    paintPixel(identiconImage, x + 1, y + 1, identiconOptions.identiconText.shadowColor);\n                }\n            }\n        }\n    }\n    return identiconImage;\n};\nconst getRenderedIdenticonBase64 = (tokenId, text, options) => {\n    return identiconPNGtoBase64(getRenderedIdenticonPNG(tokenId, text, options));\n};\nexports.getRenderedIdenticonBase64 = getRenderedIdenticonBase64;\n","var bigInt = (function (undefined) {\r\n    \"use strict\";\r\n\r\n    var BASE = 1e7,\r\n        LOG_BASE = 7,\r\n        MAX_INT = 9007199254740992,\r\n        MAX_INT_ARR = smallToArray(MAX_INT),\r\n        DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\r\n\r\n    var supportsNativeBigInt = typeof BigInt === \"function\";\r\n\r\n    function Integer(v, radix, alphabet, caseSensitive) {\r\n        if (typeof v === \"undefined\") return Integer[0];\r\n        if (typeof radix !== \"undefined\") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\r\n        return parseValue(v);\r\n    }\r\n\r\n    function BigInteger(value, sign) {\r\n        this.value = value;\r\n        this.sign = sign;\r\n        this.isSmall = false;\r\n    }\r\n    BigInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function SmallInteger(value) {\r\n        this.value = value;\r\n        this.sign = value < 0;\r\n        this.isSmall = true;\r\n    }\r\n    SmallInteger.prototype = Object.create(Integer.prototype);\r\n\r\n    function NativeBigInt(value) {\r\n        this.value = value;\r\n    }\r\n    NativeBigInt.prototype = Object.create(Integer.prototype);\r\n\r\n    function isPrecise(n) {\r\n        return -MAX_INT < n && n < MAX_INT;\r\n    }\r\n\r\n    function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\r\n        if (n < 1e7)\r\n            return [n];\r\n        if (n < 1e14)\r\n            return [n % 1e7, Math.floor(n / 1e7)];\r\n        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\r\n    }\r\n\r\n    function arrayToSmall(arr) { // If BASE changes this function may need to change\r\n        trim(arr);\r\n        var length = arr.length;\r\n        if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {\r\n            switch (length) {\r\n                case 0: return 0;\r\n                case 1: return arr[0];\r\n                case 2: return arr[0] + arr[1] * BASE;\r\n                default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\r\n            }\r\n        }\r\n        return arr;\r\n    }\r\n\r\n    function trim(v) {\r\n        var i = v.length;\r\n        while (v[--i] === 0);\r\n        v.length = i + 1;\r\n    }\r\n\r\n    function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\r\n        var x = new Array(length);\r\n        var i = -1;\r\n        while (++i < length) {\r\n            x[i] = 0;\r\n        }\r\n        return x;\r\n    }\r\n\r\n    function truncate(n) {\r\n        if (n > 0) return Math.floor(n);\r\n        return Math.ceil(n);\r\n    }\r\n\r\n    function add(a, b) { // assumes a and b are arrays with a.length >= b.length\r\n        var l_a = a.length,\r\n            l_b = b.length,\r\n            r = new Array(l_a),\r\n            carry = 0,\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i < l_b; i++) {\r\n            sum = a[i] + b[i] + carry;\r\n            carry = sum >= base ? 1 : 0;\r\n            r[i] = sum - carry * base;\r\n        }\r\n        while (i < l_a) {\r\n            sum = a[i] + carry;\r\n            carry = sum === base ? 1 : 0;\r\n            r[i++] = sum - carry * base;\r\n        }\r\n        if (carry > 0) r.push(carry);\r\n        return r;\r\n    }\r\n\r\n    function addAny(a, b) {\r\n        if (a.length >= b.length) return add(a, b);\r\n        return add(b, a);\r\n    }\r\n\r\n    function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            sum, i;\r\n        for (i = 0; i < l; i++) {\r\n            sum = a[i] - base + carry;\r\n            carry = Math.floor(sum / base);\r\n            r[i] = sum - carry * base;\r\n            carry += 1;\r\n        }\r\n        while (carry > 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall) {\r\n            return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\r\n        }\r\n        return new BigInteger(addAny(a, b), this.sign);\r\n    };\r\n    BigInteger.prototype.plus = BigInteger.prototype.add;\r\n\r\n    SmallInteger.prototype.add = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a < 0 !== n.sign) {\r\n            return this.subtract(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            if (isPrecise(a + b)) return new SmallInteger(a + b);\r\n            b = smallToArray(Math.abs(b));\r\n        }\r\n        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);\r\n    };\r\n    SmallInteger.prototype.plus = SmallInteger.prototype.add;\r\n\r\n    NativeBigInt.prototype.add = function (v) {\r\n        return new NativeBigInt(this.value + parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\r\n\r\n    function subtract(a, b) { // assumes a and b are arrays with a >= b\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            r = new Array(a_l),\r\n            borrow = 0,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i < b_l; i++) {\r\n            difference = a[i] - borrow - b[i];\r\n            if (difference < 0) {\r\n                difference += base;\r\n                borrow = 1;\r\n            } else borrow = 0;\r\n            r[i] = difference;\r\n        }\r\n        for (i = b_l; i < a_l; i++) {\r\n            difference = a[i] - borrow;\r\n            if (difference < 0) difference += base;\r\n            else {\r\n                r[i++] = difference;\r\n                break;\r\n            }\r\n            r[i] = difference;\r\n        }\r\n        for (; i < a_l; i++) {\r\n            r[i] = a[i];\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function subtractAny(a, b, sign) {\r\n        var value;\r\n        if (compareAbs(a, b) >= 0) {\r\n            value = subtract(a, b);\r\n        } else {\r\n            value = subtract(b, a);\r\n            sign = !sign;\r\n        }\r\n        value = arrayToSmall(value);\r\n        if (typeof value === \"number\") {\r\n            if (sign) value = -value;\r\n            return new SmallInteger(value);\r\n        }\r\n        return new BigInteger(value, sign);\r\n    }\r\n\r\n    function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            carry = -b,\r\n            base = BASE,\r\n            i, difference;\r\n        for (i = 0; i < l; i++) {\r\n            difference = a[i] + carry;\r\n            carry = Math.floor(difference / base);\r\n            difference %= base;\r\n            r[i] = difference < 0 ? difference + base : difference;\r\n        }\r\n        r = arrayToSmall(r);\r\n        if (typeof r === \"number\") {\r\n            if (sign) r = -r;\r\n            return new SmallInteger(r);\r\n        } return new BigInteger(r, sign);\r\n    }\r\n\r\n    BigInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        if (this.sign !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var a = this.value, b = n.value;\r\n        if (n.isSmall)\r\n            return subtractSmall(a, Math.abs(b), this.sign);\r\n        return subtractAny(a, b, this.sign);\r\n    };\r\n    BigInteger.prototype.minus = BigInteger.prototype.subtract;\r\n\r\n    SmallInteger.prototype.subtract = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value;\r\n        if (a < 0 !== n.sign) {\r\n            return this.add(n.negate());\r\n        }\r\n        var b = n.value;\r\n        if (n.isSmall) {\r\n            return new SmallInteger(a - b);\r\n        }\r\n        return subtractSmall(b, Math.abs(a), a >= 0);\r\n    };\r\n    SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\r\n\r\n    NativeBigInt.prototype.subtract = function (v) {\r\n        return new NativeBigInt(this.value - parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\r\n\r\n    BigInteger.prototype.negate = function () {\r\n        return new BigInteger(this.value, !this.sign);\r\n    };\r\n    SmallInteger.prototype.negate = function () {\r\n        var sign = this.sign;\r\n        var small = new SmallInteger(-this.value);\r\n        small.sign = !sign;\r\n        return small;\r\n    };\r\n    NativeBigInt.prototype.negate = function () {\r\n        return new NativeBigInt(-this.value);\r\n    }\r\n\r\n    BigInteger.prototype.abs = function () {\r\n        return new BigInteger(this.value, false);\r\n    };\r\n    SmallInteger.prototype.abs = function () {\r\n        return new SmallInteger(Math.abs(this.value));\r\n    };\r\n    NativeBigInt.prototype.abs = function () {\r\n        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);\r\n    }\r\n\r\n\r\n    function multiplyLong(a, b) {\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            l = a_l + b_l,\r\n            r = createArray(l),\r\n            base = BASE,\r\n            product, carry, i, a_i, b_j;\r\n        for (i = 0; i < a_l; ++i) {\r\n            a_i = a[i];\r\n            for (var j = 0; j < b_l; ++j) {\r\n                b_j = b[j];\r\n                product = a_i * b_j + r[i + j];\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n                r[i + j + 1] += carry;\r\n            }\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE\r\n        var l = a.length,\r\n            r = new Array(l),\r\n            base = BASE,\r\n            carry = 0,\r\n            product, i;\r\n        for (i = 0; i < l; i++) {\r\n            product = a[i] * b + carry;\r\n            carry = Math.floor(product / base);\r\n            r[i] = product - carry * base;\r\n        }\r\n        while (carry > 0) {\r\n            r[i++] = carry % base;\r\n            carry = Math.floor(carry / base);\r\n        }\r\n        return r;\r\n    }\r\n\r\n    function shiftLeft(x, n) {\r\n        var r = [];\r\n        while (n-- > 0) r.push(0);\r\n        return r.concat(x);\r\n    }\r\n\r\n    function multiplyKaratsuba(x, y) {\r\n        var n = Math.max(x.length, y.length);\r\n\r\n        if (n <= 30) return multiplyLong(x, y);\r\n        n = Math.ceil(n / 2);\r\n\r\n        var b = x.slice(n),\r\n            a = x.slice(0, n),\r\n            d = y.slice(n),\r\n            c = y.slice(0, n);\r\n\r\n        var ac = multiplyKaratsuba(a, c),\r\n            bd = multiplyKaratsuba(b, d),\r\n            abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\r\n\r\n        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\r\n        trim(product);\r\n        return product;\r\n    }\r\n\r\n    // The following function is derived from a surface fit of a graph plotting the performance difference\r\n    // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\r\n    function useKaratsuba(l1, l2) {\r\n        return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;\r\n    }\r\n\r\n    BigInteger.prototype.multiply = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value, b = n.value,\r\n            sign = this.sign !== n.sign,\r\n            abs;\r\n        if (n.isSmall) {\r\n            if (b === 0) return Integer[0];\r\n            if (b === 1) return this;\r\n            if (b === -1) return this.negate();\r\n            abs = Math.abs(b);\r\n            if (abs < BASE) {\r\n                return new BigInteger(multiplySmall(a, abs), sign);\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\r\n            return new BigInteger(multiplyKaratsuba(a, b), sign);\r\n        return new BigInteger(multiplyLong(a, b), sign);\r\n    };\r\n\r\n    BigInteger.prototype.times = BigInteger.prototype.multiply;\r\n\r\n    function multiplySmallAndArray(a, b, sign) { // a >= 0\r\n        if (a < BASE) {\r\n            return new BigInteger(multiplySmall(b, a), sign);\r\n        }\r\n        return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\r\n    }\r\n    SmallInteger.prototype._multiplyBySmall = function (a) {\r\n        if (isPrecise(a.value * this.value)) {\r\n            return new SmallInteger(a.value * this.value);\r\n        }\r\n        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\r\n    };\r\n    BigInteger.prototype._multiplyBySmall = function (a) {\r\n        if (a.value === 0) return Integer[0];\r\n        if (a.value === 1) return this;\r\n        if (a.value === -1) return this.negate();\r\n        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\r\n    };\r\n    SmallInteger.prototype.multiply = function (v) {\r\n        return parseValue(v)._multiplyBySmall(this);\r\n    };\r\n    SmallInteger.prototype.times = SmallInteger.prototype.multiply;\r\n\r\n    NativeBigInt.prototype.multiply = function (v) {\r\n        return new NativeBigInt(this.value * parseValue(v).value);\r\n    }\r\n    NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\r\n\r\n    function square(a) {\r\n        //console.assert(2 * BASE * BASE < MAX_INT);\r\n        var l = a.length,\r\n            r = createArray(l + l),\r\n            base = BASE,\r\n            product, carry, i, a_i, a_j;\r\n        for (i = 0; i < l; i++) {\r\n            a_i = a[i];\r\n            carry = 0 - a_i * a_i;\r\n            for (var j = i; j < l; j++) {\r\n                a_j = a[j];\r\n                product = 2 * (a_i * a_j) + r[i + j] + carry;\r\n                carry = Math.floor(product / base);\r\n                r[i + j] = product - carry * base;\r\n            }\r\n            r[i + l] = carry;\r\n        }\r\n        trim(r);\r\n        return r;\r\n    }\r\n\r\n    BigInteger.prototype.square = function () {\r\n        return new BigInteger(square(this.value), false);\r\n    };\r\n\r\n    SmallInteger.prototype.square = function () {\r\n        var value = this.value * this.value;\r\n        if (isPrecise(value)) return new SmallInteger(value);\r\n        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\r\n    };\r\n\r\n    NativeBigInt.prototype.square = function (v) {\r\n        return new NativeBigInt(this.value * this.value);\r\n    }\r\n\r\n    function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            base = BASE,\r\n            result = createArray(b.length),\r\n            divisorMostSignificantDigit = b[b_l - 1],\r\n            // normalization\r\n            lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\r\n            remainder = multiplySmall(a, lambda),\r\n            divisor = multiplySmall(b, lambda),\r\n            quotientDigit, shift, carry, borrow, i, l, q;\r\n        if (remainder.length <= a_l) remainder.push(0);\r\n        divisor.push(0);\r\n        divisorMostSignificantDigit = divisor[b_l - 1];\r\n        for (shift = a_l - b_l; shift >= 0; shift--) {\r\n            quotientDigit = base - 1;\r\n            if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\r\n                quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\r\n            }\r\n            // quotientDigit <= base - 1\r\n            carry = 0;\r\n            borrow = 0;\r\n            l = divisor.length;\r\n            for (i = 0; i < l; i++) {\r\n                carry += quotientDigit * divisor[i];\r\n                q = Math.floor(carry / base);\r\n                borrow += remainder[shift + i] - (carry - q * base);\r\n                carry = q;\r\n                if (borrow < 0) {\r\n                    remainder[shift + i] = borrow + base;\r\n                    borrow = -1;\r\n                } else {\r\n                    remainder[shift + i] = borrow;\r\n                    borrow = 0;\r\n                }\r\n            }\r\n            while (borrow !== 0) {\r\n                quotientDigit -= 1;\r\n                carry = 0;\r\n                for (i = 0; i < l; i++) {\r\n                    carry += remainder[shift + i] - base + divisor[i];\r\n                    if (carry < 0) {\r\n                        remainder[shift + i] = carry + base;\r\n                        carry = 0;\r\n                    } else {\r\n                        remainder[shift + i] = carry;\r\n                        carry = 1;\r\n                    }\r\n                }\r\n                borrow += carry;\r\n            }\r\n            result[shift] = quotientDigit;\r\n        }\r\n        // denormalization\r\n        remainder = divModSmall(remainder, lambda)[0];\r\n        return [arrayToSmall(result), arrayToSmall(remainder)];\r\n    }\r\n\r\n    function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\r\n        // Performs faster than divMod1 on larger input sizes.\r\n        var a_l = a.length,\r\n            b_l = b.length,\r\n            result = [],\r\n            part = [],\r\n            base = BASE,\r\n            guess, xlen, highx, highy, check;\r\n        while (a_l) {\r\n            part.unshift(a[--a_l]);\r\n            trim(part);\r\n            if (compareAbs(part, b) < 0) {\r\n                result.push(0);\r\n                continue;\r\n            }\r\n            xlen = part.length;\r\n            highx = part[xlen - 1] * base + part[xlen - 2];\r\n            highy = b[b_l - 1] * base + b[b_l - 2];\r\n            if (xlen > b_l) {\r\n                highx = (highx + 1) * base;\r\n            }\r\n            guess = Math.ceil(highx / highy);\r\n            do {\r\n                check = multiplySmall(b, guess);\r\n                if (compareAbs(check, part) <= 0) break;\r\n                guess--;\r\n            } while (guess);\r\n            result.push(guess);\r\n            part = subtract(part, check);\r\n        }\r\n        result.reverse();\r\n        return [arrayToSmall(result), arrayToSmall(part)];\r\n    }\r\n\r\n    function divModSmall(value, lambda) {\r\n        var length = value.length,\r\n            quotient = createArray(length),\r\n            base = BASE,\r\n            i, q, remainder, divisor;\r\n        remainder = 0;\r\n        for (i = length - 1; i >= 0; --i) {\r\n            divisor = remainder * base + value[i];\r\n            q = truncate(divisor / lambda);\r\n            remainder = divisor - q * lambda;\r\n            quotient[i] = q | 0;\r\n        }\r\n        return [quotient, remainder | 0];\r\n    }\r\n\r\n    function divModAny(self, v) {\r\n        var value, n = parseValue(v);\r\n        if (supportsNativeBigInt) {\r\n            return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\r\n        }\r\n        var a = self.value, b = n.value;\r\n        var quotient;\r\n        if (b === 0) throw new Error(\"Cannot divide by zero\");\r\n        if (self.isSmall) {\r\n            if (n.isSmall) {\r\n                return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\r\n            }\r\n            return [Integer[0], self];\r\n        }\r\n        if (n.isSmall) {\r\n            if (b === 1) return [self, Integer[0]];\r\n            if (b == -1) return [self.negate(), Integer[0]];\r\n            var abs = Math.abs(b);\r\n            if (abs < BASE) {\r\n                value = divModSmall(a, abs);\r\n                quotient = arrayToSmall(value[0]);\r\n                var remainder = value[1];\r\n                if (self.sign) remainder = -remainder;\r\n                if (typeof quotient === \"number\") {\r\n                    if (self.sign !== n.sign) quotient = -quotient;\r\n                    return [new SmallInteger(quotient), new SmallInteger(remainder)];\r\n                }\r\n                return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\r\n            }\r\n            b = smallToArray(abs);\r\n        }\r\n        var comparison = compareAbs(a, b);\r\n        if (comparison === -1) return [Integer[0], self];\r\n        if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\r\n\r\n        // divMod1 is faster on smaller input sizes\r\n        if (a.length + b.length <= 200)\r\n            value = divMod1(a, b);\r\n        else value = divMod2(a, b);\r\n\r\n        quotient = value[0];\r\n        var qSign = self.sign !== n.sign,\r\n            mod = value[1],\r\n            mSign = self.sign;\r\n        if (typeof quotient === \"number\") {\r\n            if (qSign) quotient = -quotient;\r\n            quotient = new SmallInteger(quotient);\r\n        } else quotient = new BigInteger(quotient, qSign);\r\n        if (typeof mod === \"number\") {\r\n            if (mSign) mod = -mod;\r\n            mod = new SmallInteger(mod);\r\n        } else mod = new BigInteger(mod, mSign);\r\n        return [quotient, mod];\r\n    }\r\n\r\n    BigInteger.prototype.divmod = function (v) {\r\n        var result = divModAny(this, v);\r\n        return {\r\n            quotient: result[0],\r\n            remainder: result[1]\r\n        };\r\n    };\r\n    NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\r\n\r\n\r\n    BigInteger.prototype.divide = function (v) {\r\n        return divModAny(this, v)[0];\r\n    };\r\n    NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {\r\n        return new NativeBigInt(this.value / parseValue(v).value);\r\n    };\r\n    SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\r\n\r\n    BigInteger.prototype.mod = function (v) {\r\n        return divModAny(this, v)[1];\r\n    };\r\n    NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {\r\n        return new NativeBigInt(this.value % parseValue(v).value);\r\n    };\r\n    SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\r\n\r\n    BigInteger.prototype.pow = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value,\r\n            value, x, y;\r\n        if (b === 0) return Integer[1];\r\n        if (a === 0) return Integer[0];\r\n        if (a === 1) return Integer[1];\r\n        if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.sign) {\r\n            return Integer[0];\r\n        }\r\n        if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\r\n        if (this.isSmall) {\r\n            if (isPrecise(value = Math.pow(a, b)))\r\n                return new SmallInteger(truncate(value));\r\n        }\r\n        x = this;\r\n        y = Integer[1];\r\n        while (true) {\r\n            if (b & 1 === 1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === 0) break;\r\n            b /= 2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    };\r\n    SmallInteger.prototype.pow = BigInteger.prototype.pow;\r\n\r\n    NativeBigInt.prototype.pow = function (v) {\r\n        var n = parseValue(v);\r\n        var a = this.value, b = n.value;\r\n        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);\r\n        if (b === _0) return Integer[1];\r\n        if (a === _0) return Integer[0];\r\n        if (a === _1) return Integer[1];\r\n        if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\r\n        if (n.isNegative()) return new NativeBigInt(_0);\r\n        var x = this;\r\n        var y = Integer[1];\r\n        while (true) {\r\n            if ((b & _1) === _1) {\r\n                y = y.times(x);\r\n                --b;\r\n            }\r\n            if (b === _0) break;\r\n            b /= _2;\r\n            x = x.square();\r\n        }\r\n        return y;\r\n    }\r\n\r\n    BigInteger.prototype.modPow = function (exp, mod) {\r\n        exp = parseValue(exp);\r\n        mod = parseValue(mod);\r\n        if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\r\n        var r = Integer[1],\r\n            base = this.mod(mod);\r\n        if (exp.isNegative()) {\r\n            exp = exp.multiply(Integer[-1]);\r\n            base = base.modInv(mod);\r\n        }\r\n        while (exp.isPositive()) {\r\n            if (base.isZero()) return Integer[0];\r\n            if (exp.isOdd()) r = r.multiply(base).mod(mod);\r\n            exp = exp.divide(2);\r\n            base = base.square().mod(mod);\r\n        }\r\n        return r;\r\n    };\r\n    NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\r\n\r\n    function compareAbs(a, b) {\r\n        if (a.length !== b.length) {\r\n            return a.length > b.length ? 1 : -1;\r\n        }\r\n        for (var i = a.length - 1; i >= 0; i--) {\r\n            if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;\r\n        }\r\n        return 0;\r\n    }\r\n\r\n    BigInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) return 1;\r\n        return compareAbs(a, b);\r\n    };\r\n    SmallInteger.prototype.compareAbs = function (v) {\r\n        var n = parseValue(v),\r\n            a = Math.abs(this.value),\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            b = Math.abs(b);\r\n            return a === b ? 0 : a > b ? 1 : -1;\r\n        }\r\n        return -1;\r\n    };\r\n    NativeBigInt.prototype.compareAbs = function (v) {\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        a = a >= 0 ? a : -a;\r\n        b = b >= 0 ? b : -b;\r\n        return a === b ? 0 : a > b ? 1 : -1;\r\n    }\r\n\r\n    BigInteger.prototype.compare = function (v) {\r\n        // See discussion about comparison with Infinity:\r\n        // https://github.com/peterolson/BigInteger.js/issues/61\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (this.sign !== n.sign) {\r\n            return n.sign ? 1 : -1;\r\n        }\r\n        if (n.isSmall) {\r\n            return this.sign ? -1 : 1;\r\n        }\r\n        return compareAbs(a, b) * (this.sign ? -1 : 1);\r\n    };\r\n    BigInteger.prototype.compareTo = BigInteger.prototype.compare;\r\n\r\n    SmallInteger.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n\r\n        var n = parseValue(v),\r\n            a = this.value,\r\n            b = n.value;\r\n        if (n.isSmall) {\r\n            return a == b ? 0 : a > b ? 1 : -1;\r\n        }\r\n        if (a < 0 !== n.sign) {\r\n            return a < 0 ? -1 : 1;\r\n        }\r\n        return a < 0 ? 1 : -1;\r\n    };\r\n    SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\r\n\r\n    NativeBigInt.prototype.compare = function (v) {\r\n        if (v === Infinity) {\r\n            return -1;\r\n        }\r\n        if (v === -Infinity) {\r\n            return 1;\r\n        }\r\n        var a = this.value;\r\n        var b = parseValue(v).value;\r\n        return a === b ? 0 : a > b ? 1 : -1;\r\n    }\r\n    NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\r\n\r\n    BigInteger.prototype.equals = function (v) {\r\n        return this.compare(v) === 0;\r\n    };\r\n    NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\r\n\r\n    BigInteger.prototype.notEquals = function (v) {\r\n        return this.compare(v) !== 0;\r\n    };\r\n    NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\r\n\r\n    BigInteger.prototype.greater = function (v) {\r\n        return this.compare(v) > 0;\r\n    };\r\n    NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\r\n\r\n    BigInteger.prototype.lesser = function (v) {\r\n        return this.compare(v) < 0;\r\n    };\r\n    NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\r\n\r\n    BigInteger.prototype.greaterOrEquals = function (v) {\r\n        return this.compare(v) >= 0;\r\n    };\r\n    NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\r\n\r\n    BigInteger.prototype.lesserOrEquals = function (v) {\r\n        return this.compare(v) <= 0;\r\n    };\r\n    NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\r\n\r\n    BigInteger.prototype.isEven = function () {\r\n        return (this.value[0] & 1) === 0;\r\n    };\r\n    SmallInteger.prototype.isEven = function () {\r\n        return (this.value & 1) === 0;\r\n    };\r\n    NativeBigInt.prototype.isEven = function () {\r\n        return (this.value & BigInt(1)) === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isOdd = function () {\r\n        return (this.value[0] & 1) === 1;\r\n    };\r\n    SmallInteger.prototype.isOdd = function () {\r\n        return (this.value & 1) === 1;\r\n    };\r\n    NativeBigInt.prototype.isOdd = function () {\r\n        return (this.value & BigInt(1)) === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isPositive = function () {\r\n        return !this.sign;\r\n    };\r\n    SmallInteger.prototype.isPositive = function () {\r\n        return this.value > 0;\r\n    };\r\n    NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\r\n\r\n    BigInteger.prototype.isNegative = function () {\r\n        return this.sign;\r\n    };\r\n    SmallInteger.prototype.isNegative = function () {\r\n        return this.value < 0;\r\n    };\r\n    NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\r\n\r\n    BigInteger.prototype.isUnit = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isUnit = function () {\r\n        return Math.abs(this.value) === 1;\r\n    };\r\n    NativeBigInt.prototype.isUnit = function () {\r\n        return this.abs().value === BigInt(1);\r\n    }\r\n\r\n    BigInteger.prototype.isZero = function () {\r\n        return false;\r\n    };\r\n    SmallInteger.prototype.isZero = function () {\r\n        return this.value === 0;\r\n    };\r\n    NativeBigInt.prototype.isZero = function () {\r\n        return this.value === BigInt(0);\r\n    }\r\n\r\n    BigInteger.prototype.isDivisibleBy = function (v) {\r\n        var n = parseValue(v);\r\n        if (n.isZero()) return false;\r\n        if (n.isUnit()) return true;\r\n        if (n.compareAbs(2) === 0) return this.isEven();\r\n        return this.mod(n).isZero();\r\n    };\r\n    NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\r\n\r\n    function isBasicPrime(v) {\r\n        var n = v.abs();\r\n        if (n.isUnit()) return false;\r\n        if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\r\n        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\r\n        if (n.lesser(49)) return true;\r\n        // we don't know if it's prime: let the other functions figure it out\r\n    }\r\n\r\n    function millerRabinTest(n, a) {\r\n        var nPrev = n.prev(),\r\n            b = nPrev,\r\n            r = 0,\r\n            d, t, i, x;\r\n        while (b.isEven()) b = b.divide(2), r++;\r\n        next: for (i = 0; i < a.length; i++) {\r\n            if (n.lesser(a[i])) continue;\r\n            x = bigInt(a[i]).modPow(b, n);\r\n            if (x.isUnit() || x.equals(nPrev)) continue;\r\n            for (d = r - 1; d != 0; d--) {\r\n                x = x.square().mod(n);\r\n                if (x.isUnit()) return false;\r\n                if (x.equals(nPrev)) continue next;\r\n            }\r\n            return false;\r\n        }\r\n        return true;\r\n    }\r\n\r\n    // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\r\n    BigInteger.prototype.isPrime = function (strict) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var bits = n.bitLength();\r\n        if (bits <= 64)\r\n            return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);\r\n        var logN = Math.log(2) * bits.toJSNumber();\r\n        var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\r\n        for (var a = [], i = 0; i < t; i++) {\r\n            a.push(bigInt(i + 2));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\r\n\r\n    BigInteger.prototype.isProbablePrime = function (iterations, rng) {\r\n        var isPrime = isBasicPrime(this);\r\n        if (isPrime !== undefined) return isPrime;\r\n        var n = this.abs();\r\n        var t = iterations === undefined ? 5 : iterations;\r\n        for (var a = [], i = 0; i < t; i++) {\r\n            a.push(bigInt.randBetween(2, n.minus(2), rng));\r\n        }\r\n        return millerRabinTest(n, a);\r\n    };\r\n    NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\r\n\r\n    BigInteger.prototype.modInv = function (n) {\r\n        var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\r\n        while (!newR.isZero()) {\r\n            q = r.divide(newR);\r\n            lastT = t;\r\n            lastR = r;\r\n            t = newT;\r\n            r = newR;\r\n            newT = lastT.subtract(q.multiply(newT));\r\n            newR = lastR.subtract(q.multiply(newR));\r\n        }\r\n        if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\r\n        if (t.compare(0) === -1) {\r\n            t = t.add(n);\r\n        }\r\n        if (this.isNegative()) {\r\n            return t.negate();\r\n        }\r\n        return t;\r\n    };\r\n\r\n    NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\r\n\r\n    BigInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return subtractSmall(value, 1, this.sign);\r\n        }\r\n        return new BigInteger(addSmall(value, 1), this.sign);\r\n    };\r\n    SmallInteger.prototype.next = function () {\r\n        var value = this.value;\r\n        if (value + 1 < MAX_INT) return new SmallInteger(value + 1);\r\n        return new BigInteger(MAX_INT_ARR, false);\r\n    };\r\n    NativeBigInt.prototype.next = function () {\r\n        return new NativeBigInt(this.value + BigInt(1));\r\n    }\r\n\r\n    BigInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (this.sign) {\r\n            return new BigInteger(addSmall(value, 1), true);\r\n        }\r\n        return subtractSmall(value, 1, this.sign);\r\n    };\r\n    SmallInteger.prototype.prev = function () {\r\n        var value = this.value;\r\n        if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);\r\n        return new BigInteger(MAX_INT_ARR, true);\r\n    };\r\n    NativeBigInt.prototype.prev = function () {\r\n        return new NativeBigInt(this.value - BigInt(1));\r\n    }\r\n\r\n    var powersOfTwo = [1];\r\n    while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\r\n    var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\r\n\r\n    function shift_isSmall(n) {\r\n        return Math.abs(n) <= BASE;\r\n    }\r\n\r\n    BigInteger.prototype.shiftLeft = function (v) {\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n < 0) return this.shiftRight(-n);\r\n        var result = this;\r\n        if (result.isZero()) return result;\r\n        while (n >= powers2Length) {\r\n            result = result.multiply(highestPower2);\r\n            n -= powers2Length - 1;\r\n        }\r\n        return result.multiply(powersOfTwo[n]);\r\n    };\r\n    NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\r\n\r\n    BigInteger.prototype.shiftRight = function (v) {\r\n        var remQuo;\r\n        var n = parseValue(v).toJSNumber();\r\n        if (!shift_isSmall(n)) {\r\n            throw new Error(String(n) + \" is too large for shifting.\");\r\n        }\r\n        if (n < 0) return this.shiftLeft(-n);\r\n        var result = this;\r\n        while (n >= powers2Length) {\r\n            if (result.isZero() || (result.isNegative() && result.isUnit())) return result;\r\n            remQuo = divModAny(result, highestPower2);\r\n            result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n            n -= powers2Length - 1;\r\n        }\r\n        remQuo = divModAny(result, powersOfTwo[n]);\r\n        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n    };\r\n    NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\r\n\r\n    function bitwise(x, y, fn) {\r\n        y = parseValue(y);\r\n        var xSign = x.isNegative(), ySign = y.isNegative();\r\n        var xRem = xSign ? x.not() : x,\r\n            yRem = ySign ? y.not() : y;\r\n        var xDigit = 0, yDigit = 0;\r\n        var xDivMod = null, yDivMod = null;\r\n        var result = [];\r\n        while (!xRem.isZero() || !yRem.isZero()) {\r\n            xDivMod = divModAny(xRem, highestPower2);\r\n            xDigit = xDivMod[1].toJSNumber();\r\n            if (xSign) {\r\n                xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            yDivMod = divModAny(yRem, highestPower2);\r\n            yDigit = yDivMod[1].toJSNumber();\r\n            if (ySign) {\r\n                yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\r\n            }\r\n\r\n            xRem = xDivMod[0];\r\n            yRem = yDivMod[0];\r\n            result.push(fn(xDigit, yDigit));\r\n        }\r\n        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\r\n        for (var i = result.length - 1; i >= 0; i -= 1) {\r\n            sum = sum.multiply(highestPower2).add(bigInt(result[i]));\r\n        }\r\n        return sum;\r\n    }\r\n\r\n    BigInteger.prototype.not = function () {\r\n        return this.negate().prev();\r\n    };\r\n    NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\r\n\r\n    BigInteger.prototype.and = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a & b; });\r\n    };\r\n    NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\r\n\r\n    BigInteger.prototype.or = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a | b; });\r\n    };\r\n    NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\r\n\r\n    BigInteger.prototype.xor = function (n) {\r\n        return bitwise(this, n, function (a, b) { return a ^ b; });\r\n    };\r\n    NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\r\n\r\n    var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\r\n    function roughLOB(n) { // get lowestOneBit (rough)\r\n        // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\r\n        // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]\r\n        var v = n.value,\r\n            x = typeof v === \"number\" ? v | LOBMASK_I :\r\n                typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\r\n                    v[0] + v[1] * BASE | LOBMASK_BI;\r\n        return x & -x;\r\n    }\r\n\r\n    function integerLogarithm(value, base) {\r\n        if (base.compareTo(value) <= 0) {\r\n            var tmp = integerLogarithm(value, base.square(base));\r\n            var p = tmp.p;\r\n            var e = tmp.e;\r\n            var t = p.multiply(base);\r\n            return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\r\n        }\r\n        return { p: bigInt(1), e: 0 };\r\n    }\r\n\r\n    BigInteger.prototype.bitLength = function () {\r\n        var n = this;\r\n        if (n.compareTo(bigInt(0)) < 0) {\r\n            n = n.negate().subtract(bigInt(1));\r\n        }\r\n        if (n.compareTo(bigInt(0)) === 0) {\r\n            return bigInt(0);\r\n        }\r\n        return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\r\n    }\r\n    NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\r\n\r\n    function max(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.greater(b) ? a : b;\r\n    }\r\n    function min(a, b) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        return a.lesser(b) ? a : b;\r\n    }\r\n    function gcd(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        if (a.equals(b)) return a;\r\n        if (a.isZero()) return b;\r\n        if (b.isZero()) return a;\r\n        var c = Integer[1], d, t;\r\n        while (a.isEven() && b.isEven()) {\r\n            d = min(roughLOB(a), roughLOB(b));\r\n            a = a.divide(d);\r\n            b = b.divide(d);\r\n            c = c.multiply(d);\r\n        }\r\n        while (a.isEven()) {\r\n            a = a.divide(roughLOB(a));\r\n        }\r\n        do {\r\n            while (b.isEven()) {\r\n                b = b.divide(roughLOB(b));\r\n            }\r\n            if (a.greater(b)) {\r\n                t = b; b = a; a = t;\r\n            }\r\n            b = b.subtract(a);\r\n        } while (!b.isZero());\r\n        return c.isUnit() ? a : a.multiply(c);\r\n    }\r\n    function lcm(a, b) {\r\n        a = parseValue(a).abs();\r\n        b = parseValue(b).abs();\r\n        return a.divide(gcd(a, b)).multiply(b);\r\n    }\r\n    function randBetween(a, b, rng) {\r\n        a = parseValue(a);\r\n        b = parseValue(b);\r\n        var usedRNG = rng || Math.random;\r\n        var low = min(a, b), high = max(a, b);\r\n        var range = high.subtract(low).add(1);\r\n        if (range.isSmall) return low.add(Math.floor(usedRNG() * range));\r\n        var digits = toBase(range, BASE).value;\r\n        var result = [], restricted = true;\r\n        for (var i = 0; i < digits.length; i++) {\r\n            var top = restricted ? digits[i] + (i + 1 < digits.length ? digits[i + 1] / BASE : 0) : BASE;\r\n            var digit = truncate(usedRNG() * top);\r\n            result.push(digit);\r\n            if (digit < digits[i]) restricted = false;\r\n        }\r\n        return low.add(Integer.fromArray(result, BASE, false));\r\n    }\r\n\r\n    var parseBase = function (text, base, alphabet, caseSensitive) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        text = String(text);\r\n        if (!caseSensitive) {\r\n            text = text.toLowerCase();\r\n            alphabet = alphabet.toLowerCase();\r\n        }\r\n        var length = text.length;\r\n        var i;\r\n        var absBase = Math.abs(base);\r\n        var alphabetValues = {};\r\n        for (i = 0; i < alphabet.length; i++) {\r\n            alphabetValues[alphabet[i]] = i;\r\n        }\r\n        for (i = 0; i < length; i++) {\r\n            var c = text[i];\r\n            if (c === \"-\") continue;\r\n            if (c in alphabetValues) {\r\n                if (alphabetValues[c] >= absBase) {\r\n                    if (c === \"1\" && absBase === 1) continue;\r\n                    throw new Error(c + \" is not a valid digit in base \" + base + \".\");\r\n                }\r\n            }\r\n        }\r\n        base = parseValue(base);\r\n        var digits = [];\r\n        var isNegative = text[0] === \"-\";\r\n        for (i = isNegative ? 1 : 0; i < text.length; i++) {\r\n            var c = text[i];\r\n            if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\r\n            else if (c === \"<\") {\r\n                var start = i;\r\n                do { i++; } while (text[i] !== \">\" && i < text.length);\r\n                digits.push(parseValue(text.slice(start + 1, i)));\r\n            }\r\n            else throw new Error(c + \" is not a valid character\");\r\n        }\r\n        return parseBaseFromArray(digits, base, isNegative);\r\n    };\r\n\r\n    function parseBaseFromArray(digits, base, isNegative) {\r\n        var val = Integer[0], pow = Integer[1], i;\r\n        for (i = digits.length - 1; i >= 0; i--) {\r\n            val = val.add(digits[i].times(pow));\r\n            pow = pow.times(base);\r\n        }\r\n        return isNegative ? val.negate() : val;\r\n    }\r\n\r\n    function stringify(digit, alphabet) {\r\n        alphabet = alphabet || DEFAULT_ALPHABET;\r\n        if (digit < alphabet.length) {\r\n            return alphabet[digit];\r\n        }\r\n        return \"<\" + digit + \">\";\r\n    }\r\n\r\n    function toBase(n, base) {\r\n        base = bigInt(base);\r\n        if (base.isZero()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            throw new Error(\"Cannot convert nonzero numbers to base 0.\");\r\n        }\r\n        if (base.equals(-1)) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n            if (n.isNegative())\r\n                return {\r\n                    value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\r\n                        .map(Array.prototype.valueOf, [1, 0])\r\n                    ),\r\n                    isNegative: false\r\n                };\r\n\r\n            var arr = Array.apply(null, Array(n.toJSNumber() - 1))\r\n                .map(Array.prototype.valueOf, [0, 1]);\r\n            arr.unshift([1]);\r\n            return {\r\n                value: [].concat.apply([], arr),\r\n                isNegative: false\r\n            };\r\n        }\r\n\r\n        var neg = false;\r\n        if (n.isNegative() && base.isPositive()) {\r\n            neg = true;\r\n            n = n.abs();\r\n        }\r\n        if (base.isUnit()) {\r\n            if (n.isZero()) return { value: [0], isNegative: false };\r\n\r\n            return {\r\n                value: Array.apply(null, Array(n.toJSNumber()))\r\n                    .map(Number.prototype.valueOf, 1),\r\n                isNegative: neg\r\n            };\r\n        }\r\n        var out = [];\r\n        var left = n, divmod;\r\n        while (left.isNegative() || left.compareAbs(base) >= 0) {\r\n            divmod = left.divmod(base);\r\n            left = divmod.quotient;\r\n            var digit = divmod.remainder;\r\n            if (digit.isNegative()) {\r\n                digit = base.minus(digit).abs();\r\n                left = left.next();\r\n            }\r\n            out.push(digit.toJSNumber());\r\n        }\r\n        out.push(left.toJSNumber());\r\n        return { value: out.reverse(), isNegative: neg };\r\n    }\r\n\r\n    function toBaseString(n, base, alphabet) {\r\n        var arr = toBase(n, base);\r\n        return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\r\n            return stringify(x, alphabet);\r\n        }).join('');\r\n    }\r\n\r\n    BigInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    SmallInteger.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    NativeBigInt.prototype.toArray = function (radix) {\r\n        return toBase(this, radix);\r\n    };\r\n\r\n    BigInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix !== 10) return toBaseString(this, radix, alphabet);\r\n        var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\r\n        while (--l >= 0) {\r\n            digit = String(v[l]);\r\n            str += zeros.slice(digit.length) + digit;\r\n        }\r\n        var sign = this.sign ? \"-\" : \"\";\r\n        return sign + str;\r\n    };\r\n\r\n    SmallInteger.prototype.toString = function (radix, alphabet) {\r\n        if (radix === undefined) radix = 10;\r\n        if (radix != 10) return toBaseString(this, radix, alphabet);\r\n        return String(this.value);\r\n    };\r\n\r\n    NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\r\n\r\n    NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\r\n\r\n    BigInteger.prototype.valueOf = function () {\r\n        return parseInt(this.toString(), 10);\r\n    };\r\n    BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\r\n\r\n    SmallInteger.prototype.valueOf = function () {\r\n        return this.value;\r\n    };\r\n    SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\r\n    NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\r\n        return parseInt(this.toString(), 10);\r\n    }\r\n\r\n    function parseStringValue(v) {\r\n        if (isPrecise(+v)) {\r\n            var x = +v;\r\n            if (x === truncate(x))\r\n                return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\r\n            throw new Error(\"Invalid integer: \" + v);\r\n        }\r\n        var sign = v[0] === \"-\";\r\n        if (sign) v = v.slice(1);\r\n        var split = v.split(/e/i);\r\n        if (split.length > 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\r\n        if (split.length === 2) {\r\n            var exp = split[1];\r\n            if (exp[0] === \"+\") exp = exp.slice(1);\r\n            exp = +exp;\r\n            if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\r\n            var text = split[0];\r\n            var decimalPlace = text.indexOf(\".\");\r\n            if (decimalPlace >= 0) {\r\n                exp -= text.length - decimalPlace - 1;\r\n                text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\r\n            }\r\n            if (exp < 0) throw new Error(\"Cannot include negative exponent part for integers\");\r\n            text += (new Array(exp + 1)).join(\"0\");\r\n            v = text;\r\n        }\r\n        var isValid = /^([0-9][0-9]*)$/.test(v);\r\n        if (!isValid) throw new Error(\"Invalid integer: \" + v);\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\r\n        }\r\n        var r = [], max = v.length, l = LOG_BASE, min = max - l;\r\n        while (max > 0) {\r\n            r.push(+v.slice(min, max));\r\n            min -= l;\r\n            if (min < 0) min = 0;\r\n            max -= l;\r\n        }\r\n        trim(r);\r\n        return new BigInteger(r, sign);\r\n    }\r\n\r\n    function parseNumberValue(v) {\r\n        if (supportsNativeBigInt) {\r\n            return new NativeBigInt(BigInt(v));\r\n        }\r\n        if (isPrecise(v)) {\r\n            if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\r\n            return new SmallInteger(v);\r\n        }\r\n        return parseStringValue(v.toString());\r\n    }\r\n\r\n    function parseValue(v) {\r\n        if (typeof v === \"number\") {\r\n            return parseNumberValue(v);\r\n        }\r\n        if (typeof v === \"string\") {\r\n            return parseStringValue(v);\r\n        }\r\n        if (typeof v === \"bigint\") {\r\n            return new NativeBigInt(v);\r\n        }\r\n        return v;\r\n    }\r\n    // Pre-define numbers in range [-999,999]\r\n    for (var i = 0; i < 1000; i++) {\r\n        Integer[i] = parseValue(i);\r\n        if (i > 0) Integer[-i] = parseValue(-i);\r\n    }\r\n    // Backwards compatibility\r\n    Integer.one = Integer[1];\r\n    Integer.zero = Integer[0];\r\n    Integer.minusOne = Integer[-1];\r\n    Integer.max = max;\r\n    Integer.min = min;\r\n    Integer.gcd = gcd;\r\n    Integer.lcm = lcm;\r\n    Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\r\n    Integer.randBetween = randBetween;\r\n\r\n    Integer.fromArray = function (digits, base, isNegative) {\r\n        return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\r\n    };\r\n\r\n    return Integer;\r\n})();\r\n\r\n// Node.js check\r\nif (typeof module !== \"undefined\" && module.hasOwnProperty(\"exports\")) {\r\n    module.exports = bigInt;\r\n}\r\n\r\n//amd check\r\nif (typeof define === \"function\" && define.amd) {\r\n    define( function () {\r\n        return bigInt;\r\n    });\r\n}\r\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst cashaddr = require('./cashaddr');\nconst networks = require('./networks');\nconst payments = require('./payments');\nconst bscript = require('./script');\nconst types = require('./types');\nconst bech32 = require('bech32');\nconst bs58check = require('bs58check');\nconst typeforce = require('typeforce');\nfunction fromBase58Check(address) {\n  const isBCH = cashaddr.VALID_PREFIXES.indexOf(address.split(':')[0]) > -1;\n  if (isBCH) {\n    const result = cashaddr.decode(address);\n    let network;\n    switch (result.prefix) {\n      case 'bitcoincash':\n        network = networks.bitcoin;\n        break;\n      case 'bchtest':\n        network = networks.testnet;\n        break;\n      case 'bchreg':\n        network = networks.regtest;\n        break;\n    }\n    let version;\n    switch (result.type) {\n      case 'P2PKH':\n        version = network.pubKeyHash;\n        break;\n      case 'P2SH':\n        version = network.scriptHash;\n        break;\n    }\n    if (result.hash.length < 20) throw new TypeError(address + ' is too short');\n    if (result.hash.length > 20) throw new TypeError(address + ' is too long');\n    return {\n      version: version,\n      hash: Buffer.from(result.hash),\n    };\n  } else {\n    const payload = bs58check.decode(address);\n    // TODO: 4.0.0, move to \"toOutputScript\"\n    if (payload.length < 21) throw new TypeError(address + ' is too short');\n    if (payload.length > 21) throw new TypeError(address + ' is too long');\n    const version = payload.readUInt8(0);\n    const hash = payload.slice(1);\n    return { version, hash };\n  }\n}\nexports.fromBase58Check = fromBase58Check;\nfunction fromBech32(address) {\n  const result = bech32.decode(address);\n  const data = bech32.fromWords(result.words.slice(1));\n  return {\n    version: result.words[0],\n    prefix: result.prefix,\n    data: Buffer.from(data),\n  };\n}\nexports.fromBech32 = fromBech32;\nfunction toBase58Check(hash, version) {\n  typeforce(types.tuple(types.Hash160bit, types.UInt8), arguments);\n  const payload = Buffer.allocUnsafe(21);\n  payload.writeUInt8(version, 0);\n  hash.copy(payload, 1);\n  return bs58check.encode(payload);\n}\nexports.toBase58Check = toBase58Check;\nfunction toBech32(data, version, prefix) {\n  const words = bech32.toWords(data);\n  words.unshift(version);\n  return bech32.encode(prefix, words);\n}\nexports.toBech32 = toBech32;\nfunction fromOutputScript(output, network) {\n  // TODO: Network\n  network = network || networks.bitcoin;\n  try {\n    return payments.p2pkh({ output, network }).address;\n  } catch (e) {}\n  try {\n    return payments.p2sh({ output, network }).address;\n  } catch (e) {}\n  try {\n    return payments.p2wpkh({ output, network }).address;\n  } catch (e) {}\n  try {\n    return payments.p2wsh({ output, network }).address;\n  } catch (e) {}\n  throw new Error(bscript.toASM(output) + ' has no matching Address');\n}\nexports.fromOutputScript = fromOutputScript;\nfunction toOutputScript(address, network) {\n  network = network || networks.bitcoin;\n  let decodeBase58;\n  let decodeBech32;\n  try {\n    decodeBase58 = fromBase58Check(address);\n  } catch (e) {}\n  if (decodeBase58) {\n    if (decodeBase58.version === network.pubKeyHash)\n      return payments.p2pkh({ hash: decodeBase58.hash }).output;\n    if (decodeBase58.version === network.scriptHash)\n      return payments.p2sh({ hash: decodeBase58.hash }).output;\n  } else {\n    try {\n      decodeBech32 = fromBech32(address);\n    } catch (e) {}\n    if (decodeBech32) {\n      if (decodeBech32.prefix !== network.bech32)\n        throw new Error(address + ' has an invalid prefix');\n      if (decodeBech32.version === 0) {\n        if (decodeBech32.data.length === 20)\n          return payments.p2wpkh({ hash: decodeBech32.data }).output;\n        if (decodeBech32.data.length === 32)\n          return payments.p2wsh({ hash: decodeBech32.data }).output;\n      }\n    }\n  }\n  throw new Error(address + ' has no matching Script');\n}\nexports.toOutputScript = toOutputScript;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bufferutils_1 = require('./bufferutils');\nconst bcrypto = require('./crypto');\nconst transaction_1 = require('./transaction');\nconst types = require('./types');\nconst fastMerkleRoot = require('merkle-lib/fastRoot');\nconst typeforce = require('typeforce');\nconst varuint = require('varuint-bitcoin');\nconst errorMerkleNoTxes = new TypeError(\n  'Cannot compute merkle root for zero transactions',\n);\nconst errorWitnessNotSegwit = new TypeError(\n  'Cannot compute witness commit for non-segwit block',\n);\nclass Block {\n  constructor() {\n    this.version = 1;\n    this.prevHash = undefined;\n    this.merkleRoot = undefined;\n    this.timestamp = 0;\n    this.witnessCommit = undefined;\n    this.bits = 0;\n    this.nonce = 0;\n    this.transactions = undefined;\n  }\n  static fromBuffer(buffer) {\n    if (buffer.length < 80) throw new Error('Buffer too small (< 80 bytes)');\n    const bufferReader = new bufferutils_1.BufferReader(buffer);\n    const block = new Block();\n    block.version = bufferReader.readInt32();\n    block.prevHash = bufferReader.readSlice(32);\n    block.merkleRoot = bufferReader.readSlice(32);\n    block.timestamp = bufferReader.readUInt32();\n    block.bits = bufferReader.readUInt32();\n    block.nonce = bufferReader.readUInt32();\n    if (buffer.length === 80) return block;\n    const readTransaction = () => {\n      const tx = transaction_1.Transaction.fromBuffer(\n        bufferReader.buffer.slice(bufferReader.offset),\n        true,\n      );\n      bufferReader.offset += tx.byteLength();\n      return tx;\n    };\n    const nTransactions = bufferReader.readVarInt();\n    block.transactions = [];\n    for (let i = 0; i < nTransactions; ++i) {\n      const tx = readTransaction();\n      block.transactions.push(tx);\n    }\n    const witnessCommit = block.getWitnessCommit();\n    // This Block contains a witness commit\n    if (witnessCommit) block.witnessCommit = witnessCommit;\n    return block;\n  }\n  static fromHex(hex) {\n    return Block.fromBuffer(Buffer.from(hex, 'hex'));\n  }\n  static calculateTarget(bits) {\n    const exponent = ((bits & 0xff000000) >> 24) - 3;\n    const mantissa = bits & 0x007fffff;\n    const target = Buffer.alloc(32, 0);\n    target.writeUIntBE(mantissa, 29 - exponent, 3);\n    return target;\n  }\n  static calculateMerkleRoot(transactions, forWitness) {\n    typeforce([{ getHash: types.Function }], transactions);\n    if (transactions.length === 0) throw errorMerkleNoTxes;\n    if (forWitness && !txesHaveWitnessCommit(transactions))\n      throw errorWitnessNotSegwit;\n    const hashes = transactions.map(transaction =>\n      transaction.getHash(forWitness),\n    );\n    const rootHash = fastMerkleRoot(hashes, bcrypto.hash256);\n    return forWitness\n      ? bcrypto.hash256(\n          Buffer.concat([rootHash, transactions[0].ins[0].witness[0]]),\n        )\n      : rootHash;\n  }\n  getWitnessCommit() {\n    if (!txesHaveWitnessCommit(this.transactions)) return null;\n    // The merkle root for the witness data is in an OP_RETURN output.\n    // There is no rule for the index of the output, so use filter to find it.\n    // The root is prepended with 0xaa21a9ed so check for 0x6a24aa21a9ed\n    // If multiple commits are found, the output with highest index is assumed.\n    const witnessCommits = this.transactions[0].outs\n      .filter(out =>\n        out.script.slice(0, 6).equals(Buffer.from('6a24aa21a9ed', 'hex')),\n      )\n      .map(out => out.script.slice(6, 38));\n    if (witnessCommits.length === 0) return null;\n    // Use the commit with the highest output (should only be one though)\n    const result = witnessCommits[witnessCommits.length - 1];\n    if (!(result instanceof Buffer && result.length === 32)) return null;\n    return result;\n  }\n  hasWitnessCommit() {\n    if (\n      this.witnessCommit instanceof Buffer &&\n      this.witnessCommit.length === 32\n    )\n      return true;\n    if (this.getWitnessCommit() !== null) return true;\n    return false;\n  }\n  hasWitness() {\n    return anyTxHasWitness(this.transactions);\n  }\n  weight() {\n    const base = this.byteLength(false, false);\n    const total = this.byteLength(false, true);\n    return base * 3 + total;\n  }\n  byteLength(headersOnly, allowWitness = true) {\n    if (headersOnly || !this.transactions) return 80;\n    return (\n      80 +\n      varuint.encodingLength(this.transactions.length) +\n      this.transactions.reduce((a, x) => a + x.byteLength(allowWitness), 0)\n    );\n  }\n  getHash() {\n    return bcrypto.hash256(this.toBuffer(true));\n  }\n  getId() {\n    return bufferutils_1.reverseBuffer(this.getHash()).toString('hex');\n  }\n  getUTCDate() {\n    const date = new Date(0); // epoch\n    date.setUTCSeconds(this.timestamp);\n    return date;\n  }\n  // TODO: buffer, offset compatibility\n  toBuffer(headersOnly) {\n    const buffer = Buffer.allocUnsafe(this.byteLength(headersOnly));\n    const bufferWriter = new bufferutils_1.BufferWriter(buffer);\n    bufferWriter.writeInt32(this.version);\n    bufferWriter.writeSlice(this.prevHash);\n    bufferWriter.writeSlice(this.merkleRoot);\n    bufferWriter.writeUInt32(this.timestamp);\n    bufferWriter.writeUInt32(this.bits);\n    bufferWriter.writeUInt32(this.nonce);\n    if (headersOnly || !this.transactions) return buffer;\n    varuint.encode(this.transactions.length, buffer, bufferWriter.offset);\n    bufferWriter.offset += varuint.encode.bytes;\n    this.transactions.forEach(tx => {\n      const txSize = tx.byteLength(); // TODO: extract from toBuffer?\n      tx.toBuffer(buffer, bufferWriter.offset);\n      bufferWriter.offset += txSize;\n    });\n    return buffer;\n  }\n  toHex(headersOnly) {\n    return this.toBuffer(headersOnly).toString('hex');\n  }\n  checkTxRoots() {\n    // If the Block has segwit transactions but no witness commit,\n    // there's no way it can be valid, so fail the check.\n    const hasWitnessCommit = this.hasWitnessCommit();\n    if (!hasWitnessCommit && this.hasWitness()) return false;\n    return (\n      this.__checkMerkleRoot() &&\n      (hasWitnessCommit ? this.__checkWitnessCommit() : true)\n    );\n  }\n  checkProofOfWork() {\n    const hash = bufferutils_1.reverseBuffer(this.getHash());\n    const target = Block.calculateTarget(this.bits);\n    return hash.compare(target) <= 0;\n  }\n  __checkMerkleRoot() {\n    if (!this.transactions) throw errorMerkleNoTxes;\n    const actualMerkleRoot = Block.calculateMerkleRoot(this.transactions);\n    return this.merkleRoot.compare(actualMerkleRoot) === 0;\n  }\n  __checkWitnessCommit() {\n    if (!this.transactions) throw errorMerkleNoTxes;\n    if (!this.hasWitnessCommit()) throw errorWitnessNotSegwit;\n    const actualWitnessCommit = Block.calculateMerkleRoot(\n      this.transactions,\n      true,\n    );\n    return this.witnessCommit.compare(actualWitnessCommit) === 0;\n  }\n}\nexports.Block = Block;\nfunction txesHaveWitnessCommit(transactions) {\n  return (\n    transactions instanceof Array &&\n    transactions[0] &&\n    transactions[0].ins &&\n    transactions[0].ins instanceof Array &&\n    transactions[0].ins[0] &&\n    transactions[0].ins[0].witness &&\n    transactions[0].ins[0].witness instanceof Array &&\n    transactions[0].ins[0].witness.length > 0\n  );\n}\nfunction anyTxHasWitness(transactions) {\n  return (\n    transactions instanceof Array &&\n    transactions.some(\n      tx =>\n        typeof tx === 'object' &&\n        tx.ins instanceof Array &&\n        tx.ins.some(\n          input =>\n            typeof input === 'object' &&\n            input.witness instanceof Array &&\n            input.witness.length > 0,\n        ),\n    )\n  );\n}\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst types = require('./types');\nconst typeforce = require('typeforce');\nconst varuint = require('varuint-bitcoin');\n// https://github.com/feross/buffer/blob/master/index.js#L1127\nfunction verifuint(value, max) {\n  if (typeof value !== 'number')\n    throw new Error('cannot write a non-number as a number');\n  if (value < 0)\n    throw new Error('specified a negative value for writing an unsigned value');\n  if (value > max) throw new Error('RangeError: value out of range');\n  if (Math.floor(value) !== value)\n    throw new Error('value has a fractional component');\n}\nfunction readUInt64LE(buffer, offset) {\n  const a = buffer.readUInt32LE(offset);\n  let b = buffer.readUInt32LE(offset + 4);\n  b *= 0x100000000;\n  verifuint(b + a, 0x001fffffffffffff);\n  return b + a;\n}\nexports.readUInt64LE = readUInt64LE;\nfunction writeUInt64LE(buffer, value, offset) {\n  verifuint(value, 0x001fffffffffffff);\n  buffer.writeInt32LE(value & -1, offset);\n  buffer.writeUInt32LE(Math.floor(value / 0x100000000), offset + 4);\n  return offset + 8;\n}\nexports.writeUInt64LE = writeUInt64LE;\nfunction reverseBuffer(buffer) {\n  if (buffer.length < 1) return buffer;\n  let j = buffer.length - 1;\n  let tmp = 0;\n  for (let i = 0; i < buffer.length / 2; i++) {\n    tmp = buffer[i];\n    buffer[i] = buffer[j];\n    buffer[j] = tmp;\n    j--;\n  }\n  return buffer;\n}\nexports.reverseBuffer = reverseBuffer;\nfunction cloneBuffer(buffer) {\n  const clone = Buffer.allocUnsafe(buffer.length);\n  buffer.copy(clone);\n  return clone;\n}\nexports.cloneBuffer = cloneBuffer;\n/**\n * Helper class for serialization of bitcoin data types into a pre-allocated buffer.\n */\nclass BufferWriter {\n  constructor(buffer, offset = 0) {\n    this.buffer = buffer;\n    this.offset = offset;\n    typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);\n  }\n  writeUInt8(i) {\n    this.offset = this.buffer.writeUInt8(i, this.offset);\n  }\n  writeInt32(i) {\n    this.offset = this.buffer.writeInt32LE(i, this.offset);\n  }\n  writeUInt32(i) {\n    this.offset = this.buffer.writeUInt32LE(i, this.offset);\n  }\n  writeUInt64(i) {\n    this.offset = writeUInt64LE(this.buffer, i, this.offset);\n  }\n  writeVarInt(i) {\n    varuint.encode(i, this.buffer, this.offset);\n    this.offset += varuint.encode.bytes;\n  }\n  writeSlice(slice) {\n    if (this.buffer.length < this.offset + slice.length) {\n      throw new Error('Cannot write slice out of bounds');\n    }\n    this.offset += slice.copy(this.buffer, this.offset);\n  }\n  writeVarSlice(slice) {\n    this.writeVarInt(slice.length);\n    this.writeSlice(slice);\n  }\n  writeVector(vector) {\n    this.writeVarInt(vector.length);\n    vector.forEach(buf => this.writeVarSlice(buf));\n  }\n}\nexports.BufferWriter = BufferWriter;\n/**\n * Helper class for reading of bitcoin data types from a buffer.\n */\nclass BufferReader {\n  constructor(buffer, offset = 0) {\n    this.buffer = buffer;\n    this.offset = offset;\n    typeforce(types.tuple(types.Buffer, types.UInt32), [buffer, offset]);\n  }\n  readUInt8() {\n    const result = this.buffer.readUInt8(this.offset);\n    this.offset++;\n    return result;\n  }\n  readInt32() {\n    const result = this.buffer.readInt32LE(this.offset);\n    this.offset += 4;\n    return result;\n  }\n  readUInt32() {\n    const result = this.buffer.readUInt32LE(this.offset);\n    this.offset += 4;\n    return result;\n  }\n  readUInt64() {\n    const result = readUInt64LE(this.buffer, this.offset);\n    this.offset += 8;\n    return result;\n  }\n  readVarInt() {\n    const vi = varuint.decode(this.buffer, this.offset);\n    this.offset += varuint.decode.bytes;\n    return vi;\n  }\n  readSlice(n) {\n    if (this.buffer.length < this.offset + n) {\n      throw new Error('Cannot read slice out of bounds');\n    }\n    const result = this.buffer.slice(this.offset, this.offset + n);\n    this.offset += n;\n    return result;\n  }\n  readVarSlice() {\n    return this.readSlice(this.readVarInt());\n  }\n  readVector() {\n    const count = this.readVarInt();\n    const vector = [];\n    for (let i = 0; i < count; i++) vector.push(this.readVarSlice());\n    return vector;\n  }\n}\nexports.BufferReader = BufferReader;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\n/**\n * @license\n * https://github.com/bitcoincashjs/cashaddr\n * Copyright (c) 2017-2018 Emilio Almansi\n * Distributed under the MIT software license, see the accompanying\n * file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n */\nconst validation_1 = require('./validation');\n/**\n * Base32 encoding and decoding.\n *\n * @module base32\n */\n/**\n * Charset containing the 32 symbols used in the base32 encoding.\n * @private\n */\nconst CHARSET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';\n/**\n * Inverted index mapping each symbol into its index within the charset.\n * @private\n */\nconst CHARSET_INVERSE_INDEX = {\n  q: 0,\n  p: 1,\n  z: 2,\n  r: 3,\n  y: 4,\n  9: 5,\n  x: 6,\n  8: 7,\n  g: 8,\n  f: 9,\n  2: 10,\n  t: 11,\n  v: 12,\n  d: 13,\n  w: 14,\n  0: 15,\n  s: 16,\n  3: 17,\n  j: 18,\n  n: 19,\n  5: 20,\n  4: 21,\n  k: 22,\n  h: 23,\n  c: 24,\n  e: 25,\n  6: 26,\n  m: 27,\n  u: 28,\n  a: 29,\n  7: 30,\n  l: 31,\n};\n/**\n * Encodes the given array of 5-bit integers as a base32-encoded string.\n *\n * @static\n * @param {Uint8Array} data Array of integers between 0 and 31 inclusive.\n * @returns {string}\n * @throws {ValidationError}\n */\nfunction encode(data) {\n  validation_1.validate(\n    data instanceof Uint8Array,\n    'Invalid data: ' + data + '.',\n  );\n  let base32 = '';\n  for (const value of data) {\n    validation_1.validate(\n      0 <= value && value < 32,\n      'Invalid value: ' + value + '.',\n    );\n    base32 += CHARSET[value];\n  }\n  return base32;\n}\nexports.encode = encode;\n/**\n * Decodes the given base32-encoded string into an array of 5-bit integers.\n *\n * @static\n * @param {string} string\n * @returns {Uint8Array}\n * @throws {ValidationError}\n */\nfunction decode(strng) {\n  validation_1.validate(\n    typeof strng === 'string',\n    'Invalid base32-encoded string: ' + strng + '.',\n  );\n  const data = new Uint8Array(strng.length);\n  for (let i = 0; i < strng.length; ++i) {\n    const value = strng[i];\n    validation_1.validate(\n      value in CHARSET_INVERSE_INDEX,\n      'Invalid value: ' + value + '.',\n    );\n    data[i] = CHARSET_INVERSE_INDEX[value];\n  }\n  return data;\n}\nexports.decode = decode;\n","'use strict';\n// Copyright (c) 2017-2018 Emilio Almansi\n// Copyright (c) 2017 Pieter Wuille\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\nObject.defineProperty(exports, '__esModule', { value: true });\nconst validation_1 = require('./validation');\n/**\n * Converts an array of integers made up of 'from' bits into an\n * array of integers made up of 'to' bits. The output array is\n * zero-padded if necessary, unless strict mode is true.\n * Throws a {@link ValidationError} if input is invalid.\n * Original by Pieter Wuille: https://github.com/sipa/bech32.\n *\n * @param {Uint8Array} data Array of integers made up of 'from' bits.\n * @param {number} from Length in bits of elements in the input array.\n * @param {number} to Length in bits of elements in the output array.\n * @param {bool} strictMode Require the conversion to be completed without padding.\n * @returns {Uint8Array}\n */\nfunction convertBits(data, from, to, strictMode) {\n  const length = strictMode\n    ? Math.floor((data.length * from) / to)\n    : Math.ceil((data.length * from) / to);\n  const mask = (1 << to) - 1;\n  const result = new Uint8Array(length);\n  let index = 0;\n  let accumulator = 0;\n  let bits = 0;\n  for (const value of data) {\n    validation_1.validate(\n      0 <= value && value >> from === 0,\n      'Invalid value: ' + value + '.',\n    );\n    accumulator = (accumulator << from) | value;\n    bits += from;\n    while (bits >= to) {\n      bits -= to;\n      result[index] = (accumulator >> bits) & mask;\n      ++index;\n    }\n  }\n  if (!strictMode) {\n    if (bits > 0) {\n      result[index] = (accumulator << (to - bits)) & mask;\n      ++index;\n    }\n  } else {\n    validation_1.validate(\n      bits < from && ((accumulator << (to - bits)) & mask) === 0,\n      'Input cannot be converted to ' +\n        to +\n        ' bits without padding, but strict mode was used.',\n    );\n  }\n  return result;\n}\nexports.convertBits = convertBits;\n","'use strict';\n/**\n * @license\n * https://github.com/bitcoincashjs/cashaddr\n * Copyright (c) 2017-2018 Emilio Almansi\n * Distributed under the MIT software license, see the accompanying\n * file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n */\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bigInt = require('big-integer');\nconst base32 = require('./base32');\nconst convertBits_1 = require('./convertBits');\nconst validation = require('./validation');\nconst validate = validation.validate;\n/**\n * Encoding and decoding of the new Cash Address format for Bitcoin Cash. <br />\n * Compliant with the original cashaddr specification:\n * {@link https://github.com/Bitcoin-UAHF/spec/blob/master/cashaddr.md}\n * @module cashaddr\n */\n/**\n * Encodes a hash from a given type into a Bitcoin Cash address with the given prefix.\n *\n * @static\n * @param {string} prefix Network prefix. E.g.: 'bitcoincash'.\n * @param {string} type Type of address to generate. Either 'P2PKH' or 'P2SH'.\n * @param {Uint8Array} hash Hash to encode represented as an array of 8-bit integers.\n * @returns {string}\n * @throws {ValidationError}\n */\nfunction encode(prefix, type, hash) {\n  validate(\n    typeof prefix === 'string' && isValidPrefix(prefix),\n    'Invalid prefix: ' + prefix + '.',\n  );\n  validate(typeof type === 'string', 'Invalid type: ' + type + '.');\n  validate(hash instanceof Uint8Array, 'Invalid hash: ' + hash + '.');\n  const prefixData = concat(prefixToUint5Array(prefix), new Uint8Array(1));\n  const versionByte = getTypeBits(type) + getHashSizeBits(hash);\n  const payloadData = toUint5Array(concat(new Uint8Array([versionByte]), hash));\n  const checksumData = concat(\n    concat(prefixData, payloadData),\n    new Uint8Array(8),\n  );\n  const payload = concat(\n    payloadData,\n    checksumToUint5Array(polymod(checksumData)),\n  );\n  return prefix + ':' + base32.encode(payload);\n}\nexports.encode = encode;\n/**\n * Decodes the given address into its constituting prefix, type and hash. See [#encode()]{@link encode}.\n *\n * @static\n * @param {string} address Address to decode. E.g.: 'bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a'.\n * @returns {object}\n * @throws {ValidationError}\n */\nfunction decode(address) {\n  validate(\n    typeof address === 'string' && hasSingleCase(address),\n    'Invalid address: ' + address + '.',\n  );\n  const pieces = address.toLowerCase().split(':');\n  validate(pieces.length === 2, 'Missing prefix: ' + address + '.');\n  const prefix = pieces[0];\n  const payload = base32.decode(pieces[1]);\n  validate(\n    validChecksum(prefix, payload),\n    'Invalid checksum: ' + address + '.',\n  );\n  const payloadData = fromUint5Array(payload.subarray(0, -8));\n  const versionByte = payloadData[0];\n  const hash = payloadData.subarray(1);\n  validate(\n    getHashSize(versionByte) === hash.length * 8,\n    'Invalid hash size: ' + address + '.',\n  );\n  const type = getType(versionByte);\n  return {\n    prefix,\n    type,\n    hash,\n  };\n}\nexports.decode = decode;\n/**\n * Error thrown when encoding or decoding fail due to invalid input.\n *\n * @constructor ValidationError\n * @param {string} message Error description.\n */\nexports.ValidationError = validation.ValidationError;\n/**\n * Valid address prefixes.\n *\n * @private\n */\nexports.VALID_PREFIXES = ['bitcoincash', 'bchtest', 'bchreg'];\n/**\n * Checks whether a string is a valid prefix; ie., it has a single letter case\n * and is one of 'bitcoincash', 'bchtest', or 'bchreg'.\n *\n * @private\n * @param {string} prefix\n * @returns {boolean}\n */\nfunction isValidPrefix(prefix) {\n  return (\n    hasSingleCase(prefix) &&\n    exports.VALID_PREFIXES.indexOf(prefix.toLowerCase()) !== -1\n  );\n}\n/**\n * Derives an array from the given prefix to be used in the computation\n * of the address' checksum.\n *\n * @private\n * @param {string} prefix Network prefix. E.g.: 'bitcoincash'.\n * @returns {Uint8Array}\n */\nfunction prefixToUint5Array(prefix) {\n  const result = new Uint8Array(prefix.length);\n  for (let i = 0; i < prefix.length; ++i) {\n    result[i] = prefix[i].charCodeAt(0) & 31;\n  }\n  return result;\n}\n/**\n * Returns an array representation of the given checksum to be encoded\n * within the address' payload.\n *\n * @private\n * @param {BigInteger} checksum Computed checksum.\n * @returns {Uint8Array}\n */\nfunction checksumToUint5Array(checksum) {\n  const result = new Uint8Array(8);\n  for (let i = 0; i < 8; ++i) {\n    result[7 - i] = checksum.and(31).toJSNumber();\n    checksum = checksum.shiftRight(5);\n  }\n  return result;\n}\n/**\n * Returns the bit representation of the given type within the version\n * byte.\n *\n * @private\n * @param {string} type Address type. Either 'P2PKH' or 'P2SH'.\n * @returns {number}\n * @throws {ValidationError}\n */\nfunction getTypeBits(type) {\n  switch (type) {\n    case 'P2PKH':\n      return 0;\n    case 'P2SH':\n      return 8;\n    default:\n      throw new exports.ValidationError('Invalid type: ' + type + '.');\n  }\n}\n/**\n * Retrieves the address type from its bit representation within the\n * version byte.\n *\n * @private\n * @param {number} versionByte\n * @returns {string}\n * @throws {ValidationError}\n */\nfunction getType(versionByte) {\n  switch (versionByte & 0x78) {\n    case 0:\n      return 'P2PKH';\n    case 8:\n      return 'P2SH';\n    default:\n      throw new exports.ValidationError(\n        'Invalid address type in version byte: ' + versionByte + '.',\n      );\n  }\n}\n/**\n * Returns the bit representation of the length in bits of the given\n * hash within the version byte.\n *\n * @private\n * @param {Uint8Array} hash Hash to encode represented as an array of 8-bit integers.\n * @returns {number}\n * @throws {ValidationError}\n */\nfunction getHashSizeBits(hash) {\n  switch (hash.length * 8) {\n    case 160:\n      return 0;\n    case 192:\n      return 1;\n    case 224:\n      return 2;\n    case 256:\n      return 3;\n    case 320:\n      return 4;\n    case 384:\n      return 5;\n    case 448:\n      return 6;\n    case 512:\n      return 7;\n    default:\n      throw new exports.ValidationError(\n        'Invalid hash size: ' + hash.length + '.',\n      );\n  }\n}\n/**\n * Retrieves the the length in bits of the encoded hash from its bit\n * representation within the version byte.\n *\n * @private\n * @param {number} versionByte\n * @returns {number}\n * @throws {ValidationError}\n */\nfunction getHashSize(versionByte) {\n  switch (versionByte & 7) {\n    case 0:\n      return 160;\n    case 1:\n      return 192;\n    case 2:\n      return 224;\n    case 3:\n      return 256;\n    case 4:\n      return 320;\n    case 5:\n      return 384;\n    case 6:\n      return 448;\n    case 7:\n      return 512;\n    default:\n      throw new exports.ValidationError(\n        'Invalid versionByte: ' + (versionByte & 7) + '.',\n      );\n  }\n}\n/**\n * Converts an array of 8-bit integers into an array of 5-bit integers,\n * right-padding with zeroes if necessary.\n *\n * @private\n * @param {Uint8Array} data\n * @returns {Uint8Array}\n */\nfunction toUint5Array(data) {\n  return convertBits_1.convertBits(data, 8, 5);\n}\n/**\n * Converts an array of 5-bit integers back into an array of 8-bit integers,\n * removing extra zeroes left from padding if necessary.\n * Throws a {@link ValidationError} if input is not a zero-padded array of 8-bit integers.\n *\n * @private\n * @param {Uint8Array} data\n * @returns {Uint8Array}\n * @throws {ValidationError}\n */\nfunction fromUint5Array(data) {\n  return convertBits_1.convertBits(data, 5, 8, true);\n}\n/**\n * Returns the concatenation a and b.\n *\n * @private\n * @param {Uint8Array} a\n * @param {Uint8Array} b\n * @returns {Uint8Array}\n * @throws {ValidationError}\n */\nfunction concat(a, b) {\n  const ab = new Uint8Array(a.length + b.length);\n  ab.set(a);\n  ab.set(b, a.length);\n  return ab;\n}\n/**\n * Computes a checksum from the given input data as specified for the CashAddr\n * format: https://github.com/Bitcoin-UAHF/spec/blob/master/cashaddr.md.\n *\n * @private\n * @param {Uint8Array} data Array of 5-bit integers over which the checksum is to be computed.\n * @returns {BigInteger}\n */\nfunction polymod(data) {\n  const GENERATOR = [\n    0x98f2bc8e61,\n    0x79b76d99e2,\n    0xf33e5fb3c4,\n    0xae2eabe2a8,\n    0x1e4f43e470,\n  ];\n  let checksum = bigInt(1);\n  for (const value of data) {\n    const topBits = checksum.shiftRight(35);\n    checksum = checksum\n      .and(0x07ffffffff)\n      .shiftLeft(5)\n      .xor(value);\n    for (let j = 0; j < GENERATOR.length; ++j) {\n      if (\n        topBits\n          .shiftRight(j)\n          .and(1)\n          .equals(1)\n      ) {\n        checksum = checksum.xor(GENERATOR[j]);\n      }\n    }\n  }\n  return checksum.xor(1);\n}\n/**\n * Verify that the payload has not been corrupted by checking that the\n * checksum is valid.\n *\n * @private\n * @param {string} prefix Network prefix. E.g.: 'bitcoincash'.\n * @param {Uint8Array} payload Array of 5-bit integers containing the address' payload.\n * @returns {boolean}\n */\nfunction validChecksum(prefix, payload) {\n  const prefixData = concat(prefixToUint5Array(prefix), new Uint8Array(1));\n  const checksumData = concat(prefixData, payload);\n  return polymod(checksumData).equals(0);\n}\n/**\n * Returns true if, and only if, the given string contains either uppercase\n * or lowercase letters, but not both.\n *\n * @private\n * @param {string} string Input string.\n * @returns {boolean}\n */\nfunction hasSingleCase(strng) {\n  return strng === strng.toLowerCase() || strng === strng.toUpperCase();\n}\n","'use strict';\n/**\n * @license\n * https://github.com/bitcoincashjs/cashaddr\n * Copyright (c) 2017-2018 Emilio Almansi\n * Distributed under the MIT software license, see the accompanying\n * file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n */\nObject.defineProperty(exports, '__esModule', { value: true });\n/**\n * Validation utility.\n *\n * @module validation\n */\n/**\n * Error thrown when encoding or decoding fail due to invalid input.\n *\n * @constructor ValidationError\n * @param {string} message Error description.\n */\nclass ValidationError extends Error {\n  constructor(message) {\n    super(message);\n    this.name = 'ValidationError';\n    Object.setPrototypeOf(this, ValidationError.prototype);\n  }\n}\nexports.ValidationError = ValidationError;\n/**\n * Validates a given condition, throwing a {@link ValidationError} if\n * the given condition does not hold.\n *\n * @static\n * @param {boolean} condition Condition to validate.\n * @param {string} message Error message in case the condition does not hold.\n */\nfunction validate(condition, message) {\n  if (!condition) {\n    throw new ValidationError(message);\n  }\n}\nexports.validate = validate;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst script_1 = require('./script');\nconst multisig = require('./templates/multisig');\nconst nullData = require('./templates/nulldata');\nconst pubKey = require('./templates/pubkey');\nconst pubKeyHash = require('./templates/pubkeyhash');\nconst scriptHash = require('./templates/scripthash');\nconst witnessCommitment = require('./templates/witnesscommitment');\nconst witnessPubKeyHash = require('./templates/witnesspubkeyhash');\nconst witnessScriptHash = require('./templates/witnessscripthash');\nconst types = {\n  P2MS: 'multisig',\n  NONSTANDARD: 'nonstandard',\n  NULLDATA: 'nulldata',\n  P2PK: 'pubkey',\n  P2PKH: 'pubkeyhash',\n  P2SH: 'scripthash',\n  P2WPKH: 'witnesspubkeyhash',\n  P2WSH: 'witnessscripthash',\n  WITNESS_COMMITMENT: 'witnesscommitment',\n};\nexports.types = types;\nfunction classifyOutput(script) {\n  if (witnessPubKeyHash.output.check(script)) return types.P2WPKH;\n  if (witnessScriptHash.output.check(script)) return types.P2WSH;\n  if (pubKeyHash.output.check(script)) return types.P2PKH;\n  if (scriptHash.output.check(script)) return types.P2SH;\n  // XXX: optimization, below functions .decompile before use\n  const chunks = script_1.decompile(script);\n  if (!chunks) throw new TypeError('Invalid script');\n  if (multisig.output.check(chunks)) return types.P2MS;\n  if (pubKey.output.check(chunks)) return types.P2PK;\n  if (witnessCommitment.output.check(chunks)) return types.WITNESS_COMMITMENT;\n  if (nullData.output.check(chunks)) return types.NULLDATA;\n  return types.NONSTANDARD;\n}\nexports.output = classifyOutput;\nfunction classifyInput(script, allowIncomplete) {\n  // XXX: optimization, below functions .decompile before use\n  const chunks = script_1.decompile(script);\n  if (!chunks) throw new TypeError('Invalid script');\n  if (pubKeyHash.input.check(chunks)) return types.P2PKH;\n  if (scriptHash.input.check(chunks, allowIncomplete)) return types.P2SH;\n  if (multisig.input.check(chunks, allowIncomplete)) return types.P2MS;\n  if (pubKey.input.check(chunks)) return types.P2PK;\n  return types.NONSTANDARD;\n}\nexports.input = classifyInput;\nfunction classifyWitness(script, allowIncomplete) {\n  // XXX: optimization, below functions .decompile before use\n  const chunks = script_1.decompile(script);\n  if (!chunks) throw new TypeError('Invalid script');\n  if (witnessPubKeyHash.input.check(chunks)) return types.P2WPKH;\n  if (witnessScriptHash.input.check(chunks, allowIncomplete))\n    return types.P2WSH;\n  return types.NONSTANDARD;\n}\nexports.witness = classifyWitness;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst createHash = require('create-hash');\nconst AlgorithmLength = {\n  ripemd160: 20,\n  sha1: 20,\n  sha256: 32,\n  hash160: 20,\n  hash256: 32,\n};\nfunction asDigest(buffer, preimage, algorithm) {\n  const out = Object.assign(buffer, {\n    preimage,\n    algorithm,\n  });\n  const expectedLength = AlgorithmLength[algorithm];\n  if (out.length !== expectedLength) throw new Error('bad digest length');\n  return out;\n}\nfunction ripemd160(buffer) {\n  let out;\n  try {\n    out = createHash('rmd160')\n      .update(buffer)\n      .digest();\n  } catch (err) {\n    out = createHash('ripemd160')\n      .update(buffer)\n      .digest();\n  }\n  return asDigest(out, buffer, 'ripemd160');\n}\nexports.ripemd160 = ripemd160;\nfunction sha1(buffer) {\n  const out = createHash('sha1')\n    .update(buffer)\n    .digest();\n  return asDigest(out, buffer, 'sha1');\n}\nexports.sha1 = sha1;\nfunction sha256(buffer) {\n  const out = createHash('sha256')\n    .update(buffer)\n    .digest();\n  return asDigest(out, buffer, 'sha256');\n}\nexports.sha256 = sha256;\nfunction hash160(buffer) {\n  const out = ripemd160(sha256(buffer));\n  return asDigest(out, buffer, 'hash160');\n}\nexports.hash160 = hash160;\nfunction hash256(buffer) {\n  const out = sha256(sha256(buffer));\n  return asDigest(out, buffer, 'hash256');\n}\nexports.hash256 = hash256;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst NETWORKS = require('./networks');\nconst types = require('./types');\nconst ecc = require('tiny-secp256k1');\nconst randomBytes = require('randombytes');\nconst typeforce = require('typeforce');\nconst wif = require('wif');\nconst isOptions = typeforce.maybe(\n  typeforce.compile({\n    compressed: types.maybe(types.Boolean),\n    network: types.maybe(types.Network),\n  }),\n);\nclass ECPair {\n  constructor(__D, __Q, options) {\n    this.__D = __D;\n    this.__Q = __Q;\n    this.lowR = false;\n    if (options === undefined) options = {};\n    this.compressed =\n      options.compressed === undefined ? true : options.compressed;\n    this.network = options.network || NETWORKS.bitcoin;\n    if (__Q !== undefined) this.__Q = ecc.pointCompress(__Q, this.compressed);\n  }\n  get privateKey() {\n    return this.__D;\n  }\n  get publicKey() {\n    if (!this.__Q) this.__Q = ecc.pointFromScalar(this.__D, this.compressed);\n    return this.__Q;\n  }\n  toWIF() {\n    if (!this.__D) throw new Error('Missing private key');\n    return wif.encode(this.network.wif, this.__D, this.compressed);\n  }\n  sign(hash, lowR) {\n    if (!this.__D) throw new Error('Missing private key');\n    if (lowR === undefined) lowR = this.lowR;\n    if (lowR === false) {\n      return ecc.sign(hash, this.__D);\n    } else {\n      let sig = ecc.sign(hash, this.__D);\n      const extraData = Buffer.alloc(32, 0);\n      let counter = 0;\n      // if first try is lowR, skip the loop\n      // for second try and on, add extra entropy counting up\n      while (sig[0] > 0x7f) {\n        counter++;\n        extraData.writeUIntLE(counter, 0, 6);\n        sig = ecc.signWithEntropy(hash, this.__D, extraData);\n      }\n      return sig;\n    }\n  }\n  verify(hash, signature) {\n    return ecc.verify(hash, this.publicKey, signature);\n  }\n}\nfunction fromPrivateKey(buffer, options) {\n  typeforce(types.Buffer256bit, buffer);\n  if (!ecc.isPrivate(buffer))\n    throw new TypeError('Private key not in range [1, n)');\n  typeforce(isOptions, options);\n  return new ECPair(buffer, undefined, options);\n}\nexports.fromPrivateKey = fromPrivateKey;\nfunction fromPublicKey(buffer, options) {\n  typeforce(ecc.isPoint, buffer);\n  typeforce(isOptions, options);\n  return new ECPair(undefined, buffer, options);\n}\nexports.fromPublicKey = fromPublicKey;\nfunction fromWIF(wifString, network) {\n  const decoded = wif.decode(wifString);\n  const version = decoded.version;\n  // list of networks?\n  if (types.Array(network)) {\n    network = network\n      .filter(x => {\n        return version === x.wif;\n      })\n      .pop();\n    if (!network) throw new Error('Unknown network version');\n    // otherwise, assume a network object (or default to bitcoin)\n  } else {\n    network = network || NETWORKS.bitcoin;\n    if (version !== network.wif) throw new Error('Invalid network version');\n  }\n  return fromPrivateKey(decoded.privateKey, {\n    compressed: decoded.compressed,\n    network: network,\n  });\n}\nexports.fromWIF = fromWIF;\nfunction makeRandom(options) {\n  typeforce(isOptions, options);\n  if (options === undefined) options = {};\n  const rng = options.rng || randomBytes;\n  let d;\n  do {\n    d = rng(32);\n    typeforce(types.Buffer256bit, d);\n  } while (!ecc.isPrivate(d));\n  return fromPrivateKey(d, options);\n}\nexports.makeRandom = makeRandom;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bip32 = require('bip32');\nexports.bip32 = bip32;\nconst address = require('./address');\nexports.address = address;\nconst crypto = require('./crypto');\nexports.crypto = crypto;\nconst ECPair = require('./ecpair');\nexports.ECPair = ECPair;\nconst networks = require('./networks');\nexports.networks = networks;\nconst payments = require('./payments');\nexports.payments = payments;\nconst script = require('./script');\nexports.script = script;\nvar block_1 = require('./block');\nexports.Block = block_1.Block;\nvar psbt_1 = require('./psbt');\nexports.Psbt = psbt_1.Psbt;\nvar script_1 = require('./script');\nexports.opcodes = script_1.OPS;\nvar transaction_1 = require('./transaction');\nexports.Transaction = transaction_1.Transaction;\nvar transaction_builder_1 = require('./transaction_builder');\nexports.TransactionBuilder = transaction_builder_1.TransactionBuilder;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nexports.bitcoingold = {\n  messagePrefix: '\\x18Bitcoin Gold Signed Message:\\n',\n  bech32: 'btg',\n  bip32: {\n    public: 0x0488b21e,\n    private: 0x0488ade4,\n  },\n  pubKeyHash: 0x26,\n  scriptHash: 0x17,\n  wif: 0x80,\n};\nexports.bitcoin = {\n  messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n  bech32: 'bc',\n  bip32: {\n    public: 0x0488b21e,\n    private: 0x0488ade4,\n  },\n  pubKeyHash: 0x00,\n  scriptHash: 0x05,\n  wif: 0x80,\n};\nexports.regtest = {\n  messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n  bech32: 'bcrt',\n  bip32: {\n    public: 0x043587cf,\n    private: 0x04358394,\n  },\n  pubKeyHash: 0x6f,\n  scriptHash: 0xc4,\n  wif: 0xef,\n};\nexports.testnet = {\n  messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n  bech32: 'tb',\n  bip32: {\n    public: 0x043587cf,\n    private: 0x04358394,\n  },\n  pubKeyHash: 0x6f,\n  scriptHash: 0xc4,\n  wif: 0xef,\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\nfunction stacksEqual(a, b) {\n  if (a.length !== b.length) return false;\n  return a.every((x, i) => {\n    return x.equals(b[i]);\n  });\n}\n// output: OP_RETURN ...\nfunction p2data(a, opts) {\n  if (!a.data && !a.output) throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n      output: typef.maybe(typef.Buffer),\n      data: typef.maybe(typef.arrayOf(typef.Buffer)),\n    },\n    a,\n  );\n  const network = a.network || networks_1.bitcoin;\n  const o = { name: 'embed', network };\n  lazy.prop(o, 'output', () => {\n    if (!a.data) return;\n    return bscript.compile([OPS.OP_RETURN].concat(a.data));\n  });\n  lazy.prop(o, 'data', () => {\n    if (!a.output) return;\n    return bscript.decompile(a.output).slice(1);\n  });\n  // extended validation\n  if (opts.validate) {\n    if (a.output) {\n      const chunks = bscript.decompile(a.output);\n      if (chunks[0] !== OPS.OP_RETURN) throw new TypeError('Output is invalid');\n      if (!chunks.slice(1).every(typef.Buffer))\n        throw new TypeError('Output is invalid');\n      if (a.data && !stacksEqual(a.data, o.data))\n        throw new TypeError('Data mismatch');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2data = p2data;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst embed_1 = require('./embed');\nexports.embed = embed_1.p2data;\nconst p2ms_1 = require('./p2ms');\nexports.p2ms = p2ms_1.p2ms;\nconst p2pk_1 = require('./p2pk');\nexports.p2pk = p2pk_1.p2pk;\nconst p2pkh_1 = require('./p2pkh');\nexports.p2pkh = p2pkh_1.p2pkh;\nconst p2sh_1 = require('./p2sh');\nexports.p2sh = p2sh_1.p2sh;\nconst p2wpkh_1 = require('./p2wpkh');\nexports.p2wpkh = p2wpkh_1.p2wpkh;\nconst p2wsh_1 = require('./p2wsh');\nexports.p2wsh = p2wsh_1.p2wsh;\n// TODO\n// witness commitment\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nfunction prop(object, name, f) {\n  Object.defineProperty(object, name, {\n    configurable: true,\n    enumerable: true,\n    get() {\n      const _value = f.call(this);\n      this[name] = _value;\n      return _value;\n    },\n    set(_value) {\n      Object.defineProperty(this, name, {\n        configurable: true,\n        enumerable: true,\n        value: _value,\n        writable: true,\n      });\n    },\n  });\n}\nexports.prop = prop;\nfunction value(f) {\n  let _value;\n  return () => {\n    if (_value !== undefined) return _value;\n    _value = f();\n    return _value;\n  };\n}\nexports.value = value;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst OPS = bscript.OPS;\nconst typef = require('typeforce');\nconst ecc = require('tiny-secp256k1');\nconst OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1\nfunction stacksEqual(a, b) {\n  if (a.length !== b.length) return false;\n  return a.every((x, i) => {\n    return x.equals(b[i]);\n  });\n}\n// input: OP_0 [signatures ...]\n// output: m [pubKeys ...] n OP_CHECKMULTISIG\nfunction p2ms(a, opts) {\n  if (\n    !a.input &&\n    !a.output &&\n    !(a.pubkeys && a.m !== undefined) &&\n    !a.signatures\n  )\n    throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  function isAcceptableSignature(x) {\n    return (\n      bscript.isCanonicalScriptSignature(x) ||\n      (opts.allowIncomplete && x === OPS.OP_0) !== undefined\n    );\n  }\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n      m: typef.maybe(typef.Number),\n      n: typef.maybe(typef.Number),\n      output: typef.maybe(typef.Buffer),\n      pubkeys: typef.maybe(typef.arrayOf(ecc.isPoint)),\n      signatures: typef.maybe(typef.arrayOf(isAcceptableSignature)),\n      input: typef.maybe(typef.Buffer),\n    },\n    a,\n  );\n  const network = a.network || networks_1.bitcoin;\n  const o = { network };\n  let chunks = [];\n  let decoded = false;\n  function decode(output) {\n    if (decoded) return;\n    decoded = true;\n    chunks = bscript.decompile(output);\n    o.m = chunks[0] - OP_INT_BASE;\n    o.n = chunks[chunks.length - 2] - OP_INT_BASE;\n    o.pubkeys = chunks.slice(1, -2);\n  }\n  lazy.prop(o, 'output', () => {\n    if (!a.m) return;\n    if (!o.n) return;\n    if (!a.pubkeys) return;\n    return bscript.compile(\n      [].concat(\n        OP_INT_BASE + a.m,\n        a.pubkeys,\n        OP_INT_BASE + o.n,\n        OPS.OP_CHECKMULTISIG,\n      ),\n    );\n  });\n  lazy.prop(o, 'm', () => {\n    if (!o.output) return;\n    decode(o.output);\n    return o.m;\n  });\n  lazy.prop(o, 'n', () => {\n    if (!o.pubkeys) return;\n    return o.pubkeys.length;\n  });\n  lazy.prop(o, 'pubkeys', () => {\n    if (!a.output) return;\n    decode(a.output);\n    return o.pubkeys;\n  });\n  lazy.prop(o, 'signatures', () => {\n    if (!a.input) return;\n    return bscript.decompile(a.input).slice(1);\n  });\n  lazy.prop(o, 'input', () => {\n    if (!a.signatures) return;\n    return bscript.compile([OPS.OP_0].concat(a.signatures));\n  });\n  lazy.prop(o, 'witness', () => {\n    if (!o.input) return;\n    return [];\n  });\n  lazy.prop(o, 'name', () => {\n    if (!o.m || !o.n) return;\n    return `p2ms(${o.m} of ${o.n})`;\n  });\n  // extended validation\n  if (opts.validate) {\n    if (a.output) {\n      decode(a.output);\n      if (!typef.Number(chunks[0])) throw new TypeError('Output is invalid');\n      if (!typef.Number(chunks[chunks.length - 2]))\n        throw new TypeError('Output is invalid');\n      if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG)\n        throw new TypeError('Output is invalid');\n      if (o.m <= 0 || o.n > 16 || o.m > o.n || o.n !== chunks.length - 3)\n        throw new TypeError('Output is invalid');\n      if (!o.pubkeys.every(x => ecc.isPoint(x)))\n        throw new TypeError('Output is invalid');\n      if (a.m !== undefined && a.m !== o.m) throw new TypeError('m mismatch');\n      if (a.n !== undefined && a.n !== o.n) throw new TypeError('n mismatch');\n      if (a.pubkeys && !stacksEqual(a.pubkeys, o.pubkeys))\n        throw new TypeError('Pubkeys mismatch');\n    }\n    if (a.pubkeys) {\n      if (a.n !== undefined && a.n !== a.pubkeys.length)\n        throw new TypeError('Pubkey count mismatch');\n      o.n = a.pubkeys.length;\n      if (o.n < o.m) throw new TypeError('Pubkey count cannot be less than m');\n    }\n    if (a.signatures) {\n      if (a.signatures.length < o.m)\n        throw new TypeError('Not enough signatures provided');\n      if (a.signatures.length > o.m)\n        throw new TypeError('Too many signatures provided');\n    }\n    if (a.input) {\n      if (a.input[0] !== OPS.OP_0) throw new TypeError('Input is invalid');\n      if (\n        o.signatures.length === 0 ||\n        !o.signatures.every(isAcceptableSignature)\n      )\n        throw new TypeError('Input has invalid signature(s)');\n      if (a.signatures && !stacksEqual(a.signatures, o.signatures))\n        throw new TypeError('Signature mismatch');\n      if (a.m !== undefined && a.m !== a.signatures.length)\n        throw new TypeError('Signature count mismatch');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2ms = p2ms;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\nconst ecc = require('tiny-secp256k1');\n// input: {signature}\n// output: {pubKey} OP_CHECKSIG\nfunction p2pk(a, opts) {\n  if (!a.input && !a.output && !a.pubkey && !a.input && !a.signature)\n    throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n      output: typef.maybe(typef.Buffer),\n      pubkey: typef.maybe(ecc.isPoint),\n      signature: typef.maybe(bscript.isCanonicalScriptSignature),\n      input: typef.maybe(typef.Buffer),\n    },\n    a,\n  );\n  const _chunks = lazy.value(() => {\n    return bscript.decompile(a.input);\n  });\n  const network = a.network || networks_1.bitcoin;\n  const o = { name: 'p2pk', network };\n  lazy.prop(o, 'output', () => {\n    if (!a.pubkey) return;\n    return bscript.compile([a.pubkey, OPS.OP_CHECKSIG]);\n  });\n  lazy.prop(o, 'pubkey', () => {\n    if (!a.output) return;\n    return a.output.slice(1, -1);\n  });\n  lazy.prop(o, 'signature', () => {\n    if (!a.input) return;\n    return _chunks()[0];\n  });\n  lazy.prop(o, 'input', () => {\n    if (!a.signature) return;\n    return bscript.compile([a.signature]);\n  });\n  lazy.prop(o, 'witness', () => {\n    if (!o.input) return;\n    return [];\n  });\n  // extended validation\n  if (opts.validate) {\n    if (a.output) {\n      if (a.output[a.output.length - 1] !== OPS.OP_CHECKSIG)\n        throw new TypeError('Output is invalid');\n      if (!ecc.isPoint(o.pubkey))\n        throw new TypeError('Output pubkey is invalid');\n      if (a.pubkey && !a.pubkey.equals(o.pubkey))\n        throw new TypeError('Pubkey mismatch');\n    }\n    if (a.signature) {\n      if (a.input && !a.input.equals(o.input))\n        throw new TypeError('Signature mismatch');\n    }\n    if (a.input) {\n      if (_chunks().length !== 1) throw new TypeError('Input is invalid');\n      if (!bscript.isCanonicalScriptSignature(o.signature))\n        throw new TypeError('Input has invalid signature');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2pk = p2pk;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bcrypto = require('../crypto');\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\nconst ecc = require('tiny-secp256k1');\nconst bs58check = require('bs58check');\n// input: {signature} {pubkey}\n// output: OP_DUP OP_HASH160 {hash160(pubkey)} OP_EQUALVERIFY OP_CHECKSIG\nfunction p2pkh(a, opts) {\n  if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input)\n    throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n      address: typef.maybe(typef.String),\n      hash: typef.maybe(typef.BufferN(20)),\n      output: typef.maybe(typef.BufferN(25)),\n      pubkey: typef.maybe(ecc.isPoint),\n      signature: typef.maybe(bscript.isCanonicalScriptSignature),\n      input: typef.maybe(typef.Buffer),\n    },\n    a,\n  );\n  const _address = lazy.value(() => {\n    const payload = bs58check.decode(a.address);\n    const version = payload.readUInt8(0);\n    const hash = payload.slice(1);\n    return { version, hash };\n  });\n  const _chunks = lazy.value(() => {\n    return bscript.decompile(a.input);\n  });\n  const network = a.network || networks_1.bitcoin;\n  const o = { name: 'p2pkh', network };\n  lazy.prop(o, 'address', () => {\n    if (!o.hash) return;\n    const payload = Buffer.allocUnsafe(21);\n    payload.writeUInt8(network.pubKeyHash, 0);\n    o.hash.copy(payload, 1);\n    return bs58check.encode(payload);\n  });\n  lazy.prop(o, 'hash', () => {\n    if (a.output) return a.output.slice(3, 23);\n    if (a.address) return _address().hash;\n    if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey || o.pubkey);\n  });\n  lazy.prop(o, 'output', () => {\n    if (!o.hash) return;\n    return bscript.compile([\n      OPS.OP_DUP,\n      OPS.OP_HASH160,\n      o.hash,\n      OPS.OP_EQUALVERIFY,\n      OPS.OP_CHECKSIG,\n    ]);\n  });\n  lazy.prop(o, 'pubkey', () => {\n    if (!a.input) return;\n    return _chunks()[1];\n  });\n  lazy.prop(o, 'signature', () => {\n    if (!a.input) return;\n    return _chunks()[0];\n  });\n  lazy.prop(o, 'input', () => {\n    if (!a.pubkey) return;\n    if (!a.signature) return;\n    return bscript.compile([a.signature, a.pubkey]);\n  });\n  lazy.prop(o, 'witness', () => {\n    if (!o.input) return;\n    return [];\n  });\n  // extended validation\n  if (opts.validate) {\n    let hash = Buffer.from([]);\n    if (a.address) {\n      if (_address().version !== network.pubKeyHash)\n        throw new TypeError('Invalid version or Network mismatch');\n      if (_address().hash.length !== 20) throw new TypeError('Invalid address');\n      hash = _address().hash;\n    }\n    if (a.hash) {\n      if (hash.length > 0 && !hash.equals(a.hash))\n        throw new TypeError('Hash mismatch');\n      else hash = a.hash;\n    }\n    if (a.output) {\n      if (\n        a.output.length !== 25 ||\n        a.output[0] !== OPS.OP_DUP ||\n        a.output[1] !== OPS.OP_HASH160 ||\n        a.output[2] !== 0x14 ||\n        a.output[23] !== OPS.OP_EQUALVERIFY ||\n        a.output[24] !== OPS.OP_CHECKSIG\n      )\n        throw new TypeError('Output is invalid');\n      const hash2 = a.output.slice(3, 23);\n      if (hash.length > 0 && !hash.equals(hash2))\n        throw new TypeError('Hash mismatch');\n      else hash = hash2;\n    }\n    if (a.pubkey) {\n      const pkh = bcrypto.hash160(a.pubkey);\n      if (hash.length > 0 && !hash.equals(pkh))\n        throw new TypeError('Hash mismatch');\n      else hash = pkh;\n    }\n    if (a.input) {\n      const chunks = _chunks();\n      if (chunks.length !== 2) throw new TypeError('Input is invalid');\n      if (!bscript.isCanonicalScriptSignature(chunks[0]))\n        throw new TypeError('Input has invalid signature');\n      if (!ecc.isPoint(chunks[1]))\n        throw new TypeError('Input has invalid pubkey');\n      if (a.signature && !a.signature.equals(chunks[0]))\n        throw new TypeError('Signature mismatch');\n      if (a.pubkey && !a.pubkey.equals(chunks[1]))\n        throw new TypeError('Pubkey mismatch');\n      const pkh = bcrypto.hash160(chunks[1]);\n      if (hash.length > 0 && !hash.equals(pkh))\n        throw new TypeError('Hash mismatch');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2pkh = p2pkh;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bcrypto = require('../crypto');\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\nconst bs58check = require('bs58check');\nfunction stacksEqual(a, b) {\n  if (a.length !== b.length) return false;\n  return a.every((x, i) => {\n    return x.equals(b[i]);\n  });\n}\n// input: [redeemScriptSig ...] {redeemScript}\n// witness: <?>\n// output: OP_HASH160 {hash160(redeemScript)} OP_EQUAL\nfunction p2sh(a, opts) {\n  if (!a.address && !a.hash && !a.output && !a.redeem && !a.input)\n    throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n      address: typef.maybe(typef.String),\n      hash: typef.maybe(typef.BufferN(20)),\n      output: typef.maybe(typef.BufferN(23)),\n      redeem: typef.maybe({\n        network: typef.maybe(typef.Object),\n        output: typef.maybe(typef.Buffer),\n        input: typef.maybe(typef.Buffer),\n        witness: typef.maybe(typef.arrayOf(typef.Buffer)),\n      }),\n      input: typef.maybe(typef.Buffer),\n      witness: typef.maybe(typef.arrayOf(typef.Buffer)),\n    },\n    a,\n  );\n  let network = a.network;\n  if (!network) {\n    network = (a.redeem && a.redeem.network) || networks_1.bitcoin;\n  }\n  const o = { network };\n  const _address = lazy.value(() => {\n    const payload = bs58check.decode(a.address);\n    const version = payload.readUInt8(0);\n    const hash = payload.slice(1);\n    return { version, hash };\n  });\n  const _chunks = lazy.value(() => {\n    return bscript.decompile(a.input);\n  });\n  const _redeem = lazy.value(() => {\n    const chunks = _chunks();\n    return {\n      network,\n      output: chunks[chunks.length - 1],\n      input: bscript.compile(chunks.slice(0, -1)),\n      witness: a.witness || [],\n    };\n  });\n  // output dependents\n  lazy.prop(o, 'address', () => {\n    if (!o.hash) return;\n    const payload = Buffer.allocUnsafe(21);\n    payload.writeUInt8(o.network.scriptHash, 0);\n    o.hash.copy(payload, 1);\n    return bs58check.encode(payload);\n  });\n  lazy.prop(o, 'hash', () => {\n    // in order of least effort\n    if (a.output) return a.output.slice(2, 22);\n    if (a.address) return _address().hash;\n    if (o.redeem && o.redeem.output) return bcrypto.hash160(o.redeem.output);\n  });\n  lazy.prop(o, 'output', () => {\n    if (!o.hash) return;\n    return bscript.compile([OPS.OP_HASH160, o.hash, OPS.OP_EQUAL]);\n  });\n  // input dependents\n  lazy.prop(o, 'redeem', () => {\n    if (!a.input) return;\n    return _redeem();\n  });\n  lazy.prop(o, 'input', () => {\n    if (!a.redeem || !a.redeem.input || !a.redeem.output) return;\n    return bscript.compile(\n      [].concat(bscript.decompile(a.redeem.input), a.redeem.output),\n    );\n  });\n  lazy.prop(o, 'witness', () => {\n    if (o.redeem && o.redeem.witness) return o.redeem.witness;\n    if (o.input) return [];\n  });\n  lazy.prop(o, 'name', () => {\n    const nameParts = ['p2sh'];\n    if (o.redeem !== undefined) nameParts.push(o.redeem.name);\n    return nameParts.join('-');\n  });\n  if (opts.validate) {\n    let hash = Buffer.from([]);\n    if (a.address) {\n      if (_address().version !== network.scriptHash)\n        throw new TypeError('Invalid version or Network mismatch');\n      if (_address().hash.length !== 20) throw new TypeError('Invalid address');\n      hash = _address().hash;\n    }\n    if (a.hash) {\n      if (hash.length > 0 && !hash.equals(a.hash))\n        throw new TypeError('Hash mismatch');\n      else hash = a.hash;\n    }\n    if (a.output) {\n      if (\n        a.output.length !== 23 ||\n        a.output[0] !== OPS.OP_HASH160 ||\n        a.output[1] !== 0x14 ||\n        a.output[22] !== OPS.OP_EQUAL\n      )\n        throw new TypeError('Output is invalid');\n      const hash2 = a.output.slice(2, 22);\n      if (hash.length > 0 && !hash.equals(hash2))\n        throw new TypeError('Hash mismatch');\n      else hash = hash2;\n    }\n    // inlined to prevent 'no-inner-declarations' failing\n    const checkRedeem = redeem => {\n      // is the redeem output empty/invalid?\n      if (redeem.output) {\n        const decompile = bscript.decompile(redeem.output);\n        if (!decompile || decompile.length < 1)\n          throw new TypeError('Redeem.output too short');\n        // match hash against other sources\n        const hash2 = bcrypto.hash160(redeem.output);\n        if (hash.length > 0 && !hash.equals(hash2))\n          throw new TypeError('Hash mismatch');\n        else hash = hash2;\n      }\n      if (redeem.input) {\n        const hasInput = redeem.input.length > 0;\n        const hasWitness = redeem.witness && redeem.witness.length > 0;\n        if (!hasInput && !hasWitness) throw new TypeError('Empty input');\n        if (hasInput && hasWitness)\n          throw new TypeError('Input and witness provided');\n        if (hasInput) {\n          const richunks = bscript.decompile(redeem.input);\n          if (!bscript.isPushOnly(richunks))\n            throw new TypeError('Non push-only scriptSig');\n        }\n      }\n    };\n    if (a.input) {\n      const chunks = _chunks();\n      if (!chunks || chunks.length < 1) throw new TypeError('Input too short');\n      if (!Buffer.isBuffer(_redeem().output))\n        throw new TypeError('Input is invalid');\n      checkRedeem(_redeem());\n    }\n    if (a.redeem) {\n      if (a.redeem.network && a.redeem.network !== network)\n        throw new TypeError('Network mismatch');\n      if (a.input) {\n        const redeem = _redeem();\n        if (a.redeem.output && !a.redeem.output.equals(redeem.output))\n          throw new TypeError('Redeem.output mismatch');\n        if (a.redeem.input && !a.redeem.input.equals(redeem.input))\n          throw new TypeError('Redeem.input mismatch');\n      }\n      checkRedeem(a.redeem);\n    }\n    if (a.witness) {\n      if (\n        a.redeem &&\n        a.redeem.witness &&\n        !stacksEqual(a.redeem.witness, a.witness)\n      )\n        throw new TypeError('Witness and redeem.witness mismatch');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2sh = p2sh;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bcrypto = require('../crypto');\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\nconst ecc = require('tiny-secp256k1');\nconst bech32 = require('bech32');\nconst EMPTY_BUFFER = Buffer.alloc(0);\n// witness: {signature} {pubKey}\n// input: <>\n// output: OP_0 {pubKeyHash}\nfunction p2wpkh(a, opts) {\n  if (!a.address && !a.hash && !a.output && !a.pubkey && !a.witness)\n    throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  typef(\n    {\n      address: typef.maybe(typef.String),\n      hash: typef.maybe(typef.BufferN(20)),\n      input: typef.maybe(typef.BufferN(0)),\n      network: typef.maybe(typef.Object),\n      output: typef.maybe(typef.BufferN(22)),\n      pubkey: typef.maybe(ecc.isPoint),\n      signature: typef.maybe(bscript.isCanonicalScriptSignature),\n      witness: typef.maybe(typef.arrayOf(typef.Buffer)),\n    },\n    a,\n  );\n  const _address = lazy.value(() => {\n    const result = bech32.decode(a.address);\n    const version = result.words.shift();\n    const data = bech32.fromWords(result.words);\n    return {\n      version,\n      prefix: result.prefix,\n      data: Buffer.from(data),\n    };\n  });\n  const network = a.network || networks_1.bitcoin;\n  const o = { name: 'p2wpkh', network };\n  lazy.prop(o, 'address', () => {\n    if (!o.hash) return;\n    const words = bech32.toWords(o.hash);\n    words.unshift(0x00);\n    return bech32.encode(network.bech32, words);\n  });\n  lazy.prop(o, 'hash', () => {\n    if (a.output) return a.output.slice(2, 22);\n    if (a.address) return _address().data;\n    if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey || o.pubkey);\n  });\n  lazy.prop(o, 'output', () => {\n    if (!o.hash) return;\n    return bscript.compile([OPS.OP_0, o.hash]);\n  });\n  lazy.prop(o, 'pubkey', () => {\n    if (a.pubkey) return a.pubkey;\n    if (!a.witness) return;\n    return a.witness[1];\n  });\n  lazy.prop(o, 'signature', () => {\n    if (!a.witness) return;\n    return a.witness[0];\n  });\n  lazy.prop(o, 'input', () => {\n    if (!o.witness) return;\n    return EMPTY_BUFFER;\n  });\n  lazy.prop(o, 'witness', () => {\n    if (!a.pubkey) return;\n    if (!a.signature) return;\n    return [a.signature, a.pubkey];\n  });\n  // extended validation\n  if (opts.validate) {\n    let hash = Buffer.from([]);\n    if (a.address) {\n      if (network && network.bech32 !== _address().prefix)\n        throw new TypeError('Invalid prefix or Network mismatch');\n      if (_address().version !== 0x00)\n        throw new TypeError('Invalid address version');\n      if (_address().data.length !== 20)\n        throw new TypeError('Invalid address data');\n      hash = _address().data;\n    }\n    if (a.hash) {\n      if (hash.length > 0 && !hash.equals(a.hash))\n        throw new TypeError('Hash mismatch');\n      else hash = a.hash;\n    }\n    if (a.output) {\n      if (\n        a.output.length !== 22 ||\n        a.output[0] !== OPS.OP_0 ||\n        a.output[1] !== 0x14\n      )\n        throw new TypeError('Output is invalid');\n      if (hash.length > 0 && !hash.equals(a.output.slice(2)))\n        throw new TypeError('Hash mismatch');\n      else hash = a.output.slice(2);\n    }\n    if (a.pubkey) {\n      const pkh = bcrypto.hash160(a.pubkey);\n      if (hash.length > 0 && !hash.equals(pkh))\n        throw new TypeError('Hash mismatch');\n      else hash = pkh;\n      if (!ecc.isPoint(a.pubkey) || a.pubkey.length !== 33)\n        throw new TypeError('Invalid pubkey for p2wpkh');\n    }\n    if (a.witness) {\n      if (a.witness.length !== 2) throw new TypeError('Witness is invalid');\n      if (!bscript.isCanonicalScriptSignature(a.witness[0]))\n        throw new TypeError('Witness has invalid signature');\n      if (!ecc.isPoint(a.witness[1]) || a.witness[1].length !== 33)\n        throw new TypeError('Witness has invalid pubkey');\n      if (a.signature && !a.signature.equals(a.witness[0]))\n        throw new TypeError('Signature mismatch');\n      if (a.pubkey && !a.pubkey.equals(a.witness[1]))\n        throw new TypeError('Pubkey mismatch');\n      const pkh = bcrypto.hash160(a.witness[1]);\n      if (hash.length > 0 && !hash.equals(pkh))\n        throw new TypeError('Hash mismatch');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2wpkh = p2wpkh;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bcrypto = require('../crypto');\nconst networks_1 = require('../networks');\nconst bscript = require('../script');\nconst lazy = require('./lazy');\nconst typef = require('typeforce');\nconst OPS = bscript.OPS;\nconst ecc = require('tiny-secp256k1');\nconst bech32 = require('bech32');\nconst EMPTY_BUFFER = Buffer.alloc(0);\nfunction stacksEqual(a, b) {\n  if (a.length !== b.length) return false;\n  return a.every((x, i) => {\n    return x.equals(b[i]);\n  });\n}\nfunction chunkHasUncompressedPubkey(chunk) {\n  if (\n    Buffer.isBuffer(chunk) &&\n    chunk.length === 65 &&\n    chunk[0] === 0x04 &&\n    ecc.isPoint(chunk)\n  ) {\n    return true;\n  } else {\n    return false;\n  }\n}\n// input: <>\n// witness: [redeemScriptSig ...] {redeemScript}\n// output: OP_0 {sha256(redeemScript)}\nfunction p2wsh(a, opts) {\n  if (!a.address && !a.hash && !a.output && !a.redeem && !a.witness)\n    throw new TypeError('Not enough data');\n  opts = Object.assign({ validate: true }, opts || {});\n  typef(\n    {\n      network: typef.maybe(typef.Object),\n      address: typef.maybe(typef.String),\n      hash: typef.maybe(typef.BufferN(32)),\n      output: typef.maybe(typef.BufferN(34)),\n      redeem: typef.maybe({\n        input: typef.maybe(typef.Buffer),\n        network: typef.maybe(typef.Object),\n        output: typef.maybe(typef.Buffer),\n        witness: typef.maybe(typef.arrayOf(typef.Buffer)),\n      }),\n      input: typef.maybe(typef.BufferN(0)),\n      witness: typef.maybe(typef.arrayOf(typef.Buffer)),\n    },\n    a,\n  );\n  const _address = lazy.value(() => {\n    const result = bech32.decode(a.address);\n    const version = result.words.shift();\n    const data = bech32.fromWords(result.words);\n    return {\n      version,\n      prefix: result.prefix,\n      data: Buffer.from(data),\n    };\n  });\n  const _rchunks = lazy.value(() => {\n    return bscript.decompile(a.redeem.input);\n  });\n  let network = a.network;\n  if (!network) {\n    network = (a.redeem && a.redeem.network) || networks_1.bitcoin;\n  }\n  const o = { network };\n  lazy.prop(o, 'address', () => {\n    if (!o.hash) return;\n    const words = bech32.toWords(o.hash);\n    words.unshift(0x00);\n    return bech32.encode(network.bech32, words);\n  });\n  lazy.prop(o, 'hash', () => {\n    if (a.output) return a.output.slice(2);\n    if (a.address) return _address().data;\n    if (o.redeem && o.redeem.output) return bcrypto.sha256(o.redeem.output);\n  });\n  lazy.prop(o, 'output', () => {\n    if (!o.hash) return;\n    return bscript.compile([OPS.OP_0, o.hash]);\n  });\n  lazy.prop(o, 'redeem', () => {\n    if (!a.witness) return;\n    return {\n      output: a.witness[a.witness.length - 1],\n      input: EMPTY_BUFFER,\n      witness: a.witness.slice(0, -1),\n    };\n  });\n  lazy.prop(o, 'input', () => {\n    if (!o.witness) return;\n    return EMPTY_BUFFER;\n  });\n  lazy.prop(o, 'witness', () => {\n    // transform redeem input to witness stack?\n    if (\n      a.redeem &&\n      a.redeem.input &&\n      a.redeem.input.length > 0 &&\n      a.redeem.output &&\n      a.redeem.output.length > 0\n    ) {\n      const stack = bscript.toStack(_rchunks());\n      // assign, and blank the existing input\n      o.redeem = Object.assign({ witness: stack }, a.redeem);\n      o.redeem.input = EMPTY_BUFFER;\n      return [].concat(stack, a.redeem.output);\n    }\n    if (!a.redeem) return;\n    if (!a.redeem.output) return;\n    if (!a.redeem.witness) return;\n    return [].concat(a.redeem.witness, a.redeem.output);\n  });\n  lazy.prop(o, 'name', () => {\n    const nameParts = ['p2wsh'];\n    if (o.redeem !== undefined) nameParts.push(o.redeem.name);\n    return nameParts.join('-');\n  });\n  // extended validation\n  if (opts.validate) {\n    let hash = Buffer.from([]);\n    if (a.address) {\n      if (_address().prefix !== network.bech32)\n        throw new TypeError('Invalid prefix or Network mismatch');\n      if (_address().version !== 0x00)\n        throw new TypeError('Invalid address version');\n      if (_address().data.length !== 32)\n        throw new TypeError('Invalid address data');\n      hash = _address().data;\n    }\n    if (a.hash) {\n      if (hash.length > 0 && !hash.equals(a.hash))\n        throw new TypeError('Hash mismatch');\n      else hash = a.hash;\n    }\n    if (a.output) {\n      if (\n        a.output.length !== 34 ||\n        a.output[0] !== OPS.OP_0 ||\n        a.output[1] !== 0x20\n      )\n        throw new TypeError('Output is invalid');\n      const hash2 = a.output.slice(2);\n      if (hash.length > 0 && !hash.equals(hash2))\n        throw new TypeError('Hash mismatch');\n      else hash = hash2;\n    }\n    if (a.redeem) {\n      if (a.redeem.network && a.redeem.network !== network)\n        throw new TypeError('Network mismatch');\n      // is there two redeem sources?\n      if (\n        a.redeem.input &&\n        a.redeem.input.length > 0 &&\n        a.redeem.witness &&\n        a.redeem.witness.length > 0\n      )\n        throw new TypeError('Ambiguous witness source');\n      // is the redeem output non-empty?\n      if (a.redeem.output) {\n        if (bscript.decompile(a.redeem.output).length === 0)\n          throw new TypeError('Redeem.output is invalid');\n        // match hash against other sources\n        const hash2 = bcrypto.sha256(a.redeem.output);\n        if (hash.length > 0 && !hash.equals(hash2))\n          throw new TypeError('Hash mismatch');\n        else hash = hash2;\n      }\n      if (a.redeem.input && !bscript.isPushOnly(_rchunks()))\n        throw new TypeError('Non push-only scriptSig');\n      if (\n        a.witness &&\n        a.redeem.witness &&\n        !stacksEqual(a.witness, a.redeem.witness)\n      )\n        throw new TypeError('Witness and redeem.witness mismatch');\n      if (\n        (a.redeem.input && _rchunks().some(chunkHasUncompressedPubkey)) ||\n        (a.redeem.output &&\n          (bscript.decompile(a.redeem.output) || []).some(\n            chunkHasUncompressedPubkey,\n          ))\n      ) {\n        throw new TypeError(\n          'redeem.input or redeem.output contains uncompressed pubkey',\n        );\n      }\n    }\n    if (a.witness && a.witness.length > 0) {\n      const wScript = a.witness[a.witness.length - 1];\n      if (a.redeem && a.redeem.output && !a.redeem.output.equals(wScript))\n        throw new TypeError('Witness and redeem.output mismatch');\n      if (\n        a.witness.some(chunkHasUncompressedPubkey) ||\n        (bscript.decompile(wScript) || []).some(chunkHasUncompressedPubkey)\n      )\n        throw new TypeError('Witness contains uncompressed pubkey');\n    }\n  }\n  return Object.assign(o, a);\n}\nexports.p2wsh = p2wsh;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bip174_1 = require('bip174');\nconst varuint = require('bip174/src/lib/converter/varint');\nconst utils_1 = require('bip174/src/lib/utils');\nconst address_1 = require('./address');\nconst bufferutils_1 = require('./bufferutils');\nconst crypto_1 = require('./crypto');\nconst ecpair_1 = require('./ecpair');\nconst networks_1 = require('./networks');\nconst payments = require('./payments');\nconst bscript = require('./script');\nconst transaction_1 = require('./transaction');\nconst BCH_SIGHASH_ALL =\n  transaction_1.Transaction.SIGHASH_ALL |\n  transaction_1.Transaction.SIGHASH_BITCOINCASHBIP143;\nconst BTG_SIGHASH_ALL =\n  transaction_1.Transaction.SIGHASH_ALL |\n  transaction_1.Transaction.SIGHASH_BITCOINCASHBIP143 |\n  (transaction_1.Transaction.FORKID_BTG << 8);\nconst DEFAULT_SIGHASHES = [\n  // BTC SIGHASH_ALL\n  transaction_1.Transaction.SIGHASH_ALL,\n  // BCH SIGHASH_ALL\n  BCH_SIGHASH_ALL,\n  // BTG SIGHASH_ALL\n  BTG_SIGHASH_ALL,\n];\n/**\n * These are the default arguments for a Psbt instance.\n */\nconst DEFAULT_OPTS = {\n  /**\n   * A bitcoinjs Network object. This is only used if you pass an `address`\n   * parameter to addOutput. Otherwise it is not needed and can be left default.\n   */\n  network: networks_1.bitcoin,\n  /**\n   * When extractTransaction is called, the fee rate is checked.\n   * THIS IS NOT TO BE RELIED ON.\n   * It is only here as a last ditch effort to prevent sending a 500 BTC fee etc.\n   */\n  maximumFeeRate: 5000,\n  forkCoin: 'none',\n};\n/**\n * Psbt class can parse and generate a PSBT binary based off of the BIP174.\n * There are 6 roles that this class fulfills. (Explained in BIP174)\n *\n * Creator: This can be done with `new Psbt()`\n * Updater: This can be done with `psbt.addInput(input)`, `psbt.addInputs(inputs)`,\n *   `psbt.addOutput(output)`, `psbt.addOutputs(outputs)` when you are looking to\n *   add new inputs and outputs to the PSBT, and `psbt.updateGlobal(itemObject)`,\n *   `psbt.updateInput(itemObject)`, `psbt.updateOutput(itemObject)`\n *   addInput requires hash: Buffer | string; and index: number; as attributes\n *   and can also include any attributes that are used in updateInput method.\n *   addOutput requires script: Buffer; and value: number; and likewise can include\n *   data for updateOutput.\n *   For a list of what attributes should be what types. Check the bip174 library.\n *   Also, check the integration tests for some examples of usage.\n * Signer: There are a few methods. signAllInputs and signAllInputsAsync, which will search all input\n *   information for your pubkey or pubkeyhash, and only sign inputs where it finds\n *   your info. Or you can explicitly sign a specific input with signInput and\n *   signInputAsync. For the async methods you can create a SignerAsync object\n *   and use something like a hardware wallet to sign with. (You must implement this)\n * Combiner: psbts can be combined easily with `psbt.combine(psbt2, psbt3, psbt4 ...)`\n *   the psbt calling combine will always have precedence when a conflict occurs.\n *   Combine checks if the internal bitcoin transaction is the same, so be sure that\n *   all sequences, version, locktime, etc. are the same before combining.\n * Input Finalizer: This role is fairly important. Not only does it need to construct\n *   the input scriptSigs and witnesses, but it SHOULD verify the signatures etc.\n *   Before running `psbt.finalizeAllInputs()` please run `psbt.validateSignaturesOfAllInputs()`\n *   Running any finalize method will delete any data in the input(s) that are no longer\n *   needed due to the finalized scripts containing the information.\n * Transaction Extractor: This role will perform some checks before returning a\n *   Transaction object. Such as fee rate not being larger than maximumFeeRate etc.\n */\nclass Psbt {\n  constructor(opts = {}, data = new bip174_1.Psbt(new PsbtTransaction())) {\n    this.data = data;\n    // set defaults\n    this.opts = Object.assign({}, DEFAULT_OPTS, opts);\n    this.__CACHE = {\n      __NON_WITNESS_UTXO_TX_CACHE: [],\n      __NON_WITNESS_UTXO_BUF_CACHE: [],\n      __TX_IN_CACHE: {},\n      __TX: this.data.globalMap.unsignedTx.tx,\n      // Old TransactionBuilder behavior was to not confirm input values\n      // before signing. Even though we highly encourage people to get\n      // the full parent transaction to verify values, the ability to\n      // sign non-segwit inputs without the full transaction was often\n      // requested. So the only way to activate is to use @ts-ignore.\n      // We will disable exporting the Psbt when unsafe sign is active.\n      // because it is not BIP174 compliant.\n      __UNSAFE_SIGN_NONSEGWIT: false,\n    };\n    if (this.data.inputs.length === 0) this.setVersion(2);\n    // Make data hidden when enumerating\n    const dpew = (obj, attr, enumerable, writable) =>\n      Object.defineProperty(obj, attr, {\n        enumerable,\n        writable,\n      });\n    dpew(this, '__CACHE', false, true);\n    dpew(this, 'opts', false, true);\n  }\n  static fromBase64(data, opts = {}) {\n    const buffer = Buffer.from(data, 'base64');\n    return this.fromBuffer(buffer, opts);\n  }\n  static fromHex(data, opts = {}) {\n    const buffer = Buffer.from(data, 'hex');\n    return this.fromBuffer(buffer, opts);\n  }\n  static fromBuffer(buffer, opts = {}) {\n    const psbtBase = bip174_1.Psbt.fromBuffer(buffer, transactionFromBuffer);\n    const psbt = new Psbt(opts, psbtBase);\n    checkTxForDupeIns(psbt.__CACHE.__TX, psbt.__CACHE);\n    return psbt;\n  }\n  get inputCount() {\n    return this.data.inputs.length;\n  }\n  get version() {\n    return this.__CACHE.__TX.version;\n  }\n  set version(version) {\n    this.setVersion(version);\n  }\n  get locktime() {\n    return this.__CACHE.__TX.locktime;\n  }\n  set locktime(locktime) {\n    this.setLocktime(locktime);\n  }\n  get txInputs() {\n    return this.__CACHE.__TX.ins.map(input => ({\n      hash: bufferutils_1.cloneBuffer(input.hash),\n      index: input.index,\n      sequence: input.sequence,\n    }));\n  }\n  get txOutputs() {\n    return this.__CACHE.__TX.outs.map(output => {\n      let address;\n      try {\n        address = address_1.fromOutputScript(output.script, this.opts.network);\n      } catch (_) {}\n      return {\n        script: bufferutils_1.cloneBuffer(output.script),\n        value: output.value,\n        address,\n      };\n    });\n  }\n  combine(...those) {\n    this.data.combine(...those.map(o => o.data));\n    return this;\n  }\n  clone() {\n    // TODO: more efficient cloning\n    const res = Psbt.fromBuffer(this.data.toBuffer());\n    res.opts = JSON.parse(JSON.stringify(this.opts));\n    return res;\n  }\n  setMaximumFeeRate(satoshiPerByte) {\n    check32Bit(satoshiPerByte); // 42.9 BTC per byte IS excessive... so throw\n    this.opts.maximumFeeRate = satoshiPerByte;\n  }\n  setVersion(version) {\n    check32Bit(version);\n    checkInputsForPartialSig(this.data.inputs, 'setVersion');\n    const c = this.__CACHE;\n    c.__TX.version = version;\n    c.__EXTRACTED_TX = undefined;\n    return this;\n  }\n  setLocktime(locktime) {\n    check32Bit(locktime);\n    checkInputsForPartialSig(this.data.inputs, 'setLocktime');\n    const c = this.__CACHE;\n    c.__TX.locktime = locktime;\n    c.__EXTRACTED_TX = undefined;\n    return this;\n  }\n  setInputSequence(inputIndex, sequence) {\n    check32Bit(sequence);\n    checkInputsForPartialSig(this.data.inputs, 'setInputSequence');\n    const c = this.__CACHE;\n    if (c.__TX.ins.length <= inputIndex) {\n      throw new Error('Input index too high');\n    }\n    c.__TX.ins[inputIndex].sequence = sequence;\n    c.__EXTRACTED_TX = undefined;\n    return this;\n  }\n  addInputs(inputDatas) {\n    inputDatas.forEach(inputData => this.addInput(inputData));\n    return this;\n  }\n  addInput(inputData) {\n    if (\n      arguments.length > 1 ||\n      !inputData ||\n      inputData.hash === undefined ||\n      inputData.index === undefined\n    ) {\n      throw new Error(\n        `Invalid arguments for Psbt.addInput. ` +\n          `Requires single object with at least [hash] and [index]`,\n      );\n    }\n    checkInputsForPartialSig(this.data.inputs, 'addInput');\n    if (inputData.witnessScript) checkInvalidP2WSH(inputData.witnessScript);\n    const c = this.__CACHE;\n    this.data.addInput(inputData);\n    const txIn = c.__TX.ins[c.__TX.ins.length - 1];\n    checkTxInputCache(c, txIn);\n    const inputIndex = this.data.inputs.length - 1;\n    const input = this.data.inputs[inputIndex];\n    if (input.nonWitnessUtxo) {\n      addNonWitnessTxCache(this.__CACHE, input, inputIndex);\n    }\n    c.__FEE = undefined;\n    c.__FEE_RATE = undefined;\n    c.__EXTRACTED_TX = undefined;\n    return this;\n  }\n  addOutputs(outputDatas) {\n    outputDatas.forEach(outputData => this.addOutput(outputData));\n    return this;\n  }\n  addOutput(outputData) {\n    if (\n      arguments.length > 1 ||\n      !outputData ||\n      outputData.value === undefined ||\n      (outputData.address === undefined && outputData.script === undefined)\n    ) {\n      throw new Error(\n        `Invalid arguments for Psbt.addOutput. ` +\n          `Requires single object with at least [script or address] and [value]`,\n      );\n    }\n    checkInputsForPartialSig(this.data.inputs, 'addOutput');\n    const { address } = outputData;\n    if (typeof address === 'string') {\n      const { network } = this.opts;\n      const script = address_1.toOutputScript(address, network);\n      outputData = Object.assign(outputData, { script });\n    }\n    const c = this.__CACHE;\n    this.data.addOutput(outputData);\n    c.__FEE = undefined;\n    c.__FEE_RATE = undefined;\n    c.__EXTRACTED_TX = undefined;\n    return this;\n  }\n  extractTransaction(disableFeeCheck) {\n    if (!this.data.inputs.every(isFinalized)) throw new Error('Not finalized');\n    const c = this.__CACHE;\n    if (!disableFeeCheck) {\n      checkFees(this, c, this.opts);\n    }\n    if (c.__EXTRACTED_TX) return c.__EXTRACTED_TX;\n    const tx = c.__TX.clone();\n    inputFinalizeGetAmts(this.data.inputs, tx, c, true);\n    return tx;\n  }\n  getFeeRate() {\n    return getTxCacheValue(\n      '__FEE_RATE',\n      'fee rate',\n      this.data.inputs,\n      this.__CACHE,\n    );\n  }\n  getFee() {\n    return getTxCacheValue('__FEE', 'fee', this.data.inputs, this.__CACHE);\n  }\n  finalizeAllInputs() {\n    utils_1.checkForInput(this.data.inputs, 0); // making sure we have at least one\n    range(this.data.inputs.length).forEach(idx => this.finalizeInput(idx));\n    return this;\n  }\n  finalizeInput(inputIndex, finalScriptsFunc = getFinalScripts) {\n    const input = utils_1.checkForInput(this.data.inputs, inputIndex);\n    const { script, isP2SH, isP2WSH, isSegwit } = getScriptFromInput(\n      inputIndex,\n      input,\n      this.__CACHE,\n    );\n    if (!script) throw new Error(`No script found for input #${inputIndex}`);\n    checkPartialSigSighashes(input);\n    const { finalScriptSig, finalScriptWitness } = finalScriptsFunc(\n      inputIndex,\n      input,\n      script,\n      isSegwit,\n      isP2SH,\n      isP2WSH,\n    );\n    if (finalScriptSig) this.data.updateInput(inputIndex, { finalScriptSig });\n    if (finalScriptWitness)\n      this.data.updateInput(inputIndex, { finalScriptWitness });\n    if (!finalScriptSig && !finalScriptWitness)\n      throw new Error(`Unknown error finalizing input #${inputIndex}`);\n    this.data.clearFinalizedInput(inputIndex);\n    return this;\n  }\n  getInputType(inputIndex) {\n    const input = utils_1.checkForInput(this.data.inputs, inputIndex);\n    const script = getScriptFromUtxo(inputIndex, input, this.__CACHE);\n    const result = getMeaningfulScript(\n      script,\n      inputIndex,\n      'input',\n      input.redeemScript || redeemFromFinalScriptSig(input.finalScriptSig),\n      input.witnessScript ||\n        redeemFromFinalWitnessScript(input.finalScriptWitness),\n    );\n    const type = result.type === 'raw' ? '' : result.type + '-';\n    const mainType = classifyScript(result.meaningfulScript);\n    return type + mainType;\n  }\n  inputHasPubkey(inputIndex, pubkey) {\n    const input = utils_1.checkForInput(this.data.inputs, inputIndex);\n    return pubkeyInInput(pubkey, input, inputIndex, this.__CACHE);\n  }\n  inputHasHDKey(inputIndex, root) {\n    const input = utils_1.checkForInput(this.data.inputs, inputIndex);\n    const derivationIsMine = bip32DerivationIsMine(root);\n    return (\n      !!input.bip32Derivation && input.bip32Derivation.some(derivationIsMine)\n    );\n  }\n  outputHasPubkey(outputIndex, pubkey) {\n    const output = utils_1.checkForOutput(this.data.outputs, outputIndex);\n    return pubkeyInOutput(pubkey, output, outputIndex, this.__CACHE);\n  }\n  outputHasHDKey(outputIndex, root) {\n    const output = utils_1.checkForOutput(this.data.outputs, outputIndex);\n    const derivationIsMine = bip32DerivationIsMine(root);\n    return (\n      !!output.bip32Derivation && output.bip32Derivation.some(derivationIsMine)\n    );\n  }\n  validateSignaturesOfAllInputs() {\n    utils_1.checkForInput(this.data.inputs, 0); // making sure we have at least one\n    const results = range(this.data.inputs.length).map(idx =>\n      this.validateSignaturesOfInput(idx),\n    );\n    return results.reduce((final, res) => res === true && final, true);\n  }\n  validateSignaturesOfInput(inputIndex, pubkey) {\n    const input = this.data.inputs[inputIndex];\n    const partialSig = (input || {}).partialSig;\n    if (!input || !partialSig || partialSig.length < 1)\n      throw new Error('No signatures to validate');\n    const mySigs = pubkey\n      ? partialSig.filter(sig => sig.pubkey.equals(pubkey))\n      : partialSig;\n    if (mySigs.length < 1) throw new Error('No signatures for this pubkey');\n    const results = [];\n    let hashCache;\n    let scriptCache;\n    let sighashCache;\n    for (const pSig of mySigs) {\n      const sig = bscript.signature.decode(pSig.signature);\n      const { hash, script } =\n        sighashCache !== sig.hashType\n          ? getHashForSig(\n              inputIndex,\n              Object.assign({}, input, { sighashType: sig.hashType }),\n              this.__CACHE,\n              true,\n              this.opts.forkCoin,\n            )\n          : { hash: hashCache, script: scriptCache };\n      sighashCache = sig.hashType;\n      hashCache = hash;\n      scriptCache = script;\n      checkScriptForPubkey(pSig.pubkey, script, 'verify');\n      const keypair = ecpair_1.fromPublicKey(pSig.pubkey);\n      results.push(keypair.verify(hash, sig.signature));\n    }\n    return results.every(res => res === true);\n  }\n  signAllInputsHD(hdKeyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {\n      throw new Error('Need HDSigner to sign input');\n    }\n    const results = [];\n    for (const i of range(this.data.inputs.length)) {\n      try {\n        this.signInputHD(i, hdKeyPair, sighashTypes);\n        results.push(true);\n      } catch (err) {\n        results.push(false);\n      }\n    }\n    if (results.every(v => v === false)) {\n      throw new Error('No inputs were signed');\n    }\n    return this;\n  }\n  signAllInputsHDAsync(hdKeyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    return new Promise((resolve, reject) => {\n      if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {\n        return reject(new Error('Need HDSigner to sign input'));\n      }\n      const results = [];\n      const promises = [];\n      for (const i of range(this.data.inputs.length)) {\n        promises.push(\n          this.signInputHDAsync(i, hdKeyPair, sighashTypes).then(\n            () => {\n              results.push(true);\n            },\n            () => {\n              results.push(false);\n            },\n          ),\n        );\n      }\n      return Promise.all(promises).then(() => {\n        if (results.every(v => v === false)) {\n          return reject(new Error('No inputs were signed'));\n        }\n        resolve();\n      });\n    });\n  }\n  signInputHD(inputIndex, hdKeyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {\n      throw new Error('Need HDSigner to sign input');\n    }\n    const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);\n    signers.forEach(signer => this.signInput(inputIndex, signer, sighashTypes));\n    return this;\n  }\n  signInputHDAsync(inputIndex, hdKeyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    return new Promise((resolve, reject) => {\n      if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {\n        return reject(new Error('Need HDSigner to sign input'));\n      }\n      const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);\n      const promises = signers.map(signer =>\n        this.signInputAsync(inputIndex, signer, sighashTypes),\n      );\n      return Promise.all(promises)\n        .then(() => {\n          resolve();\n        })\n        .catch(reject);\n    });\n  }\n  signAllInputs(keyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    if (!keyPair || !keyPair.publicKey)\n      throw new Error('Need Signer to sign input');\n    // TODO: Add a pubkey/pubkeyhash cache to each input\n    // as input information is added, then eventually\n    // optimize this method.\n    const results = [];\n    for (const i of range(this.data.inputs.length)) {\n      try {\n        this.signInput(i, keyPair, sighashTypes);\n        results.push(true);\n      } catch (err) {\n        results.push(false);\n      }\n    }\n    if (results.every(v => v === false)) {\n      throw new Error('No inputs were signed');\n    }\n    return this;\n  }\n  signAllInputsAsync(keyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    return new Promise((resolve, reject) => {\n      if (!keyPair || !keyPair.publicKey)\n        return reject(new Error('Need Signer to sign input'));\n      // TODO: Add a pubkey/pubkeyhash cache to each input\n      // as input information is added, then eventually\n      // optimize this method.\n      const results = [];\n      const promises = [];\n      for (const [i] of this.data.inputs.entries()) {\n        promises.push(\n          this.signInputAsync(i, keyPair, sighashTypes).then(\n            () => {\n              results.push(true);\n            },\n            () => {\n              results.push(false);\n            },\n          ),\n        );\n      }\n      return Promise.all(promises).then(() => {\n        if (results.every(v => v === false)) {\n          return reject(new Error('No inputs were signed'));\n        }\n        resolve();\n      });\n    });\n  }\n  signInput(inputIndex, keyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    if (!keyPair || !keyPair.publicKey)\n      throw new Error('Need Signer to sign input');\n    const { hash, sighashType } = getHashAndSighashType(\n      this.data.inputs,\n      inputIndex,\n      keyPair.publicKey,\n      this.__CACHE,\n      sighashTypes,\n      this.opts.forkCoin,\n    );\n    const partialSig = [\n      {\n        pubkey: keyPair.publicKey,\n        signature: bscript.signature.encode(\n          keyPair.sign(hash),\n          sighashType & 0xff,\n        ),\n      },\n    ];\n    this.data.updateInput(inputIndex, { partialSig });\n    return this;\n  }\n  signInputAsync(inputIndex, keyPair, sighashTypes = DEFAULT_SIGHASHES) {\n    return Promise.resolve().then(() => {\n      if (!keyPair || !keyPair.publicKey)\n        throw new Error('Need Signer to sign input');\n      const { hash, sighashType } = getHashAndSighashType(\n        this.data.inputs,\n        inputIndex,\n        keyPair.publicKey,\n        this.__CACHE,\n        sighashTypes,\n        this.opts.forkCoin,\n      );\n      return Promise.resolve(keyPair.sign(hash)).then(signature => {\n        const partialSig = [\n          {\n            pubkey: keyPair.publicKey,\n            signature: bscript.signature.encode(signature, sighashType & 0xff),\n          },\n        ];\n        this.data.updateInput(inputIndex, { partialSig });\n      });\n    });\n  }\n  toBuffer() {\n    checkCache(this.__CACHE);\n    return this.data.toBuffer();\n  }\n  toHex() {\n    checkCache(this.__CACHE);\n    return this.data.toHex();\n  }\n  toBase64() {\n    checkCache(this.__CACHE);\n    return this.data.toBase64();\n  }\n  updateGlobal(updateData) {\n    this.data.updateGlobal(updateData);\n    return this;\n  }\n  updateInput(inputIndex, updateData) {\n    if (updateData.witnessScript) checkInvalidP2WSH(updateData.witnessScript);\n    this.data.updateInput(inputIndex, updateData);\n    if (updateData.nonWitnessUtxo) {\n      addNonWitnessTxCache(\n        this.__CACHE,\n        this.data.inputs[inputIndex],\n        inputIndex,\n      );\n    }\n    return this;\n  }\n  updateOutput(outputIndex, updateData) {\n    this.data.updateOutput(outputIndex, updateData);\n    return this;\n  }\n  addUnknownKeyValToGlobal(keyVal) {\n    this.data.addUnknownKeyValToGlobal(keyVal);\n    return this;\n  }\n  addUnknownKeyValToInput(inputIndex, keyVal) {\n    this.data.addUnknownKeyValToInput(inputIndex, keyVal);\n    return this;\n  }\n  addUnknownKeyValToOutput(outputIndex, keyVal) {\n    this.data.addUnknownKeyValToOutput(outputIndex, keyVal);\n    return this;\n  }\n  clearFinalizedInput(inputIndex) {\n    this.data.clearFinalizedInput(inputIndex);\n    return this;\n  }\n}\nexports.Psbt = Psbt;\n/**\n * This function is needed to pass to the bip174 base class's fromBuffer.\n * It takes the \"transaction buffer\" portion of the psbt buffer and returns a\n * Transaction (From the bip174 library) interface.\n */\nconst transactionFromBuffer = buffer => new PsbtTransaction(buffer);\n/**\n * This class implements the Transaction interface from bip174 library.\n * It contains a bitcoinjs-lib Transaction object.\n */\nclass PsbtTransaction {\n  constructor(buffer = Buffer.from([2, 0, 0, 0, 0, 0, 0, 0, 0, 0])) {\n    this.tx = transaction_1.Transaction.fromBuffer(buffer);\n    checkTxEmpty(this.tx);\n    Object.defineProperty(this, 'tx', {\n      enumerable: false,\n      writable: true,\n    });\n  }\n  getInputOutputCounts() {\n    return {\n      inputCount: this.tx.ins.length,\n      outputCount: this.tx.outs.length,\n    };\n  }\n  addInput(input) {\n    if (\n      input.hash === undefined ||\n      input.index === undefined ||\n      (!Buffer.isBuffer(input.hash) && typeof input.hash !== 'string') ||\n      typeof input.index !== 'number'\n    ) {\n      throw new Error('Error adding input.');\n    }\n    const hash =\n      typeof input.hash === 'string'\n        ? bufferutils_1.reverseBuffer(Buffer.from(input.hash, 'hex'))\n        : input.hash;\n    this.tx.addInput(hash, input.index, input.sequence);\n  }\n  addOutput(output) {\n    if (\n      output.script === undefined ||\n      output.value === undefined ||\n      !Buffer.isBuffer(output.script) ||\n      typeof output.value !== 'number'\n    ) {\n      throw new Error('Error adding output.');\n    }\n    this.tx.addOutput(output.script, output.value);\n  }\n  toBuffer() {\n    return this.tx.toBuffer();\n  }\n}\nfunction canFinalize(input, script, scriptType) {\n  switch (scriptType) {\n    case 'pubkey':\n    case 'pubkeyhash':\n    case 'witnesspubkeyhash':\n      return hasSigs(1, input.partialSig);\n    case 'multisig':\n      const p2ms = payments.p2ms({ output: script });\n      return hasSigs(p2ms.m, input.partialSig, p2ms.pubkeys);\n    default:\n      return false;\n  }\n}\nfunction checkCache(cache) {\n  if (cache.__UNSAFE_SIGN_NONSEGWIT !== false) {\n    throw new Error('Not BIP174 compliant, can not export');\n  }\n}\nfunction hasSigs(neededSigs, partialSig, pubkeys) {\n  if (!partialSig) return false;\n  let sigs;\n  if (pubkeys) {\n    sigs = pubkeys\n      .map(pkey => {\n        const pubkey = ecpair_1.fromPublicKey(pkey, { compressed: true })\n          .publicKey;\n        return partialSig.find(pSig => pSig.pubkey.equals(pubkey));\n      })\n      .filter(v => !!v);\n  } else {\n    sigs = partialSig;\n  }\n  if (sigs.length > neededSigs) throw new Error('Too many signatures');\n  return sigs.length === neededSigs;\n}\nfunction isFinalized(input) {\n  return !!input.finalScriptSig || !!input.finalScriptWitness;\n}\nfunction isPaymentFactory(payment) {\n  return script => {\n    try {\n      payment({ output: script });\n      return true;\n    } catch (err) {\n      return false;\n    }\n  };\n}\nconst isP2MS = isPaymentFactory(payments.p2ms);\nconst isP2PK = isPaymentFactory(payments.p2pk);\nconst isP2PKH = isPaymentFactory(payments.p2pkh);\nconst isP2WPKH = isPaymentFactory(payments.p2wpkh);\nconst isP2WSHScript = isPaymentFactory(payments.p2wsh);\nconst isP2SHScript = isPaymentFactory(payments.p2sh);\nfunction bip32DerivationIsMine(root) {\n  return d => {\n    if (!d.masterFingerprint.equals(root.fingerprint)) return false;\n    if (!root.derivePath(d.path).publicKey.equals(d.pubkey)) return false;\n    return true;\n  };\n}\nfunction check32Bit(num) {\n  if (\n    typeof num !== 'number' ||\n    num !== Math.floor(num) ||\n    num > 0xffffffff ||\n    num < 0\n  ) {\n    throw new Error('Invalid 32 bit integer');\n  }\n}\nfunction checkFees(psbt, cache, opts) {\n  const feeRate = cache.__FEE_RATE || psbt.getFeeRate();\n  const vsize = cache.__EXTRACTED_TX.virtualSize();\n  const satoshis = feeRate * vsize;\n  if (feeRate >= opts.maximumFeeRate) {\n    throw new Error(\n      `Warning: You are paying around ${(satoshis / 1e8).toFixed(8)} in ` +\n        `fees, which is ${feeRate} satoshi per byte for a transaction ` +\n        `with a VSize of ${vsize} bytes (segwit counted as 0.25 byte per ` +\n        `byte). Use setMaximumFeeRate method to raise your threshold, or ` +\n        `pass true to the first arg of extractTransaction.`,\n    );\n  }\n}\nfunction checkInputsForPartialSig(inputs, action) {\n  inputs.forEach(input => {\n    let throws = false;\n    let pSigs = [];\n    if ((input.partialSig || []).length === 0) {\n      if (!input.finalScriptSig && !input.finalScriptWitness) return;\n      pSigs = getPsigsFromInputFinalScripts(input);\n    } else {\n      pSigs = input.partialSig;\n    }\n    pSigs.forEach(pSig => {\n      const { hashType } = bscript.signature.decode(pSig.signature);\n      const whitelist = [];\n      const isAnyoneCanPay =\n        hashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY;\n      if (isAnyoneCanPay) whitelist.push('addInput');\n      const hashMod = hashType & 0x1f;\n      switch (hashMod) {\n        case transaction_1.Transaction.SIGHASH_ALL:\n          break;\n        case transaction_1.Transaction.SIGHASH_SINGLE:\n        case transaction_1.Transaction.SIGHASH_NONE:\n          whitelist.push('addOutput');\n          whitelist.push('setInputSequence');\n          break;\n      }\n      if (whitelist.indexOf(action) === -1) {\n        throws = true;\n      }\n    });\n    if (throws) {\n      throw new Error('Can not modify transaction, signatures exist.');\n    }\n  });\n}\nfunction checkPartialSigSighashes(input) {\n  if (!input.sighashType || !input.partialSig) return;\n  const { partialSig, sighashType } = input;\n  partialSig.forEach(pSig => {\n    const { hashType } = bscript.signature.decode(pSig.signature);\n    if ((sighashType & 0xff) !== hashType) {\n      throw new Error('Signature sighash does not match input sighash type');\n    }\n  });\n}\nfunction checkScriptForPubkey(pubkey, script, action) {\n  if (!pubkeyInScript(pubkey, script)) {\n    throw new Error(\n      `Can not ${action} for this input with the key ${pubkey.toString('hex')}`,\n    );\n  }\n}\nfunction checkTxEmpty(tx) {\n  const isEmpty = tx.ins.every(\n    input =>\n      input.script &&\n      input.script.length === 0 &&\n      input.witness &&\n      input.witness.length === 0,\n  );\n  if (!isEmpty) {\n    throw new Error('Format Error: Transaction ScriptSigs are not empty');\n  }\n}\nfunction checkTxForDupeIns(tx, cache) {\n  tx.ins.forEach(input => {\n    checkTxInputCache(cache, input);\n  });\n}\nfunction checkTxInputCache(cache, input) {\n  const key =\n    bufferutils_1.reverseBuffer(Buffer.from(input.hash)).toString('hex') +\n    ':' +\n    input.index;\n  if (cache.__TX_IN_CACHE[key]) throw new Error('Duplicate input detected.');\n  cache.__TX_IN_CACHE[key] = 1;\n}\nfunction scriptCheckerFactory(payment, paymentScriptName) {\n  return (inputIndex, scriptPubKey, redeemScript, ioType) => {\n    const redeemScriptOutput = payment({\n      redeem: { output: redeemScript },\n    }).output;\n    if (!scriptPubKey.equals(redeemScriptOutput)) {\n      throw new Error(\n        `${paymentScriptName} for ${ioType} #${inputIndex} doesn't match the scriptPubKey in the prevout`,\n      );\n    }\n  };\n}\nconst checkRedeemScript = scriptCheckerFactory(payments.p2sh, 'Redeem script');\nconst checkWitnessScript = scriptCheckerFactory(\n  payments.p2wsh,\n  'Witness script',\n);\nfunction getTxCacheValue(key, name, inputs, c) {\n  if (!inputs.every(isFinalized))\n    throw new Error(`PSBT must be finalized to calculate ${name}`);\n  if (key === '__FEE_RATE' && c.__FEE_RATE) return c.__FEE_RATE;\n  if (key === '__FEE' && c.__FEE) return c.__FEE;\n  let tx;\n  let mustFinalize = true;\n  if (c.__EXTRACTED_TX) {\n    tx = c.__EXTRACTED_TX;\n    mustFinalize = false;\n  } else {\n    tx = c.__TX.clone();\n  }\n  inputFinalizeGetAmts(inputs, tx, c, mustFinalize);\n  if (key === '__FEE_RATE') return c.__FEE_RATE;\n  else if (key === '__FEE') return c.__FEE;\n}\nfunction getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH) {\n  const scriptType = classifyScript(script);\n  if (!canFinalize(input, script, scriptType))\n    throw new Error(`Can not finalize input #${inputIndex}`);\n  return prepareFinalScripts(\n    script,\n    scriptType,\n    input.partialSig,\n    isSegwit,\n    isP2SH,\n    isP2WSH,\n  );\n}\nfunction prepareFinalScripts(\n  script,\n  scriptType,\n  partialSig,\n  isSegwit,\n  isP2SH,\n  isP2WSH,\n) {\n  let finalScriptSig;\n  let finalScriptWitness;\n  // Wow, the payments API is very handy\n  const payment = getPayment(script, scriptType, partialSig);\n  const p2wsh = !isP2WSH ? null : payments.p2wsh({ redeem: payment });\n  const p2sh = !isP2SH ? null : payments.p2sh({ redeem: p2wsh || payment });\n  if (isSegwit) {\n    if (p2wsh) {\n      finalScriptWitness = witnessStackToScriptWitness(p2wsh.witness);\n    } else {\n      finalScriptWitness = witnessStackToScriptWitness(payment.witness);\n    }\n    if (p2sh) {\n      finalScriptSig = p2sh.input;\n    }\n  } else {\n    if (p2sh) {\n      finalScriptSig = p2sh.input;\n    } else {\n      finalScriptSig = payment.input;\n    }\n  }\n  return {\n    finalScriptSig,\n    finalScriptWitness,\n  };\n}\nfunction getHashAndSighashType(\n  inputs,\n  inputIndex,\n  pubkey,\n  cache,\n  sighashTypes,\n  forkCoin,\n) {\n  const input = utils_1.checkForInput(inputs, inputIndex);\n  const { hash, sighashType, script } = getHashForSig(\n    inputIndex,\n    input,\n    cache,\n    false,\n    forkCoin,\n    sighashTypes,\n  );\n  checkScriptForPubkey(pubkey, script, 'sign');\n  return {\n    hash,\n    sighashType,\n  };\n}\nfunction getDefaultSighash(forkCoin) {\n  switch (forkCoin) {\n    case 'bch':\n      return BCH_SIGHASH_ALL;\n    case 'btg':\n      return BTG_SIGHASH_ALL;\n    case 'none':\n      return transaction_1.Transaction.SIGHASH_ALL;\n  }\n}\nfunction getHashForSig(\n  inputIndex,\n  input,\n  cache,\n  forValidate,\n  forkCoin,\n  sighashTypes,\n) {\n  const unsignedTx = cache.__TX;\n  const sighashType = input.sighashType || getDefaultSighash(forkCoin);\n  if (sighashTypes && sighashTypes.indexOf(sighashType) < 0) {\n    const str = sighashTypeToString(sighashType);\n    throw new Error(\n      `Sighash type is not allowed. Retry the sign method passing the ` +\n        `sighashTypes array of whitelisted types. Sighash type: ${str}`,\n    );\n  }\n  let hash;\n  let prevout;\n  const isForkId =\n    (sighashType & transaction_1.Transaction.SIGHASH_BITCOINCASHBIP143) > 0;\n  const isBTG = (sighashType & (transaction_1.Transaction.FORKID_BTG << 8)) > 0;\n  if (input.nonWitnessUtxo) {\n    const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(\n      cache,\n      input,\n      inputIndex,\n    );\n    const prevoutHash = unsignedTx.ins[inputIndex].hash;\n    const utxoHash = nonWitnessUtxoTx.getHash();\n    // If a non-witness UTXO is provided, its hash must match the hash specified in the prevout\n    if (!prevoutHash.equals(utxoHash)) {\n      throw new Error(\n        `Non-witness UTXO hash for input #${inputIndex} doesn't match the hash specified in the prevout`,\n      );\n    }\n    const prevoutIndex = unsignedTx.ins[inputIndex].index;\n    prevout = nonWitnessUtxoTx.outs[prevoutIndex];\n  } else if (input.witnessUtxo) {\n    prevout = input.witnessUtxo;\n  } else {\n    throw new Error('Need a Utxo input item for signing');\n  }\n  const { meaningfulScript, type } = getMeaningfulScript(\n    prevout.script,\n    inputIndex,\n    'input',\n    input.redeemScript,\n    input.witnessScript,\n  );\n  if (['p2sh-p2wsh', 'p2wsh'].indexOf(type) >= 0) {\n    if (isForkId && isBTG) {\n      hash = unsignedTx.hashForGoldSignature(\n        inputIndex,\n        meaningfulScript,\n        prevout.value,\n        sighashType,\n        true,\n      );\n    } else {\n      hash = unsignedTx.hashForWitnessV0(\n        inputIndex,\n        meaningfulScript,\n        prevout.value,\n        sighashType,\n      );\n    }\n  } else if (isP2WPKH(meaningfulScript)) {\n    // P2WPKH uses the P2PKH template for prevoutScript when signing\n    const signingScript = payments.p2pkh({ hash: meaningfulScript.slice(2) })\n      .output;\n    if (isForkId && isBTG) {\n      hash = unsignedTx.hashForGoldSignature(\n        inputIndex,\n        signingScript,\n        prevout.value,\n        sighashType,\n        true,\n      );\n    } else {\n      hash = unsignedTx.hashForWitnessV0(\n        inputIndex,\n        signingScript,\n        prevout.value,\n        sighashType,\n      );\n    }\n  } else {\n    // non-segwit\n    if (\n      !isForkId &&\n      input.nonWitnessUtxo === undefined &&\n      cache.__UNSAFE_SIGN_NONSEGWIT === false\n    )\n      throw new Error(\n        `Input #${inputIndex} has witnessUtxo but non-segwit script: ` +\n          `${meaningfulScript.toString('hex')}`,\n      );\n    if (!forValidate && cache.__UNSAFE_SIGN_NONSEGWIT !== false)\n      console.warn(\n        'Warning: Signing non-segwit inputs without the full parent transaction ' +\n          'means there is a chance that a miner could feed you incorrect information ' +\n          'to trick you into paying large fees. This behavior is the same as the old ' +\n          'TransactionBuilder class when signing non-segwit scripts. You are not ' +\n          'able to export this Psbt with toBuffer|toBase64|toHex since it is not ' +\n          'BIP174 compliant.\\n*********************\\nPROCEED WITH CAUTION!\\n' +\n          '*********************',\n      );\n    if (isForkId && isBTG) {\n      hash = unsignedTx.hashForGoldSignature(\n        inputIndex,\n        meaningfulScript,\n        prevout.value,\n        sighashType,\n        true,\n      );\n    } else if (isForkId) {\n      hash = unsignedTx.hashForCashSignature(\n        inputIndex,\n        meaningfulScript,\n        prevout.value,\n        sighashType,\n      );\n    } else {\n      hash = unsignedTx.hashForSignature(\n        inputIndex,\n        meaningfulScript,\n        sighashType,\n      );\n    }\n  }\n  return {\n    script: meaningfulScript,\n    sighashType,\n    hash,\n  };\n}\nfunction getPayment(script, scriptType, partialSig) {\n  let payment;\n  switch (scriptType) {\n    case 'multisig':\n      const sigs = getSortedSigs(script, partialSig);\n      payment = payments.p2ms({\n        output: script,\n        signatures: sigs,\n      });\n      break;\n    case 'pubkey':\n      payment = payments.p2pk({\n        output: script,\n        signature: partialSig[0].signature,\n      });\n      break;\n    case 'pubkeyhash':\n      payment = payments.p2pkh({\n        output: script,\n        pubkey: partialSig[0].pubkey,\n        signature: partialSig[0].signature,\n      });\n      break;\n    case 'witnesspubkeyhash':\n      payment = payments.p2wpkh({\n        output: script,\n        pubkey: partialSig[0].pubkey,\n        signature: partialSig[0].signature,\n      });\n      break;\n  }\n  return payment;\n}\nfunction getPsigsFromInputFinalScripts(input) {\n  const scriptItems = !input.finalScriptSig\n    ? []\n    : bscript.decompile(input.finalScriptSig) || [];\n  const witnessItems = !input.finalScriptWitness\n    ? []\n    : bscript.decompile(input.finalScriptWitness) || [];\n  return scriptItems\n    .concat(witnessItems)\n    .filter(item => {\n      return Buffer.isBuffer(item) && bscript.isCanonicalScriptSignature(item);\n    })\n    .map(sig => ({ signature: sig }));\n}\nfunction getScriptFromInput(inputIndex, input, cache) {\n  const unsignedTx = cache.__TX;\n  const res = {\n    script: null,\n    isSegwit: false,\n    isP2SH: false,\n    isP2WSH: false,\n  };\n  res.isP2SH = !!input.redeemScript;\n  res.isP2WSH = !!input.witnessScript;\n  if (input.witnessScript) {\n    res.script = input.witnessScript;\n  } else if (input.redeemScript) {\n    res.script = input.redeemScript;\n  } else {\n    if (input.nonWitnessUtxo) {\n      const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(\n        cache,\n        input,\n        inputIndex,\n      );\n      const prevoutIndex = unsignedTx.ins[inputIndex].index;\n      res.script = nonWitnessUtxoTx.outs[prevoutIndex].script;\n    } else if (input.witnessUtxo) {\n      res.script = input.witnessUtxo.script;\n    }\n  }\n  if (input.witnessScript || isP2WPKH(res.script)) {\n    res.isSegwit = true;\n  }\n  return res;\n}\nfunction getSignersFromHD(inputIndex, inputs, hdKeyPair) {\n  const input = utils_1.checkForInput(inputs, inputIndex);\n  if (!input.bip32Derivation || input.bip32Derivation.length === 0) {\n    throw new Error('Need bip32Derivation to sign with HD');\n  }\n  const myDerivations = input.bip32Derivation\n    .map(bipDv => {\n      if (bipDv.masterFingerprint.equals(hdKeyPair.fingerprint)) {\n        return bipDv;\n      } else {\n        return;\n      }\n    })\n    .filter(v => !!v);\n  if (myDerivations.length === 0) {\n    throw new Error(\n      'Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint',\n    );\n  }\n  const signers = myDerivations.map(bipDv => {\n    const node = hdKeyPair.derivePath(bipDv.path);\n    if (!bipDv.pubkey.equals(node.publicKey)) {\n      throw new Error('pubkey did not match bip32Derivation');\n    }\n    return node;\n  });\n  return signers;\n}\nfunction getSortedSigs(script, partialSig) {\n  const p2ms = payments.p2ms({ output: script });\n  // for each pubkey in order of p2ms script\n  return p2ms.pubkeys\n    .map(pk => {\n      // filter partialSig array by pubkey being equal\n      return (\n        partialSig.filter(ps => {\n          return ps.pubkey.equals(pk);\n        })[0] || {}\n      ).signature;\n      // Any pubkey without a match will return undefined\n      // this last filter removes all the undefined items in the array.\n    })\n    .filter(v => !!v);\n}\nfunction scriptWitnessToWitnessStack(buffer) {\n  let offset = 0;\n  function readSlice(n) {\n    offset += n;\n    return buffer.slice(offset - n, offset);\n  }\n  function readVarInt() {\n    const vi = varuint.decode(buffer, offset);\n    offset += varuint.decode.bytes;\n    return vi;\n  }\n  function readVarSlice() {\n    return readSlice(readVarInt());\n  }\n  function readVector() {\n    const count = readVarInt();\n    const vector = [];\n    for (let i = 0; i < count; i++) vector.push(readVarSlice());\n    return vector;\n  }\n  return readVector();\n}\nfunction sighashTypeToString(sighashType) {\n  let text =\n    sighashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY\n      ? 'SIGHASH_ANYONECANPAY | '\n      : '';\n  if (sighashType & transaction_1.Transaction.SIGHASH_BITCOINCASHBIP143)\n    text += 'SIGHASH_BITCOINCASHBIP143 | ';\n  if (sighashType & (transaction_1.Transaction.FORKID_BTG << 8)) {\n    text += 'FORKID_BTG | ';\n  } else {\n    text += 'FORKID_BCH | ';\n  }\n  const sigMod = sighashType & 0x1f;\n  switch (sigMod) {\n    case transaction_1.Transaction.SIGHASH_ALL:\n      text += 'SIGHASH_ALL';\n      break;\n    case transaction_1.Transaction.SIGHASH_SINGLE:\n      text += 'SIGHASH_SINGLE';\n      break;\n    case transaction_1.Transaction.SIGHASH_NONE:\n      text += 'SIGHASH_NONE';\n      break;\n  }\n  return text;\n}\nfunction witnessStackToScriptWitness(witness) {\n  let buffer = Buffer.allocUnsafe(0);\n  function writeSlice(slice) {\n    buffer = Buffer.concat([buffer, Buffer.from(slice)]);\n  }\n  function writeVarInt(i) {\n    const currentLen = buffer.length;\n    const varintLen = varuint.encodingLength(i);\n    buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);\n    varuint.encode(i, buffer, currentLen);\n  }\n  function writeVarSlice(slice) {\n    writeVarInt(slice.length);\n    writeSlice(slice);\n  }\n  function writeVector(vector) {\n    writeVarInt(vector.length);\n    vector.forEach(writeVarSlice);\n  }\n  writeVector(witness);\n  return buffer;\n}\nfunction addNonWitnessTxCache(cache, input, inputIndex) {\n  cache.__NON_WITNESS_UTXO_BUF_CACHE[inputIndex] = input.nonWitnessUtxo;\n  const tx = transaction_1.Transaction.fromBuffer(input.nonWitnessUtxo);\n  cache.__NON_WITNESS_UTXO_TX_CACHE[inputIndex] = tx;\n  const self = cache;\n  const selfIndex = inputIndex;\n  delete input.nonWitnessUtxo;\n  Object.defineProperty(input, 'nonWitnessUtxo', {\n    enumerable: true,\n    get() {\n      const buf = self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex];\n      const txCache = self.__NON_WITNESS_UTXO_TX_CACHE[selfIndex];\n      if (buf !== undefined) {\n        return buf;\n      } else {\n        const newBuf = txCache.toBuffer();\n        self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = newBuf;\n        return newBuf;\n      }\n    },\n    set(data) {\n      self.__NON_WITNESS_UTXO_BUF_CACHE[selfIndex] = data;\n    },\n  });\n}\nfunction inputFinalizeGetAmts(inputs, tx, cache, mustFinalize) {\n  let inputAmount = 0;\n  inputs.forEach((input, idx) => {\n    if (mustFinalize && input.finalScriptSig)\n      tx.ins[idx].script = input.finalScriptSig;\n    if (mustFinalize && input.finalScriptWitness) {\n      tx.ins[idx].witness = scriptWitnessToWitnessStack(\n        input.finalScriptWitness,\n      );\n    }\n    if (input.witnessUtxo) {\n      inputAmount += input.witnessUtxo.value;\n    } else if (input.nonWitnessUtxo) {\n      const nwTx = nonWitnessUtxoTxFromCache(cache, input, idx);\n      const vout = tx.ins[idx].index;\n      const out = nwTx.outs[vout];\n      inputAmount += out.value;\n    }\n  });\n  const outputAmount = tx.outs.reduce((total, o) => total + o.value, 0);\n  const fee = inputAmount - outputAmount;\n  if (fee < 0) {\n    throw new Error('Outputs are spending more than Inputs');\n  }\n  const bytes = tx.virtualSize();\n  cache.__FEE = fee;\n  cache.__EXTRACTED_TX = tx;\n  cache.__FEE_RATE = Math.floor(fee / bytes);\n}\nfunction nonWitnessUtxoTxFromCache(cache, input, inputIndex) {\n  const c = cache.__NON_WITNESS_UTXO_TX_CACHE;\n  if (!c[inputIndex]) {\n    addNonWitnessTxCache(cache, input, inputIndex);\n  }\n  return c[inputIndex];\n}\nfunction getScriptFromUtxo(inputIndex, input, cache) {\n  if (input.witnessUtxo !== undefined) {\n    return input.witnessUtxo.script;\n  } else if (input.nonWitnessUtxo !== undefined) {\n    const nonWitnessUtxoTx = nonWitnessUtxoTxFromCache(\n      cache,\n      input,\n      inputIndex,\n    );\n    return nonWitnessUtxoTx.outs[cache.__TX.ins[inputIndex].index].script;\n  } else {\n    throw new Error(\"Can't find pubkey in input without Utxo data\");\n  }\n}\nfunction pubkeyInInput(pubkey, input, inputIndex, cache) {\n  const script = getScriptFromUtxo(inputIndex, input, cache);\n  const { meaningfulScript } = getMeaningfulScript(\n    script,\n    inputIndex,\n    'input',\n    input.redeemScript,\n    input.witnessScript,\n  );\n  return pubkeyInScript(pubkey, meaningfulScript);\n}\nfunction pubkeyInOutput(pubkey, output, outputIndex, cache) {\n  const script = cache.__TX.outs[outputIndex].script;\n  const { meaningfulScript } = getMeaningfulScript(\n    script,\n    outputIndex,\n    'output',\n    output.redeemScript,\n    output.witnessScript,\n  );\n  return pubkeyInScript(pubkey, meaningfulScript);\n}\nfunction redeemFromFinalScriptSig(finalScript) {\n  if (!finalScript) return;\n  const decomp = bscript.decompile(finalScript);\n  if (!decomp) return;\n  const lastItem = decomp[decomp.length - 1];\n  if (\n    !Buffer.isBuffer(lastItem) ||\n    isPubkeyLike(lastItem) ||\n    isSigLike(lastItem)\n  )\n    return;\n  const sDecomp = bscript.decompile(lastItem);\n  if (!sDecomp) return;\n  return lastItem;\n}\nfunction redeemFromFinalWitnessScript(finalScript) {\n  if (!finalScript) return;\n  const decomp = scriptWitnessToWitnessStack(finalScript);\n  const lastItem = decomp[decomp.length - 1];\n  if (isPubkeyLike(lastItem)) return;\n  const sDecomp = bscript.decompile(lastItem);\n  if (!sDecomp) return;\n  return lastItem;\n}\nfunction isPubkeyLike(buf) {\n  return buf.length === 33 && bscript.isCanonicalPubKey(buf);\n}\nfunction isSigLike(buf) {\n  return bscript.isCanonicalScriptSignature(buf);\n}\nfunction getMeaningfulScript(\n  script,\n  index,\n  ioType,\n  redeemScript,\n  witnessScript,\n) {\n  const isP2SH = isP2SHScript(script);\n  const isP2SHP2WSH = isP2SH && redeemScript && isP2WSHScript(redeemScript);\n  const isP2WSH = isP2WSHScript(script);\n  if (isP2SH && redeemScript === undefined)\n    throw new Error('scriptPubkey is P2SH but redeemScript missing');\n  if ((isP2WSH || isP2SHP2WSH) && witnessScript === undefined)\n    throw new Error(\n      'scriptPubkey or redeemScript is P2WSH but witnessScript missing',\n    );\n  let meaningfulScript;\n  if (isP2SHP2WSH) {\n    meaningfulScript = witnessScript;\n    checkRedeemScript(index, script, redeemScript, ioType);\n    checkWitnessScript(index, redeemScript, witnessScript, ioType);\n    checkInvalidP2WSH(meaningfulScript);\n  } else if (isP2WSH) {\n    meaningfulScript = witnessScript;\n    checkWitnessScript(index, script, witnessScript, ioType);\n    checkInvalidP2WSH(meaningfulScript);\n  } else if (isP2SH) {\n    meaningfulScript = redeemScript;\n    checkRedeemScript(index, script, redeemScript, ioType);\n  } else {\n    meaningfulScript = script;\n  }\n  return {\n    meaningfulScript,\n    type: isP2SHP2WSH\n      ? 'p2sh-p2wsh'\n      : isP2SH\n      ? 'p2sh'\n      : isP2WSH\n      ? 'p2wsh'\n      : 'raw',\n  };\n}\nfunction checkInvalidP2WSH(script) {\n  if (isP2WPKH(script) || isP2SHScript(script)) {\n    throw new Error('P2WPKH or P2SH can not be contained within P2WSH');\n  }\n}\nfunction pubkeyInScript(pubkey, script) {\n  const pubkeyHash = crypto_1.hash160(pubkey);\n  const decompiled = bscript.decompile(script);\n  if (decompiled === null) throw new Error('Unknown script error');\n  return decompiled.some(element => {\n    if (typeof element === 'number') return false;\n    return element.equals(pubkey) || element.equals(pubkeyHash);\n  });\n}\nfunction classifyScript(script) {\n  if (isP2WPKH(script)) return 'witnesspubkeyhash';\n  if (isP2PKH(script)) return 'pubkeyhash';\n  if (isP2MS(script)) return 'multisig';\n  if (isP2PK(script)) return 'pubkey';\n  return 'nonstandard';\n}\nfunction range(n) {\n  return [...Array(n).keys()];\n}\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst scriptNumber = require('./script_number');\nconst scriptSignature = require('./script_signature');\nconst types = require('./types');\nconst bip66 = require('bip66');\nconst ecc = require('tiny-secp256k1');\nconst pushdata = require('pushdata-bitcoin');\nconst typeforce = require('typeforce');\nexports.OPS = require('bitcoin-ops');\nconst REVERSE_OPS = require('bitcoin-ops/map');\nconst OP_INT_BASE = exports.OPS.OP_RESERVED; // OP_1 - 1\nfunction isOPInt(value) {\n  return (\n    types.Number(value) &&\n    (value === exports.OPS.OP_0 ||\n      (value >= exports.OPS.OP_1 && value <= exports.OPS.OP_16) ||\n      value === exports.OPS.OP_1NEGATE)\n  );\n}\nfunction isPushOnlyChunk(value) {\n  return types.Buffer(value) || isOPInt(value);\n}\nfunction isPushOnly(value) {\n  return types.Array(value) && value.every(isPushOnlyChunk);\n}\nexports.isPushOnly = isPushOnly;\nfunction asMinimalOP(buffer) {\n  if (buffer.length === 0) return exports.OPS.OP_0;\n  if (buffer.length !== 1) return;\n  if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];\n  if (buffer[0] === 0x81) return exports.OPS.OP_1NEGATE;\n}\nfunction chunksIsBuffer(buf) {\n  return Buffer.isBuffer(buf);\n}\nfunction chunksIsArray(buf) {\n  return types.Array(buf);\n}\nfunction singleChunkIsBuffer(buf) {\n  return Buffer.isBuffer(buf);\n}\nfunction compile(chunks) {\n  // TODO: remove me\n  if (chunksIsBuffer(chunks)) return chunks;\n  typeforce(types.Array, chunks);\n  const bufferSize = chunks.reduce((accum, chunk) => {\n    // data chunk\n    if (singleChunkIsBuffer(chunk)) {\n      // adhere to BIP62.3, minimal push policy\n      if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {\n        return accum + 1;\n      }\n      return accum + pushdata.encodingLength(chunk.length) + chunk.length;\n    }\n    // opcode\n    return accum + 1;\n  }, 0.0);\n  const buffer = Buffer.allocUnsafe(bufferSize);\n  let offset = 0;\n  chunks.forEach(chunk => {\n    // data chunk\n    if (singleChunkIsBuffer(chunk)) {\n      // adhere to BIP62.3, minimal push policy\n      const opcode = asMinimalOP(chunk);\n      if (opcode !== undefined) {\n        buffer.writeUInt8(opcode, offset);\n        offset += 1;\n        return;\n      }\n      offset += pushdata.encode(buffer, chunk.length, offset);\n      chunk.copy(buffer, offset);\n      offset += chunk.length;\n      // opcode\n    } else {\n      buffer.writeUInt8(chunk, offset);\n      offset += 1;\n    }\n  });\n  if (offset !== buffer.length) throw new Error('Could not decode chunks');\n  return buffer;\n}\nexports.compile = compile;\nfunction decompile(buffer) {\n  // TODO: remove me\n  if (chunksIsArray(buffer)) return buffer;\n  typeforce(types.Buffer, buffer);\n  const chunks = [];\n  let i = 0;\n  while (i < buffer.length) {\n    const opcode = buffer[i];\n    // data chunk\n    if (opcode > exports.OPS.OP_0 && opcode <= exports.OPS.OP_PUSHDATA4) {\n      const d = pushdata.decode(buffer, i);\n      // did reading a pushDataInt fail?\n      if (d === null) return null;\n      i += d.size;\n      // attempt to read too much data?\n      if (i + d.number > buffer.length) return null;\n      const data = buffer.slice(i, i + d.number);\n      i += d.number;\n      // decompile minimally\n      const op = asMinimalOP(data);\n      if (op !== undefined) {\n        chunks.push(op);\n      } else {\n        chunks.push(data);\n      }\n      // opcode\n    } else {\n      chunks.push(opcode);\n      i += 1;\n    }\n  }\n  return chunks;\n}\nexports.decompile = decompile;\nfunction toASM(chunks) {\n  if (chunksIsBuffer(chunks)) {\n    chunks = decompile(chunks);\n  }\n  return chunks\n    .map(chunk => {\n      // data?\n      if (singleChunkIsBuffer(chunk)) {\n        const op = asMinimalOP(chunk);\n        if (op === undefined) return chunk.toString('hex');\n        chunk = op;\n      }\n      // opcode!\n      return REVERSE_OPS[chunk];\n    })\n    .join(' ');\n}\nexports.toASM = toASM;\nfunction fromASM(asm) {\n  typeforce(types.String, asm);\n  return compile(\n    asm.split(' ').map(chunkStr => {\n      // opcode?\n      if (exports.OPS[chunkStr] !== undefined) return exports.OPS[chunkStr];\n      typeforce(types.Hex, chunkStr);\n      // data!\n      return Buffer.from(chunkStr, 'hex');\n    }),\n  );\n}\nexports.fromASM = fromASM;\nfunction toStack(chunks) {\n  chunks = decompile(chunks);\n  typeforce(isPushOnly, chunks);\n  return chunks.map(op => {\n    if (singleChunkIsBuffer(op)) return op;\n    if (op === exports.OPS.OP_0) return Buffer.allocUnsafe(0);\n    return scriptNumber.encode(op - OP_INT_BASE);\n  });\n}\nexports.toStack = toStack;\nfunction isCanonicalPubKey(buffer) {\n  return ecc.isPoint(buffer);\n}\nexports.isCanonicalPubKey = isCanonicalPubKey;\nfunction isDefinedHashType(hashType) {\n  const hashTypeMod = hashType & ~0xc0;\n  // return hashTypeMod > SIGHASH_ALL && hashTypeMod < SIGHASH_SINGLE\n  return hashTypeMod > 0x00 && hashTypeMod < 0x04;\n}\nexports.isDefinedHashType = isDefinedHashType;\nfunction isCanonicalScriptSignature(buffer) {\n  if (!Buffer.isBuffer(buffer)) return false;\n  if (!isDefinedHashType(buffer[buffer.length - 1])) return false;\n  return bip66.check(buffer.slice(0, -1));\n}\nexports.isCanonicalScriptSignature = isCanonicalScriptSignature;\n// tslint:disable-next-line variable-name\nexports.number = scriptNumber;\nexports.signature = scriptSignature;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nfunction decode(buffer, maxLength, minimal) {\n  maxLength = maxLength || 4;\n  minimal = minimal === undefined ? true : minimal;\n  const length = buffer.length;\n  if (length === 0) return 0;\n  if (length > maxLength) throw new TypeError('Script number overflow');\n  if (minimal) {\n    if ((buffer[length - 1] & 0x7f) === 0) {\n      if (length <= 1 || (buffer[length - 2] & 0x80) === 0)\n        throw new Error('Non-minimally encoded script number');\n    }\n  }\n  // 40-bit\n  if (length === 5) {\n    const a = buffer.readUInt32LE(0);\n    const b = buffer.readUInt8(4);\n    if (b & 0x80) return -((b & ~0x80) * 0x100000000 + a);\n    return b * 0x100000000 + a;\n  }\n  // 32-bit / 24-bit / 16-bit / 8-bit\n  let result = 0;\n  for (let i = 0; i < length; ++i) {\n    result |= buffer[i] << (8 * i);\n  }\n  if (buffer[length - 1] & 0x80)\n    return -(result & ~(0x80 << (8 * (length - 1))));\n  return result;\n}\nexports.decode = decode;\nfunction scriptNumSize(i) {\n  return i > 0x7fffffff\n    ? 5\n    : i > 0x7fffff\n    ? 4\n    : i > 0x7fff\n    ? 3\n    : i > 0x7f\n    ? 2\n    : i > 0x00\n    ? 1\n    : 0;\n}\nfunction encode(_number) {\n  let value = Math.abs(_number);\n  const size = scriptNumSize(value);\n  const buffer = Buffer.allocUnsafe(size);\n  const negative = _number < 0;\n  for (let i = 0; i < size; ++i) {\n    buffer.writeUInt8(value & 0xff, i);\n    value >>= 8;\n  }\n  if (buffer[size - 1] & 0x80) {\n    buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);\n  } else if (negative) {\n    buffer[size - 1] |= 0x80;\n  }\n  return buffer;\n}\nexports.encode = encode;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst types = require('./types');\nconst bip66 = require('bip66');\nconst typeforce = require('typeforce');\nconst ZERO = Buffer.alloc(1, 0);\nfunction toDER(x) {\n  let i = 0;\n  while (x[i] === 0) ++i;\n  if (i === x.length) return ZERO;\n  x = x.slice(i);\n  if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length);\n  return x;\n}\nfunction fromDER(x) {\n  if (x[0] === 0x00) x = x.slice(1);\n  const buffer = Buffer.alloc(32, 0);\n  const bstart = Math.max(0, 32 - x.length);\n  x.copy(buffer, bstart);\n  return buffer;\n}\n// BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are allowed)\nfunction decode(buffer) {\n  const hashType = buffer.readUInt8(buffer.length - 1);\n  const hashTypeMod = hashType & ~0xc0;\n  if (hashTypeMod <= 0 || hashTypeMod >= 4)\n    throw new Error('Invalid hashType ' + hashType);\n  const decoded = bip66.decode(buffer.slice(0, -1));\n  const r = fromDER(decoded.r);\n  const s = fromDER(decoded.s);\n  const signature = Buffer.concat([r, s], 64);\n  return { signature, hashType };\n}\nexports.decode = decode;\nfunction encode(signature, hashType) {\n  typeforce(\n    {\n      signature: types.BufferN(64),\n      hashType: types.UInt8,\n    },\n    { signature, hashType },\n  );\n  const hashTypeMod = hashType & ~0xc0;\n  if (hashTypeMod <= 0 || hashTypeMod >= 4)\n    throw new Error('Invalid hashType ' + hashType);\n  const hashTypeBuffer = Buffer.allocUnsafe(1);\n  hashTypeBuffer.writeUInt8(hashType, 0);\n  const r = toDER(signature.slice(0, 32));\n  const s = toDER(signature.slice(32, 64));\n  return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);\n}\nexports.encode = encode;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst input = require('./input');\nexports.input = input;\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// OP_0 [signatures ...]\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nfunction partialSignature(value) {\n  return (\n    value === script_1.OPS.OP_0 || bscript.isCanonicalScriptSignature(value)\n  );\n}\nfunction check(script, allowIncomplete) {\n  const chunks = bscript.decompile(script);\n  if (chunks.length < 2) return false;\n  if (chunks[0] !== script_1.OPS.OP_0) return false;\n  if (allowIncomplete) {\n    return chunks.slice(1).every(partialSignature);\n  }\n  return chunks.slice(1).every(bscript.isCanonicalScriptSignature);\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'multisig input';\n};\n","'use strict';\n// m [pubKeys ...] n OP_CHECKMULTISIG\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nconst types = require('../../types');\nconst OP_INT_BASE = script_1.OPS.OP_RESERVED; // OP_1 - 1\nfunction check(script, allowIncomplete) {\n  const chunks = bscript.decompile(script);\n  if (chunks.length < 4) return false;\n  if (chunks[chunks.length - 1] !== script_1.OPS.OP_CHECKMULTISIG) return false;\n  if (!types.Number(chunks[0])) return false;\n  if (!types.Number(chunks[chunks.length - 2])) return false;\n  const m = chunks[0] - OP_INT_BASE;\n  const n = chunks[chunks.length - 2] - OP_INT_BASE;\n  if (m <= 0) return false;\n  if (n > 16) return false;\n  if (m > n) return false;\n  if (n !== chunks.length - 3) return false;\n  if (allowIncomplete) return true;\n  const keys = chunks.slice(1, -2);\n  return keys.every(bscript.isCanonicalPubKey);\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'multi-sig output';\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\n// OP_RETURN {data}\nconst bscript = require('../script');\nconst OPS = bscript.OPS;\nfunction check(script) {\n  const buffer = bscript.compile(script);\n  return buffer.length > 1 && buffer[0] === OPS.OP_RETURN;\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'null data output';\n};\nconst output = { check };\nexports.output = output;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst input = require('./input');\nexports.input = input;\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// {signature}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nfunction check(script) {\n  const chunks = bscript.decompile(script);\n  return chunks.length === 1 && bscript.isCanonicalScriptSignature(chunks[0]);\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'pubKey input';\n};\n","'use strict';\n// {pubKey} OP_CHECKSIG\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nfunction check(script) {\n  const chunks = bscript.decompile(script);\n  return (\n    chunks.length === 2 &&\n    bscript.isCanonicalPubKey(chunks[0]) &&\n    chunks[1] === script_1.OPS.OP_CHECKSIG\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'pubKey output';\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst input = require('./input');\nexports.input = input;\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// {signature} {pubKey}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nfunction check(script) {\n  const chunks = bscript.decompile(script);\n  return (\n    chunks.length === 2 &&\n    bscript.isCanonicalScriptSignature(chunks[0]) &&\n    bscript.isCanonicalPubKey(chunks[1])\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'pubKeyHash input';\n};\n","'use strict';\n// OP_DUP OP_HASH160 {pubKeyHash} OP_EQUALVERIFY OP_CHECKSIG\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nfunction check(script) {\n  const buffer = bscript.compile(script);\n  return (\n    buffer.length === 25 &&\n    buffer[0] === script_1.OPS.OP_DUP &&\n    buffer[1] === script_1.OPS.OP_HASH160 &&\n    buffer[2] === 0x14 &&\n    buffer[23] === script_1.OPS.OP_EQUALVERIFY &&\n    buffer[24] === script_1.OPS.OP_CHECKSIG\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'pubKeyHash output';\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst input = require('./input');\nexports.input = input;\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// <scriptSig> {serialized scriptPubKey script}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst p2ms = require('../multisig');\nconst p2pk = require('../pubkey');\nconst p2pkh = require('../pubkeyhash');\nconst p2wpkho = require('../witnesspubkeyhash/output');\nconst p2wsho = require('../witnessscripthash/output');\nfunction check(script, allowIncomplete) {\n  const chunks = bscript.decompile(script);\n  if (chunks.length < 1) return false;\n  const lastChunk = chunks[chunks.length - 1];\n  if (!Buffer.isBuffer(lastChunk)) return false;\n  const scriptSigChunks = bscript.decompile(\n    bscript.compile(chunks.slice(0, -1)),\n  );\n  const redeemScriptChunks = bscript.decompile(lastChunk);\n  // is redeemScript a valid script?\n  if (!redeemScriptChunks) return false;\n  // is redeemScriptSig push only?\n  if (!bscript.isPushOnly(scriptSigChunks)) return false;\n  // is witness?\n  if (chunks.length === 1) {\n    return (\n      p2wsho.check(redeemScriptChunks) || p2wpkho.check(redeemScriptChunks)\n    );\n  }\n  // match types\n  if (\n    p2pkh.input.check(scriptSigChunks) &&\n    p2pkh.output.check(redeemScriptChunks)\n  )\n    return true;\n  if (\n    p2ms.input.check(scriptSigChunks, allowIncomplete) &&\n    p2ms.output.check(redeemScriptChunks)\n  )\n    return true;\n  if (\n    p2pk.input.check(scriptSigChunks) &&\n    p2pk.output.check(redeemScriptChunks)\n  )\n    return true;\n  return false;\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'scriptHash input';\n};\n","'use strict';\n// OP_HASH160 {scriptHash} OP_EQUAL\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nfunction check(script) {\n  const buffer = bscript.compile(script);\n  return (\n    buffer.length === 23 &&\n    buffer[0] === script_1.OPS.OP_HASH160 &&\n    buffer[1] === 0x14 &&\n    buffer[22] === script_1.OPS.OP_EQUAL\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'scriptHash output';\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// OP_RETURN {aa21a9ed} {commitment}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nconst types = require('../../types');\nconst typeforce = require('typeforce');\nconst HEADER = Buffer.from('aa21a9ed', 'hex');\nfunction check(script) {\n  const buffer = bscript.compile(script);\n  return (\n    buffer.length > 37 &&\n    buffer[0] === script_1.OPS.OP_RETURN &&\n    buffer[1] === 0x24 &&\n    buffer.slice(2, 6).equals(HEADER)\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'Witness commitment output';\n};\nfunction encode(commitment) {\n  typeforce(types.Hash256bit, commitment);\n  const buffer = Buffer.allocUnsafe(36);\n  HEADER.copy(buffer, 0);\n  commitment.copy(buffer, 4);\n  return bscript.compile([script_1.OPS.OP_RETURN, buffer]);\n}\nexports.encode = encode;\nfunction decode(buffer) {\n  typeforce(check, buffer);\n  return bscript.decompile(buffer)[1].slice(4, 36);\n}\nexports.decode = decode;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst input = require('./input');\nexports.input = input;\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// {signature} {pubKey}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nfunction isCompressedCanonicalPubKey(pubKey) {\n  return bscript.isCanonicalPubKey(pubKey) && pubKey.length === 33;\n}\nfunction check(script) {\n  const chunks = bscript.decompile(script);\n  return (\n    chunks.length === 2 &&\n    bscript.isCanonicalScriptSignature(chunks[0]) &&\n    isCompressedCanonicalPubKey(chunks[1])\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'witnessPubKeyHash input';\n};\n","'use strict';\n// OP_0 {pubKeyHash}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nfunction check(script) {\n  const buffer = bscript.compile(script);\n  return (\n    buffer.length === 22 &&\n    buffer[0] === script_1.OPS.OP_0 &&\n    buffer[1] === 0x14\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'Witness pubKeyHash output';\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst input = require('./input');\nexports.input = input;\nconst output = require('./output');\nexports.output = output;\n","'use strict';\n// <scriptSig> {serialized scriptPubKey script}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst typeforce = require('typeforce');\nconst p2ms = require('../multisig');\nconst p2pk = require('../pubkey');\nconst p2pkh = require('../pubkeyhash');\nfunction check(chunks, allowIncomplete) {\n  typeforce(typeforce.Array, chunks);\n  if (chunks.length < 1) return false;\n  const witnessScript = chunks[chunks.length - 1];\n  if (!Buffer.isBuffer(witnessScript)) return false;\n  const witnessScriptChunks = bscript.decompile(witnessScript);\n  // is witnessScript a valid script?\n  if (!witnessScriptChunks || witnessScriptChunks.length === 0) return false;\n  const witnessRawScriptSig = bscript.compile(chunks.slice(0, -1));\n  // match types\n  if (\n    p2pkh.input.check(witnessRawScriptSig) &&\n    p2pkh.output.check(witnessScriptChunks)\n  )\n    return true;\n  if (\n    p2ms.input.check(witnessRawScriptSig, allowIncomplete) &&\n    p2ms.output.check(witnessScriptChunks)\n  )\n    return true;\n  if (\n    p2pk.input.check(witnessRawScriptSig) &&\n    p2pk.output.check(witnessScriptChunks)\n  )\n    return true;\n  return false;\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'witnessScriptHash input';\n};\n","'use strict';\n// OP_0 {scriptHash}\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bscript = require('../../script');\nconst script_1 = require('../../script');\nfunction check(script) {\n  const buffer = bscript.compile(script);\n  return (\n    buffer.length === 34 &&\n    buffer[0] === script_1.OPS.OP_0 &&\n    buffer[1] === 0x20\n  );\n}\nexports.check = check;\ncheck.toJSON = () => {\n  return 'Witness scriptHash output';\n};\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst bufferutils_1 = require('./bufferutils');\nconst bcrypto = require('./crypto');\nconst bscript = require('./script');\nconst script_1 = require('./script');\nconst types = require('./types');\nconst typeforce = require('typeforce');\nconst varuint = require('varuint-bitcoin');\nfunction varSliceSize(someScript) {\n  const length = someScript.length;\n  return varuint.encodingLength(length) + length;\n}\nfunction vectorSize(someVector) {\n  const length = someVector.length;\n  return (\n    varuint.encodingLength(length) +\n    someVector.reduce((sum, witness) => {\n      return sum + varSliceSize(witness);\n    }, 0)\n  );\n}\nconst EMPTY_SCRIPT = Buffer.allocUnsafe(0);\nconst EMPTY_WITNESS = [];\nconst ZERO = Buffer.from(\n  '0000000000000000000000000000000000000000000000000000000000000000',\n  'hex',\n);\nconst ONE = Buffer.from(\n  '0000000000000000000000000000000000000000000000000000000000000001',\n  'hex',\n);\nconst VALUE_UINT64_MAX = Buffer.from('ffffffffffffffff', 'hex');\nconst BLANK_OUTPUT = {\n  script: EMPTY_SCRIPT,\n  valueBuffer: VALUE_UINT64_MAX,\n};\nfunction isOutput(out) {\n  return out.value !== undefined;\n}\nclass Transaction {\n  constructor() {\n    this.version = 1;\n    this.locktime = 0;\n    this.ins = [];\n    this.outs = [];\n  }\n  static fromBuffer(buffer, _NO_STRICT) {\n    const bufferReader = new bufferutils_1.BufferReader(buffer);\n    const tx = new Transaction();\n    tx.version = bufferReader.readInt32();\n    const marker = bufferReader.readUInt8();\n    const flag = bufferReader.readUInt8();\n    let hasWitnesses = false;\n    if (\n      marker === Transaction.ADVANCED_TRANSACTION_MARKER &&\n      flag === Transaction.ADVANCED_TRANSACTION_FLAG\n    ) {\n      hasWitnesses = true;\n    } else {\n      bufferReader.offset -= 2;\n    }\n    const vinLen = bufferReader.readVarInt();\n    for (let i = 0; i < vinLen; ++i) {\n      tx.ins.push({\n        hash: bufferReader.readSlice(32),\n        index: bufferReader.readUInt32(),\n        script: bufferReader.readVarSlice(),\n        sequence: bufferReader.readUInt32(),\n        witness: EMPTY_WITNESS,\n      });\n    }\n    const voutLen = bufferReader.readVarInt();\n    for (let i = 0; i < voutLen; ++i) {\n      tx.outs.push({\n        value: bufferReader.readUInt64(),\n        script: bufferReader.readVarSlice(),\n      });\n    }\n    if (hasWitnesses) {\n      for (let i = 0; i < vinLen; ++i) {\n        tx.ins[i].witness = bufferReader.readVector();\n      }\n      // was this pointless?\n      if (!tx.hasWitnesses())\n        throw new Error('Transaction has superfluous witness data');\n    }\n    tx.locktime = bufferReader.readUInt32();\n    if (_NO_STRICT) return tx;\n    if (bufferReader.offset !== buffer.length)\n      throw new Error('Transaction has unexpected data');\n    return tx;\n  }\n  static fromHex(hex) {\n    return Transaction.fromBuffer(Buffer.from(hex, 'hex'), false);\n  }\n  static isCoinbaseHash(buffer) {\n    typeforce(types.Hash256bit, buffer);\n    for (let i = 0; i < 32; ++i) {\n      if (buffer[i] !== 0) return false;\n    }\n    return true;\n  }\n  isCoinbase() {\n    return (\n      this.ins.length === 1 && Transaction.isCoinbaseHash(this.ins[0].hash)\n    );\n  }\n  addInput(hash, index, sequence, scriptSig) {\n    typeforce(\n      types.tuple(\n        types.Hash256bit,\n        types.UInt32,\n        types.maybe(types.UInt32),\n        types.maybe(types.Buffer),\n      ),\n      arguments,\n    );\n    if (types.Null(sequence)) {\n      sequence = Transaction.DEFAULT_SEQUENCE;\n    }\n    // Add the input and return the input's index\n    return (\n      this.ins.push({\n        hash,\n        index,\n        script: scriptSig || EMPTY_SCRIPT,\n        sequence: sequence,\n        witness: EMPTY_WITNESS,\n      }) - 1\n    );\n  }\n  addOutput(scriptPubKey, value) {\n    typeforce(types.tuple(types.Buffer, types.Satoshi), arguments);\n    // Add the output and return the output's index\n    return (\n      this.outs.push({\n        script: scriptPubKey,\n        value,\n      }) - 1\n    );\n  }\n  hasWitnesses() {\n    return this.ins.some(x => {\n      return x.witness.length !== 0;\n    });\n  }\n  weight() {\n    const base = this.byteLength(false);\n    const total = this.byteLength(true);\n    return base * 3 + total;\n  }\n  virtualSize() {\n    return Math.ceil(this.weight() / 4);\n  }\n  byteLength(_ALLOW_WITNESS = true) {\n    const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();\n    return (\n      (hasWitnesses ? 10 : 8) +\n      varuint.encodingLength(this.ins.length) +\n      varuint.encodingLength(this.outs.length) +\n      this.ins.reduce((sum, input) => {\n        return sum + 40 + varSliceSize(input.script);\n      }, 0) +\n      this.outs.reduce((sum, output) => {\n        return sum + 8 + varSliceSize(output.script);\n      }, 0) +\n      (hasWitnesses\n        ? this.ins.reduce((sum, input) => {\n            return sum + vectorSize(input.witness);\n          }, 0)\n        : 0)\n    );\n  }\n  clone() {\n    const newTx = new Transaction();\n    newTx.version = this.version;\n    newTx.locktime = this.locktime;\n    newTx.ins = this.ins.map(txIn => {\n      return {\n        hash: txIn.hash,\n        index: txIn.index,\n        script: txIn.script,\n        sequence: txIn.sequence,\n        witness: txIn.witness,\n      };\n    });\n    newTx.outs = this.outs.map(txOut => {\n      return {\n        script: txOut.script,\n        value: txOut.value,\n      };\n    });\n    return newTx;\n  }\n  /**\n   * Hash transaction for signing a specific input.\n   *\n   * Bitcoin uses a different hash for each signed transaction input.\n   * This method copies the transaction, makes the necessary changes based on the\n   * hashType, and then hashes the result.\n   * This hash can then be used to sign the provided transaction input.\n   */\n  hashForSignature(inIndex, prevOutScript, hashType) {\n    typeforce(\n      types.tuple(types.UInt32, types.Buffer, /* types.UInt8 */ types.Number),\n      arguments,\n    );\n    // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L29\n    if (inIndex >= this.ins.length) return ONE;\n    // ignore OP_CODESEPARATOR\n    const ourScript = bscript.compile(\n      bscript.decompile(prevOutScript).filter(x => {\n        return x !== script_1.OPS.OP_CODESEPARATOR;\n      }),\n    );\n    const txTmp = this.clone();\n    // SIGHASH_NONE: ignore all outputs? (wildcard payee)\n    if ((hashType & 0x1f) === Transaction.SIGHASH_NONE) {\n      txTmp.outs = [];\n      // ignore sequence numbers (except at inIndex)\n      txTmp.ins.forEach((input, i) => {\n        if (i === inIndex) return;\n        input.sequence = 0;\n      });\n      // SIGHASH_SINGLE: ignore all outputs, except at the same index?\n    } else if ((hashType & 0x1f) === Transaction.SIGHASH_SINGLE) {\n      // https://github.com/bitcoin/bitcoin/blob/master/src/test/sighash_tests.cpp#L60\n      if (inIndex >= this.outs.length) return ONE;\n      // truncate outputs after\n      txTmp.outs.length = inIndex + 1;\n      // \"blank\" outputs before\n      for (let i = 0; i < inIndex; i++) {\n        txTmp.outs[i] = BLANK_OUTPUT;\n      }\n      // ignore sequence numbers (except at inIndex)\n      txTmp.ins.forEach((input, y) => {\n        if (y === inIndex) return;\n        input.sequence = 0;\n      });\n    }\n    // SIGHASH_ANYONECANPAY: ignore inputs entirely?\n    if (hashType & Transaction.SIGHASH_ANYONECANPAY) {\n      txTmp.ins = [txTmp.ins[inIndex]];\n      txTmp.ins[0].script = ourScript;\n      // SIGHASH_ALL: only ignore input scripts\n    } else {\n      // \"blank\" others input scripts\n      txTmp.ins.forEach(input => {\n        input.script = EMPTY_SCRIPT;\n      });\n      txTmp.ins[inIndex].script = ourScript;\n    }\n    // serialize and hash\n    const buffer = Buffer.allocUnsafe(txTmp.byteLength(false) + 4);\n    buffer.writeInt32LE(hashType, buffer.length - 4);\n    txTmp.__toBuffer(buffer, 0, false);\n    return bcrypto.hash256(buffer);\n  }\n  hashForWitnessV0(inIndex, prevOutScript, value, hashType) {\n    typeforce(\n      types.tuple(types.UInt32, types.Buffer, types.Satoshi, types.UInt32),\n      arguments,\n    );\n    let tbuffer = Buffer.from([]);\n    let bufferWriter;\n    let hashOutputs = ZERO;\n    let hashPrevouts = ZERO;\n    let hashSequence = ZERO;\n    if (!(hashType & Transaction.SIGHASH_ANYONECANPAY)) {\n      tbuffer = Buffer.allocUnsafe(36 * this.ins.length);\n      bufferWriter = new bufferutils_1.BufferWriter(tbuffer, 0);\n      this.ins.forEach(txIn => {\n        bufferWriter.writeSlice(txIn.hash);\n        bufferWriter.writeUInt32(txIn.index);\n      });\n      hashPrevouts = bcrypto.hash256(tbuffer);\n    }\n    if (\n      !(hashType & Transaction.SIGHASH_ANYONECANPAY) &&\n      (hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&\n      (hashType & 0x1f) !== Transaction.SIGHASH_NONE\n    ) {\n      tbuffer = Buffer.allocUnsafe(4 * this.ins.length);\n      bufferWriter = new bufferutils_1.BufferWriter(tbuffer, 0);\n      this.ins.forEach(txIn => {\n        bufferWriter.writeUInt32(txIn.sequence);\n      });\n      hashSequence = bcrypto.hash256(tbuffer);\n    }\n    if (\n      (hashType & 0x1f) !== Transaction.SIGHASH_SINGLE &&\n      (hashType & 0x1f) !== Transaction.SIGHASH_NONE\n    ) {\n      const txOutsSize = this.outs.reduce((sum, output) => {\n        return sum + 8 + varSliceSize(output.script);\n      }, 0);\n      tbuffer = Buffer.allocUnsafe(txOutsSize);\n      bufferWriter = new bufferutils_1.BufferWriter(tbuffer, 0);\n      this.outs.forEach(out => {\n        bufferWriter.writeUInt64(out.value);\n        bufferWriter.writeVarSlice(out.script);\n      });\n      hashOutputs = bcrypto.hash256(tbuffer);\n    } else if (\n      (hashType & 0x1f) === Transaction.SIGHASH_SINGLE &&\n      inIndex < this.outs.length\n    ) {\n      const output = this.outs[inIndex];\n      tbuffer = Buffer.allocUnsafe(8 + varSliceSize(output.script));\n      bufferWriter = new bufferutils_1.BufferWriter(tbuffer, 0);\n      bufferWriter.writeUInt64(output.value);\n      bufferWriter.writeVarSlice(output.script);\n      hashOutputs = bcrypto.hash256(tbuffer);\n    }\n    tbuffer = Buffer.allocUnsafe(156 + varSliceSize(prevOutScript));\n    bufferWriter = new bufferutils_1.BufferWriter(tbuffer, 0);\n    const input = this.ins[inIndex];\n    bufferWriter.writeUInt32(this.version);\n    bufferWriter.writeSlice(hashPrevouts);\n    bufferWriter.writeSlice(hashSequence);\n    bufferWriter.writeSlice(input.hash);\n    bufferWriter.writeUInt32(input.index);\n    bufferWriter.writeVarSlice(prevOutScript);\n    bufferWriter.writeUInt64(value);\n    bufferWriter.writeUInt32(input.sequence);\n    bufferWriter.writeSlice(hashOutputs);\n    bufferWriter.writeUInt32(this.locktime);\n    bufferWriter.writeUInt32(hashType);\n    return bcrypto.hash256(tbuffer);\n  }\n  /**\n   * Hash transaction for signing a specific input for Bitcoin Cash.\n   */\n  hashForCashSignature(inIndex, prevOutScript, inAmount, hashType) {\n    typeforce(\n      types.tuple(\n        types.UInt32,\n        types.Buffer,\n        /* types.UInt8 */ types.Number,\n        types.maybe(types.UInt53),\n      ),\n      arguments,\n    );\n    // This function works the way it does because Bitcoin Cash\n    // uses BIP143 as their replay protection, AND their algo\n    // includes `forkId | hashType`, AND since their forkId=0,\n    // this is a NOP, and has no difference to segwit. To support\n    // other forks, another parameter is required, and a new parameter\n    // would be required in the hashForWitnessV0 function, or\n    // it could be broken into two..\n    // BIP143 sighash activated in BitcoinCash via 0x40 bit\n    if (hashType & Transaction.SIGHASH_BITCOINCASHBIP143) {\n      if (types.Null(inAmount)) {\n        throw new Error(\n          'Bitcoin Cash sighash requires value of input to be signed.',\n        );\n      }\n      return this.hashForWitnessV0(inIndex, prevOutScript, inAmount, hashType);\n    } else {\n      return this.hashForSignature(inIndex, prevOutScript, hashType);\n    }\n  }\n  /**\n   * Hash transaction for signing a specific input for Bitcoin Gold.\n   */\n  hashForGoldSignature(inIndex, prevOutScript, inAmount, hashType, sigVersion) {\n    typeforce(\n      types.tuple(\n        types.UInt32,\n        types.Buffer,\n        /* types.UInt8 */ types.Number,\n        types.maybe(types.UInt53),\n      ),\n      arguments,\n    );\n    // Bitcoin Gold also implements segregated witness\n    // therefore we can pull out the setting of nForkHashType\n    // and pass it into the functions.\n    let nForkHashType = hashType;\n    const fUseForkId = (hashType & Transaction.SIGHASH_BITCOINCASHBIP143) > 0;\n    if (fUseForkId) {\n      nForkHashType |= Transaction.FORKID_BTG << 8;\n    }\n    // BIP143 sighash activated in BitcoinCash via 0x40 bit\n    if (sigVersion || fUseForkId) {\n      if (types.Null(inAmount)) {\n        throw new Error(\n          'Bitcoin Cash sighash requires value of input to be signed.',\n        );\n      }\n      return this.hashForWitnessV0(\n        inIndex,\n        prevOutScript,\n        inAmount,\n        nForkHashType,\n      );\n    } else {\n      return this.hashForSignature(inIndex, prevOutScript, nForkHashType);\n    }\n  }\n  getHash(forWitness) {\n    // wtxid for coinbase is always 32 bytes of 0x00\n    if (forWitness && this.isCoinbase()) return Buffer.alloc(32, 0);\n    return bcrypto.hash256(this.__toBuffer(undefined, undefined, forWitness));\n  }\n  getId() {\n    // transaction hash's are displayed in reverse order\n    return bufferutils_1.reverseBuffer(this.getHash(false)).toString('hex');\n  }\n  toBuffer(buffer, initialOffset) {\n    return this.__toBuffer(buffer, initialOffset, true);\n  }\n  toHex() {\n    return this.toBuffer(undefined, undefined).toString('hex');\n  }\n  setInputScript(index, scriptSig) {\n    typeforce(types.tuple(types.Number, types.Buffer), arguments);\n    this.ins[index].script = scriptSig;\n  }\n  setWitness(index, witness) {\n    typeforce(types.tuple(types.Number, [types.Buffer]), arguments);\n    this.ins[index].witness = witness;\n  }\n  __toBuffer(buffer, initialOffset, _ALLOW_WITNESS = false) {\n    if (!buffer) buffer = Buffer.allocUnsafe(this.byteLength(_ALLOW_WITNESS));\n    const bufferWriter = new bufferutils_1.BufferWriter(\n      buffer,\n      initialOffset || 0,\n    );\n    bufferWriter.writeInt32(this.version);\n    const hasWitnesses = _ALLOW_WITNESS && this.hasWitnesses();\n    if (hasWitnesses) {\n      bufferWriter.writeUInt8(Transaction.ADVANCED_TRANSACTION_MARKER);\n      bufferWriter.writeUInt8(Transaction.ADVANCED_TRANSACTION_FLAG);\n    }\n    bufferWriter.writeVarInt(this.ins.length);\n    this.ins.forEach(txIn => {\n      bufferWriter.writeSlice(txIn.hash);\n      bufferWriter.writeUInt32(txIn.index);\n      bufferWriter.writeVarSlice(txIn.script);\n      bufferWriter.writeUInt32(txIn.sequence);\n    });\n    bufferWriter.writeVarInt(this.outs.length);\n    this.outs.forEach(txOut => {\n      if (isOutput(txOut)) {\n        bufferWriter.writeUInt64(txOut.value);\n      } else {\n        bufferWriter.writeSlice(txOut.valueBuffer);\n      }\n      bufferWriter.writeVarSlice(txOut.script);\n    });\n    if (hasWitnesses) {\n      this.ins.forEach(input => {\n        bufferWriter.writeVector(input.witness);\n      });\n    }\n    bufferWriter.writeUInt32(this.locktime);\n    // avoid slicing unless necessary\n    if (initialOffset !== undefined)\n      return buffer.slice(initialOffset, bufferWriter.offset);\n    return buffer;\n  }\n}\nTransaction.DEFAULT_SEQUENCE = 0xffffffff;\nTransaction.SIGHASH_ALL = 0x01;\nTransaction.SIGHASH_NONE = 0x02;\nTransaction.SIGHASH_SINGLE = 0x03;\nTransaction.SIGHASH_ANYONECANPAY = 0x80;\nTransaction.SIGHASH_BITCOINCASHBIP143 = 0x40;\nTransaction.ADVANCED_TRANSACTION_MARKER = 0x00;\nTransaction.ADVANCED_TRANSACTION_FLAG = 0x01;\nTransaction.FORKID_BTG = 0x4f; // 79\nTransaction.FORKID_BCH = 0x00;\nexports.Transaction = Transaction;\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst baddress = require('./address');\nconst bufferutils_1 = require('./bufferutils');\nconst classify = require('./classify');\nconst bcrypto = require('./crypto');\nconst ECPair = require('./ecpair');\nconst networks = require('./networks');\nconst payments = require('./payments');\nconst bscript = require('./script');\nconst script_1 = require('./script');\nconst transaction_1 = require('./transaction');\nconst types = require('./types');\nconst typeforce = require('typeforce');\nconst SCRIPT_TYPES = classify.types;\nconst PREVOUT_TYPES = new Set([\n  // Raw\n  'p2pkh',\n  'p2pk',\n  'p2wpkh',\n  'p2ms',\n  // P2SH wrapped\n  'p2sh-p2pkh',\n  'p2sh-p2pk',\n  'p2sh-p2wpkh',\n  'p2sh-p2ms',\n  // P2WSH wrapped\n  'p2wsh-p2pkh',\n  'p2wsh-p2pk',\n  'p2wsh-p2ms',\n  // P2SH-P2WSH wrapper\n  'p2sh-p2wsh-p2pkh',\n  'p2sh-p2wsh-p2pk',\n  'p2sh-p2wsh-p2ms',\n]);\nfunction tfMessage(type, value, message) {\n  try {\n    typeforce(type, value);\n  } catch (err) {\n    throw new Error(message);\n  }\n}\nfunction txIsString(tx) {\n  return typeof tx === 'string' || tx instanceof String;\n}\nfunction txIsTransaction(tx) {\n  return tx instanceof transaction_1.Transaction;\n}\nclass TransactionBuilder {\n  // WARNING: maximumFeeRate is __NOT__ to be relied on,\n  //          it's just another potential safety mechanism (safety in-depth)\n  constructor(network = networks.bitcoin, maximumFeeRate = 2500) {\n    this.network = network;\n    this.maximumFeeRate = maximumFeeRate;\n    this.__PREV_TX_SET = {};\n    this.__INPUTS = [];\n    this.__BITCOINCASH = false;\n    this.__BITCOINGOLD = false;\n    this.__TX = new transaction_1.Transaction();\n    this.__TX.version = 2;\n    this.__USE_LOW_R = false;\n    console.warn(\n      'Deprecation Warning: TransactionBuilder will be removed in the future. ' +\n        '(v6.x.x or later) Please use the Psbt class instead. Examples of usage ' +\n        'are available in the transactions-psbt.js integration test file on our ' +\n        'Github. A high level explanation is available in the psbt.ts and psbt.js ' +\n        'files as well.',\n    );\n  }\n  static fromTransaction(transaction, network, forkId) {\n    const txb = new TransactionBuilder(network);\n    if (typeof forkId === 'number') {\n      if (forkId === transaction_1.Transaction.FORKID_BTG) {\n        txb.enableBitcoinGold(true);\n      } else if (forkId === transaction_1.Transaction.FORKID_BCH) {\n        txb.enableBitcoinCash(true);\n      }\n    }\n    // Copy transaction fields\n    txb.setVersion(transaction.version);\n    txb.setLockTime(transaction.locktime);\n    // Copy outputs (done first to avoid signature invalidation)\n    transaction.outs.forEach(txOut => {\n      txb.addOutput(txOut.script, txOut.value);\n    });\n    // Copy inputs\n    transaction.ins.forEach(txIn => {\n      txb.__addInputUnsafe(txIn.hash, txIn.index, {\n        sequence: txIn.sequence,\n        script: txIn.script,\n        witness: txIn.witness,\n        value: txIn.value,\n      });\n    });\n    // fix some things not possible through the public API\n    txb.__INPUTS.forEach((input, i) => {\n      fixMultisigOrder(input, transaction, i, input.value, forkId);\n    });\n    return txb;\n  }\n  enableBitcoinCash(enable) {\n    if (typeof enable === 'undefined') {\n      enable = true;\n    }\n    this.__BITCOINCASH = enable;\n  }\n  enableBitcoinGold(enable) {\n    if (typeof enable === 'undefined') {\n      enable = true;\n    }\n    this.__BITCOINGOLD = enable;\n  }\n  setLowR(setting) {\n    typeforce(typeforce.maybe(typeforce.Boolean), setting);\n    if (setting === undefined) {\n      setting = true;\n    }\n    this.__USE_LOW_R = setting;\n    return setting;\n  }\n  setLockTime(locktime) {\n    typeforce(types.UInt32, locktime);\n    // if any signatures exist, throw\n    if (\n      this.__INPUTS.some(input => {\n        if (!input.signatures) return false;\n        return input.signatures.some(s => s !== undefined);\n      })\n    ) {\n      throw new Error('No, this would invalidate signatures');\n    }\n    this.__TX.locktime = locktime;\n  }\n  setVersion(version) {\n    typeforce(types.UInt32, version);\n    // XXX: this might eventually become more complex depending on what the versions represent\n    this.__TX.version = version;\n  }\n  addInput(txHash, vout, sequence, prevOutScript) {\n    if (!this.__canModifyInputs()) {\n      throw new Error('No, this would invalidate signatures');\n    }\n    let value;\n    // is it a hex string?\n    if (txIsString(txHash)) {\n      // transaction hashs's are displayed in reverse order, un-reverse it\n      txHash = bufferutils_1.reverseBuffer(Buffer.from(txHash, 'hex'));\n      // is it a Transaction object?\n    } else if (txIsTransaction(txHash)) {\n      const txOut = txHash.outs[vout];\n      prevOutScript = txOut.script;\n      value = txOut.value;\n      txHash = txHash.getHash(false);\n    }\n    return this.__addInputUnsafe(txHash, vout, {\n      sequence,\n      prevOutScript,\n      value,\n    });\n  }\n  addOutput(scriptPubKey, value) {\n    if (!this.__canModifyOutputs()) {\n      throw new Error('No, this would invalidate signatures');\n    }\n    // Attempt to get a script if it's a base58 or bech32 address string\n    if (typeof scriptPubKey === 'string') {\n      scriptPubKey = baddress.toOutputScript(scriptPubKey, this.network);\n    }\n    return this.__TX.addOutput(scriptPubKey, value);\n  }\n  build() {\n    return this.__build(false);\n  }\n  buildIncomplete() {\n    return this.__build(true);\n  }\n  sign(\n    signParams,\n    keyPair,\n    redeemScript,\n    hashType,\n    witnessValue,\n    witnessScript,\n  ) {\n    trySign(\n      getSigningData(\n        this.network,\n        this.__INPUTS,\n        this.__needsOutputs.bind(this),\n        this.__TX,\n        signParams,\n        {\n          btg: this.__BITCOINGOLD,\n          bch: this.__BITCOINCASH,\n        },\n        keyPair,\n        redeemScript,\n        hashType,\n        witnessValue,\n        witnessScript,\n        this.__USE_LOW_R,\n      ),\n    );\n  }\n  __addInputUnsafe(txHash, vout, options) {\n    if (transaction_1.Transaction.isCoinbaseHash(txHash)) {\n      throw new Error('coinbase inputs not supported');\n    }\n    const prevTxOut = txHash.toString('hex') + ':' + vout;\n    if (this.__PREV_TX_SET[prevTxOut] !== undefined)\n      throw new Error('Duplicate TxOut: ' + prevTxOut);\n    let input = {};\n    // derive what we can from the scriptSig\n    if (options.script !== undefined) {\n      input = expandInput(options.script, options.witness || []);\n    }\n    // if an input value was given, retain it\n    if (options.value !== undefined) {\n      input.value = options.value;\n    }\n    // derive what we can from the previous transactions output script\n    if (!input.prevOutScript && options.prevOutScript) {\n      let prevOutType;\n      if (!input.pubkeys && !input.signatures) {\n        const expanded = expandOutput(options.prevOutScript);\n        if (expanded.pubkeys) {\n          input.pubkeys = expanded.pubkeys;\n          input.signatures = expanded.signatures;\n        }\n        prevOutType = expanded.type;\n      }\n      input.prevOutScript = options.prevOutScript;\n      input.prevOutType = prevOutType || classify.output(options.prevOutScript);\n    }\n    const vin = this.__TX.addInput(\n      txHash,\n      vout,\n      options.sequence,\n      options.scriptSig,\n    );\n    this.__INPUTS[vin] = input;\n    this.__PREV_TX_SET[prevTxOut] = true;\n    return vin;\n  }\n  __build(allowIncomplete) {\n    if (!allowIncomplete) {\n      if (!this.__TX.ins.length) throw new Error('Transaction has no inputs');\n      if (!this.__TX.outs.length) throw new Error('Transaction has no outputs');\n    }\n    const tx = this.__TX.clone();\n    // create script signatures from inputs\n    this.__INPUTS.forEach((input, i) => {\n      if (!input.prevOutType && !allowIncomplete)\n        throw new Error('Transaction is not complete');\n      const result = build(input.prevOutType, input, allowIncomplete);\n      if (!result) {\n        if (!allowIncomplete && input.prevOutType === SCRIPT_TYPES.NONSTANDARD)\n          throw new Error('Unknown input type');\n        if (!allowIncomplete) throw new Error('Not enough information');\n        return;\n      }\n      tx.setInputScript(i, result.input);\n      tx.setWitness(i, result.witness);\n    });\n    if (!allowIncomplete) {\n      // do not rely on this, its merely a last resort\n      if (this.__overMaximumFees(tx.virtualSize())) {\n        throw new Error('Transaction has absurd fees');\n      }\n    }\n    return tx;\n  }\n  __canModifyInputs() {\n    return this.__INPUTS.every(input => {\n      if (!input.signatures) return true;\n      return input.signatures.every(signature => {\n        if (!signature) return true;\n        const hashType = signatureHashType(signature);\n        // if SIGHASH_ANYONECANPAY is set, signatures would not\n        // be invalidated by more inputs\n        return (\n          (hashType & transaction_1.Transaction.SIGHASH_ANYONECANPAY) !== 0\n        );\n      });\n    });\n  }\n  __needsOutputs(signingHashType) {\n    if (signingHashType === transaction_1.Transaction.SIGHASH_ALL) {\n      return this.__TX.outs.length === 0;\n    }\n    // if inputs are being signed with SIGHASH_NONE, we don't strictly need outputs\n    // .build() will fail, but .buildIncomplete() is OK\n    return (\n      this.__TX.outs.length === 0 &&\n      this.__INPUTS.some(input => {\n        if (!input.signatures) return false;\n        return input.signatures.some(signature => {\n          if (!signature) return false; // no signature, no issue\n          const hashType = signatureHashType(signature);\n          if (hashType & transaction_1.Transaction.SIGHASH_NONE) return false; // SIGHASH_NONE doesn't care about outputs\n          return true; // SIGHASH_* does care\n        });\n      })\n    );\n  }\n  __canModifyOutputs() {\n    const nInputs = this.__TX.ins.length;\n    const nOutputs = this.__TX.outs.length;\n    return this.__INPUTS.every(input => {\n      if (input.signatures === undefined) return true;\n      return input.signatures.every(signature => {\n        if (!signature) return true;\n        const hashType = signatureHashType(signature);\n        const hashTypeMod = hashType & 0x1f;\n        if (hashTypeMod === transaction_1.Transaction.SIGHASH_NONE) return true;\n        if (hashTypeMod === transaction_1.Transaction.SIGHASH_SINGLE) {\n          // if SIGHASH_SINGLE is set, and nInputs > nOutputs\n          // some signatures would be invalidated by the addition\n          // of more outputs\n          return nInputs <= nOutputs;\n        }\n        return false;\n      });\n    });\n  }\n  __overMaximumFees(bytes) {\n    // not all inputs will have .value defined\n    const incoming = this.__INPUTS.reduce((a, x) => a + (x.value >>> 0), 0);\n    // but all outputs do, and if we have any input value\n    // we can immediately determine if the outputs are too small\n    const outgoing = this.__TX.outs.reduce((a, x) => a + x.value, 0);\n    const fee = incoming - outgoing;\n    const feeRate = fee / bytes;\n    return feeRate > this.maximumFeeRate;\n  }\n}\nexports.TransactionBuilder = TransactionBuilder;\nfunction expandInput(scriptSig, witnessStack, type, scriptPubKey) {\n  if (scriptSig.length === 0 && witnessStack.length === 0) return {};\n  if (!type) {\n    let ssType = classify.input(scriptSig, true);\n    let wsType = classify.witness(witnessStack, true);\n    if (ssType === SCRIPT_TYPES.NONSTANDARD) ssType = undefined;\n    if (wsType === SCRIPT_TYPES.NONSTANDARD) wsType = undefined;\n    type = ssType || wsType;\n  }\n  switch (type) {\n    case SCRIPT_TYPES.P2WPKH: {\n      const { output, pubkey, signature } = payments.p2wpkh({\n        witness: witnessStack,\n      });\n      return {\n        prevOutScript: output,\n        prevOutType: SCRIPT_TYPES.P2WPKH,\n        pubkeys: [pubkey],\n        signatures: [signature],\n      };\n    }\n    case SCRIPT_TYPES.P2PKH: {\n      const { output, pubkey, signature } = payments.p2pkh({\n        input: scriptSig,\n      });\n      return {\n        prevOutScript: output,\n        prevOutType: SCRIPT_TYPES.P2PKH,\n        pubkeys: [pubkey],\n        signatures: [signature],\n      };\n    }\n    case SCRIPT_TYPES.P2PK: {\n      const { signature } = payments.p2pk({ input: scriptSig });\n      return {\n        prevOutType: SCRIPT_TYPES.P2PK,\n        pubkeys: [undefined],\n        signatures: [signature],\n      };\n    }\n    case SCRIPT_TYPES.P2MS: {\n      const { m, pubkeys, signatures } = payments.p2ms(\n        {\n          input: scriptSig,\n          output: scriptPubKey,\n        },\n        { allowIncomplete: true },\n      );\n      return {\n        prevOutType: SCRIPT_TYPES.P2MS,\n        pubkeys,\n        signatures,\n        maxSignatures: m,\n      };\n    }\n  }\n  if (type === SCRIPT_TYPES.P2SH) {\n    const { output, redeem } = payments.p2sh({\n      input: scriptSig,\n      witness: witnessStack,\n    });\n    const outputType = classify.output(redeem.output);\n    const expanded = expandInput(\n      redeem.input,\n      redeem.witness,\n      outputType,\n      redeem.output,\n    );\n    if (!expanded.prevOutType) return {};\n    return {\n      prevOutScript: output,\n      prevOutType: SCRIPT_TYPES.P2SH,\n      redeemScript: redeem.output,\n      redeemScriptType: expanded.prevOutType,\n      witnessScript: expanded.witnessScript,\n      witnessScriptType: expanded.witnessScriptType,\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n    };\n  }\n  if (type === SCRIPT_TYPES.P2WSH) {\n    const { output, redeem } = payments.p2wsh({\n      input: scriptSig,\n      witness: witnessStack,\n    });\n    const outputType = classify.output(redeem.output);\n    let expanded;\n    if (outputType === SCRIPT_TYPES.P2WPKH) {\n      expanded = expandInput(redeem.input, redeem.witness, outputType);\n    } else {\n      expanded = expandInput(\n        bscript.compile(redeem.witness),\n        [],\n        outputType,\n        redeem.output,\n      );\n    }\n    if (!expanded.prevOutType) return {};\n    return {\n      prevOutScript: output,\n      prevOutType: SCRIPT_TYPES.P2WSH,\n      witnessScript: redeem.output,\n      witnessScriptType: expanded.prevOutType,\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n    };\n  }\n  return {\n    prevOutType: SCRIPT_TYPES.NONSTANDARD,\n    prevOutScript: scriptSig,\n  };\n}\n// could be done in expandInput, but requires the original Transaction for hashForSignature\nfunction fixMultisigOrder(input, transaction, vin, value, forkId) {\n  if (input.redeemScriptType !== SCRIPT_TYPES.P2MS || !input.redeemScript)\n    return;\n  if (input.pubkeys.length === input.signatures.length) return;\n  const unmatched = input.signatures.concat();\n  input.signatures = input.pubkeys.map(pubKey => {\n    const keyPair = ECPair.fromPublicKey(pubKey);\n    let match;\n    // check for a signature\n    unmatched.some((signature, i) => {\n      // skip if undefined || OP_0\n      if (!signature) return false;\n      // TODO: avoid O(n) hashForSignature\n      const parsed = bscript.signature.decode(signature);\n      let hash;\n      switch (forkId) {\n        case transaction_1.Transaction.FORKID_BCH:\n          hash = transaction.hashForCashSignature(\n            vin,\n            input.redeemScript,\n            value,\n            parsed.hashType,\n          );\n          break;\n        case transaction_1.Transaction.FORKID_BTG:\n          hash = transaction.hashForGoldSignature(\n            vin,\n            input.redeemScript,\n            value,\n            parsed.hashType,\n          );\n          break;\n        default:\n          if (input.witness) {\n            hash = transaction.hashForWitnessV0(\n              vin,\n              input.redeemScript,\n              value,\n              parsed.hashType,\n            );\n          } else {\n            hash = transaction.hashForSignature(\n              vin,\n              input.redeemScript,\n              parsed.hashType,\n            );\n          }\n          break;\n      }\n      // skip if signature does not match pubKey\n      if (!keyPair.verify(hash, parsed.signature)) return false;\n      // remove matched signature from unmatched\n      unmatched[i] = undefined;\n      match = signature;\n      return true;\n    });\n    return match;\n  });\n}\nfunction expandOutput(script, ourPubKey) {\n  typeforce(types.Buffer, script);\n  const type = classify.output(script);\n  switch (type) {\n    case SCRIPT_TYPES.P2PKH: {\n      if (!ourPubKey) return { type };\n      // does our hash160(pubKey) match the output scripts?\n      const pkh1 = payments.p2pkh({ output: script }).hash;\n      const pkh2 = bcrypto.hash160(ourPubKey);\n      if (!pkh1.equals(pkh2)) return { type };\n      return {\n        type,\n        pubkeys: [ourPubKey],\n        signatures: [undefined],\n      };\n    }\n    case SCRIPT_TYPES.P2WPKH: {\n      if (!ourPubKey) return { type };\n      // does our hash160(pubKey) match the output scripts?\n      const wpkh1 = payments.p2wpkh({ output: script }).hash;\n      const wpkh2 = bcrypto.hash160(ourPubKey);\n      if (!wpkh1.equals(wpkh2)) return { type };\n      return {\n        type,\n        pubkeys: [ourPubKey],\n        signatures: [undefined],\n      };\n    }\n    case SCRIPT_TYPES.P2PK: {\n      const p2pk = payments.p2pk({ output: script });\n      return {\n        type,\n        pubkeys: [p2pk.pubkey],\n        signatures: [undefined],\n      };\n    }\n    case SCRIPT_TYPES.P2MS: {\n      const p2ms = payments.p2ms({ output: script });\n      return {\n        type,\n        pubkeys: p2ms.pubkeys,\n        signatures: p2ms.pubkeys.map(() => undefined),\n        maxSignatures: p2ms.m,\n      };\n    }\n  }\n  return { type };\n}\nfunction prepareInput(input, ourPubKey, redeemScript, witnessScript) {\n  if (redeemScript && witnessScript) {\n    const p2wsh = payments.p2wsh({\n      redeem: { output: witnessScript },\n    });\n    const p2wshAlt = payments.p2wsh({ output: redeemScript });\n    const p2sh = payments.p2sh({ redeem: { output: redeemScript } });\n    const p2shAlt = payments.p2sh({ redeem: p2wsh });\n    // enforces P2SH(P2WSH(...))\n    if (!p2wsh.hash.equals(p2wshAlt.hash))\n      throw new Error('Witness script inconsistent with prevOutScript');\n    if (!p2sh.hash.equals(p2shAlt.hash))\n      throw new Error('Redeem script inconsistent with prevOutScript');\n    const expanded = expandOutput(p2wsh.redeem.output, ourPubKey);\n    if (!expanded.pubkeys)\n      throw new Error(\n        expanded.type +\n          ' not supported as witnessScript (' +\n          bscript.toASM(witnessScript) +\n          ')',\n      );\n    if (input.signatures && input.signatures.some(x => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n    const signScript = witnessScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH)\n      throw new Error('P2SH(P2WSH(P2WPKH)) is a consensus failure');\n    return {\n      redeemScript,\n      redeemScriptType: SCRIPT_TYPES.P2WSH,\n      witnessScript,\n      witnessScriptType: expanded.type,\n      prevOutType: SCRIPT_TYPES.P2SH,\n      prevOutScript: p2sh.output,\n      hasWitness: true,\n      signScript,\n      signType: expanded.type,\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n  if (redeemScript) {\n    const p2sh = payments.p2sh({ redeem: { output: redeemScript } });\n    if (input.prevOutScript) {\n      let p2shAlt;\n      try {\n        p2shAlt = payments.p2sh({ output: input.prevOutScript });\n      } catch (e) {\n        throw new Error('PrevOutScript must be P2SH');\n      }\n      if (!p2sh.hash.equals(p2shAlt.hash))\n        throw new Error('Redeem script inconsistent with prevOutScript');\n    }\n    const expanded = expandOutput(p2sh.redeem.output, ourPubKey);\n    if (!expanded.pubkeys)\n      throw new Error(\n        expanded.type +\n          ' not supported as redeemScript (' +\n          bscript.toASM(redeemScript) +\n          ')',\n      );\n    if (input.signatures && input.signatures.some(x => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n    let signScript = redeemScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) {\n      signScript = payments.p2pkh({ pubkey: expanded.pubkeys[0] }).output;\n    }\n    return {\n      redeemScript,\n      redeemScriptType: expanded.type,\n      prevOutType: SCRIPT_TYPES.P2SH,\n      prevOutScript: p2sh.output,\n      hasWitness: expanded.type === SCRIPT_TYPES.P2WPKH,\n      signScript,\n      signType: expanded.type,\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n  if (witnessScript) {\n    const p2wsh = payments.p2wsh({ redeem: { output: witnessScript } });\n    if (input.prevOutScript) {\n      const p2wshAlt = payments.p2wsh({ output: input.prevOutScript });\n      if (!p2wsh.hash.equals(p2wshAlt.hash))\n        throw new Error('Witness script inconsistent with prevOutScript');\n    }\n    const expanded = expandOutput(p2wsh.redeem.output, ourPubKey);\n    if (!expanded.pubkeys)\n      throw new Error(\n        expanded.type +\n          ' not supported as witnessScript (' +\n          bscript.toASM(witnessScript) +\n          ')',\n      );\n    if (input.signatures && input.signatures.some(x => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n    const signScript = witnessScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH)\n      throw new Error('P2WSH(P2WPKH) is a consensus failure');\n    return {\n      witnessScript,\n      witnessScriptType: expanded.type,\n      prevOutType: SCRIPT_TYPES.P2WSH,\n      prevOutScript: p2wsh.output,\n      hasWitness: true,\n      signScript,\n      signType: expanded.type,\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n  if (input.prevOutType && input.prevOutScript) {\n    // embedded scripts are not possible without extra information\n    if (input.prevOutType === SCRIPT_TYPES.P2SH)\n      throw new Error(\n        'PrevOutScript is ' + input.prevOutType + ', requires redeemScript',\n      );\n    if (input.prevOutType === SCRIPT_TYPES.P2WSH)\n      throw new Error(\n        'PrevOutScript is ' + input.prevOutType + ', requires witnessScript',\n      );\n    if (!input.prevOutScript) throw new Error('PrevOutScript is missing');\n    const expanded = expandOutput(input.prevOutScript, ourPubKey);\n    if (!expanded.pubkeys)\n      throw new Error(\n        expanded.type +\n          ' not supported (' +\n          bscript.toASM(input.prevOutScript) +\n          ')',\n      );\n    if (input.signatures && input.signatures.some(x => x !== undefined)) {\n      expanded.signatures = input.signatures;\n    }\n    let signScript = input.prevOutScript;\n    if (expanded.type === SCRIPT_TYPES.P2WPKH) {\n      signScript = payments.p2pkh({ pubkey: expanded.pubkeys[0] }).output;\n    }\n    return {\n      prevOutType: expanded.type,\n      prevOutScript: input.prevOutScript,\n      hasWitness: expanded.type === SCRIPT_TYPES.P2WPKH,\n      signScript,\n      signType: expanded.type,\n      pubkeys: expanded.pubkeys,\n      signatures: expanded.signatures,\n      maxSignatures: expanded.maxSignatures,\n    };\n  }\n  const prevOutScript = payments.p2pkh({ pubkey: ourPubKey }).output;\n  return {\n    prevOutType: SCRIPT_TYPES.P2PKH,\n    prevOutScript,\n    hasWitness: false,\n    signScript: prevOutScript,\n    signType: SCRIPT_TYPES.P2PKH,\n    pubkeys: [ourPubKey],\n    signatures: [undefined],\n  };\n}\nfunction build(type, input, allowIncomplete) {\n  const pubkeys = input.pubkeys || [];\n  let signatures = input.signatures || [];\n  switch (type) {\n    case SCRIPT_TYPES.P2PKH: {\n      if (pubkeys.length === 0) break;\n      if (signatures.length === 0) break;\n      return payments.p2pkh({ pubkey: pubkeys[0], signature: signatures[0] });\n    }\n    case SCRIPT_TYPES.P2WPKH: {\n      if (pubkeys.length === 0) break;\n      if (signatures.length === 0) break;\n      return payments.p2wpkh({ pubkey: pubkeys[0], signature: signatures[0] });\n    }\n    case SCRIPT_TYPES.P2PK: {\n      if (pubkeys.length === 0) break;\n      if (signatures.length === 0) break;\n      return payments.p2pk({ signature: signatures[0] });\n    }\n    case SCRIPT_TYPES.P2MS: {\n      const m = input.maxSignatures;\n      if (allowIncomplete) {\n        signatures = signatures.map(x => x || script_1.OPS.OP_0);\n      } else {\n        signatures = signatures.filter(x => x);\n      }\n      // if the transaction is not not complete (complete), or if signatures.length === m, validate\n      // otherwise, the number of OP_0's may be >= m, so don't validate (boo)\n      const validate = !allowIncomplete || m === signatures.length;\n      return payments.p2ms(\n        { m, pubkeys, signatures },\n        { allowIncomplete, validate },\n      );\n    }\n    case SCRIPT_TYPES.P2SH: {\n      const redeem = build(input.redeemScriptType, input, allowIncomplete);\n      if (!redeem) return;\n      return payments.p2sh({\n        redeem: {\n          output: redeem.output || input.redeemScript,\n          input: redeem.input,\n          witness: redeem.witness,\n        },\n      });\n    }\n    case SCRIPT_TYPES.P2WSH: {\n      const redeem = build(input.witnessScriptType, input, allowIncomplete);\n      if (!redeem) return;\n      return payments.p2wsh({\n        redeem: {\n          output: input.witnessScript,\n          input: redeem.input,\n          witness: redeem.witness,\n        },\n      });\n    }\n  }\n}\nfunction canSign(input) {\n  return (\n    input.signScript !== undefined &&\n    input.signType !== undefined &&\n    input.pubkeys !== undefined &&\n    input.signatures !== undefined &&\n    input.signatures.length === input.pubkeys.length &&\n    input.pubkeys.length > 0 &&\n    (input.hasWitness === false || input.value !== undefined)\n  );\n}\nfunction signatureHashType(buffer) {\n  return buffer.readUInt8(buffer.length - 1);\n}\nfunction checkSignArgs(inputs, signParams) {\n  if (!PREVOUT_TYPES.has(signParams.prevOutScriptType)) {\n    throw new TypeError(\n      `Unknown prevOutScriptType \"${signParams.prevOutScriptType}\"`,\n    );\n  }\n  tfMessage(\n    typeforce.Number,\n    signParams.vin,\n    `sign must include vin parameter as Number (input index)`,\n  );\n  tfMessage(\n    types.Signer,\n    signParams.keyPair,\n    `sign must include keyPair parameter as Signer interface`,\n  );\n  tfMessage(\n    typeforce.maybe(typeforce.Number),\n    signParams.hashType,\n    `sign hashType parameter must be a number`,\n  );\n  const prevOutType = (inputs[signParams.vin] || []).prevOutType;\n  const posType = signParams.prevOutScriptType;\n  switch (posType) {\n    case 'p2pkh':\n      if (prevOutType && prevOutType !== 'pubkeyhash') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type p2pkh: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessScript,\n        `${posType} requires NO witnessScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.redeemScript,\n        `${posType} requires NO redeemScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessValue,\n        `${posType} requires NO witnessValue`,\n      );\n      break;\n    case 'p2pk':\n      if (prevOutType && prevOutType !== 'pubkey') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type p2pk: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessScript,\n        `${posType} requires NO witnessScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.redeemScript,\n        `${posType} requires NO redeemScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessValue,\n        `${posType} requires NO witnessValue`,\n      );\n      break;\n    case 'p2wpkh':\n      if (prevOutType && prevOutType !== 'witnesspubkeyhash') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type p2wpkh: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessScript,\n        `${posType} requires NO witnessScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.redeemScript,\n        `${posType} requires NO redeemScript`,\n      );\n      tfMessage(\n        types.Satoshi,\n        signParams.witnessValue,\n        `${posType} requires witnessValue`,\n      );\n      break;\n    case 'p2ms':\n      if (prevOutType && prevOutType !== 'multisig') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type p2ms: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessScript,\n        `${posType} requires NO witnessScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.redeemScript,\n        `${posType} requires NO redeemScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessValue,\n        `${posType} requires NO witnessValue`,\n      );\n      break;\n    case 'p2sh-p2wpkh':\n      if (prevOutType && prevOutType !== 'scripthash') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type p2sh-p2wpkh: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessScript,\n        `${posType} requires NO witnessScript`,\n      );\n      tfMessage(\n        typeforce.Buffer,\n        signParams.redeemScript,\n        `${posType} requires redeemScript`,\n      );\n      tfMessage(\n        types.Satoshi,\n        signParams.witnessValue,\n        `${posType} requires witnessValue`,\n      );\n      break;\n    case 'p2sh-p2ms':\n    case 'p2sh-p2pk':\n    case 'p2sh-p2pkh':\n      if (prevOutType && prevOutType !== 'scripthash') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type ${posType}: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessScript,\n        `${posType} requires NO witnessScript`,\n      );\n      tfMessage(\n        typeforce.Buffer,\n        signParams.redeemScript,\n        `${posType} requires redeemScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.witnessValue,\n        `${posType} requires NO witnessValue`,\n      );\n      break;\n    case 'p2wsh-p2ms':\n    case 'p2wsh-p2pk':\n    case 'p2wsh-p2pkh':\n      if (prevOutType && prevOutType !== 'witnessscripthash') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type ${posType}: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.Buffer,\n        signParams.witnessScript,\n        `${posType} requires witnessScript`,\n      );\n      tfMessage(\n        typeforce.value(undefined),\n        signParams.redeemScript,\n        `${posType} requires NO redeemScript`,\n      );\n      tfMessage(\n        types.Satoshi,\n        signParams.witnessValue,\n        `${posType} requires witnessValue`,\n      );\n      break;\n    case 'p2sh-p2wsh-p2ms':\n    case 'p2sh-p2wsh-p2pk':\n    case 'p2sh-p2wsh-p2pkh':\n      if (prevOutType && prevOutType !== 'scripthash') {\n        throw new TypeError(\n          `input #${signParams.vin} is not of type ${posType}: ${prevOutType}`,\n        );\n      }\n      tfMessage(\n        typeforce.Buffer,\n        signParams.witnessScript,\n        `${posType} requires witnessScript`,\n      );\n      tfMessage(\n        typeforce.Buffer,\n        signParams.redeemScript,\n        `${posType} requires witnessScript`,\n      );\n      tfMessage(\n        types.Satoshi,\n        signParams.witnessValue,\n        `${posType} requires witnessScript`,\n      );\n      break;\n  }\n}\nfunction trySign({\n  input,\n  ourPubKey,\n  keyPair,\n  signatureHash,\n  hashType,\n  useLowR,\n}) {\n  // enforce in order signing of public keys\n  let signed = false;\n  for (const [i, pubKey] of input.pubkeys.entries()) {\n    if (!ourPubKey.equals(pubKey)) continue;\n    if (input.signatures[i]) throw new Error('Signature already exists');\n    // TODO: add tests\n    if (ourPubKey.length !== 33 && input.hasWitness) {\n      throw new Error(\n        'BIP143 rejects uncompressed public keys in P2WPKH or P2WSH',\n      );\n    }\n    const signature = keyPair.sign(signatureHash, useLowR);\n    input.signatures[i] = bscript.signature.encode(signature, hashType);\n    signed = true;\n  }\n  if (!signed) throw new Error('Key pair cannot sign for this input');\n}\nfunction getSigningData(\n  network,\n  inputs,\n  needsOutputs,\n  tx,\n  signParams,\n  forkBools,\n  keyPair,\n  redeemScript,\n  hashType,\n  witnessValue,\n  witnessScript,\n  useLowR,\n) {\n  let vin;\n  if (typeof signParams === 'number') {\n    console.warn(\n      'DEPRECATED: TransactionBuilder sign method arguments ' +\n        'will change in v6, please use the TxbSignArg interface',\n    );\n    vin = signParams;\n  } else if (typeof signParams === 'object') {\n    checkSignArgs(inputs, signParams);\n    ({\n      vin,\n      keyPair,\n      redeemScript,\n      hashType,\n      witnessValue,\n      witnessScript,\n    } = signParams);\n  } else {\n    throw new TypeError(\n      'TransactionBuilder sign first arg must be TxbSignArg or number',\n    );\n  }\n  if (keyPair === undefined) {\n    throw new Error('sign requires keypair');\n  }\n  // TODO: remove keyPair.network matching in 4.0.0\n  if (keyPair.network && keyPair.network !== network)\n    throw new TypeError('Inconsistent network');\n  if (!inputs[vin]) throw new Error('No input at index: ' + vin);\n  hashType = hashType || transaction_1.Transaction.SIGHASH_ALL;\n  if (needsOutputs(hashType)) throw new Error('Transaction needs outputs');\n  const input = inputs[vin];\n  // if redeemScript was previously provided, enforce consistency\n  if (\n    input.redeemScript !== undefined &&\n    redeemScript &&\n    !input.redeemScript.equals(redeemScript)\n  ) {\n    throw new Error('Inconsistent redeemScript');\n  }\n  const ourPubKey =\n    keyPair.publicKey || (keyPair.getPublicKey && keyPair.getPublicKey());\n  if (!canSign(input)) {\n    if (witnessValue !== undefined) {\n      if (input.value !== undefined && input.value !== witnessValue)\n        throw new Error('Input did not match witnessValue');\n      typeforce(types.Satoshi, witnessValue);\n      input.value = witnessValue;\n    }\n    if (!canSign(input)) {\n      const prepared = prepareInput(\n        input,\n        ourPubKey,\n        redeemScript,\n        witnessScript,\n      );\n      // updates inline\n      Object.assign(input, prepared);\n    }\n    if (!canSign(input)) throw Error(input.prevOutType + ' not supported');\n  }\n  // ready to sign\n  let signatureHash;\n  if (forkBools.btg) {\n    signatureHash = tx.hashForGoldSignature(\n      vin,\n      input.signScript,\n      input.value,\n      hashType,\n      !!input.witness,\n    );\n  } else if (forkBools.bch) {\n    signatureHash = tx.hashForCashSignature(\n      vin,\n      input.signScript,\n      input.value,\n      hashType,\n    );\n  } else {\n    if (input.hasWitness) {\n      signatureHash = tx.hashForWitnessV0(\n        vin,\n        input.signScript,\n        input.value,\n        hashType,\n      );\n    } else {\n      signatureHash = tx.hashForSignature(vin, input.signScript, hashType);\n    }\n  }\n  return {\n    input,\n    ourPubKey,\n    keyPair,\n    signatureHash,\n    hashType,\n    useLowR: !!useLowR,\n  };\n}\n","'use strict';\nObject.defineProperty(exports, '__esModule', { value: true });\nconst typeforce = require('typeforce');\nconst UINT31_MAX = Math.pow(2, 31) - 1;\nfunction UInt31(value) {\n  return typeforce.UInt32(value) && value <= UINT31_MAX;\n}\nexports.UInt31 = UInt31;\nfunction BIP32Path(value) {\n  return typeforce.String(value) && !!value.match(/^(m\\/)?(\\d+'?\\/)*\\d+'?$/);\n}\nexports.BIP32Path = BIP32Path;\nBIP32Path.toJSON = () => {\n  return 'BIP32 derivation path';\n};\nfunction Signer(obj) {\n  return (\n    (typeforce.Buffer(obj.publicKey) ||\n      typeof obj.getPublicKey === 'function') &&\n    typeof obj.sign === 'function'\n  );\n}\nexports.Signer = Signer;\nconst SATOSHI_MAX = 21 * 1e14;\nfunction Satoshi(value) {\n  return typeforce.UInt53(value) && value <= SATOSHI_MAX;\n}\nexports.Satoshi = Satoshi;\n// external dependent types\nexports.ECPoint = typeforce.quacksLike('Point');\n// exposed, external API\nexports.Network = typeforce.compile({\n  messagePrefix: typeforce.oneOf(typeforce.Buffer, typeforce.String),\n  bip32: {\n    public: typeforce.UInt32,\n    private: typeforce.UInt32,\n  },\n  pubKeyHash: typeforce.UInt8,\n  scriptHash: typeforce.UInt8,\n  wif: typeforce.UInt8,\n});\nexports.Buffer256bit = typeforce.BufferN(32);\nexports.Hash160bit = typeforce.BufferN(20);\nexports.Hash256bit = typeforce.BufferN(32);\nexports.Number = typeforce.Number; // tslint:disable-line variable-name\nexports.Array = typeforce.Array;\nexports.Boolean = typeforce.Boolean; // tslint:disable-line variable-name\nexports.String = typeforce.String; // tslint:disable-line variable-name\nexports.Buffer = typeforce.Buffer;\nexports.Hex = typeforce.Hex;\nexports.maybe = typeforce.maybe;\nexports.tuple = typeforce.tuple;\nexports.UInt8 = typeforce.UInt8;\nexports.UInt32 = typeforce.UInt32;\nexports.UInt53 = typeforce.UInt53;\nexports.Function = typeforce.Function;\nexports.BufferN = typeforce.BufferN;\nexports.Null = typeforce.Null;\nexports.oneOf = typeforce.oneOf;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.fromCAIP10 = exports.toCAIP10 = exports.fromAccountId = exports.toAccountId = void 0;\nconst chainId_1 = require(\"../chainId/chainId\");\nconst toAccountId = ({ chainId, account }) => {\n    if (!(0, chainId_1.isChainId)(chainId)) {\n        throw new Error(`toAccountId: invalid ChainId ${chainId}`);\n    }\n    if (!account) {\n        throw new Error(`toAccountId: account is required`);\n    }\n    const [namespace] = chainId.split(':');\n    // we lowercase eth accounts as per the draft spec\n    // it's not explicit, but cHecKsUM can be recovered from lowercase eth accounts\n    // we don't lowercase bitcoin addresses as they'll fail checksum\n    const outputAccount = namespace === chainId_1.CHAIN_NAMESPACE.Ethereum ? account.toLowerCase() : account;\n    return `${chainId}:${outputAccount}`;\n};\nexports.toAccountId = toAccountId;\nconst fromAccountId = (accountId) => {\n    const parts = accountId.split(':');\n    if (parts.length !== 3) {\n        throw new Error(`fromAccountId: invalid AccountId ${accountId}`);\n    }\n    const chainId = parts.slice(0, 2).join(':');\n    if (!(0, chainId_1.isChainId)(chainId)) {\n        throw new Error(`fromAccountId: invalid ChainId ${chainId}`);\n    }\n    const account = parts[2];\n    if (!account) {\n        throw new Error(`fromAccountId: account required`);\n    }\n    const [namespace] = chainId.split(':');\n    // we lowercase eth accounts as per the draft spec\n    // it's not explicit, but cHecKsUM can be recovered from lowercase eth accounts\n    // we don't lowercase bitcoin addresses as they'll fail checksum\n    const outputAccount = namespace === chainId_1.CHAIN_NAMESPACE.Ethereum ? account.toLowerCase() : account;\n    return { chainId, account: outputAccount };\n};\nexports.fromAccountId = fromAccountId;\nexports.toCAIP10 = exports.toAccountId;\nexports.fromCAIP10 = exports.fromAccountId;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getBanxaBlockchainFromBanxaAssetTicker = exports.getSupportedBanxaAssets = exports.AssetIdToBanxaTicker = exports.banxaTickerToAssetId = void 0;\nconst entries_1 = __importDefault(require(\"lodash/entries\"));\nconst toLower_1 = __importDefault(require(\"lodash/toLower\"));\nconst assetId_1 = require(\"../../assetId/assetId\");\nconst chainId_1 = require(\"../../chainId/chainId\");\nconst AssetIdToBanxaTickerMap = {\n    'bip122:000000000019d6689c085ae165831e93/slip44:0': 'btc',\n    'cosmos:cosmoshub-4/slip44:118': 'atom',\n    'eip155:1/slip44:60': 'eth',\n    'eip155:1/erc20:0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9': 'aave',\n    'eip155:1/erc20:0xbb0e17ef65f82ab018d8edd776e8dd940327b28b': 'axs',\n    'eip155:1/erc20:0x4d224452801aced8b2f0aebe155379bb5d594381': 'ape',\n    'eip155:1/erc20:0x0d8775f648430679a709e98d2b0cb6250d2887ef': 'bat',\n    'eip155:1/erc20:0x4fabb145d64652a948d72533023f6e7a623c7c53': 'busd',\n    'eip155:1/erc20:0x3506424f91fd33084466f402d5d97f05f8e3b4af': 'chz',\n    'eip155:1/erc20:0x41e5560054824ea6b0732e656e3ad64e20e94e45': 'cvc',\n    'eip155:1/erc20:0xc00e94cb662c3520282e6f5717214004a7f26888': 'comp',\n    'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f': 'dai',\n    'eip155:1/erc20:0xf629cbd94d3791c9250152bd8dfbdf380e2a3b9c': 'enj',\n    'eip155:1/erc20:0x4e15361fd6b4bb609fa63c81a2be19d873717870': 'ftm',\n    'eip155:1/erc20:0x165440036ce972c5f8ebef667086707e48b2623e': 'grt',\n    'eip155:1/erc20:0xf57e7e7c23978c3caec3c3548e3d615c346e79ff': 'imx',\n    'eip155:1/erc20:0x514910771af9ca656af840dff83e8264ecf986ca': 'link',\n    'eip155:1/erc20:0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2': 'mkr',\n    'eip155:1/erc20:0x0f5d2fb29fb7d3cfee444a200298f468908cc942': 'mana',\n    'eip155:1/erc20:0xd26114cd6ee289accf82350c8d8487fedb8a0c07': 'omg',\n    'eip155:1/erc20:0x57ab1ec28d129707052df4df418d58a2d46d5f51': 'susd',\n    'eip155:1/erc20:0x6b3595068778dd592e39a122f4f5a5cf09c90fe2': 'sushi',\n    'eip155:1/erc20:0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f': 'snx',\n    'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984': 'uni',\n    'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 'usdc',\n    'eip155:1/erc20:0x8e870d67f660d95d5be530380d0ec0bd388289e1': 'usdp',\n    'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7': 'usdt',\n    'eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599': 'wbtc'\n};\nconst invert = (data) => Object.entries(data).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});\nconst banxaTickerToAssetIdMap = invert(AssetIdToBanxaTickerMap);\nconst banxaTickerToAssetId = (id) => banxaTickerToAssetIdMap[id];\nexports.banxaTickerToAssetId = banxaTickerToAssetId;\nconst AssetIdToBanxaTicker = (assetId) => AssetIdToBanxaTickerMap[(0, toLower_1.default)(assetId)];\nexports.AssetIdToBanxaTicker = AssetIdToBanxaTicker;\nconst getSupportedBanxaAssets = () => (0, entries_1.default)(AssetIdToBanxaTickerMap).map(([assetId, ticker]) => ({\n    assetId,\n    ticker\n}));\nexports.getSupportedBanxaAssets = getSupportedBanxaAssets;\n/**\n * map ChainIds to Banxa blockchain codes (ETH, BTC, COSMOS),\n * since some Banxa assets could be on multiple chains and their default\n * chain won't be exactly the same as ours.\n */\nconst chainIdToBanxaBlockchainCodeMap = {\n    'eip155:1': 'ETH',\n    'bip122:000000000019d6689c085ae165831e93': 'BTC',\n    'cosmos:cosmoshub-4': 'COSMOS'\n};\n/**\n * Convert a banxa asset identifier to a Banxa chain identifier for use in Banxa HTTP URLs\n *\n * @param {string} banxaAssetId - a Banxa asset string referencing a specific asset; e.g., 'atom'\n * @returns {string} - a Banxa chain identifier; e.g., 'cosmos'\n */\nconst getBanxaBlockchainFromBanxaAssetTicker = (banxaAssetId) => {\n    const assetAssetId = (0, exports.banxaTickerToAssetId)(banxaAssetId.toLowerCase());\n    if (!assetAssetId)\n        throw new Error(`getBanxaBlockchainFromBanxaAssetTicker: ${banxaAssetId} is not supported`);\n    const { chain, network } = (0, assetId_1.fromAssetId)(assetAssetId);\n    const chainId = (0, chainId_1.toChainId)({ network, chain });\n    return chainIdToBanxaBlockchainCodeMap[chainId];\n};\nexports.getBanxaBlockchainFromBanxaAssetTicker = getBanxaBlockchainFromBanxaAssetTicker;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.osmosis = exports.cosmos = exports.eip155 = exports.bip122 = void 0;\nconst adapter_json_1 = __importDefault(require(\"./bip122_000000000019d6689c085ae165831e93/adapter.json\"));\nexports.bip122 = adapter_json_1.default;\nconst adapter_json_2 = __importDefault(require(\"./eip155_1/adapter.json\"));\nexports.eip155 = adapter_json_2.default;\nconst adapter_json_3 = __importDefault(require(\"./cosmos_cosmoshub-4/adapter.json\"));\nexports.cosmos = adapter_json_3.default;\nconst adapter_json_4 = __importDefault(require(\"./cosmos_osmosis-1/adapter.json\"));\nexports.osmosis = adapter_json_4.default;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assetIdToCoinCap = exports.coincapToAssetId = exports.coincapUrl = void 0;\nconst toLower_1 = __importDefault(require(\"lodash/toLower\"));\nconst adapters = __importStar(require(\"./generated\"));\nexports.coincapUrl = 'https://api.coincap.io/v2/assets?limit=2000';\nconst generatedAssetIdToCoinCapMap = Object.values(adapters).reduce((acc, cur) => ({\n    ...acc,\n    ...cur\n}));\nconst invert = (data) => Object.entries(data).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});\nconst generatedCoinCapToAssetIdMap = invert(generatedAssetIdToCoinCapMap);\nconst coincapToAssetId = (id) => generatedCoinCapToAssetIdMap[id];\nexports.coincapToAssetId = coincapToAssetId;\nconst assetIdToCoinCap = (assetId) => generatedAssetIdToCoinCapMap[(0, toLower_1.default)(assetId)];\nexports.assetIdToCoinCap = assetIdToCoinCap;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.osmosis = exports.cosmos = exports.eip155 = exports.bip122 = void 0;\nconst adapter_json_1 = __importDefault(require(\"./bip122_000000000019d6689c085ae165831e93/adapter.json\"));\nexports.bip122 = adapter_json_1.default;\nconst adapter_json_2 = __importDefault(require(\"./eip155_1/adapter.json\"));\nexports.eip155 = adapter_json_2.default;\nconst adapter_json_3 = __importDefault(require(\"./cosmos_cosmoshub-4/adapter.json\"));\nexports.cosmos = adapter_json_3.default;\nconst adapter_json_4 = __importDefault(require(\"./cosmos_osmosis-1/adapter.json\"));\nexports.osmosis = adapter_json_4.default;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assetIdToCoingecko = exports.coingeckoToAssetId = exports.coingeckoUrl = void 0;\nconst toLower_1 = __importDefault(require(\"lodash/toLower\"));\nconst adapters = __importStar(require(\"./generated\"));\nexports.coingeckoUrl = 'https://api.coingecko.com/api/v3/coins/list?include_platform=true';\nconst generatedAssetIdToCoingeckoMap = Object.values(adapters).reduce((acc, cur) => ({\n    ...acc,\n    ...cur\n}));\nconst invert = (data) => Object.entries(data).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});\nconst generatedCoingeckoToAssetIdMap = invert(generatedAssetIdToCoingeckoMap);\nconst coingeckoToAssetId = (id) => generatedCoingeckoToAssetIdMap[id];\nexports.coingeckoToAssetId = coingeckoToAssetId;\nconst assetIdToCoingecko = (assetId) => generatedAssetIdToCoingeckoMap[(0, toLower_1.default)(assetId)];\nexports.assetIdToCoingecko = assetIdToCoingecko;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assetIdToGemAssetId = exports.gemAssetIdToAssetId = void 0;\nconst toLower_1 = __importDefault(require(\"lodash/toLower\"));\nconst assetIdToGemAssetIdMap = {\n    'bip122:000000000019d6689c085ae165831e93/slip44:0': 'bitcoin',\n    'eip155:1/slip44:60': 'ethereum',\n    'eip155:1/erc20:0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9': 'aave',\n    'eip155:1/erc20:0x0d8775f648430679a709e98d2b0cb6250d2887ef': 'basic-attention-token',\n    'eip155:1/erc20:0x4fabb145d64652a948d72533023f6e7a623c7c53': 'busd',\n    'eip155:1/erc20:0xc00e94cb662c3520282e6f5717214004a7f26888': 'compound-coin',\n    'eip155:1/erc20:0xd533a949740bb3306d119cc777fa900ba034cd52': 'curve-dao',\n    'eip155:1/erc20:0x6b175474e89094c44da98b954eedeac495271d0f': 'dai',\n    'eip155:1/erc20:0x056fd409e1d7a124bd7017459dfea2f387b6d5cd': 'gemini-dollar',\n    'eip155:1/erc20:0x514910771af9ca656af840dff83e8264ecf986ca': 'chainlink',\n    'eip155:1/erc20:0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2': 'maker',\n    'eip155:1/erc20:0x75231f58b43240c9718dd58b4967c5114342a86c': 'okb',\n    'eip155:1/erc20:0xc011a73ee8576fb46f5e1c5751ca3b9fe0af2a6f': 'synthetix-network-token',\n    'eip155:1/erc20:0xa4bdb11dc0a2bec88d24a3aa1e6bb17201112ebe': 'usds',\n    'eip155:1/erc20:0xdac17f958d2ee523a2206206994597c13d831ec7': 'tether',\n    'eip155:1/erc20:0x04fa0d235c4abf4bcf4787af4cf447de572ef828': 'universal-market-access',\n    'eip155:1/erc20:0x1f9840a85d5af5bf1d1762f925bdaddc4201f984': 'uniswap',\n    'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48': 'usd-coin',\n    'eip155:1/erc20:0x2260fac5e5542a773aa44fbcfedf7c193bc2c599': 'wrapped-bitcoin',\n    'eip155:1/erc20:0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2': 'weth',\n    'eip155:1/erc20:0x0bc529c00c6401aef6d220be8c6ea1667f6ad93e': 'yearn-finance'\n};\nconst invert = (data) => Object.entries(data).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});\nconst gemAssetIdToAssetIdMap = invert(assetIdToGemAssetIdMap);\nconst gemAssetIdToAssetId = (id) => gemAssetIdToAssetIdMap[id];\nexports.gemAssetIdToAssetId = gemAssetIdToAssetId;\nconst assetIdToGemAssetId = (assetId) => assetIdToGemAssetIdMap[(0, toLower_1.default)(assetId)];\nexports.assetIdToGemAssetId = assetIdToGemAssetId;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\n__exportStar(require(\"./coingecko\"), exports);\n__exportStar(require(\"./coincap\"), exports);\n__exportStar(require(\"./yearn\"), exports);\n__exportStar(require(\"./osmosis\"), exports);\n__exportStar(require(\"./gem\"), exports);\n__exportStar(require(\"./banxa\"), exports);\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.osmosis = void 0;\nconst adapter_json_1 = __importDefault(require(\"./cosmos_osmosis-1/adapter.json\"));\nexports.osmosis = adapter_json_1.default;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assetIdToOsmosis = exports.osmosisToAssetId = exports.osmosisUrl = void 0;\nconst adapters = __importStar(require(\"./generated\"));\nexports.osmosisUrl = 'https://api-osmosis.imperator.co/tokens/v2/all';\nconst generatedAssetIdToOsmosisMap = Object.values(adapters).reduce((acc, cur) => ({\n    ...acc,\n    ...cur\n}));\nconst invert = (data) => Object.entries(data).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});\nconst generatedOsmosisToAssetIdMap = invert(generatedAssetIdToOsmosisMap);\nconst osmosisToAssetId = (id) => generatedOsmosisToAssetIdMap[id];\nexports.osmosisToAssetId = osmosisToAssetId;\nconst assetIdToOsmosis = (assetId) => generatedAssetIdToOsmosisMap[assetId];\nexports.assetIdToOsmosis = assetIdToOsmosis;\n","\"use strict\";\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.eip155 = void 0;\nconst adapter_json_1 = __importDefault(require(\"./eip155_1/adapter.json\"));\nexports.eip155 = adapter_json_1.default;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assetIdToYearn = exports.yearnToAssetId = void 0;\nconst toLower_1 = __importDefault(require(\"lodash/toLower\"));\nconst adapters = __importStar(require(\"./generated\"));\nconst generatedAssedIdToYearnMap = Object.values(adapters).reduce((acc, cur) => ({\n    ...acc,\n    ...cur\n}));\nconst invert = (data) => Object.entries(data).reduce((acc, [k, v]) => ((acc[v] = k), acc), {});\nconst generatedYearnToAssetIdMap = invert(generatedAssedIdToYearnMap);\nconst yearnToAssetId = (id) => generatedYearnToAssetIdMap[id];\nexports.yearnToAssetId = yearnToAssetId;\nconst assetIdToYearn = (assetId) => generatedAssedIdToYearnMap[(0, toLower_1.default)(assetId)];\nexports.assetIdToYearn = assetIdToYearn;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.fromCAIP19 = exports.toCAIP19 = exports.fromAssetId = exports.toAssetId = exports.ASSET_REFERENCE = void 0;\n// https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-19.md\nconst types_1 = require(\"@shapeshiftoss/types\");\nconst chainId_1 = require(\"../chainId/chainId\");\nconst assetNamespaceStrings = [\n    'cw20',\n    'cw721',\n    'erc20',\n    'erc721',\n    'slip44',\n    'native',\n    'ibc'\n];\nexports.ASSET_REFERENCE = {\n    Bitcoin: '0',\n    Ethereum: '60',\n    Cosmos: '118',\n    Osmosis: '118'\n};\nconst validAssetNamespaces = Object.freeze({\n    [types_1.ChainTypes.Bitcoin]: ['slip44'],\n    [types_1.ChainTypes.Ethereum]: ['slip44', 'erc20', 'erc721'],\n    [types_1.ChainTypes.Cosmos]: ['cw20', 'cw721', 'ibc', 'native', 'slip44'],\n    [types_1.ChainTypes.Osmosis]: ['cw20', 'cw721', 'ibc', 'native', 'slip44']\n});\nconst isAssetNamespace = (maybeAssetNamespace) => assetNamespaceStrings.some((s) => s === maybeAssetNamespace);\n/**\n * validate that a value is a string slip44 value\n * @see https://github.com/satoshilabs/slips/blob/master/slip-0044.md\n * @param {string} value - possible slip44 value\n */\nconst isValidSlip44 = (value) => {\n    const n = Number(value);\n    // slip44 has a max value of an unsigned 32-bit integer\n    return !isNaN(n) && n >= 0 && n < 4294967296;\n};\nconst toAssetId = (args) => {\n    const { chain, network, assetNamespace } = args;\n    let { assetReference } = args;\n    if (!chain)\n        throw new Error('toAssetId: No chain provided');\n    if (!network)\n        throw new Error('toAssetId: No chainReference Provided');\n    if (!assetNamespace)\n        throw new Error('toAssetId: No assetNamespace provided');\n    if (!assetReference)\n        throw new Error('toAssetId: No assetReference provided');\n    const chainId = (0, chainId_1.toChainId)({ chain, network });\n    if (!validAssetNamespaces[chain].includes(assetNamespace)) {\n        throw new Error(`toAssetId: Asset Namespace ${assetNamespace} not supported for chain ${chain}`);\n    }\n    if (assetNamespace === 'slip44' && !isValidSlip44(String(assetReference))) {\n        throw new Error(`Invalid reference for namespace slip44`);\n    }\n    if (Array('erc20', 'erc721').includes(assetNamespace)) {\n        if (!assetReference.startsWith('0x')) {\n            throw new Error(`toAssetId: assetReference must start with 0x: ${assetReference}`);\n        }\n        if (assetReference.length !== 42) {\n            throw new Error(`toAssetId: assetReference length must be 42, length: ${assetReference.length}`);\n        }\n        // We make Eth contract addresses lower case to simplify comparisons\n        assetReference = assetReference.toLowerCase();\n    }\n    return `${chainId}/${assetNamespace}:${assetReference}`;\n};\nexports.toAssetId = toAssetId;\nconst parseAssetIdRegExp = /([-a-z\\d]{3,8}):([-a-zA-Z\\d]{1,32})\\/([-a-z\\d]{3,8}):([-a-zA-Z\\d]+)/;\nconst fromAssetId = (assetId) => {\n    var _a;\n    const matches = (_a = parseAssetIdRegExp.exec(assetId)) !== null && _a !== void 0 ? _a : [];\n    // We're okay casting these strings to enums because we check to make sure\n    // they are valid enum values\n    let chain = chainId_1.chainNamespaceToChainType[matches[1]];\n    const network = chainId_1.chainReferenceToNetworkType[matches[2]];\n    const assetNamespace = isAssetNamespace(matches[3]) ? matches[3] : undefined;\n    let assetReference = matches[4];\n    if (chain && network && assetNamespace && assetReference) {\n        switch (network) {\n            case types_1.NetworkTypes.OSMOSIS_MAINNET:\n            case types_1.NetworkTypes.OSMOSIS_TESTNET:\n                chain = types_1.ChainTypes.Osmosis;\n        }\n        switch (assetNamespace) {\n            case 'erc20':\n            case 'erc721': {\n                assetReference = assetReference.toLowerCase();\n            }\n        }\n        return { chain, network, assetNamespace, assetReference };\n    }\n    throw new Error(`fromAssetId: invalid AssetId: ${assetId}`);\n};\nexports.fromAssetId = fromAssetId;\nexports.toCAIP19 = exports.toAssetId;\nexports.fromCAIP19 = exports.fromAssetId;\n","\"use strict\";\n// https://github.com/ChainAgnostic/CAIPs/blob/master/CAIPs/caip-2.md\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.fromCAIP2 = exports.toCAIP2 = exports.chainNamespaceToChainType = exports.networkTypeToChainReference = exports.chainReferenceToNetworkType = exports.isChainId = exports.fromChainId = exports.toChainId = exports.CHAIN_REFERENCE = exports.CHAIN_NAMESPACE = void 0;\nconst types_1 = require(\"@shapeshiftoss/types\");\nconst invert_1 = __importDefault(require(\"lodash/invert\"));\nexports.CHAIN_NAMESPACE = {\n    Ethereum: 'eip155',\n    Bitcoin: 'bip122',\n    Cosmos: 'cosmos'\n};\nexports.CHAIN_REFERENCE = {\n    EthereumMainnet: '1',\n    EthereumRopsten: '3',\n    EthereumRinkeby: '4',\n    // EthereumKovan: '42', // currently unsupported by ShapeShift\n    // https://github.com/bitcoin/bips/blob/master/bip-0122.mediawiki#definition-of-chain-id\n    // chainId uses max length of 32 chars of the genesis block\n    BitcoinMainnet: '000000000019d6689c085ae165831e93',\n    BitcoinTestnet: '000000000933ea01ad0ee984209779ba',\n    CosmosHubMainnet: 'cosmoshub-4',\n    CosmosHubVega: 'vega-testnet',\n    OsmosisMainnet: 'osmosis-1',\n    OsmosisTestnet: 'osmo-testnet-1'\n};\nconst shapeShiftToChainId = Object.freeze({\n    [types_1.ChainTypes.Ethereum]: {\n        namespace: exports.CHAIN_NAMESPACE.Ethereum,\n        reference: {\n            [types_1.NetworkTypes.MAINNET]: exports.CHAIN_REFERENCE.EthereumMainnet,\n            [types_1.NetworkTypes.ETH_ROPSTEN]: exports.CHAIN_REFERENCE.EthereumRopsten,\n            [types_1.NetworkTypes.ETH_RINKEBY]: exports.CHAIN_REFERENCE.EthereumRinkeby\n        }\n    },\n    [types_1.ChainTypes.Bitcoin]: {\n        namespace: exports.CHAIN_NAMESPACE.Bitcoin,\n        reference: {\n            [types_1.NetworkTypes.MAINNET]: exports.CHAIN_REFERENCE.BitcoinMainnet,\n            [types_1.NetworkTypes.TESTNET]: exports.CHAIN_REFERENCE.BitcoinTestnet\n        }\n    },\n    [types_1.ChainTypes.Cosmos]: {\n        namespace: exports.CHAIN_NAMESPACE.Cosmos,\n        reference: {\n            [types_1.NetworkTypes.COSMOSHUB_MAINNET]: exports.CHAIN_REFERENCE.CosmosHubMainnet,\n            [types_1.NetworkTypes.COSMOSHUB_VEGA]: exports.CHAIN_REFERENCE.CosmosHubVega\n        }\n    },\n    [types_1.ChainTypes.Osmosis]: {\n        namespace: exports.CHAIN_NAMESPACE.Cosmos,\n        reference: {\n            [types_1.NetworkTypes.OSMOSIS_MAINNET]: exports.CHAIN_REFERENCE.OsmosisMainnet,\n            [types_1.NetworkTypes.OSMOSIS_TESTNET]: exports.CHAIN_REFERENCE.OsmosisTestnet\n        }\n    }\n});\nconst toChainId = (args) => {\n    const { chain, network } = args;\n    const namespace = shapeShiftToChainId[chain].namespace;\n    switch (chain) {\n        case types_1.ChainTypes.Ethereum: {\n            const referenceMap = shapeShiftToChainId[chain].reference;\n            switch (network) {\n                case types_1.NetworkTypes.MAINNET:\n                case types_1.NetworkTypes.ETH_ROPSTEN:\n                case types_1.NetworkTypes.ETH_RINKEBY: {\n                    const reference = referenceMap[network];\n                    return `${namespace}:${reference}`;\n                }\n            }\n            break;\n        }\n        case types_1.ChainTypes.Bitcoin: {\n            const referenceMap = shapeShiftToChainId[chain].reference;\n            switch (network) {\n                case types_1.NetworkTypes.MAINNET:\n                case types_1.NetworkTypes.TESTNET: {\n                    const reference = referenceMap[network];\n                    return `${namespace}:${reference}`;\n                }\n            }\n            break;\n        }\n        case types_1.ChainTypes.Cosmos: {\n            const referenceMap = shapeShiftToChainId[chain].reference;\n            switch (network) {\n                case types_1.NetworkTypes.COSMOSHUB_MAINNET:\n                case types_1.NetworkTypes.COSMOSHUB_VEGA: {\n                    const reference = referenceMap[network];\n                    return `${namespace}:${reference}`;\n                }\n            }\n            break;\n        }\n        case types_1.ChainTypes.Osmosis: {\n            const referenceMap = shapeShiftToChainId[chain].reference;\n            switch (network) {\n                case types_1.NetworkTypes.OSMOSIS_MAINNET:\n                case types_1.NetworkTypes.OSMOSIS_TESTNET: {\n                    const reference = referenceMap[network];\n                    return `${namespace}:${reference}`;\n                }\n            }\n            break;\n        }\n    }\n    throw new Error(`toChainId: unsupported ${chain} network: ${network}`);\n};\nexports.toChainId = toChainId;\nconst fromChainId = (chainId) => {\n    const [c, n] = chainId.split(':');\n    if (!(c && n)) {\n        throw new Error(`fromChainId: error parsing chainId, chain: ${c}, network: ${n}`);\n    }\n    switch (c) {\n        case exports.CHAIN_NAMESPACE.Cosmos: {\n            switch (n) {\n                case exports.CHAIN_REFERENCE.CosmosHubMainnet: {\n                    return { chain: types_1.ChainTypes.Cosmos, network: types_1.NetworkTypes.COSMOSHUB_MAINNET };\n                }\n                case exports.CHAIN_REFERENCE.CosmosHubVega: {\n                    return { chain: types_1.ChainTypes.Cosmos, network: types_1.NetworkTypes.COSMOSHUB_VEGA };\n                }\n                case exports.CHAIN_REFERENCE.OsmosisMainnet: {\n                    return { chain: types_1.ChainTypes.Osmosis, network: types_1.NetworkTypes.OSMOSIS_MAINNET };\n                }\n                case exports.CHAIN_REFERENCE.OsmosisTestnet: {\n                    return { chain: types_1.ChainTypes.Osmosis, network: types_1.NetworkTypes.OSMOSIS_TESTNET };\n                }\n                default: {\n                    throw new Error(`fromChainId: unsupported ${c} network: ${n}`);\n                }\n            }\n        }\n        case exports.CHAIN_NAMESPACE.Ethereum: {\n            const chain = types_1.ChainTypes.Ethereum;\n            switch (n) {\n                case exports.CHAIN_REFERENCE.EthereumMainnet: {\n                    const network = types_1.NetworkTypes.MAINNET;\n                    return { chain, network };\n                }\n                case exports.CHAIN_REFERENCE.EthereumRopsten: {\n                    const network = types_1.NetworkTypes.ETH_ROPSTEN;\n                    return { chain, network };\n                }\n                case exports.CHAIN_REFERENCE.EthereumRinkeby: {\n                    const network = types_1.NetworkTypes.ETH_RINKEBY;\n                    return { chain, network };\n                }\n                default: {\n                    throw new Error(`fromChainId: unsupported ${c} network: ${n}`);\n                }\n            }\n        }\n        case exports.CHAIN_NAMESPACE.Bitcoin: {\n            const chain = types_1.ChainTypes.Bitcoin;\n            switch (n) {\n                case exports.CHAIN_REFERENCE.BitcoinMainnet: {\n                    const network = types_1.NetworkTypes.MAINNET;\n                    return { chain, network };\n                }\n                case exports.CHAIN_REFERENCE.BitcoinTestnet: {\n                    const network = types_1.NetworkTypes.TESTNET;\n                    return { chain, network };\n                }\n                default: {\n                    throw new Error(`fromChainId: unsupported ${c} network: ${n}`);\n                }\n            }\n        }\n    }\n    throw new Error(`fromChainId: unsupported chain: ${c}`);\n};\nexports.fromChainId = fromChainId;\nconst isChainId = (chainId) => {\n    const [c, n] = chainId.split(':');\n    if (!(c && n)) {\n        throw new Error(`isChainId: error parsing chainId, chain: ${c}, network: ${n}`);\n    }\n    switch (c) {\n        case exports.CHAIN_NAMESPACE.Cosmos: {\n            switch (n) {\n                case exports.CHAIN_REFERENCE.CosmosHubMainnet:\n                case exports.CHAIN_REFERENCE.CosmosHubVega:\n                case exports.CHAIN_REFERENCE.OsmosisMainnet:\n                case exports.CHAIN_REFERENCE.OsmosisTestnet:\n                    return true;\n            }\n            break;\n        }\n        case exports.CHAIN_NAMESPACE.Ethereum: {\n            switch (n) {\n                case exports.CHAIN_REFERENCE.EthereumMainnet:\n                case exports.CHAIN_REFERENCE.EthereumRopsten:\n                case exports.CHAIN_REFERENCE.EthereumRinkeby:\n                    return true;\n            }\n            break;\n        }\n        case exports.CHAIN_NAMESPACE.Bitcoin: {\n            switch (n) {\n                case exports.CHAIN_REFERENCE.BitcoinMainnet:\n                case exports.CHAIN_REFERENCE.BitcoinTestnet:\n                    return true;\n            }\n            break;\n        }\n    }\n    throw new Error(`isChainId: invalid ChainId ${chainId}`);\n};\nexports.isChainId = isChainId;\nexports.chainReferenceToNetworkType = Object.freeze({\n    [exports.CHAIN_REFERENCE.BitcoinMainnet]: types_1.NetworkTypes.MAINNET,\n    [exports.CHAIN_REFERENCE.BitcoinTestnet]: types_1.NetworkTypes.TESTNET,\n    [exports.CHAIN_REFERENCE.EthereumMainnet]: types_1.NetworkTypes.MAINNET,\n    [exports.CHAIN_REFERENCE.EthereumRopsten]: types_1.NetworkTypes.ETH_ROPSTEN,\n    [exports.CHAIN_REFERENCE.EthereumRinkeby]: types_1.NetworkTypes.ETH_RINKEBY,\n    [exports.CHAIN_REFERENCE.CosmosHubMainnet]: types_1.NetworkTypes.COSMOSHUB_MAINNET,\n    [exports.CHAIN_REFERENCE.CosmosHubVega]: types_1.NetworkTypes.COSMOSHUB_VEGA,\n    [exports.CHAIN_REFERENCE.OsmosisMainnet]: types_1.NetworkTypes.OSMOSIS_MAINNET,\n    [exports.CHAIN_REFERENCE.OsmosisTestnet]: types_1.NetworkTypes.OSMOSIS_TESTNET\n});\nexports.networkTypeToChainReference = (0, invert_1.default)(exports.chainReferenceToNetworkType);\nexports.chainNamespaceToChainType = Object.freeze({\n    [exports.CHAIN_NAMESPACE.Bitcoin]: types_1.ChainTypes.Bitcoin,\n    [exports.CHAIN_NAMESPACE.Ethereum]: types_1.ChainTypes.Ethereum,\n    [exports.CHAIN_NAMESPACE.Cosmos]: types_1.ChainTypes.Cosmos\n});\nexports.toCAIP2 = exports.toChainId;\nexports.fromCAIP2 = exports.fromChainId;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.adapters = void 0;\nexports.adapters = __importStar(require(\"./adapters\"));\n__exportStar(require(\"./chainId/chainId\"), exports);\n__exportStar(require(\"./accountId/accountId\"), exports);\n__exportStar(require(\"./assetId/assetId\"), exports);\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n  this._block = Buffer.alloc(blockSize)\n  this._finalSize = finalSize\n  this._blockSize = blockSize\n  this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n  if (typeof data === 'string') {\n    enc = enc || 'utf8'\n    data = Buffer.from(data, enc)\n  }\n\n  var block = this._block\n  var blockSize = this._blockSize\n  var length = data.length\n  var accum = this._len\n\n  for (var offset = 0; offset < length;) {\n    var assigned = accum % blockSize\n    var remainder = Math.min(length - offset, blockSize - assigned)\n\n    for (var i = 0; i < remainder; i++) {\n      block[assigned + i] = data[offset + i]\n    }\n\n    accum += remainder\n    offset += remainder\n\n    if ((accum % blockSize) === 0) {\n      this._update(block)\n    }\n  }\n\n  this._len += length\n  return this\n}\n\nHash.prototype.digest = function (enc) {\n  var rem = this._len % this._blockSize\n\n  this._block[rem] = 0x80\n\n  // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n  // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n  this._block.fill(0, rem + 1)\n\n  if (rem >= this._finalSize) {\n    this._update(this._block)\n    this._block.fill(0)\n  }\n\n  var bits = this._len * 8\n\n  // uint32\n  if (bits <= 0xffffffff) {\n    this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n  // uint64\n  } else {\n    var lowBits = (bits & 0xffffffff) >>> 0\n    var highBits = (bits - lowBits) / 0x100000000\n\n    this._block.writeUInt32BE(highBits, this._blockSize - 8)\n    this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n  }\n\n  this._update(this._block)\n  var hash = this._hash()\n\n  return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n  throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","var exports = module.exports = function SHA (algorithm) {\n  algorithm = algorithm.toLowerCase()\n\n  var Algorithm = exports[algorithm]\n  if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n  return new Algorithm()\n}\n\nexports.sha = require('./sha')\nexports.sha1 = require('./sha1')\nexports.sha224 = require('./sha224')\nexports.sha256 = require('./sha256')\nexports.sha384 = require('./sha384')\nexports.sha512 = require('./sha512')\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n  this._a = 0x67452301\n  this._b = 0xefcdab89\n  this._c = 0x98badcfe\n  this._d = 0x10325476\n  this._e = 0xc3d2e1f0\n\n  return this\n}\n\nfunction rotl1 (num) {\n  return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n  return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n  return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n  if (s === 0) return (b & c) | ((~b) & d)\n  if (s === 2) return (b & c) | (b & d) | (c & d)\n  return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n  for (var j = 0; j < 80; ++j) {\n    var s = ~~(j / 20)\n    var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n    e = d\n    d = c\n    c = rotl30(b)\n    b = a\n    a = t\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(20)\n\n  H.writeInt32BE(this._a | 0, 0)\n  H.writeInt32BE(this._b | 0, 4)\n  H.writeInt32BE(this._c | 0, 8)\n  H.writeInt32BE(this._d | 0, 12)\n  H.writeInt32BE(this._e | 0, 16)\n\n  return H\n}\n\nmodule.exports = Sha1\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Sha256 = require('./sha256')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n  this._a = 0xc1059ed8\n  this._b = 0x367cd507\n  this._c = 0x3070dd17\n  this._d = 0xf70e5939\n  this._e = 0xffc00b31\n  this._f = 0x68581511\n  this._g = 0x64f98fa7\n  this._h = 0xbefa4fa4\n\n  return this\n}\n\nSha224.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(28)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n\n  return H\n}\n\nmodule.exports = Sha224\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n  0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n  0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n  0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n  0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n  0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n  0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n  0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n  0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n  0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n  0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n  0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n  0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n  0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n  0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n  0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n  this.init()\n\n  this._w = W // new Array(64)\n\n  Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n  this._a = 0x6a09e667\n  this._b = 0xbb67ae85\n  this._c = 0x3c6ef372\n  this._d = 0xa54ff53a\n  this._e = 0x510e527f\n  this._f = 0x9b05688c\n  this._g = 0x1f83d9ab\n  this._h = 0x5be0cd19\n\n  return this\n}\n\nfunction ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n  return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n  return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n  return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n  return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n  var W = this._w\n\n  var a = this._a | 0\n  var b = this._b | 0\n  var c = this._c | 0\n  var d = this._d | 0\n  var e = this._e | 0\n  var f = this._f | 0\n  var g = this._g | 0\n  var h = this._h | 0\n\n  for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n  for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n  for (var j = 0; j < 64; ++j) {\n    var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n    var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n    h = g\n    g = f\n    f = e\n    e = (d + T1) | 0\n    d = c\n    c = b\n    b = a\n    a = (T1 + T2) | 0\n  }\n\n  this._a = (a + this._a) | 0\n  this._b = (b + this._b) | 0\n  this._c = (c + this._c) | 0\n  this._d = (d + this._d) | 0\n  this._e = (e + this._e) | 0\n  this._f = (f + this._f) | 0\n  this._g = (g + this._g) | 0\n  this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(32)\n\n  H.writeInt32BE(this._a, 0)\n  H.writeInt32BE(this._b, 4)\n  H.writeInt32BE(this._c, 8)\n  H.writeInt32BE(this._d, 12)\n  H.writeInt32BE(this._e, 16)\n  H.writeInt32BE(this._f, 20)\n  H.writeInt32BE(this._g, 24)\n  H.writeInt32BE(this._h, 28)\n\n  return H\n}\n\nmodule.exports = Sha256\n","var inherits = require('inherits')\nvar SHA512 = require('./sha512')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n  this._ah = 0xcbbb9d5d\n  this._bh = 0x629a292a\n  this._ch = 0x9159015a\n  this._dh = 0x152fecd8\n  this._eh = 0x67332667\n  this._fh = 0x8eb44a87\n  this._gh = 0xdb0c2e0d\n  this._hh = 0x47b5481d\n\n  this._al = 0xc1059ed8\n  this._bl = 0x367cd507\n  this._cl = 0x3070dd17\n  this._dl = 0xf70e5939\n  this._el = 0xffc00b31\n  this._fl = 0x68581511\n  this._gl = 0x64f98fa7\n  this._hl = 0xbefa4fa4\n\n  return this\n}\n\nSha384.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(48)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n\n  return H\n}\n\nmodule.exports = Sha384\n","var inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n  0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n  0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n  0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n  0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n  0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n  0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n  0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n  0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n  0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n  0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n  0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n  0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n  0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n  0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n  0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n  0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n  0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n  0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n  0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n  0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n  0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n  0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n  0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n  0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n  0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n  0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n  0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n  0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n  0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n  0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n  0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n  0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n  0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n  0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n  0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n  0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n  0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n  0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n  0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n  0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n  this.init()\n  this._w = W\n\n  Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n  this._ah = 0x6a09e667\n  this._bh = 0xbb67ae85\n  this._ch = 0x3c6ef372\n  this._dh = 0xa54ff53a\n  this._eh = 0x510e527f\n  this._fh = 0x9b05688c\n  this._gh = 0x1f83d9ab\n  this._hh = 0x5be0cd19\n\n  this._al = 0xf3bcc908\n  this._bl = 0x84caa73b\n  this._cl = 0xfe94f82b\n  this._dl = 0x5f1d36f1\n  this._el = 0xade682d1\n  this._fl = 0x2b3e6c1f\n  this._gl = 0xfb41bd6b\n  this._hl = 0x137e2179\n\n  return this\n}\n\nfunction Ch (x, y, z) {\n  return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n  return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n  return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n  return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n  return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n  return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n  return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n  var W = this._w\n\n  var ah = this._ah | 0\n  var bh = this._bh | 0\n  var ch = this._ch | 0\n  var dh = this._dh | 0\n  var eh = this._eh | 0\n  var fh = this._fh | 0\n  var gh = this._gh | 0\n  var hh = this._hh | 0\n\n  var al = this._al | 0\n  var bl = this._bl | 0\n  var cl = this._cl | 0\n  var dl = this._dl | 0\n  var el = this._el | 0\n  var fl = this._fl | 0\n  var gl = this._gl | 0\n  var hl = this._hl | 0\n\n  for (var i = 0; i < 32; i += 2) {\n    W[i] = M.readInt32BE(i * 4)\n    W[i + 1] = M.readInt32BE(i * 4 + 4)\n  }\n  for (; i < 160; i += 2) {\n    var xh = W[i - 15 * 2]\n    var xl = W[i - 15 * 2 + 1]\n    var gamma0 = Gamma0(xh, xl)\n    var gamma0l = Gamma0l(xl, xh)\n\n    xh = W[i - 2 * 2]\n    xl = W[i - 2 * 2 + 1]\n    var gamma1 = Gamma1(xh, xl)\n    var gamma1l = Gamma1l(xl, xh)\n\n    // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n    var Wi7h = W[i - 7 * 2]\n    var Wi7l = W[i - 7 * 2 + 1]\n\n    var Wi16h = W[i - 16 * 2]\n    var Wi16l = W[i - 16 * 2 + 1]\n\n    var Wil = (gamma0l + Wi7l) | 0\n    var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n    Wil = (Wil + gamma1l) | 0\n    Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n    Wil = (Wil + Wi16l) | 0\n    Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n    W[i] = Wih\n    W[i + 1] = Wil\n  }\n\n  for (var j = 0; j < 160; j += 2) {\n    Wih = W[j]\n    Wil = W[j + 1]\n\n    var majh = maj(ah, bh, ch)\n    var majl = maj(al, bl, cl)\n\n    var sigma0h = sigma0(ah, al)\n    var sigma0l = sigma0(al, ah)\n    var sigma1h = sigma1(eh, el)\n    var sigma1l = sigma1(el, eh)\n\n    // t1 = h + sigma1 + ch + K[j] + W[j]\n    var Kih = K[j]\n    var Kil = K[j + 1]\n\n    var chh = Ch(eh, fh, gh)\n    var chl = Ch(el, fl, gl)\n\n    var t1l = (hl + sigma1l) | 0\n    var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n    t1l = (t1l + chl) | 0\n    t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n    t1l = (t1l + Kil) | 0\n    t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n    t1l = (t1l + Wil) | 0\n    t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n    // t2 = sigma0 + maj\n    var t2l = (sigma0l + majl) | 0\n    var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n    hh = gh\n    hl = gl\n    gh = fh\n    gl = fl\n    fh = eh\n    fl = el\n    el = (dl + t1l) | 0\n    eh = (dh + t1h + getCarry(el, dl)) | 0\n    dh = ch\n    dl = cl\n    ch = bh\n    cl = bl\n    bh = ah\n    bl = al\n    al = (t1l + t2l) | 0\n    ah = (t1h + t2h + getCarry(al, t1l)) | 0\n  }\n\n  this._al = (this._al + al) | 0\n  this._bl = (this._bl + bl) | 0\n  this._cl = (this._cl + cl) | 0\n  this._dl = (this._dl + dl) | 0\n  this._el = (this._el + el) | 0\n  this._fl = (this._fl + fl) | 0\n  this._gl = (this._gl + gl) | 0\n  this._hl = (this._hl + hl) | 0\n\n  this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n  this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n  this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n  this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n  this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n  this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n  this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n  this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n  var H = Buffer.allocUnsafe(64)\n\n  function writeInt64BE (h, l, offset) {\n    H.writeInt32BE(h, offset)\n    H.writeInt32BE(l, offset + 4)\n  }\n\n  writeInt64BE(this._ah, this._al, 0)\n  writeInt64BE(this._bh, this._bl, 8)\n  writeInt64BE(this._ch, this._cl, 16)\n  writeInt64BE(this._dh, this._dl, 24)\n  writeInt64BE(this._eh, this._el, 32)\n  writeInt64BE(this._fh, this._fl, 40)\n  writeInt64BE(this._gh, this._gl, 48)\n  writeInt64BE(this._hh, this._hl, 56)\n\n  return H\n}\n\nmodule.exports = Sha512\n"],"names":["__createBinding","this","Object","create","o","m","k","k2","undefined","desc","getOwnPropertyDescriptor","__esModule","writable","configurable","enumerable","get","defineProperty","__exportStar","exports","p","prototype","hasOwnProperty","call","value","require","__importDefault","mod","AssetService","indexAssetData","flattenAssetData","types_1","axios_1","descriptions_json_1","GenerateAssetIcon_1","generatedAssetData_json_1","assetData","flatAssetData","baseAsset","newAsset","tokens","push","tokenAsset","chain","network","slip44","explorer","explorerAddressLink","explorerTxLink","getDataIndexKey","tokenId","reduce","acc","val","assetFileUrl","Array","isArray","isInitialized","Error","default","data","indexedAssetData","checkInitialized","filter","asset","index","NetworkTypes","MAINNET","result","descriptions","assetId","description","isTrusted","dataSource","AssetDataSource","CoinGecko","contractUrl","_a","toLowerCase","errorMessage","_c","_b","en","identity","text","options","getRenderedIdenticonBase64","Identicon","fonts","renderPixels","paintPixel","pngObj","x","y","color","buffer","_d","_e","_f","_g","_h","_j","_k","_l","identiconOptions","identiconImage","size","margin","foreground","background","saturation","brightness","format","identiconText","textColor","symbolScale","Math","floor","length","enableShadow","shadowColor","substring","render","symbolPixels","sevenPlus","pixelSymbolWidth","pixelSymbolHeight","offsetX","round","offsetY","offsettedX","offsettedY","getRenderedIdenticonPNG","getBase64","bigInt","BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","supportsNativeBigInt","BigInt","Integer","v","radix","alphabet","caseSensitive","parseBase","parseValue","BigInteger","sign","isSmall","SmallInteger","NativeBigInt","isPrecise","n","arrayToSmall","arr","trim","compareAbs","i","createArray","truncate","ceil","add","a","b","sum","l_a","l_b","r","carry","base","addAny","addSmall","l","subtract","difference","a_l","b_l","borrow","subtractSmall","multiplyLong","product","a_i","j","multiplySmall","shiftLeft","concat","multiplyKaratsuba","max","slice","d","c","ac","bd","abcd","multiplySmallAndArray","square","divModSmall","lambda","q","remainder","divisor","quotient","divModAny","self","negate","abs","comparison","quotientDigit","shift","divisorMostSignificantDigit","divMod1","guess","xlen","highx","highy","check","part","unshift","reverse","divMod2","qSign","mSign","isBasicPrime","isUnit","equals","isEven","isDivisibleBy","lesser","millerRabinTest","nPrev","prev","divide","next","modPow","plus","subtractAny","minus","small","multiply","l1","l2","times","_multiplyBySmall","divmod","over","pow","toString","_0","_1","_2","isNegative","exp","isZero","modInv","isPositive","isOdd","compare","Infinity","compareTo","eq","notEquals","neq","greater","gt","lt","greaterOrEquals","geq","lesserOrEquals","leq","isPrime","strict","bits","bitLength","logN","log","toJSNumber","t","isProbablePrime","iterations","rng","randBetween","lastT","lastR","zero","newT","one","newR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","bitwise","fn","xSign","ySign","xRem","not","yRem","xDigit","yDigit","xDivMod","yDivMod","String","shiftRight","remQuo","and","or","xor","LOBMASK_I","roughLOB","integerLogarithm","tmp","e","min","gcd","absBase","alphabetValues","digits","start","parseBaseFromArray","toBase","apply","map","valueOf","neg","Number","out","left","digit","toBaseString","stringify","join","parseStringValue","split","decimalPlace","indexOf","test","parseNumberValue","toArray","str","toJSON","parseInt","minusOne","lcm","isInstance","usedRNG","random","low","range","restricted","top","fromArray","module","define","cashaddr","networks","payments","bscript","types","bech32","bs58check","typeforce","fromBase58Check","address","VALID_PREFIXES","version","decode","prefix","bitcoin","testnet","regtest","type","pubKeyHash","scriptHash","hash","TypeError","Buffer","from","payload","readUInt8","fromBech32","fromWords","words","toBase58Check","tuple","Hash160bit","UInt8","arguments","allocUnsafe","writeUInt8","copy","encode","toBech32","toWords","fromOutputScript","output","p2pkh","p2sh","p2wpkh","p2wsh","toASM","toOutputScript","decodeBase58","decodeBech32","bufferutils_1","bcrypto","transaction_1","fastMerkleRoot","varuint","errorMerkleNoTxes","errorWitnessNotSegwit","Block","prevHash","merkleRoot","timestamp","witnessCommit","nonce","transactions","txesHaveWitnessCommit","witnessCommits","outs","script","getWitnessCommit","some","tx","ins","input","witness","byteLength","headersOnly","allowWitness","encodingLength","hash256","toBuffer","reverseBuffer","getHash","date","Date","setUTCSeconds","bufferWriter","BufferWriter","writeInt32","writeSlice","writeUInt32","offset","bytes","forEach","txSize","hasWitnessCommit","hasWitness","__checkMerkleRoot","__checkWitnessCommit","target","calculateTarget","actualMerkleRoot","calculateMerkleRoot","actualWitnessCommit","bufferReader","BufferReader","block","readInt32","readSlice","readUInt32","readTransaction","Transaction","fromBuffer","nTransactions","readVarInt","hex","exponent","mantissa","alloc","writeUIntBE","forWitness","Function","hashes","transaction","rootHash","verifuint","readUInt64LE","readUInt32LE","writeUInt64LE","writeInt32LE","writeUInt32LE","cloneBuffer","clone","UInt32","writeVarInt","vector","buf","writeVarSlice","readInt32LE","vi","count","readVarSlice","validation_1","CHARSET_INVERSE_INDEX","z","g","f","w","s","h","u","validate","Uint8Array","base32","strng","convertBits","to","strictMode","mask","accumulator","convertBits_1","validation","prefixToUint5Array","charCodeAt","ab","set","polymod","GENERATOR","checksum","topBits","hasSingleCase","toUpperCase","isValidPrefix","prefixData","versionByte","ValidationError","getTypeBits","getHashSizeBits","payloadData","checksumData","checksumToUint5Array","pieces","validChecksum","subarray","getHashSize","getType","message","name","setPrototypeOf","condition","script_1","multisig","nullData","pubKey","witnessCommitment","witnessPubKeyHash","witnessScriptHash","P2MS","NONSTANDARD","NULLDATA","P2PK","P2PKH","P2SH","P2WPKH","P2WSH","WITNESS_COMMITMENT","chunks","decompile","allowIncomplete","createHash","AlgorithmLength","ripemd160","sha1","sha256","hash160","asDigest","preimage","algorithm","assign","expectedLength","update","digest","err","NETWORKS","ecc","randomBytes","wif","isOptions","maybe","compile","compressed","Boolean","Network","ECPair","__D","__Q","lowR","pointCompress","pointFromScalar","sig","extraData","counter","writeUIntLE","signWithEntropy","signature","verify","publicKey","fromPrivateKey","Buffer256bit","isPrivate","fromPublicKey","isPoint","fromWIF","wifString","decoded","pop","privateKey","makeRandom","bip32","crypto","block_1","psbt_1","Psbt","opcodes","OPS","transaction_builder_1","TransactionBuilder","bitcoingold","messagePrefix","public","private","networks_1","lazy","typef","p2data","opts","arrayOf","prop","OP_RETURN","every","stacksEqual","embed_1","embed","p2ms_1","p2ms","p2pk_1","p2pk","p2pkh_1","p2sh_1","p2wpkh_1","p2wsh_1","object","_value","OP_INT_BASE","OP_RESERVED","pubkeys","signatures","isAcceptableSignature","isCanonicalScriptSignature","OP_0","OP_CHECKMULTISIG","pubkey","_chunks","OP_CHECKSIG","BufferN","_address","OP_DUP","OP_HASH160","OP_EQUALVERIFY","hash2","pkh","redeem","_redeem","OP_EQUAL","nameParts","checkRedeem","hasInput","richunks","isPushOnly","isBuffer","EMPTY_BUFFER","chunkHasUncompressedPubkey","chunk","_rchunks","stack","toStack","wScript","bip174_1","utils_1","address_1","crypto_1","ecpair_1","BCH_SIGHASH_ALL","SIGHASH_ALL","SIGHASH_BITCOINCASHBIP143","BTG_SIGHASH_ALL","FORKID_BTG","DEFAULT_SIGHASHES","DEFAULT_OPTS","maximumFeeRate","forkCoin","PsbtTransaction","__CACHE","__NON_WITNESS_UTXO_TX_CACHE","__NON_WITNESS_UTXO_BUF_CACHE","__TX_IN_CACHE","__TX","globalMap","unsignedTx","__UNSAFE_SIGN_NONSEGWIT","inputs","setVersion","dpew","obj","attr","locktime","setLocktime","sequence","_","those","combine","res","JSON","parse","satoshiPerByte","check32Bit","checkInputsForPartialSig","__EXTRACTED_TX","inputIndex","inputDatas","inputData","addInput","witnessScript","checkInvalidP2WSH","txIn","checkTxInputCache","nonWitnessUtxo","addNonWitnessTxCache","__FEE","__FEE_RATE","outputDatas","outputData","addOutput","disableFeeCheck","isFinalized","psbt","cache","feeRate","getFeeRate","vsize","virtualSize","satoshis","toFixed","checkFees","inputFinalizeGetAmts","getTxCacheValue","checkForInput","idx","finalizeInput","finalScriptsFunc","getFinalScripts","getScriptFromInput","isP2SH","isP2WSH","isSegwit","checkPartialSigSighashes","finalScriptSig","finalScriptWitness","updateInput","clearFinalizedInput","getMeaningfulScript","getScriptFromUtxo","redeemScript","finalScript","decomp","lastItem","isPubkeyLike","redeemFromFinalScriptSig","scriptWitnessToWitnessStack","redeemFromFinalWitnessScript","classifyScript","meaningfulScript","pubkeyInScript","pubkeyInInput","root","derivationIsMine","bip32DerivationIsMine","bip32Derivation","outputIndex","pubkeyInOutput","checkForOutput","outputs","validateSignaturesOfInput","final","partialSig","mySigs","hashCache","scriptCache","sighashCache","results","pSig","hashType","getHashForSig","sighashType","checkScriptForPubkey","keypair","hdKeyPair","sighashTypes","fingerprint","signInputHD","Promise","resolve","reject","promises","signInputHDAsync","then","all","signers","getSignersFromHD","signer","signInput","signInputAsync","catch","keyPair","entries","getHashAndSighashType","checkCache","toHex","toBase64","updateData","updateGlobal","updateOutput","keyVal","addUnknownKeyValToGlobal","addUnknownKeyValToInput","addUnknownKeyValToOutput","psbtBase","transactionFromBuffer","checkTxForDupeIns","checkTxEmpty","inputCount","outputCount","hasSigs","neededSigs","sigs","pkey","find","isPaymentFactory","payment","isP2MS","isP2PK","isP2PKH","isP2WPKH","isP2WSHScript","isP2SHScript","masterFingerprint","derivePath","path","num","action","throws","pSigs","scriptItems","witnessItems","item","getPsigsFromInputFinalScripts","whitelist","SIGHASH_ANYONECANPAY","SIGHASH_SINGLE","SIGHASH_NONE","key","scriptCheckerFactory","paymentScriptName","scriptPubKey","ioType","redeemScriptOutput","checkRedeemScript","checkWitnessScript","mustFinalize","scriptType","canFinalize","pk","ps","getSortedSigs","getPayment","witnessStackToScriptWitness","prepareFinalScripts","forValidate","prevout","getDefaultSighash","sighashTypeToString","isForkId","isBTG","nonWitnessUtxoTx","nonWitnessUtxoTxFromCache","prevoutHash","utxoHash","prevoutIndex","witnessUtxo","hashForGoldSignature","hashForWitnessV0","signingScript","console","warn","hashForCashSignature","hashForSignature","myDerivations","bipDv","node","readVector","currentLen","varintLen","selfIndex","txCache","newBuf","inputAmount","nwTx","vout","outputAmount","total","fee","isCanonicalPubKey","isP2SHP2WSH","pubkeyHash","decompiled","element","keys","scriptNumber","scriptSignature","bip66","pushdata","REVERSE_OPS","isPushOnlyChunk","OP_1","OP_16","OP_1NEGATE","isOPInt","asMinimalOP","chunksIsBuffer","singleChunkIsBuffer","bufferSize","accum","opcode","OP_PUSHDATA4","number","op","isDefinedHashType","hashTypeMod","fromASM","asm","chunkStr","Hex","maxLength","minimal","_number","scriptNumSize","negative","ZERO","toDER","fromDER","bstart","hashTypeBuffer","partialSignature","p2wpkho","p2wsho","lastChunk","scriptSigChunks","redeemScriptChunks","HEADER","commitment","Hash256bit","witnessScriptChunks","witnessRawScriptSig","varSliceSize","someScript","vectorSize","someVector","EMPTY_SCRIPT","EMPTY_WITNESS","ONE","VALUE_UINT64_MAX","BLANK_OUTPUT","valueBuffer","isOutput","isCoinbaseHash","scriptSig","Null","DEFAULT_SEQUENCE","Satoshi","weight","_ALLOW_WITNESS","hasWitnesses","newTx","txOut","inIndex","prevOutScript","ourScript","OP_CODESEPARATOR","txTmp","__toBuffer","tbuffer","hashOutputs","hashPrevouts","hashSequence","txOutsSize","writeUInt64","inAmount","UInt53","sigVersion","nForkHashType","fUseForkId","isCoinbase","initialOffset","ADVANCED_TRANSACTION_MARKER","ADVANCED_TRANSACTION_FLAG","writeVector","_NO_STRICT","marker","flag","vinLen","voutLen","readUInt64","FORKID_BCH","baddress","classify","SCRIPT_TYPES","PREVOUT_TYPES","Set","tfMessage","__PREV_TX_SET","__INPUTS","__BITCOINCASH","__BITCOINGOLD","__USE_LOW_R","enable","setting","txHash","__canModifyInputs","txIsTransaction","__addInputUnsafe","__canModifyOutputs","__build","signParams","witnessValue","ourPubKey","signatureHash","useLowR","signed","trySign","needsOutputs","forkBools","vin","has","prevOutScriptType","Signer","prevOutType","posType","checkSignArgs","getPublicKey","canSign","prepared","p2wshAlt","p2shAlt","expanded","expandOutput","signScript","redeemScriptType","witnessScriptType","signType","maxSignatures","prepareInput","btg","bch","getSigningData","__needsOutputs","bind","prevTxOut","expandInput","build","setInputScript","setWitness","__overMaximumFees","signatureHashType","signingHashType","nInputs","nOutputs","forkId","txb","enableBitcoinGold","enableBitcoinCash","setLockTime","unmatched","match","parsed","fixMultisigOrder","witnessStack","ssType","wsType","outputType","pkh1","pkh2","wpkh1","wpkh2","UINT31_MAX","BIP32Path","UInt31","ECPoint","quacksLike","oneOf","fromCAIP10","toCAIP10","fromAccountId","toAccountId","chainId_1","chainId","account","isChainId","outputAccount","CHAIN_NAMESPACE","Ethereum","accountId","parts","getBanxaBlockchainFromBanxaAssetTicker","getSupportedBanxaAssets","AssetIdToBanxaTicker","banxaTickerToAssetId","entries_1","toLower_1","assetId_1","AssetIdToBanxaTickerMap","banxaTickerToAssetIdMap","id","ticker","chainIdToBanxaBlockchainCodeMap","banxaAssetId","assetAssetId","fromAssetId","toChainId","osmosis","cosmos","eip155","bip122","adapter_json_1","adapter_json_2","adapter_json_3","adapter_json_4","__setModuleDefault","__importStar","assetIdToCoinCap","coincapToAssetId","coincapUrl","adapters","generatedAssetIdToCoinCapMap","values","cur","generatedCoinCapToAssetIdMap","assetIdToCoingecko","coingeckoToAssetId","coingeckoUrl","generatedAssetIdToCoingeckoMap","generatedCoingeckoToAssetIdMap","assetIdToGemAssetId","gemAssetIdToAssetId","assetIdToGemAssetIdMap","gemAssetIdToAssetIdMap","assetIdToOsmosis","osmosisToAssetId","osmosisUrl","generatedAssetIdToOsmosisMap","generatedOsmosisToAssetIdMap","assetIdToYearn","yearnToAssetId","generatedAssedIdToYearnMap","generatedYearnToAssetIdMap","fromCAIP19","toCAIP19","toAssetId","ASSET_REFERENCE","assetNamespaceStrings","Bitcoin","Cosmos","Osmosis","validAssetNamespaces","freeze","ChainTypes","args","assetNamespace","assetReference","includes","isNaN","isValidSlip44","startsWith","parseAssetIdRegExp","maybeAssetNamespace","matches","exec","chainNamespaceToChainType","chainReferenceToNetworkType","OSMOSIS_MAINNET","OSMOSIS_TESTNET","fromCAIP2","toCAIP2","networkTypeToChainReference","fromChainId","CHAIN_REFERENCE","invert_1","EthereumMainnet","EthereumRopsten","EthereumRinkeby","BitcoinMainnet","BitcoinTestnet","CosmosHubMainnet","CosmosHubVega","OsmosisMainnet","OsmosisTestnet","shapeShiftToChainId","namespace","reference","ETH_ROPSTEN","ETH_RINKEBY","TESTNET","COSMOSHUB_MAINNET","COSMOSHUB_VEGA","referenceMap","Hash","blockSize","finalSize","_block","_finalSize","_blockSize","_len","enc","assigned","_update","rem","fill","writeUInt32BE","lowBits","highBits","_hash","Algorithm","sha","sha224","sha384","sha512","inherits","K","W","Sha","init","_w","rotl30","ft","M","readInt32BE","H","writeInt32BE","Sha1","rotl5","Sha256","Sha224","ch","maj","sigma0","sigma1","gamma0","T1","T2","SHA512","Sha384","_ah","_bh","_ch","_dh","_eh","_fh","_gh","_hh","_al","_bl","_cl","_dl","_el","_fl","_gl","_hl","writeInt64BE","Sha512","Ch","xl","Gamma0","Gamma0l","Gamma1","Gamma1l","getCarry","ah","bh","dh","eh","fh","gh","hh","al","bl","cl","dl","el","fl","gl","hl","xh","gamma0l","gamma1","gamma1l","Wi7h","Wi7l","Wi16h","Wi16l","Wil","Wih","majh","majl","sigma0h","sigma0l","sigma1h","sigma1l","Kih","Kil","chh","chl","t1l","t1h","t2l","t2h"],"sourceRoot":""}