@onetokenfe/coinselect 3.1.16

package/third-party/utxo-lib/compose/sorting/randomSortingStrategy.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomSortingStrategy = void 0;
+const utils_1 = require("../../../utils");
+const convertOutput_1 = require("./convertOutput");
+const randomSortingStrategy = ({ result, request, convertedInputs }) => {
+    const nonChangeOutputPermutation = [];
+    const changeOutputPermutation = [];
+    const convertedOutputs = result.outputs.map((output, index) => {
+        if (request.outputs[index]) {
+            nonChangeOutputPermutation.push(index);
+            return (0, convertOutput_1.convertOutput)(output, request.outputs[index]);
+        }
+        changeOutputPermutation.push(index);
+        return (0, convertOutput_1.convertOutput)(output, Object.assign({ type: 'change' }, request.changeAddress));
+    });
+    const permutation = [...nonChangeOutputPermutation];
+    const newPositionOfChange = (0, utils_1.getRandomInt)(0, permutation.length + 1);
+    permutation.splice(newPositionOfChange, 0, ...changeOutputPermutation);
+    const sortedOutputs = permutation.map(index => convertedOutputs[index]);
+    return {
+        inputs: (0, utils_1.arrayShuffle)(convertedInputs, { randomInt: utils_1.getRandomInt }),
+        outputs: sortedOutputs,
+        outputsPermutation: permutation,
+    };
+};
+exports.randomSortingStrategy = randomSortingStrategy;
+//# sourceMappingURL=randomSortingStrategy.js.map

package/third-party/utxo-lib/compose/sorting/sortingStrategy.d.ts

@@ -0,0 +1,9 @@
+import { CoinSelectSuccess, ComposeChangeAddress, ComposedTransaction, ComposeFinalOutput, ComposeInput, ComposeRequest } from '../../types';
+type SortingStrategyParams<Input extends ComposeInput, Change extends ComposeChangeAddress> = {
+    request: ComposeRequest<Input, ComposeFinalOutput, Change>;
+    result: CoinSelectSuccess;
+    convertedInputs: Input[];
+};
+export type SortingStrategy = <Input extends ComposeInput, Change extends ComposeChangeAddress>(params: SortingStrategyParams<Input, Change>) => ComposedTransaction<Input, ComposeFinalOutput, Change>;
+export {};
+//# sourceMappingURL=sortingStrategy.d.ts.map

package/third-party/utxo-lib/compose/sorting/sortingStrategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=sortingStrategy.js.map

package/third-party/utxo-lib/compose/transaction.d.ts

@@ -0,0 +1,3 @@
+import { ComposeRequest, CoinSelectSuccess, ComposeInput, ComposeChangeAddress, ComposeFinalOutput, ComposedTransaction } from '../types';
+export declare function createTransaction<Input extends ComposeInput, Change extends ComposeChangeAddress>(request: ComposeRequest<Input, ComposeFinalOutput, Change>, result: CoinSelectSuccess): ComposedTransaction<Input, ComposeFinalOutput, Change>;
+//# sourceMappingURL=transaction.d.ts.map

package/third-party/utxo-lib/compose/transaction.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransaction = createTransaction;
+const noneSortingStrategy_1 = require("./sorting/noneSortingStrategy");
+const bip69SortingStrategy_1 = require("./sorting/bip69SortingStrategy");
+const randomSortingStrategy_1 = require("./sorting/randomSortingStrategy");
+const strategyMap = {
+    bip69: bip69SortingStrategy_1.bip69SortingStrategy,
+    none: noneSortingStrategy_1.noneSortingStrategy,
+    random: randomSortingStrategy_1.randomSortingStrategy,
+};
+function createTransaction(request, result) {
+    const convertedInputs = result.inputs.map(input => request.utxos[input.i]);
+    return strategyMap[request.sortingStrategy]({ result, request, convertedInputs });
+}
+//# sourceMappingURL=transaction.js.map

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

