@onetokenfe/coinselect 3.1.16

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

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doge = exports.decredSim = exports.decredTest = exports.decred = exports.komodo = exports.peercoinTest = exports.peercoin = exports.zcashTest = exports.zcash = exports.dashTest = exports.dash = exports.litecoinTest = exports.litecoin = exports.bitcoingold = exports.bitcoincashTest = exports.bitcoincash = exports.testnet = exports.regtest = exports.bitcoin = void 0;
+exports.isNetworkType = isNetworkType;
+const typeforce_1 = require("./types/typeforce");
+exports.bitcoin = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: 'bc',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x00,
+    scriptHash: 0x05,
+    wif: 0x80,
+};
+exports.regtest = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: 'bcrt',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+};
+exports.testnet = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: 'tb',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+};
+exports.bitcoincash = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x00,
+    scriptHash: 0x05,
+    wif: 0x80,
+    forkId: 0x00,
+};
+exports.bitcoincashTest = {
+    messagePrefix: '\x18Bitcoin Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0xef,
+    forkId: 0x00,
+};
+exports.bitcoingold = {
+    messagePrefix: '\x18Bitcoin Gold Signed Message:\n',
+    bech32: 'btg',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x26,
+    scriptHash: 0x17,
+    wif: 0x80,
+    forkId: 0x4f,
+};
+exports.litecoin = {
+    messagePrefix: '\x19Litecoin Signed Message:\n',
+    bech32: 'ltc',
+    bip32: {
+        public: 0x019da462,
+        private: 0x019d9cfe,
+    },
+    pubKeyHash: 0x30,
+    scriptHash: 0x32,
+    wif: 0xb0,
+};
+exports.litecoinTest = {
+    messagePrefix: '\x19Litecoin Signed Message:\n',
+    bech32: 'tltc',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0x3a,
+    wif: 0xb0,
+};
+exports.dash = {
+    messagePrefix: '\x19DarkCoin Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x02fe52cc,
+        private: 0x2fe52f8,
+    },
+    pubKeyHash: 0x4c,
+    scriptHash: 0x10,
+    wif: 0xcc,
+};
+exports.dashTest = {
+    messagePrefix: '\x19DarkCoin Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x8c,
+    scriptHash: 0x13,
+    wif: 0xef,
+};
+exports.zcash = {
+    messagePrefix: '\x18ZCash Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x1cb8,
+    scriptHash: 0x1cbd,
+    wif: 0x80,
+};
+exports.zcashTest = {
+    messagePrefix: '\x18ZCash Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x043587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x1d25,
+    scriptHash: 0x1cba,
+    wif: 0xef,
+};
+exports.peercoin = {
+    messagePrefix: '\x18Peercoin Signed Message:\n',
+    bech32: 'pc',
+    bip32: {
+        public: 0x488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x37,
+    scriptHash: 0x75,
+    wif: 0,
+};
+exports.peercoinTest = {
+    messagePrefix: '\x18Peercoin Signed Message:\n',
+    bech32: 'tpc',
+    bip32: {
+        public: 0x43587cf,
+        private: 0x04358394,
+    },
+    pubKeyHash: 0x6f,
+    scriptHash: 0xc4,
+    wif: 0,
+};
+exports.komodo = {
+    messagePrefix: '\x18Komodo Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x0488b21e,
+        private: 0x0488ade4,
+    },
+    pubKeyHash: 0x3c,
+    scriptHash: 0x55,
+    wif: 0xbc,
+};
+exports.decred = {
+    messagePrefix: '\x17Decred Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x02fda926,
+        private: 0x02fda4e8,
+    },
+    pubKeyHash: 0x073f,
+    scriptHash: 0x071a,
+    wif: 0x22de,
+};
+exports.decredTest = {
+    messagePrefix: '\x17Decred Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x043587d1,
+        private: 0x04358397,
+    },
+    pubKeyHash: 0x0f21,
+    scriptHash: 0x0efc,
+    wif: 0x230e,
+};
+exports.decredSim = {
+    messagePrefix: '\x17Decred Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x0420bd3d,
+        private: 0x0420b903,
+    },
+    pubKeyHash: 0x0e91,
+    scriptHash: 0x0e6c,
+    wif: 0x2307,
+};
+exports.doge = {
+    messagePrefix: '\x19Dogecoin Signed Message:\n',
+    bech32: '',
+    bip32: {
+        public: 0x02facafd,
+        private: 0x02fac398,
+    },
+    pubKeyHash: 0x1e,
+    scriptHash: 0x16,
+    wif: 0x9e,
+};
+const NETWORK_TYPES = {
+    bitcoinCash: [exports.bitcoincash, exports.bitcoincashTest],
+    dash: [exports.dash, exports.dashTest],
+    decred: [exports.decred, exports.decredTest, exports.decredSim],
+    peercoin: [exports.peercoin, exports.peercoinTest],
+    zcash: [exports.zcash, exports.zcashTest, exports.komodo],
+    litecoin: [exports.litecoin, exports.litecoinTest],
+    doge: [exports.doge],
+};
+function isNetworkType(type, network) {
+    if (typeof type !== 'string' || !network || !NETWORK_TYPES[type])
+        return false;
+    try {
+        (0, typeforce_1.typeforce)({
+            bip32: {
+                public: typeforce_1.typeforce.UInt32,
+                private: typeforce_1.typeforce.UInt32,
+            },
+            pubKeyHash: typeforce_1.typeforce.anyOf(typeforce_1.typeforce.UInt8, typeforce_1.typeforce.UInt16),
+            scriptHash: typeforce_1.typeforce.anyOf(typeforce_1.typeforce.UInt8, typeforce_1.typeforce.UInt16),
+        }, network);
+    }
+    catch (_a) {
+        return false;
+    }
+    return !!NETWORK_TYPES[type].find(n => n.bip32.public === network.bip32.public &&
+        n.bip32.private === network.bip32.private &&
+        ((!n.bech32 && !network.bech32) || n.bech32 === network.bech32) &&
+        ((!n.forkId && !network.forkId) || n.forkId === network.forkId) &&
+        n.pubKeyHash === network.pubKeyHash &&
+        n.scriptHash === network.scriptHash);
+}
+//# sourceMappingURL=networks.js.map

