@btc-vision/bitcoin 6.3.0 → 6.3.2

package/build/payments/index.d.ts

@@ -0,0 +1,41 @@
+import { Network } from '../networks';
+import { Taptree } from '../types';
+export * from './bip341.js';
+export * from './embed.js';
+export * from './lazy.js';
+export * from './p2ms.js';
+export * from './p2pk.js';
+export * from './p2pkh.js';
+export * from './p2sh.js';
+export * from './p2tr.js';
+export * from './p2wpkh.js';
+export * from './p2wsh.js';
+export interface Payment {
+    name?: string;
+    network?: Network;
+    output?: Buffer;
+    data?: Buffer[];
+    m?: number;
+    n?: number;
+    pubkeys?: Buffer[];
+    input?: Buffer;
+    signatures?: Buffer[];
+    internalPubkey?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+    address?: string;
+    hash?: Buffer;
+    redeem?: Payment;
+    redeemVersion?: number;
+    scriptTree?: Taptree;
+    witness?: Buffer[];
+}
+export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
+export type PaymentFunction = () => Payment;
+export interface PaymentOpts {
+    validate?: boolean;
+    allowIncomplete?: boolean;
+}
+export type StackElement = Buffer | number;
+export type Stack = StackElement[];
+export type StackFunction = () => Stack;

package/build/payments/index.js

@@ -0,0 +1,10 @@
+export * from './bip341.js';
+export * from './embed.js';
+export * from './lazy.js';
+export * from './p2ms.js';
+export * from './p2pk.js';
+export * from './p2pkh.js';
+export * from './p2sh.js';
+export * from './p2tr.js';
+export * from './p2wpkh.js';
+export * from './p2wsh.js';

package/build/payments/lazy.d.ts

@@ -0,0 +1,2 @@
+export declare function prop(object: {}, name: string, f: () => any): void;
+export declare function value<T>(f: () => T): () => T;

package/{src → build}/payments/lazy.js

@@ -1,32 +1,28 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.value = exports.prop = void 0;
-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: _value,
-                writable: true,
-            });
-        },
-    });
-}
-exports.prop = prop;
-function value(f) {
-    let _value;
-    return () => {
-        if (_value !== undefined) return _value;
-        _value = f();
-        return _value;
-    };
-}
-exports.value = value;
+export 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: _value,
+                writable: true,
+            });
+        },
+    });
+}
+export function value(f) {
+    let _value;
+    return () => {
+        if (_value !== undefined)
+            return _value;
+        _value = f();
+        return _value;
+    };
+}

package/build/payments/p2ms.d.ts

@@ -0,0 +1,2 @@
+import { Payment, PaymentOpts } from './index.js';
+export declare function p2ms(a: Payment, opts?: PaymentOpts): Payment;

package/{src → build}/payments/p2ms.js