@@ -0,0 +1,9 @@
+export declare function ripemd160(buffer: Buffer): Buffer;
+export declare function sha1(buffer: Buffer): Buffer;
+export declare function sha256(buffer: Buffer): Buffer;
+export declare function blake256(buffer: Buffer): Buffer;
+export declare function hash160(buffer: Buffer): Buffer;
+export declare function hash160blake256(buffer: Buffer): Buffer;
+export declare function hash256(buffer: Buffer): Buffer;
+export declare function hmacSHA512(key: Buffer, data: Buffer): Buffer;
+//# sourceMappingURL=crypto.d.ts.map

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ripemd160 = ripemd160;
+exports.sha1 = sha1;
+exports.sha256 = sha256;
+exports.blake256 = blake256;
+exports.hash160 = hash160;
+exports.hash160blake256 = hash160blake256;
+exports.hash256 = hash256;
+exports.hmacSHA512 = hmacSHA512;
+const tslib_1 = require("tslib");
+const blake_hash_1 = tslib_1.__importDefault(require("blake-hash"));
+const create_hmac_1 = tslib_1.__importDefault(require("create-hmac"));
+const crypto_1 = require("crypto");
+function ripemd160(buffer) {
+    try {
+        return (0, crypto_1.createHash)('rmd160').update(buffer).digest();
+    }
+    catch (_a) {
+        return (0, crypto_1.createHash)('ripemd160').update(buffer).digest();
+    }
+}
+function sha1(buffer) {
+    return (0, crypto_1.createHash)('sha1').update(buffer).digest();
+}
+function sha256(buffer) {
+    return (0, crypto_1.createHash)('sha256').update(buffer).digest();
+}
+function blake256(buffer) {
+    return (0, blake_hash_1.default)('blake256').update(buffer).digest();
+}
+function hash160(buffer) {
+    return ripemd160(sha256(buffer));
+}
+function hash160blake256(buffer) {
+    return ripemd160(blake256(buffer));
+}
+function hash256(buffer) {
+    return sha256(sha256(buffer));
+}
+function hmacSHA512(key, data) {
+    return (0, create_hmac_1.default)('sha512', key).update(data).digest();
+}
+//# sourceMappingURL=crypto.js.map

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