package/third-party/utxo-lib/payments/embed.d.ts

@@ -0,0 +1,3 @@
+import { Payment, PaymentOpts } from '../types';
+export declare function p2data(a: Payment, opts?: PaymentOpts): Payment;
+//# sourceMappingURL=embed.d.ts.map

package/third-party/utxo-lib/payments/embed.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.p2data = p2data;
+const tslib_1 = require("tslib");
+const networks_1 = require("../networks");
+const bscript = tslib_1.__importStar(require("../script"));
+const lazy = tslib_1.__importStar(require("./lazy"));
+const types_1 = require("../types");
+const { OPS } = bscript;
+function stacksEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((x, i) => x.equals(b[i]));
+}
+function p2data(a, opts) {
+    if (!a.data && !a.output)
+        throw new TypeError('Not enough data');
+    opts = Object.assign({ validate: true }, opts || {});
+    (0, types_1.typeforce)({
+        network: types_1.typeforce.maybe(types_1.typeforce.Object),
+        output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+        data: types_1.typeforce.maybe(types_1.typeforce.arrayOf(types_1.typeforce.Buffer)),
+    }, a);
+    const network = a.network || networks_1.bitcoin;
+    const o = { name: 'embed', network };
+    lazy.prop(o, 'output', () => {
+        if (!a.data)
+            return;
+        return bscript.compile([OPS.OP_RETURN].concat(a.data));
+    });
+    lazy.prop(o, 'data', () => {
+        if (!a.output)
+            return;
+        return bscript.decompile(a.output).slice(1);
+    });
+    if (opts.validate) {
+        if (a.output) {
+            const chunks = bscript.decompile(a.output);
+            if (chunks[0] !== OPS.OP_RETURN)
+                throw new TypeError('Output is invalid');
+            if (!chunks.slice(1).every(types_1.typeforce.Buffer))
+                throw new TypeError('Output is invalid');
+            if (a.data && !stacksEqual(a.data, o.data))
+                throw new TypeError('Data mismatch');
+        }
+    }
+    return Object.assign(o, a);
+}
+//# sourceMappingURL=embed.js.map

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

