@onetokenfe/coinselect 3.1.16

package/third-party/utils/typedEventEmitter.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter } from 'events';
+type EventMap = Record<string, any>;
+type EventKey<T extends EventMap> = string & keyof T;
+type IsUnion<T, U extends T = T> = T extends unknown ? ([U] extends [T] ? 0 : 1) : 2;
+type EventReceiver<T> = IsUnion<T> extends 1 ? (event: T) => void : T extends (...args: any[]) => any ? T : T extends undefined ? () => void : (event: T) => void;
+export interface TypedEmitter<T extends EventMap> {
+    on<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    once<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    addListener<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    prependListener<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    prependOnceListener<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    off<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    removeListener<K extends EventKey<T>>(eventName: K, fn: EventReceiver<T[K]>): this;
+    removeAllListeners<K extends EventKey<T>>(event?: K): this;
+    emit<K extends EventKey<T>>(eventName: K, ...params: Parameters<EventReceiver<T[K]>>): boolean;
+    listeners<K extends EventKey<T>>(eventName: K): EventReceiver<T[K]>[];
+    rawListeners<K extends EventKey<T>>(eventName: K): EventReceiver<T[K]>[];
+}
+export declare class TypedEmitter<T extends EventMap> extends EventEmitter {
+    listenerCount<K extends EventKey<T>>(eventName: K): number;
+}
+export {};
+//# sourceMappingURL=typedEventEmitter.d.ts.map

package/third-party/utils/typedEventEmitter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypedEmitter = void 0;
+const events_1 = require("events");
+class TypedEmitter extends events_1.EventEmitter {
+    listenerCount(eventName) {
+        return super.listenerCount(eventName);
+    }
+}
+exports.TypedEmitter = TypedEmitter;
+//# sourceMappingURL=typedEventEmitter.js.map

package/third-party/utils/urlToOnion.d.ts

@@ -0,0 +1,4 @@
+export declare const urlToOnion: (url: string, onionDomains: {
+    [domain: string]: string;
+}) => string | undefined;
+//# sourceMappingURL=urlToOnion.d.ts.map

package/third-party/utils/urlToOnion.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.urlToOnion = void 0;
+const urlToOnion = (url, onionDomains) => {
+    var _a;
+    const [, protocol, subdomain, domain, rest] = (_a = url.match(/^(http|ws)s?:\/\/([^:/]+\.)?([^/.]+\.[^/.]+)(\/.*)?$/i)) !== null && _a !== void 0 ? _a : [];
+    if (!domain || !onionDomains[domain])
+        return;
+    return `${protocol}://${subdomain !== null && subdomain !== void 0 ? subdomain : ''}${onionDomains[domain]}${rest !== null && rest !== void 0 ? rest : ''}`;
+};
+exports.urlToOnion = urlToOnion;
+//# sourceMappingURL=urlToOnion.js.map

package/third-party/utils/versionUtils.d.ts

@@ -0,0 +1,9 @@
+type VersionArray = [number, number, number];
+type VersionInput = VersionArray | string;
+export declare const isVersionArray: (arr: unknown) => arr is VersionArray;
+export declare const isNewer: (versionX: VersionInput, versionY: VersionInput) => boolean;
+export declare const isEqual: (versionX: VersionInput, versionY: VersionInput) => boolean;
+export declare const isNewerOrEqual: (versionX: VersionInput, versionY: VersionInput) => boolean;
+export declare const normalizeVersion: (version: string) => string;
+export {};
+//# sourceMappingURL=versionUtils.d.ts.map