@@ -0,0 +1,24 @@
+import { Network } from './networks';
+declare const BIP32_PAYMENT_TYPES: {
+    readonly 76067358: "p2pkh";
+    readonly 77429938: "p2sh";
+    readonly 78792518: "p2wpkh";
+    readonly 70617039: "p2pkh";
+    readonly 71979618: "p2sh";
+    readonly 73342198: "p2wpkh";
+    readonly 27108450: "p2pkh";
+    readonly 28471030: "p2sh";
+};
+type VersionBytes = keyof typeof BIP32_PAYMENT_TYPES;
+export type PaymentType = (typeof BIP32_PAYMENT_TYPES)[VersionBytes] | 'p2tr';
+export declare const getXpubOrDescriptorInfo: (descriptor: string, network?: Network) => {
+    levels: string[];
+    paymentType: PaymentType;
+    node: import("./bip32").BIP32Interface;
+};
+export declare const deriveAddresses: (descriptor: string, type: "receive" | "change", from: number, count: number, network?: Network) => {
+    address: string;
+    path: string;
+}[];
+export {};
+//# sourceMappingURL=derivation.d.ts.map

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveAddresses = exports.getXpubOrDescriptorInfo = void 0;
+const tslib_1 = require("tslib");
+const bs58_1 = tslib_1.__importDefault(require("bs58"));
+const utils_1 = require("../utils");
+const payments_1 = require("./payments");
+const bip32_1 = require("./bip32");
+const networks_1 = require("./networks");
+const BIP32_PAYMENT_TYPES = {
+    0x0488b21e: 'p2pkh',
+    0x049d7cb2: 'p2sh',
+    0x04b24746: 'p2wpkh',
+    0x043587cf: 'p2pkh',
+    0x044a5262: 'p2sh',
+    0x045f1cf6: 'p2wpkh',
+    0x019da462: 'p2pkh',
+    0x01b26ef6: 'p2sh',
+};
+const BIP32_COIN_TYPES = {
+    0x0488b21e: "0'",
+    0x049d7cb2: "0'",
+    0x04b24746: "0'",
+    0x043587cf: "1'",
+    0x044a5262: "1'",
+    0x045f1cf6: "1'",
+    0x019da462: "2'",
+    0x01b26ef6: "2'",
+};
+const BIP32_PURPOSES = {
+    p2pkh: "44'",
+    p2sh: "49'",
+    p2wpkh: "84'",
+    p2tr: "86'",
+};
+const validateVersion = (version) => !!BIP32_PAYMENT_TYPES[version];
+const getVersion = (xpub) => {
+    const version = Buffer.from(bs58_1.default.decode(xpub)).readUInt32BE();
+    if (!validateVersion(version))
+        throw new Error(`Unknown xpub version: ${xpub}`);
+    return version;
+};
+const getPubkeyToPayment = (type, network) => (pubkey) => {
+    switch (type) {
+        case 'p2pkh':
+            return (0, payments_1.p2pkh)({ pubkey, network });
+        case 'p2sh':
+            return (0, payments_1.p2sh)({
+                redeem: (0, payments_1.p2wpkh)({
+                    pubkey,
+                    network,
+                }),
+                network,
+            });
+        case 'p2wpkh':
+            return (0, payments_1.p2wpkh)({ pubkey, network });
+        case 'p2tr':
+            return (0, payments_1.p2tr)({ pubkey, network });
+        default:
+            throw new Error(`Unknown payment type '${type}'`);
+    }
+};
+const getBip32Node = (xpub, version, network) => (0, bip32_1.fromBase58)(xpub, Object.assign(Object.assign({}, network), { bip32: Object.assign(Object.assign({}, network.bip32), { public: version }) }));
+const getXpubInfo = (xpub, network) => {
+    const version = getVersion(xpub);
+    const paymentType = BIP32_PAYMENT_TYPES[version];
+    const coinType = network.wif === 0xb0
+        ? "2'"
+        : BIP32_COIN_TYPES[version];
+    const purpose = BIP32_PURPOSES[paymentType];
+    const node = getBip32Node(xpub, version, network);
+    const account = `${(node.index << 1) >>> 1}'`;
+    const levels = [purpose, coinType, account];
+    return {
+        levels,
+        paymentType,
+        node,
+    };
+};
+const getDescriptorInfo = (paymentType, descriptor, network) => {
+    const [_match, _script, path, xpub, _checksum] = descriptor.match(/^([a-z]+\()+\[([a-z0-9]{8}(?:\/[0-9]+'?){3,})\]([xyztuv]pub[a-zA-Z0-9]*)\/<0;1>\/\*\)+(#[a-z0-9]{8})?$/) || (0, utils_1.throwError)(`Descriptor cannot be parsed: ${descriptor}`);
+    const [_fingerprint, ...levels] = path.split('/');
+    const version = getVersion(xpub);
+    const node = getBip32Node(xpub, version, network);
+    return {
+        levels,
+        paymentType,
+        node,
+    };
+};
+const getXpubOrDescriptorInfo = (descriptor, network = networks_1.bitcoin) => {
+    if (descriptor.startsWith('pkh(')) {
+        return getDescriptorInfo('p2pkh', descriptor, network);
+    }
+    if (descriptor.startsWith('sh(wpkh(')) {
+        return getDescriptorInfo('p2sh', descriptor, network);
+    }
+    if (descriptor.startsWith('wpkh(')) {
+        return getDescriptorInfo('p2wpkh', descriptor, network);
+    }
+    if (descriptor.startsWith('tr(')) {
+        return getDescriptorInfo('p2tr', descriptor, network);
+    }
+    return getXpubInfo(descriptor, network);
+};
+exports.getXpubOrDescriptorInfo = getXpubOrDescriptorInfo;
+const deriveAddresses = (descriptor, type, from, count, network = networks_1.bitcoin) => {
+    const { levels, node, paymentType } = (0, exports.getXpubOrDescriptorInfo)(descriptor, network);
+    const getAddress = getPubkeyToPayment(paymentType, network);
+    const change = type === 'receive' ? 0 : 1;
+    const changeNode = node.derive(change);
+    return Array.from(Array(count).keys())
+        .map(i => changeNode.derive(from + i).publicKey)
+        .map(a => getAddress(a).address || (0, utils_1.throwError)('Cannot convert pubkey to address'))
+        .map((address, i) => ({
+        address,
+        path: `m/${levels.join('/')}/${change}/${from + i}`,
+    }));
+};
+exports.deriveAddresses = deriveAddresses;
+//# sourceMappingURL=derivation.js.map

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

@@ -0,0 +1,9 @@
+import { deriveAddresses } from './derivation';
+import type { Network } from './networks';
+export type AddressInfo = ReturnType<typeof deriveAddresses>[number];
+export type AddressResult<T> = T & {
+    empty: boolean;
+};
+export declare const countUnusedFromEnd: <T>(array: T[], isUnused: (t: T) => boolean, lookout: number) => number;
+export declare const discovery: <T>(discover: (addr: AddressInfo) => Promise<AddressResult<T>>, xpub: string, type: "receive" | "change", network?: Network, lookout?: number) => Promise<AddressResult<T>[]>;
+//# sourceMappingURL=discovery.d.ts.map

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discovery = exports.countUnusedFromEnd = void 0;
+const tslib_1 = require("tslib");
+const derivation_1 = require("./derivation");
+const DISCOVERY_LOOKOUT = 20;
+const countUnusedFromEnd = (array, isUnused, lookout) => {
+    const boundary = array.length > lookout ? array.length - lookout : 0;
+    for (let i = array.length; i > boundary; --i) {
+        if (!isUnused(array[i - 1])) {
+            return array.length - i;
+        }
+    }
+    return array.length;
+};
+exports.countUnusedFromEnd = countUnusedFromEnd;
+const discovery = (discover, xpub, type, network, lookout = DISCOVERY_LOOKOUT) => {
+    const discoverRecursive = (from, prev) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+        const unused = (0, exports.countUnusedFromEnd)(prev, a => a.empty, lookout);
+        if (unused >= lookout)
+            return prev;
+        const moreCount = lookout - unused;
+        const addresses = (0, derivation_1.deriveAddresses)(xpub, type, from, moreCount, network);
+        const more = yield Promise.all(addresses.map(discover));
+        return discoverRecursive(from + moreCount, prev.concat(more));
+    });
+    return discoverRecursive(0, []);
+};
+exports.discovery = discovery;
+//# sourceMappingURL=discovery.js.map

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

@@ -0,0 +1,62 @@
+declare module 'typeforce' {
+    interface Typeforce {
+        (type: any, value: any, strict?: any, surrogate?: any): boolean;
+        Array(value: any): value is any[];
+        ArrayN(length: number): (value: any) => value is any[];
+        Boolean(value: any): value is boolean;
+        Buffer(value: any): value is Buffer;
+        BufferN(length: number): (value: any) => value is Buffer;
+        Finite(value: any): value is number;
+        Function(value: any): value is FunctionConstructor;
+        Hex(value: any): value is string;
+        HexN(length: number): (value: any) => value is string;
+        Nil(value: any): boolean;
+        Number(value: any): value is number;
+        Object(value: any): value is ObjectConstructor;
+        Range(a: any, b: any, f: any): boolean;
+        String(value: any): value is string;
+        StringN(length: number): (value: any) => value is string;
+        Int8(value: any): value is number;
+        Int16(value: any): value is number;
+        Int32(value: any): value is number;
+        Int53(value: any): value is number;
+        UInt8(value: any): value is number;
+        UInt16(value: any): value is number;
+        UInt32(value: any): value is number;
+        UInt53(value: any): value is number;
+        arrayOf(type: any, options?: any): boolean;
+        maybe(type: any): boolean;
+        map(propertyType: any, propertyKeyType: any): boolean;
+        object(uncompiled: any): boolean;
+        anyOf(...args: any[]): (value: any) => boolean;
+        allOf(...args: any[]): boolean;
+        quacksLike<T>(type: T): type is T;
+        tuple(...args: any[]): boolean;
+        value(...expected: any[]): (value: any) => boolean;
+        compile(type: any): boolean;
+    }
+    const tf: Typeforce;
+    export = tf;
+}
+declare module 'bip66' {
+    function check(buffer: Buffer): boolean;
+    function decode(buffer: Buffer): {
+        r: Buffer;
+        s: Buffer;
+    };
+    function encode(r: Buffer, s: Buffer): Buffer;
+}
+declare module 'bitcoin-ops';
+declare module 'minimaldata';
+declare module 'tiny-secp256k1';
+declare module 'pushdata-bitcoin' {
+    function encodingLength(len: number): number;
+    function encode(buffer: Buffer, number: number, offset: number): number;
+    function decode(buffer: Buffer, offset: number): {
+        opcode: number;
+        number: number;
+        size: number;
+    };
+}
+declare module 'blake-hash';
+//# sourceMappingURL=global.d.ts.map

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

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=global.js.map

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

@@ -0,0 +1,18 @@
+import * as address from './address';
+import * as bip32 from './bip32';
+import * as bufferutils from './bufferutils';
+import * as crypto from './crypto';
+import * as payments from './payments';
+import * as script from './script';
+import * as networks from './networks';
+import { composeTx } from './compose';
+import { deriveAddresses, getXpubOrDescriptorInfo } from './derivation';
+import { discovery } from './discovery';
+export { Transaction } from './transaction';
+export { address, bip32, bufferutils, crypto, payments, script, networks, composeTx, deriveAddresses, getXpubOrDescriptorInfo, discovery, };
+export type { PaymentType } from './derivation';
+export type { ComposeInput, ComposeOutput, ComposeChangeAddress, ComposeRequest, ComposeResult, ComposeResultNonFinal, ComposeResultError, ComposeResultFinal, ComposedTransaction, CoinSelectPaymentType, } from './types';
+export type { Network } from './networks';
+export type { BIP32Interface } from './bip32';
+export type { TransactionInputOutputSortingStrategy } from './types/compose';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discovery = exports.getXpubOrDescriptorInfo = exports.deriveAddresses = exports.composeTx = exports.networks = exports.script = exports.payments = exports.crypto = exports.bufferutils = exports.bip32 = exports.address = exports.Transaction = void 0;
+const tslib_1 = require("tslib");
+const address = tslib_1.__importStar(require("./address"));
+exports.address = address;
+const bip32 = tslib_1.__importStar(require("./bip32"));
+exports.bip32 = bip32;
+const bufferutils = tslib_1.__importStar(require("./bufferutils"));
+exports.bufferutils = bufferutils;
+const crypto = tslib_1.__importStar(require("./crypto"));
+exports.crypto = crypto;
+const payments = tslib_1.__importStar(require("./payments"));
+exports.payments = payments;
+const script = tslib_1.__importStar(require("./script"));
+exports.script = script;
+const networks = tslib_1.__importStar(require("./networks"));
+exports.networks = networks;
+const compose_1 = require("./compose");
+Object.defineProperty(exports, "composeTx", { enumerable: true, get: function () { return compose_1.composeTx; } });
+const derivation_1 = require("./derivation");
+Object.defineProperty(exports, "deriveAddresses", { enumerable: true, get: function () { return derivation_1.deriveAddresses; } });
+Object.defineProperty(exports, "getXpubOrDescriptorInfo", { enumerable: true, get: function () { return derivation_1.getXpubOrDescriptorInfo; } });
+const discovery_1 = require("./discovery");
+Object.defineProperty(exports, "discovery", { enumerable: true, get: function () { return discovery_1.discovery; } });
+var transaction_1 = require("./transaction");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,45 @@
+export interface Bip32 {
+    public: number;
+    private: number;
+}
+export interface Network {
+    messagePrefix: string;
+    bech32: string;
+    bip32: Bip32;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+    forkId?: number;
+}
+export declare const bitcoin: Network;
+export declare const regtest: Network;
+export declare const testnet: Network;
+export declare const bitcoincash: Network;
+export declare const bitcoincashTest: Network;
+export declare const bitcoingold: Network;
+export declare const litecoin: Network;
+export declare const litecoinTest: Network;
+export declare const dash: Network;
+export declare const dashTest: Network;
+export declare const zcash: Network;
+export declare const zcashTest: Network;
+export declare const peercoin: Network;
+export declare const peercoinTest: Network;
+export declare const komodo: Network;
+export declare const decred: Network;
+export declare const decredTest: Network;
+export declare const decredSim: Network;
+export declare const doge: Network;
+declare const NETWORK_TYPES: {
+    bitcoinCash: Network[];
+    dash: Network[];
+    decred: Network[];
+    peercoin: Network[];
+    zcash: Network[];
+    litecoin: Network[];
+    doge: Network[];
+};
+export type NetworkTypes = keyof typeof NETWORK_TYPES;
+export declare function isNetworkType(type: NetworkTypes, network?: Network): boolean;
+export {};
+//# sourceMappingURL=networks.d.ts.map