@@ -0,0 +1,13 @@
+export { p2data as embed } from './embed';
+export { p2ms } from './p2ms';
+export { p2pk } from './p2pk';
+export { p2pkh } from './p2pkh';
+export { p2sh } from './p2sh';
+export { p2tr } from './p2tr';
+export { p2wpkh } from './p2wpkh';
+export { p2wsh } from './p2wsh';
+export { sstxchange } from './sstxchange';
+export { sstxcommitment } from './sstxcommitment';
+export { sstxpkh } from './sstxpkh';
+export { sstxsh } from './sstxsh';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sstxsh = exports.sstxpkh = exports.sstxcommitment = exports.sstxchange = exports.p2wsh = exports.p2wpkh = exports.p2tr = exports.p2sh = exports.p2pkh = exports.p2pk = exports.p2ms = exports.embed = void 0;
+var embed_1 = require("./embed");
+Object.defineProperty(exports, "embed", { enumerable: true, get: function () { return embed_1.p2data; } });
+var p2ms_1 = require("./p2ms");
+Object.defineProperty(exports, "p2ms", { enumerable: true, get: function () { return p2ms_1.p2ms; } });
+var p2pk_1 = require("./p2pk");
+Object.defineProperty(exports, "p2pk", { enumerable: true, get: function () { return p2pk_1.p2pk; } });
+var p2pkh_1 = require("./p2pkh");
+Object.defineProperty(exports, "p2pkh", { enumerable: true, get: function () { return p2pkh_1.p2pkh; } });
+var p2sh_1 = require("./p2sh");
+Object.defineProperty(exports, "p2sh", { enumerable: true, get: function () { return p2sh_1.p2sh; } });
+var p2tr_1 = require("./p2tr");
+Object.defineProperty(exports, "p2tr", { enumerable: true, get: function () { return p2tr_1.p2tr; } });
+var p2wpkh_1 = require("./p2wpkh");
+Object.defineProperty(exports, "p2wpkh", { enumerable: true, get: function () { return p2wpkh_1.p2wpkh; } });
+var p2wsh_1 = require("./p2wsh");
+Object.defineProperty(exports, "p2wsh", { enumerable: true, get: function () { return p2wsh_1.p2wsh; } });
+var sstxchange_1 = require("./sstxchange");
+Object.defineProperty(exports, "sstxchange", { enumerable: true, get: function () { return sstxchange_1.sstxchange; } });
+var sstxcommitment_1 = require("./sstxcommitment");
+Object.defineProperty(exports, "sstxcommitment", { enumerable: true, get: function () { return sstxcommitment_1.sstxcommitment; } });
+var sstxpkh_1 = require("./sstxpkh");
+Object.defineProperty(exports, "sstxpkh", { enumerable: true, get: function () { return sstxpkh_1.sstxpkh; } });
+var sstxsh_1 = require("./sstxsh");
+Object.defineProperty(exports, "sstxsh", { enumerable: true, get: function () { return sstxsh_1.sstxsh; } });
+//# sourceMappingURL=index.js.map

package/third-party/utxo-lib/payments/lazy.d.ts

@@ -0,0 +1,3 @@
+export declare function prop(object: Record<string, any>, name: string, f: () => any): void;
+export declare function value<T>(f: () => T): () => T;
+//# sourceMappingURL=lazy.d.ts.map

package/third-party/utxo-lib/payments/lazy.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prop = prop;
+exports.value = value;
+function prop(object, name, f) {
+    Object.defineProperty(object, name, {
+        configurable: true,
+        enumerable: true,
+        get() {
+            const value = f.call(this);
+            this[name] = value;
+            return value;
+        },
+        set(value) {
+            Object.defineProperty(this, name, {
+                configurable: true,
+                enumerable: true,
+                value,
+                writable: true,
+            });
+        },
+    });
+}
+function value(f) {
+    let value;
+    return () => {
+        if (value !== undefined)
+            return value;
+        value = f();
+        return value;
+    };
+}
+//# sourceMappingURL=lazy.js.map

package/third-party/utxo-lib/payments/p2ms.d.ts

@@ -0,0 +1,3 @@
+import { Payment, PaymentOpts } from '../types';
+export declare function p2ms(a: Payment, opts?: PaymentOpts): Payment;
+//# sourceMappingURL=p2ms.d.ts.map

