@btc-vision/bitcoin 6.3.1 → 6.3.2

package/src/payments/{index.d.ts → index.ts}

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /**
  * Represents a payment object, which is used to create a payment.
  *
@@ -6,16 +5,21 @@
  *
  * @packageDocumentation
  */
+
 import { Network } from '../networks';
 import { Taptree } from '../types';
-import { p2data as embed } from './embed';
-import { p2ms } from './p2ms';
-import { p2pk } from './p2pk';
-import { p2pkh } from './p2pkh';
-import { p2sh } from './p2sh';
-import { p2wpkh } from './p2wpkh';
-import { p2wsh } from './p2wsh';
-import { p2tr } from './p2tr';
+
+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;
@@ -36,13 +40,19 @@ export interface Payment {
     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;
-export { embed, p2ms, p2pk, p2pkh, p2sh, p2wpkh, p2wsh, p2tr };
+
+// TODO
+// witness commitment

package/src/payments/lazy.ts

@@ -0,0 +1,28 @@
+export function prop(object: {}, name: string, f: () => any): void {
+    Object.defineProperty(object, name, {
+        configurable: true,
+        enumerable: true,
+        get(): any {
+            const _value = f.call(this);
+            this[name] = _value;
+            return _value;
+        },
+        set(_value: any): void {
+            Object.defineProperty(this, name, {
+                configurable: true,
+                enumerable: true,
+                value: _value,
+                writable: true,
+            });
+        },
+    });
+}
+
+export function value<T>(f: () => T): () => T {
+    let _value: T;
+    return (): T => {
+        if (_value !== undefined) return _value;
+        _value = f();
+        return _value;
+    };
+}

package/src/payments/p2ms.ts

@@ -0,0 +1,150 @@
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
+import { Payment, PaymentOpts, Stack } from './index.js';
+import * as lazy from './lazy.js';
+
+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.
+ */
+export function p2ms(a: Payment, opts?: PaymentOpts): Payment {
+    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: Buffer | number): boolean {
+        return (
+            bscript.isCanonicalScriptSignature(x as Buffer) ||
+            (opts!.allowIncomplete && (x as number) === 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: Payment = { network };
+
+    let chunks: Stack = [];
+    let decoded = false;
+
+    function decode(output: Buffer | Stack): void {
+        if (decoded) return;
+        decoded = true;
+        chunks = bscript.decompile(output) as Stack;
+        o.m = (chunks[0] as number) - OP_INT_BASE;
+        o.n = (chunks[chunks.length - 2] as number) - OP_INT_BASE;
+        o.pubkeys = chunks.slice(1, -2) as Buffer[];
+    }
+
+    lazy.prop(o, 'output', () => {
+        if (!a.m) return;
+        if (!o.n) return;
+        if (!a.pubkeys) return;
+        return bscript.compile(
+            ([] as Stack).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] as Stack).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 (!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/src/payments/{p2pk.js → p2pk.ts}

@@ -1,11 +1,11 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.p2pk = void 0;
-const networks_1 = require('../networks');
-const bscript = require('../script');
-const types_1 = require('../types');
-const lazy = require('./lazy');
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, typeforce as typef } from '../types.js';
+import { Payment, PaymentOpts, StackFunction } from './index.js';
+import * as lazy from './lazy.js';
+
 const OPS = bscript.OPS;
+
 // input: {signature}
 // output: {pubKey} OP_CHECKSIG
 /**
@@ -16,27 +16,30 @@ const OPS = bscript.OPS;
  * @returns The P2PK payment object.
  * @throws {TypeError} If the required data is not provided or if the data is invalid.
  */
-function p2pk(a, opts) {
+export function p2pk(a: Payment, opts?: PaymentOpts): Payment {
     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)(
+
+    typef(
         {
-            network: types_1.typeforce.maybe(types_1.typeforce.Object),
-            output: types_1.typeforce.maybe(types_1.typeforce.Buffer),
-            pubkey: types_1.typeforce.maybe(types_1.isPoint),
-            signature: types_1.typeforce.maybe(
-                bscript.isCanonicalScriptSignature,
-            ),
-            input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+            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 || networks_1.bitcoin;
-    const o = { name: 'p2pk', network };
+        return bscript.decompile(a.input!);
+    }) as StackFunction;
+
+    const network = a.network || BITCOIN_NETWORK;
+    const o: Payment = { name: 'p2pk', network };
+
     lazy.prop(o, 'output', () => {
         if (!a.pubkey) return;
         return bscript.compile([a.pubkey, OPS.OP_CHECKSIG]);
@@ -47,7 +50,7 @@ function p2pk(a, opts) {
     });
     lazy.prop(o, 'signature', () => {
         if (!a.input) return;
-        return _chunks()[0];
+        return _chunks()[0] as Buffer;
     });
     lazy.prop(o, 'input', () => {
         if (!a.signature) return;
@@ -57,26 +60,26 @@ function p2pk(a, opts) {
         if (!o.input) return;
         return [];
     });
+
     // extended validation
     if (opts.validate) {
         if (a.output) {
             if (a.output[a.output.length - 1] !== OPS.OP_CHECKSIG)
                 throw new TypeError('Output is invalid');
-            if (!(0, types_1.isPoint)(o.pubkey))
-                throw new TypeError('Output pubkey is invalid');
-            if (a.pubkey && !a.pubkey.equals(o.pubkey))
-                throw new TypeError('Pubkey mismatch');
+            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 && !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))
+            if (!bscript.isCanonicalScriptSignature(o.signature!))
                 throw new TypeError('Input has invalid signature');
         }
     }
+
     return Object.assign(o, a);
 }
-exports.p2pk = p2pk;

package/src/payments/{p2pkh.js → p2pkh.ts}

@@ -1,13 +1,13 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
-exports.p2pkh = void 0;
-const bcrypto = require('../crypto');
-const networks_1 = require('../networks');
-const bscript = require('../script');
-const types_1 = require('../types');
-const lazy = require('./lazy');
-const bs58check = require('bs58check');
+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 { Payment, PaymentOpts, StackFunction } from './index.js';
+import * as lazy from './lazy.js';
+
 const OPS = bscript.OPS;
+
 // input: {signature} {pubkey}
 // output: OP_DUP OP_HASH160 {hash160(pubkey)} OP_EQUALVERIFY OP_CHECKSIG
 /**
@@ -18,46 +18,50 @@ const OPS = bscript.OPS;
  * @returns The P2PKH payment object.
  * @throws {TypeError} If the required data is not provided or if the data is invalid.
  */
-function p2pkh(a, opts) {
+export function p2pkh(a: Payment, opts?: PaymentOpts): Payment {
     if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input)
         throw new TypeError('Not enough data');
     opts = Object.assign({ validate: true }, opts || {});
-    (0, types_1.typeforce)(
+
+    typef(
         {
-            network: types_1.typeforce.maybe(types_1.typeforce.Object),
-            address: types_1.typeforce.maybe(types_1.typeforce.String),
-            hash: types_1.typeforce.maybe(types_1.typeforce.BufferN(20)),
-            output: types_1.typeforce.maybe(types_1.typeforce.BufferN(25)),
-            pubkey: types_1.typeforce.maybe(types_1.isPoint),
-            signature: types_1.typeforce.maybe(
-                bscript.isCanonicalScriptSignature,
-            ),
-            input: types_1.typeforce.maybe(types_1.typeforce.Buffer),
+            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.decode(a.address));
+        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 || networks_1.bitcoin;
-    const o = { name: 'p2pkh', network };
+        return bscript.decompile(a.input!);
+    }) as StackFunction;
+
+    const network = a.network || BITCOIN_NETWORK;
+    const o: Payment = { 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.encode(payload);
+        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);
+        if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!);
     });
     lazy.prop(o, 'output', () => {
         if (!o.hash) return;
@@ -71,11 +75,11 @@ function p2pkh(a, opts) {
     });
     lazy.prop(o, 'pubkey', () => {
         if (!a.input) return;
-        return _chunks()[1];
+        return _chunks()[1] as Buffer;
     });
     lazy.prop(o, 'signature', () => {
         if (!a.input) return;
-        return _chunks()[0];
+        return _chunks()[0] as Buffer;
     });
     lazy.prop(o, 'input', () => {
         if (!a.pubkey) return;
@@ -86,21 +90,22 @@ function p2pkh(a, opts) {
         if (!o.input) return;
         return [];
     });
+
     // extended validation
     if (opts.validate) {
-        let hash = Buffer.from([]);
+        let hash: Buffer = 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');
+            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');
+            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 ||
@@ -111,33 +116,34 @@ function p2pkh(a, opts) {
                 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');
+            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');
+            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]))
+            if (!bscript.isCanonicalScriptSignature(chunks[0] as Buffer))
                 throw new TypeError('Input has invalid signature');
-            if (!(0, types_1.isPoint)(chunks[1]))
-                throw new TypeError('Input has invalid pubkey');
-            if (a.signature && !a.signature.equals(chunks[0]))
+            if (!isPoint(chunks[1])) throw new TypeError('Input has invalid pubkey');
+
+            if (a.signature && !a.signature.equals(chunks[0] as Buffer))
                 throw new TypeError('Signature mismatch');
-            if (a.pubkey && !a.pubkey.equals(chunks[1]))
+            if (a.pubkey && !a.pubkey.equals(chunks[1] as Buffer))
                 throw new TypeError('Pubkey mismatch');
-            const pkh = bcrypto.hash160(chunks[1]);
-            if (hash.length > 0 && !hash.equals(pkh))
-                throw new TypeError('Hash mismatch');
+
+            const pkh = bcrypto.hash160(chunks[1] as Buffer);
+            if (hash.length > 0 && !hash.equals(pkh)) throw new TypeError('Hash mismatch');
         }
     }
+
     return Object.assign(o, a);
 }
-exports.p2pkh = p2pkh;