package/third-party/utils/versionUtils.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeVersion = exports.isNewerOrEqual = exports.isEqual = exports.isNewer = exports.isVersionArray = void 0;
+const throwError_1 = require("./throwError");
+const isVersionArray = (arr) => Array.isArray(arr) &&
+    arr.length === 3 &&
+    arr.every(number => typeof number === 'number' && number >= 0);
+exports.isVersionArray = isVersionArray;
+const tryParse = (version) => {
+    var _a;
+    return (_a = version
+        .match(/^(\d+)\.(\d+)\.(\d+)([+-].*)?$/)) === null || _a === void 0 ? void 0 : _a.slice(1, 4).map(n => Number(n));
+};
+const validateArray = (version) => ((0, exports.isVersionArray)(version) ? version : null);
+const ensureArray = (version) => {
+    var _a;
+    return (_a = (typeof version === 'string' ? tryParse(version) : validateArray(version))) !== null && _a !== void 0 ? _a : (0, throwError_1.throwError)(`version string is in wrong format: ${version}`);
+};
+const compare = ([majorX, minorX, patchX], [majorY, minorY, patchY]) => majorX - majorY || minorX - minorY || patchX - patchY;
+const isNewer = (versionX, versionY) => compare(ensureArray(versionX), ensureArray(versionY)) > 0;
+exports.isNewer = isNewer;
+const isEqual = (versionX, versionY) => compare(ensureArray(versionX), ensureArray(versionY)) === 0;
+exports.isEqual = isEqual;
+const isNewerOrEqual = (versionX, versionY) => compare(ensureArray(versionX), ensureArray(versionY)) >= 0;
+exports.isNewerOrEqual = isNewerOrEqual;
+const normalizeVersion = (version) => version.replace(/\b0+(\d)/g, '$1');
+exports.normalizeVersion = normalizeVersion;
+//# sourceMappingURL=versionUtils.js.map

package/third-party/utils/xssFilters.d.ts

@@ -0,0 +1,4 @@
+export declare const inHTML: (value: string) => string;
+export declare const inSingleQuotes: (value: string) => string;
+export declare const inDoubleQuotes: (value: string) => string;
+//# sourceMappingURL=xssFilters.d.ts.map

package/third-party/utils/xssFilters.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inDoubleQuotes = exports.inSingleQuotes = exports.inHTML = void 0;
+const LT = /</g;
+const SQUOT = /'/g;
+const QUOT = /"/g;
+const inHTML = (value) => value.replace(LT, '&lt;');
+exports.inHTML = inHTML;
+const inSingleQuotes = (value) => value.replace(SQUOT, '&#39;');
+exports.inSingleQuotes = inSingleQuotes;
+const inDoubleQuotes = (value) => value.replace(QUOT, '&quot;');
+exports.inDoubleQuotes = inDoubleQuotes;
+//# sourceMappingURL=xssFilters.js.map

package/third-party/utxo-lib/address.d.ts

@@ -0,0 +1,17 @@
+import { Network } from './networks';
+export interface Base58CheckResult {
+    hash: Buffer;
+    version: number;
+}
+export interface Bech32Result {
+    version: number;
+    prefix: string;
+    data: Buffer;
+}
+export declare function fromBase58Check(address: string, network?: Network): Base58CheckResult;
+export declare function fromBech32(address: string): Bech32Result;
+export declare function toBech32(data: Buffer, version: number, prefix: string): string;
+export declare function fromOutputScript(output: Buffer, network?: Network): string;
+export declare function getAddressType(address: string, network?: Network): "p2pkh" | "p2sh" | "p2tr" | "p2wpkh" | "p2wsh" | "p2w-unknown" | "unknown";
+export declare function toOutputScript(address: string, network?: Network): Buffer;
+//# sourceMappingURL=address.d.ts.map