@@ -1,158 +1,128 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.p2ms = void 0;
-const networks_1 = require('../networks');
-const bscript = require('../script');
-const types_1 = require('../types');
-const lazy = require('./lazy');
-const OPS = bscript.OPS;
-const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
-// input: OP_0 [signatures ...]
-// output: m [pubKeys ...] n OP_CHECKMULTISIG
-/**
- * Represents a function that creates a Pay-to-Multisig (P2MS) payment object.
- * @param a - The payment object.
- * @param opts - Optional payment options.
- * @returns The created payment object.
- * @throws {TypeError} If the provided data is not valid.
- */
-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(types_1.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 = { 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})`;
-    });
-    // extended validation
-    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 => (0, types_1.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 && !(0, types_1.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 &&
-                !(0, types_1.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);
-}
-exports.p2ms = p2ms;
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
+import * as lazy from './lazy.js';
+const OPS = bscript.OPS;
+const OP_INT_BASE = OPS.OP_RESERVED;
+export 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);
+    }
+    typef({
+        network: typef.maybe(typef.Object),
+        m: typef.maybe(typef.Number),
+        n: typef.maybe(typef.Number),
+        output: typef.maybe(typef.Buffer),
+        pubkeys: typef.maybe(typef.arrayOf(isPoint)),
+        signatures: typef.maybe(typef.arrayOf(isAcceptableSignature)),
+        input: typef.maybe(typef.Buffer),
+    }, a);
+    const network = a.network || BITCOIN_NETWORK;
+    const o = { 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 (!typef.Number(chunks[0]))
+                throw new TypeError('Output is invalid');
+            if (!typef.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) => 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);
+}

package/build/payments/p2pk.d.ts

@@ -0,0 +1,2 @@
+import { Payment, PaymentOpts } from './index.js';
+export declare function p2pk(a: Payment, opts?: PaymentOpts): Payment;

package/build/payments/p2pk.js

@@ -0,0 +1,68 @@
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, typeforce as typef } from '../types.js';
+import * as lazy from './lazy.js';
+const OPS = bscript.OPS;
+export 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 || {});
+    typef({
+        network: typef.maybe(typef.Object),
+        output: typef.maybe(typef.Buffer),
+        pubkey: typef.maybe(isPoint),
+        signature: typef.maybe(bscript.isCanonicalScriptSignature),
+        input: typef.maybe(typef.Buffer),
+    }, a);
+    const _chunks = lazy.value(() => {
+        return bscript.decompile(a.input);
+    });
+    const network = a.network || BITCOIN_NETWORK;
+    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.slice(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 (!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);
+}

package/build/payments/p2pkh.d.ts

@@ -0,0 +1,2 @@
+import { Payment, PaymentOpts } from './index.js';
+export declare function p2pkh(a: Payment, opts?: PaymentOpts): Payment;

package/build/payments/p2pkh.js

@@ -0,0 +1,135 @@
+import * as bs58check from 'bs58check';
+import * as bcrypto from '../crypto.js';
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, typeforce as typef } from '../types.js';
+import * as lazy from './lazy.js';
+const OPS = bscript.OPS;
+export function p2pkh(a, opts) {
+    if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input)
+        throw new TypeError('Not enough data');
+    opts = Object.assign({ validate: true }, opts || {});
+    typef({
+        network: typef.maybe(typef.Object),
+        address: typef.maybe(typef.String),
+        hash: typef.maybe(typef.BufferN(20)),
+        output: typef.maybe(typef.BufferN(25)),
+        pubkey: typef.maybe(isPoint),
+        signature: typef.maybe(bscript.isCanonicalScriptSignature),
+        input: typef.maybe(typef.Buffer),
+    }, a);
+    const _address = lazy.value(() => {
+        const payload = Buffer.from(bs58check.default.decode(a.address));
+        const version = payload.readUInt8(0);
+        const hash = payload.slice(1);
+        return { version, hash };
+    });
+    const _chunks = lazy.value(() => {
+        return bscript.decompile(a.input);
+    });
+    const network = a.network || BITCOIN_NETWORK;
+    const o = { name: 'p2pkh', network };
+    lazy.prop(o, 'address', () => {
+        if (!o.hash)
+            return;
+        const payload = Buffer.allocUnsafe(21);
+        payload.writeUInt8(network.pubKeyHash, 0);
+        o.hash.copy(payload, 1);
+        return bs58check.default.encode(payload);
+    });
+    lazy.prop(o, 'hash', () => {
+        if (a.output)
+            return a.output.slice(3, 23);
+        if (a.address)
+            return _address().hash;
+        if (a.pubkey || o.pubkey)
+            return bcrypto.hash160(a.pubkey || o.pubkey);
+    });
+    lazy.prop(o, 'output', () => {
+        if (!o.hash)
+            return;
+        return bscript.compile([
+            OPS.OP_DUP,
+            OPS.OP_HASH160,
+            o.hash,
+            OPS.OP_EQUALVERIFY,
+            OPS.OP_CHECKSIG,
+        ]);
+    });
+    lazy.prop(o, 'pubkey', () => {
+        if (!a.input)
+            return;
+        return _chunks()[1];
+    });
+    lazy.prop(o, 'signature', () => {
+        if (!a.input)
+            return;
+        return _chunks()[0];
+    });
+    lazy.prop(o, 'input', () => {
+        if (!a.pubkey)
+            return;
+        if (!a.signature)
+            return;
+        return bscript.compile([a.signature, a.pubkey]);
+    });
+    lazy.prop(o, 'witness', () => {
+        if (!o.input)
+            return;
+        return [];
+    });
+    if (opts.validate) {
+        let hash = Buffer.from([]);
+        if (a.address) {
+            if (_address().version !== network.pubKeyHash)
+                throw new TypeError('Invalid version or Network mismatch');
+            if (_address().hash.length !== 20)
+                throw new TypeError('Invalid address');
+            hash = _address().hash;
+        }
+        if (a.hash) {
+            if (hash.length > 0 && !hash.equals(a.hash))
+                throw new TypeError('Hash mismatch');
+            else
+                hash = a.hash;
+        }
+        if (a.output) {
+            if (a.output.length !== 25 ||
+                a.output[0] !== OPS.OP_DUP ||
+                a.output[1] !== OPS.OP_HASH160 ||
+                a.output[2] !== 0x14 ||
+                a.output[23] !== OPS.OP_EQUALVERIFY ||
+                a.output[24] !== OPS.OP_CHECKSIG)
+                throw new TypeError('Output is invalid');
+            const hash2 = a.output.slice(3, 23);
+            if (hash.length > 0 && !hash.equals(hash2))
+                throw new TypeError('Hash mismatch');
+            else
+                hash = hash2;
+        }
+        if (a.pubkey) {
+            const pkh = bcrypto.hash160(a.pubkey);
+            if (hash.length > 0 && !hash.equals(pkh))
+                throw new TypeError('Hash mismatch');
+            else
+                hash = pkh;
+        }
+        if (a.input) {
+            const chunks = _chunks();
+            if (chunks.length !== 2)
+                throw new TypeError('Input is invalid');
+            if (!bscript.isCanonicalScriptSignature(chunks[0]))
+                throw new TypeError('Input has invalid signature');
+            if (!isPoint(chunks[1]))
+                throw new TypeError('Input has invalid pubkey');
+            if (a.signature && !a.signature.equals(chunks[0]))
+                throw new TypeError('Signature mismatch');
+            if (a.pubkey && !a.pubkey.equals(chunks[1]))
+                throw new TypeError('Pubkey mismatch');
+            const pkh = bcrypto.hash160(chunks[1]);
+            if (hash.length > 0 && !hash.equals(pkh))
+                throw new TypeError('Hash mismatch');
+        }
+    }
+    return Object.assign(o, a);
+}

package/build/payments/p2sh.d.ts

@@ -0,0 +1,2 @@
+import { Payment, PaymentOpts } from './index.js';
+export declare function p2sh(a: Payment, opts?: PaymentOpts): Payment;