package/third-party/utxo-lib/payments/p2ms.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.p2ms = p2ms;
+const tslib_1 = require("tslib");
+const tiny_secp256k1_1 = tslib_1.__importDefault(require("tiny-secp256k1"));
+const networks_1 = require("../networks");
+const bscript = tslib_1.__importStar(require("../script"));
+const lazy = tslib_1.__importStar(require("./lazy"));
+const types_1 = require("../types");
+const { OPS } = bscript;
+const OP_INT_BASE = OPS.OP_RESERVED;
+function stacksEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((x, i) => x.equals(b[i]));
+}
+function p2ms(a, opts) {
+    if (!a.input && !a.output && !(a.pubkeys && a.m !== undefined) && !a.signatures)
+        throw new TypeError('Not enough data');
+    opts = Object.assign({ validate: true }, opts || {});
+    function isAcceptableSignature(x) {
+        return (bscript.isCanonicalScriptSignature(x) ||
+            (opts.allowIncomplete && x === OPS.OP_0) !== undefined);
+    }
+    (0, types_1.typeforce)({
+        network: types_1.typeforce.maybe(types_1.typeforce.Object),
+        m: types_1.typeforce.maybe(types_1.typeforce.Number),
+        n: types_1.typeforce.maybe(types_1.typeforce.Number),
+        output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+        pubkeys: types_1.typeforce.maybe(types_1.typeforce.arrayOf(tiny_secp256k1_1.default.isPoint)),
+        signatures: types_1.typeforce.maybe(types_1.typeforce.arrayOf(isAcceptableSignature)),
+        input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+    }, a);
+    const network = a.network || networks_1.bitcoin;
+    const o = { name: 'p2ms', network };
+    let chunks = [];
+    let decoded = false;
+    function decode(output) {
+        if (decoded)
+            return;
+        decoded = true;
+        chunks = bscript.decompile(output);
+        o.m = chunks[0] - OP_INT_BASE;
+        o.n = chunks[chunks.length - 2] - OP_INT_BASE;
+        o.pubkeys = chunks.slice(1, -2);
+    }
+    lazy.prop(o, 'output', () => {
+        if (!a.m)
+            return;
+        if (!o.n)
+            return;
+        if (!a.pubkeys)
+            return;
+        return bscript.compile([].concat(OP_INT_BASE + a.m, a.pubkeys, OP_INT_BASE + o.n, OPS.OP_CHECKMULTISIG));
+    });
+    lazy.prop(o, 'm', () => {
+        if (!o.output)
+            return;
+        decode(o.output);
+        return o.m;
+    });
+    lazy.prop(o, 'n', () => {
+        if (!o.pubkeys)
+            return;
+        return o.pubkeys.length;
+    });
+    lazy.prop(o, 'pubkeys', () => {
+        if (!a.output)
+            return;
+        decode(a.output);
+        return o.pubkeys;
+    });
+    lazy.prop(o, 'signatures', () => {
+        if (!a.input)
+            return;
+        return bscript.decompile(a.input).slice(1);
+    });
+    lazy.prop(o, 'input', () => {
+        if (!a.signatures)
+            return;
+        return bscript.compile([OPS.OP_0].concat(a.signatures));
+    });
+    lazy.prop(o, 'witness', () => {
+        if (!o.input)
+            return;
+        return [];
+    });
+    lazy.prop(o, 'name', () => {
+        if (!o.m || !o.n)
+            return;
+        return `p2ms(${o.m} of ${o.n})`;
+    });
+    if (opts.validate) {
+        if (a.output) {
+            decode(a.output);
+            if (!types_1.typeforce.Number(chunks[0]))
+                throw new TypeError('Output is invalid');
+            if (!types_1.typeforce.Number(chunks[chunks.length - 2]))
+                throw new TypeError('Output is invalid');
+            if (chunks[chunks.length - 1] !== OPS.OP_CHECKMULTISIG)
+                throw new TypeError('Output is invalid');
+            if (o.m <= 0 || o.n > 16 || o.m > o.n || o.n !== chunks.length - 3)
+                throw new TypeError('Output is invalid');
+            if (!o.pubkeys.every(x => tiny_secp256k1_1.default.isPoint(x)))
+                throw new TypeError('Output is invalid');
+            if (a.m !== undefined && a.m !== o.m)
+                throw new TypeError('m mismatch');
+            if (a.n !== undefined && a.n !== o.n)
+                throw new TypeError('n mismatch');
+            if (a.pubkeys && !stacksEqual(a.pubkeys, o.pubkeys))
+                throw new TypeError('Pubkeys mismatch');
+        }
+        if (a.pubkeys) {
+            if (a.n !== undefined && a.n !== a.pubkeys.length)
+                throw new TypeError('Pubkey count mismatch');
+            o.n = a.pubkeys.length;
+            if (o.n < o.m)
+                throw new TypeError('Pubkey count cannot be less than m');
+        }
+        if (a.signatures) {
+            if (a.signatures.length < o.m)
+                throw new TypeError('Not enough signatures provided');
+            if (a.signatures.length > o.m)
+                throw new TypeError('Too many signatures provided');
+        }
+        if (a.input) {
+            if (a.input[0] !== OPS.OP_0)
+                throw new TypeError('Input is invalid');
+            if (o.signatures.length === 0 || !o.signatures.every(isAcceptableSignature))
+                throw new TypeError('Input has invalid signature(s)');
+            if (a.signatures && !stacksEqual(a.signatures, o.signatures))
+                throw new TypeError('Signature mismatch');
+            if (a.m !== undefined && a.m !== a.signatures.length)
+                throw new TypeError('Signature count mismatch');
+        }
+    }
+    return Object.assign(o, a);
+}
+//# sourceMappingURL=p2ms.js.map