package/third-party/utxo-lib/address.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase58Check = fromBase58Check;
+exports.fromBech32 = fromBech32;
+exports.toBech32 = toBech32;
+exports.fromOutputScript = fromOutputScript;
+exports.getAddressType = getAddressType;
+exports.toOutputScript = toOutputScript;
+const tslib_1 = require("tslib");
+const bech32_1 = require("bech32");
+const bs58check = tslib_1.__importStar(require("./bs58check"));
+const bscript = tslib_1.__importStar(require("./script"));
+const payments = tslib_1.__importStar(require("./payments"));
+const networks_1 = require("./networks");
+function fromBase58Check(address, network = networks_1.bitcoin) {
+    return bs58check.decodeAddress(address, network);
+}
+function fromBech32(address) {
+    let result;
+    let version;
+    try {
+        result = bech32_1.bech32.decode(address);
+    }
+    catch (_a) {
+    }
+    if (result) {
+        [version] = result.words;
+        if (version !== 0)
+            throw new TypeError(`${address} uses wrong encoding`);
+    }
+    else {
+        result = bech32_1.bech32m.decode(address);
+        [version] = result.words;
+        if (version === 0)
+            throw new TypeError(`${address} uses wrong encoding`);
+    }
+    const data = bech32_1.bech32.fromWords(result.words.slice(1));
+    return {
+        version,
+        prefix: result.prefix,
+        data: Buffer.from(data),
+    };
+}
+function toBech32(data, version, prefix) {
+    const words = bech32_1.bech32.toWords(data);
+    words.unshift(version);
+    return version === 0 ? bech32_1.bech32.encode(prefix, words) : bech32_1.bech32m.encode(prefix, words);
+}
+const FUTURE_SEGWIT_MAX_SIZE = 40;
+const FUTURE_SEGWIT_MIN_SIZE = 2;
+const FUTURE_SEGWIT_MAX_VERSION = 16;
+const FUTURE_SEGWIT_MIN_VERSION = 1;
+const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
+function toFutureSegwitAddress(output, network = networks_1.bitcoin) {
+    const data = output.subarray(2);
+    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE)
+        throw new TypeError('Invalid program length for segwit address');
+    const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
+    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION)
+        throw new TypeError('Invalid version for segwit address');
+    if (output[1] !== data.length)
+        throw new TypeError('Invalid script for segwit address');
+    return toBech32(data, version, network.bech32);
+}
+function fromOutputScript(output, network = networks_1.bitcoin) {
+    try {
+        return payments.p2pkh({ output, network }).address;
+    }
+    catch (_a) {
+    }
+    try {
+        return payments.p2sh({ output, network }).address;
+    }
+    catch (_b) {
+    }
+    try {
+        return payments.p2wpkh({ output, network }).address;
+    }
+    catch (_c) {
+    }
+    try {
+        return payments.p2wsh({ output, network }).address;
+    }
+    catch (_d) {
+    }
+    try {
+        return payments.p2tr({ output, network }).address;
+    }
+    catch (_e) {
+    }
+    try {
+        return toFutureSegwitAddress(output, network);
+    }
+    catch (_f) {
+    }
+    throw new Error(`${bscript.toASM(output)} has no matching Address`);
+}
+function decodeAddress(address, network) {
+    try {
+        const { hash, version } = fromBase58Check(address, network);
+        return { success: true, format: 'base58', version, hash };
+    }
+    catch (_a) {
+        try {
+            const { data, prefix, version } = fromBech32(address);
+            if (prefix === network.bech32) {
+                return { success: true, format: 'bech32', version, hash: data };
+            }
+            return { success: false, error: 'bech32-invalid-prefix' };
+        }
+        catch (_b) {
+        }
+    }
+    return { success: false, error: 'unknown-format' };
+}
+function identifyAddressType(format, version, hash, network) {
+    if (format === 'base58') {
+        if (version === network.pubKeyHash)
+            return 'p2pkh';
+        if (version === network.scriptHash)
+            return 'p2sh';
+    }
+    else if (format === 'bech32') {
+        if (version === 0) {
+            if (hash.length === 20)
+                return 'p2wpkh';
+            if (hash.length === 32)
+                return 'p2wsh';
+        }
+        else if (version === 1 && hash.length === 32) {
+            return 'p2tr';
+        }
+        else if (version >= FUTURE_SEGWIT_MIN_VERSION &&
+            version <= FUTURE_SEGWIT_MAX_VERSION &&
+            hash.length >= FUTURE_SEGWIT_MIN_SIZE &&
+            hash.length <= FUTURE_SEGWIT_MAX_SIZE) {
+            return 'p2w-unknown';
+        }
+    }
+    return 'unknown';
+}
+function createOutputScript(type, hash, version) {
+    switch (type) {
+        case 'p2pkh':
+            return payments.p2pkh({ hash }).output;
+        case 'p2sh':
+            return payments.p2sh({ hash }).output;
+        case 'p2wpkh':
+            return payments.p2wpkh({ hash }).output;
+        case 'p2wsh':
+            return payments.p2wsh({ hash }).output;
+        case 'p2tr':
+        case 'p2w-unknown':
+            return bscript.compile([version + FUTURE_SEGWIT_VERSION_DIFF, hash]);
+    }
+}
+function getAddressType(address, network = networks_1.bitcoin) {
+    const { success, format, version, hash } = decodeAddress(address, network);
+    return success ? identifyAddressType(format, version, hash, network) : 'unknown';
+}
+function toOutputScript(address, network = networks_1.bitcoin) {
+    const { success, format, version, hash, error } = decodeAddress(address, network);
+    if (success) {
+        const type = identifyAddressType(format, version, hash, network);
+        if (type !== 'unknown') {
+            return createOutputScript(type, hash, version);
+        }
+    }
+    else if (error === 'bech32-invalid-prefix') {
+        throw new Error(`${address} has an invalid prefix`);
+    }
+    throw new Error(`${address} has no matching Script`);
+}
+//# sourceMappingURL=address.js.map

package/third-party/utxo-lib/bip32.d.ts

@@ -0,0 +1,28 @@
+import type { Network } from './networks';
+export interface BIP32Interface {
+    chainCode: Buffer;
+    network: Network;
+    lowR: boolean;
+    depth: number;
+    index: number;
+    parentFingerprint: number;
+    publicKey: Buffer;
+    privateKey?: Buffer;
+    identifier: Buffer;
+    fingerprint: Buffer;
+    compressed: boolean;
+    isNeutered(): boolean;
+    neutered(): BIP32Interface;
+    toBase58(): string;
+    toWIF(): string;
+    derive(index: number): BIP32Interface;
+    deriveHardened(index: number): BIP32Interface;
+    derivePath(path: string): BIP32Interface;
+    sign(hash: Buffer, lowR?: boolean): Buffer;
+    verify(hash: Buffer, signature: Buffer): boolean;
+}
+export declare function fromBase58(inString: string, network?: Network): BIP32Interface;
+export declare function fromPrivateKey(privateKey: Buffer, chainCode: Buffer, network?: Network): BIP32Interface;
+export declare function fromPublicKey(publicKey: Buffer, chainCode: Buffer, network?: Network): BIP32Interface;
+export declare function fromSeed(seed: Buffer, network?: Network): BIP32Interface;
+//# sourceMappingURL=bip32.d.ts.map