package/third-party/utxo-lib/payments/p2pk.d.ts

@@ -0,0 +1,3 @@
+import { Payment, PaymentOpts } from '../types';
+export declare function p2pk(a: Payment, opts?: PaymentOpts): Payment;
+//# sourceMappingURL=p2pk.d.ts.map

package/third-party/utxo-lib/payments/p2pk.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.p2pk = p2pk;
+const tslib_1 = require("tslib");
+const tiny_secp256k1_1 = tslib_1.__importDefault(require("tiny-secp256k1"));
+const networks_1 = require("../networks");
+const bscript = tslib_1.__importStar(require("../script"));
+const lazy = tslib_1.__importStar(require("./lazy"));
+const types_1 = require("../types");
+const { OPS } = bscript;
+function p2pk(a, opts) {
+    if (!a.input && !a.output && !a.pubkey && !a.input && !a.signature)
+        throw new TypeError('Not enough data');
+    opts = Object.assign({ validate: true }, opts || {});
+    (0, types_1.typeforce)({
+        network: types_1.typeforce.maybe(types_1.typeforce.Object),
+        output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+        pubkey: types_1.typeforce.maybe(tiny_secp256k1_1.default.isPoint),
+        signature: types_1.typeforce.maybe(bscript.isCanonicalScriptSignature),
+        input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+    }, a);
+    const _chunks = lazy.value(() => bscript.decompile(a.input));
+    const network = a.network || networks_1.bitcoin;
+    const o = { name: 'p2pk', network };
+    lazy.prop(o, 'output', () => {
+        if (!a.pubkey)
+            return;
+        return bscript.compile([a.pubkey, OPS.OP_CHECKSIG]);
+    });
+    lazy.prop(o, 'pubkey', () => {
+        if (!a.output)
+            return;
+        return a.output.subarray(1, -1);
+    });
+    lazy.prop(o, 'signature', () => {
+        if (!a.input)
+            return;
+        return _chunks()[0];
+    });
+    lazy.prop(o, 'input', () => {
+        if (!a.signature)
+            return;
+        return bscript.compile([a.signature]);
+    });
+    lazy.prop(o, 'witness', () => {
+        if (!o.input)
+            return;
+        return [];
+    });
+    if (opts.validate) {
+        if (a.output) {
+            if (a.output[a.output.length - 1] !== OPS.OP_CHECKSIG)
+                throw new TypeError('Output is invalid');
+            if (!tiny_secp256k1_1.default.isPoint(o.pubkey))
+                throw new TypeError('Output pubkey is invalid');
+            if (a.pubkey && !a.pubkey.equals(o.pubkey))
+                throw new TypeError('Pubkey mismatch');
+        }
+        if (a.signature) {
+            if (a.input && !a.input.equals(o.input))
+                throw new TypeError('Signature mismatch');
+        }
+        if (a.input) {
+            if (_chunks().length !== 1)
+                throw new TypeError('Input is invalid');
+            if (!bscript.isCanonicalScriptSignature(o.signature))
+                throw new TypeError('Input has invalid signature');
+        }
+    }
+    return Object.assign(o, a);
+}
+//# sourceMappingURL=p2pk.js.map

package/third-party/utxo-lib/payments/p2pkh.d.ts

@@ -0,0 +1,3 @@
+import { Payment, PaymentOpts } from '../types';
+export declare function p2pkh(a: Payment, opts?: PaymentOpts): Payment;
+//# sourceMappingURL=p2pkh.d.ts.map