package/third-party/utxo-lib/bip32.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromBase58 = fromBase58;
+exports.fromPrivateKey = fromPrivateKey;
+exports.fromPublicKey = fromPublicKey;
+exports.fromSeed = fromSeed;
+const tslib_1 = require("tslib");
+const tiny_secp256k1_1 = tslib_1.__importDefault(require("tiny-secp256k1"));
+const wif = tslib_1.__importStar(require("wif"));
+const typeforce_1 = require("./types/typeforce");
+const bs58check = tslib_1.__importStar(require("./bs58check"));
+const crypto = tslib_1.__importStar(require("./crypto"));
+const networks_1 = require("./networks");
+const UINT256_TYPE = typeforce_1.typeforce.BufferN(32);
+const NETWORK_TYPE = typeforce_1.typeforce.compile({
+    wif: typeforce_1.typeforce.UInt8,
+    bip32: {
+        public: typeforce_1.typeforce.UInt32,
+        private: typeforce_1.typeforce.UInt32,
+    },
+});
+const HIGHEST_BIT = 0x80000000;
+const UINT31_MAX = Math.pow(2, 31) - 1;
+function BIP32Path(value) {
+    return typeforce_1.typeforce.String(value) && value.match(/^(m\/)?(\d+'?\/)*\d+'?$/) !== null;
+}
+function UInt31(value) {
+    return typeforce_1.typeforce.UInt32(value) && value <= UINT31_MAX;
+}
+function fromPrivateKeyLocal(privateKey, chainCode, network, depth, index, parentFingerprint) {
+    (0, typeforce_1.typeforce)({
+        privateKey: UINT256_TYPE,
+        chainCode: UINT256_TYPE,
+    }, { privateKey, chainCode });
+    network = network || networks_1.bitcoin;
+    if (!tiny_secp256k1_1.default.isPrivate(privateKey))
+        throw new TypeError('Private key not in range [1, n)');
+    return new BIP32(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);
+}
+function fromPublicKeyLocal(publicKey, chainCode, network, depth, index, parentFingerprint) {
+    (0, typeforce_1.typeforce)({
+        publicKey: typeforce_1.typeforce.BufferN(33),
+        chainCode: UINT256_TYPE,
+    }, { publicKey, chainCode });
+    network = network || networks_1.bitcoin;
+    if (!tiny_secp256k1_1.default.isPoint(publicKey))
+        throw new TypeError('Point is not on the curve');
+    return new BIP32(undefined, publicKey, chainCode, network, depth, index, parentFingerprint);
+}
+class BIP32 {
+    constructor(__D, __Q, chainCode, network, __DEPTH = 0, __INDEX = 0, __PARENT_FINGERPRINT = 0x00000000) {
+        this.__D = __D;
+        this.__Q = __Q;
+        this.chainCode = chainCode;
+        this.network = network;
+        this.__DEPTH = __DEPTH;
+        this.__INDEX = __INDEX;
+        this.__PARENT_FINGERPRINT = __PARENT_FINGERPRINT;
+        (0, typeforce_1.typeforce)(NETWORK_TYPE, network);
+        this.lowR = false;
+    }
+    get depth() {
+        return this.__DEPTH;
+    }
+    get index() {
+        return this.__INDEX;
+    }
+    get parentFingerprint() {
+        return this.__PARENT_FINGERPRINT;
+    }
+    get publicKey() {
+        if (this.__Q === undefined)
+            this.__Q = tiny_secp256k1_1.default.pointFromScalar(this.__D, true);
+        return this.__Q;
+    }
+    get privateKey() {
+        return this.__D;
+    }
+    get identifier() {
+        if ((0, networks_1.isNetworkType)('decred', this.network))
+            return crypto.hash160blake256(this.publicKey);
+        return crypto.hash160(this.publicKey);
+    }
+    get fingerprint() {
+        return this.identifier.subarray(0, 4);
+    }
+    get compressed() {
+        return true;
+    }
+    isNeutered() {
+        return this.__D === undefined;
+    }
+    neutered() {
+        return fromPublicKeyLocal(this.publicKey, this.chainCode, this.network, this.depth, this.index, this.parentFingerprint);
+    }
+    toBase58() {
+        const { network } = this;
+        const version = !this.isNeutered() ? network.bip32.private : network.bip32.public;
+        const buffer = Buffer.allocUnsafe(78);
+        buffer.writeUInt32BE(version, 0);
+        buffer.writeUInt8(this.depth, 4);
+        buffer.writeUInt32BE(this.parentFingerprint, 5);
+        buffer.writeUInt32BE(this.index, 9);
+        this.chainCode.copy(buffer, 13);
+        if (!this.isNeutered()) {
+            buffer.writeUInt8(0, 45);
+            this.privateKey.copy(buffer, 46);
+        }
+        else {
+            this.publicKey.copy(buffer, 45);
+        }
+        return bs58check.encode(buffer, network);
+    }
+    toWIF() {
+        if (!this.privateKey)
+            throw new TypeError('Missing private key');
+        return wif.encode({
+            version: this.network.wif,
+            privateKey: this.privateKey,
+            compressed: true,
+        });
+    }
+    derive(index) {
+        (0, typeforce_1.typeforce)(typeforce_1.typeforce.UInt32, index);
+        const isHardened = index >= HIGHEST_BIT;
+        const data = Buffer.allocUnsafe(37);
+        if (isHardened) {
+            if (this.isNeutered())
+                throw new TypeError('Missing private key for hardened child key');
+            data[0] = 0x00;
+            this.privateKey.copy(data, 1);
+            data.writeUInt32BE(index, 33);
+        }
+        else {
+            this.publicKey.copy(data, 0);
+            data.writeUInt32BE(index, 33);
+        }
+        const I = crypto.hmacSHA512(this.chainCode, data);
+        const IL = I.subarray(0, 32);
+        const IR = I.subarray(32);
+        if (!tiny_secp256k1_1.default.isPrivate(IL))
+            return this.derive(index + 1);
+        let hd;
+        if (!this.isNeutered()) {
+            const ki = tiny_secp256k1_1.default.privateAdd(this.privateKey, IL);
+            if (ki == null)
+                return this.derive(index + 1);
+            hd = fromPrivateKeyLocal(ki, IR, this.network, this.depth + 1, index, this.fingerprint.readUInt32BE(0));
+        }
+        else {
+            const Ki = tiny_secp256k1_1.default.pointAddScalar(this.publicKey, IL, true);
+            if (Ki === null)
+                return this.derive(index + 1);
+            hd = fromPublicKeyLocal(Ki, IR, this.network, this.depth + 1, index, this.fingerprint.readUInt32BE(0));
+        }
+        return hd;
+    }
+    deriveHardened(index) {
+        (0, typeforce_1.typeforce)(UInt31, index);
+        return this.derive(index + HIGHEST_BIT);
+    }
+    derivePath(path) {
+        (0, typeforce_1.typeforce)(BIP32Path, path);
+        let splitPath = path.split('/');
+        if (splitPath[0] === 'm') {
+            if (this.parentFingerprint)
+                throw new TypeError('Expected master, got child');
+            splitPath = splitPath.slice(1);
+        }
+        return splitPath.reduce((prevHd, indexStr) => {
+            let index;
+            if (indexStr.slice(-1) === `'`) {
+                index = parseInt(indexStr.slice(0, -1), 10);
+                return prevHd.deriveHardened(index);
+            }
+            index = parseInt(indexStr, 10);
+            return prevHd.derive(index);
+        }, this);
+    }
+    sign(hash, lowR) {
+        if (!this.privateKey)
+            throw new Error('Missing private key');
+        if (lowR === undefined)
+            lowR = this.lowR;
+        if (lowR === false) {
+            return tiny_secp256k1_1.default.sign(hash, this.privateKey);
+        }
+        let sig = tiny_secp256k1_1.default.sign(hash, this.privateKey);
+        const extraData = Buffer.alloc(32, 0);
+        let counter = 0;
+        while (sig[0] > 0x7f) {
+            counter++;
+            extraData.writeUIntLE(counter, 0, 6);
+            sig = tiny_secp256k1_1.default.signWithEntropy(hash, this.privateKey, extraData);
+        }
+        return sig;
+    }
+    verify(hash, signature) {
+        return tiny_secp256k1_1.default.verify(hash, this.publicKey, signature);
+    }
+}
+function fromBase58(inString, network) {
+    const buffer = Buffer.from((0, networks_1.isNetworkType)('decred', network)
+        ? bs58check.decodeBlake256Key(inString)
+        : bs58check.decode(inString, network));
+    if (buffer.length !== 78)
+        throw new TypeError('Invalid buffer length');
+    network = network || networks_1.bitcoin;
+    const version = buffer.readUInt32BE(0);
+    if (version !== network.bip32.private && version !== network.bip32.public)
+        throw new TypeError('Invalid network version');
+    const depth = buffer[4];
+    const parentFingerprint = buffer.readUInt32BE(5);
+    if (depth === 0) {
+        if (parentFingerprint !== 0x00000000)
+            throw new TypeError('Invalid parent fingerprint');
+    }
+    const index = buffer.readUInt32BE(9);
+    if (depth === 0 && index !== 0)
+        throw new TypeError('Invalid index');
+    const chainCode = buffer.subarray(13, 45);
+    let hd;
+    if (version === network.bip32.private) {
+        if (buffer.readUInt8(45) !== 0x00)
+            throw new TypeError('Invalid private key');
+        const k = buffer.subarray(46, 78);
+        hd = fromPrivateKeyLocal(k, chainCode, network, depth, index, parentFingerprint);
+    }
+    else {
+        const X = buffer.subarray(45, 78);
+        hd = fromPublicKeyLocal(X, chainCode, network, depth, index, parentFingerprint);
+    }
+    return hd;
+}
+function fromPrivateKey(privateKey, chainCode, network) {
+    return fromPrivateKeyLocal(privateKey, chainCode, network);
+}
+function fromPublicKey(publicKey, chainCode, network) {
+    return fromPublicKeyLocal(publicKey, chainCode, network);
+}
+function fromSeed(seed, network) {
+    (0, typeforce_1.typeforce)(typeforce_1.typeforce.Buffer, seed);
+    if (seed.length < 16)
+        throw new TypeError('Seed should be at least 128 bits');
+    if (seed.length > 64)
+        throw new TypeError('Seed should be at most 512 bits');
+    network = network || networks_1.bitcoin;
+    const I = crypto.hmacSHA512(Buffer.from('Bitcoin seed', 'utf8'), seed);
+    const IL = I.subarray(0, 32);
+    const IR = I.subarray(32);
+    return fromPrivateKey(IL, IR, network);
+}
+//# sourceMappingURL=bip32.js.map

package/third-party/utxo-lib/bs58check.d.ts

@@ -0,0 +1,12 @@
+export declare function decodeBlake(buffer: Buffer): Buffer;
+export declare function decodeBlake256Key(key: string): Buffer;
+export declare function decodeBlake256(address: string): Buffer;
+export declare function encodeBlake256(payload: Buffer): string;
+export declare function encode(payload: Buffer, network?: import("./networks").Network): string;
+export declare function decode(payload: string, network?: import("./networks").Network): Buffer | Uint8Array;
+export declare function decodeAddress(address: string, network?: import("./networks").Network): {
+    version: number;
+    hash: Buffer;
+};
+export declare function encodeAddress(hash: Buffer, version: number, network?: import("./networks").Network): string;
+//# sourceMappingURL=bs58check.d.ts.map