@btc-vision/bitcoin 6.3.1 → 6.3.3

package/src/ops.ts

@@ -0,0 +1,282 @@
+export interface Opcodes {
+    OP_FALSE: number;
+    OP_0: number;
+    OP_PUSHDATA1: number;
+    OP_PUSHDATA2: number;
+    OP_PUSHDATA4: number;
+    OP_1NEGATE: number;
+    OP_RESERVED: number;
+    OP_TRUE: number;
+    OP_1: number;
+    OP_2: number;
+    OP_3: number;
+    OP_4: number;
+    OP_5: number;
+    OP_6: number;
+    OP_7: number;
+    OP_8: number;
+    OP_9: number;
+    OP_10: number;
+    OP_11: number;
+    OP_12: number;
+    OP_13: number;
+    OP_14: number;
+    OP_15: number;
+    OP_16: number;
+
+    // control
+    OP_NOP: number;
+    OP_VER: number;
+    OP_IF: number;
+    OP_NOTIF: number;
+    OP_VERIF: number;
+    OP_VERNOTIF: number;
+    OP_ELSE: number;
+    OP_ENDIF: number;
+    OP_VERIFY: number;
+    OP_RETURN: number;
+
+    // stack ops
+    OP_TOALTSTACK: number;
+    OP_FROMALTSTACK: number;
+    OP_2DROP: number;
+    OP_2DUP: number;
+    OP_3DUP: number;
+    OP_2OVER: number;
+    OP_2ROT: number;
+    OP_2SWAP: number;
+    OP_IFDUP: number;
+    OP_DEPTH: number;
+    OP_DROP: number;
+    OP_DUP: number;
+    OP_NIP: number;
+    OP_OVER: number;
+    OP_PICK: number;
+    OP_ROLL: number;
+    OP_ROT: number;
+    OP_SWAP: number;
+    OP_TUCK: number;
+
+    // splice ops
+    OP_CAT: number;
+    OP_SUBSTR: number;
+    OP_LEFT: number;
+    OP_RIGHT: number;
+    OP_SIZE: number;
+
+    // bit logic
+    OP_INVERT: number;
+    OP_AND: number;
+    OP_OR: number;
+    OP_XOR: number;
+    OP_EQUAL: number;
+    OP_EQUALVERIFY: number;
+    OP_RESERVED1: number;
+    OP_RESERVED2: number;
+
+    // numeric
+    OP_1ADD: number;
+    OP_1SUB: number;
+    OP_2MUL: number;
+    OP_2DIV: number;
+    OP_NEGATE: number;
+    OP_ABS: number;
+    OP_NOT: number;
+    OP_0NOTEQUAL: number;
+    OP_ADD: number;
+    OP_SUB: number;
+    OP_MUL: number;
+    OP_DIV: number;
+    OP_MOD: number;
+    OP_LSHIFT: number;
+    OP_RSHIFT: number;
+    OP_BOOLAND: number;
+    OP_BOOLOR: number;
+    OP_NUMEQUAL: number;
+    OP_NUMEQUALVERIFY: number;
+    OP_NUMNOTEQUAL: number;
+    OP_LESSTHAN: number;
+    OP_GREATERTHAN: number;
+    OP_LESSTHANOREQUAL: number;
+    OP_GREATERTHANOREQUAL: number;
+    OP_MIN: number;
+    OP_MAX: number;
+    OP_WITHIN: number;
+
+    // crypto
+    OP_RIPEMD160: number;
+    OP_SHA1: number;
+    OP_SHA256: number;
+    OP_HASH160: number;
+    OP_HASH256: number;
+    OP_CODESEPARATOR: number;
+    OP_CHECKSIG: number;
+    OP_CHECKSIGVERIFY: number;
+    OP_CHECKMULTISIG: number;
+    OP_CHECKMULTISIGVERIFY: number;
+    OP_CHECKLOCKTIMEVERIFY: number;
+    OP_CHECKSEQUENCEVERIFY: number;
+
+    OP_CHECKSIGADD: number;
+
+    // expansion
+    OP_NOP1: number;
+    OP_NOP2: number;
+    OP_NOP3: number;
+    OP_NOP4: number;
+    OP_NOP5: number;
+    OP_NOP6: number;
+    OP_NOP7: number;
+    OP_NOP8: number;
+    OP_NOP9: number;
+    OP_NOP10: number;
+
+    // template matching params
+    OP_PUBKEYHASH: number;
+    OP_PUBKEY: number;
+    OP_INVALIDOPCODE: number;
+}
+
+const OPS: Opcodes = {
+    OP_FALSE: 0,
+    OP_0: 0,
+    OP_PUSHDATA1: 76,
+    OP_PUSHDATA2: 77,
+    OP_PUSHDATA4: 78,
+    OP_1NEGATE: 79,
+    OP_RESERVED: 80,
+    OP_TRUE: 81,
+    OP_1: 81,
+    OP_2: 82,
+    OP_3: 83,
+    OP_4: 84,
+    OP_5: 85,
+    OP_6: 86,
+    OP_7: 87,
+    OP_8: 88,
+    OP_9: 89,
+    OP_10: 90,
+    OP_11: 91,
+    OP_12: 92,
+    OP_13: 93,
+    OP_14: 94,
+    OP_15: 95,
+    OP_16: 96,
+
+    OP_NOP: 97,
+    OP_VER: 98,
+    OP_IF: 99,
+    OP_NOTIF: 100,
+    OP_VERIF: 101,
+    OP_VERNOTIF: 102,
+    OP_ELSE: 103,
+    OP_ENDIF: 104,
+    OP_VERIFY: 105,
+    OP_RETURN: 106,
+
+    OP_TOALTSTACK: 107,
+    OP_FROMALTSTACK: 108,
+    OP_2DROP: 109,
+    OP_2DUP: 110,
+    OP_3DUP: 111,
+    OP_2OVER: 112,
+    OP_2ROT: 113,
+    OP_2SWAP: 114,
+    OP_IFDUP: 115,
+    OP_DEPTH: 116,
+    OP_DROP: 117,
+    OP_DUP: 118,
+    OP_NIP: 119,
+    OP_OVER: 120,
+    OP_PICK: 121,
+    OP_ROLL: 122,
+    OP_ROT: 123,
+    OP_SWAP: 124,
+    OP_TUCK: 125,
+
+    OP_CAT: 126,
+    OP_SUBSTR: 127,
+    OP_LEFT: 128,
+    OP_RIGHT: 129,
+    OP_SIZE: 130,
+
+    OP_INVERT: 131,
+    OP_AND: 132,
+    OP_OR: 133,
+    OP_XOR: 134,
+    OP_EQUAL: 135,
+    OP_EQUALVERIFY: 136,
+    OP_RESERVED1: 137,
+    OP_RESERVED2: 138,
+
+    OP_1ADD: 139,
+    OP_1SUB: 140,
+    OP_2MUL: 141,
+    OP_2DIV: 142,
+    OP_NEGATE: 143,
+    OP_ABS: 144,
+    OP_NOT: 145,
+    OP_0NOTEQUAL: 146,
+    OP_ADD: 147,
+    OP_SUB: 148,
+    OP_MUL: 149,
+    OP_DIV: 150,
+    OP_MOD: 151,
+    OP_LSHIFT: 152,
+    OP_RSHIFT: 153,
+
+    OP_BOOLAND: 154,
+    OP_BOOLOR: 155,
+    OP_NUMEQUAL: 156,
+    OP_NUMEQUALVERIFY: 157,
+    OP_NUMNOTEQUAL: 158,
+    OP_LESSTHAN: 159,
+    OP_GREATERTHAN: 160,
+    OP_LESSTHANOREQUAL: 161,
+    OP_GREATERTHANOREQUAL: 162,
+    OP_MIN: 163,
+    OP_MAX: 164,
+
+    OP_WITHIN: 165,
+
+    OP_RIPEMD160: 166,
+    OP_SHA1: 167,
+    OP_SHA256: 168,
+    OP_HASH160: 169,
+    OP_HASH256: 170,
+    OP_CODESEPARATOR: 171,
+    OP_CHECKSIG: 172,
+    OP_CHECKSIGVERIFY: 173,
+    OP_CHECKMULTISIG: 174,
+    OP_CHECKMULTISIGVERIFY: 175,
+
+    OP_NOP1: 176,
+
+    OP_NOP2: 177,
+    OP_CHECKLOCKTIMEVERIFY: 177,
+
+    OP_NOP3: 178,
+    OP_CHECKSEQUENCEVERIFY: 178,
+
+    OP_NOP4: 179,
+    OP_NOP5: 180,
+    OP_NOP6: 181,
+    OP_NOP7: 182,
+    OP_NOP8: 183,
+    OP_NOP9: 184,
+    OP_NOP10: 185,
+
+    OP_CHECKSIGADD: 186,
+
+    OP_PUBKEYHASH: 253,
+    OP_PUBKEY: 254,
+    OP_INVALIDOPCODE: 255,
+};
+
+const REVERSE_OPS: { [key: number]: string } = {};
+for (const op of Object.keys(OPS)) {
+    const code = OPS[op as keyof Opcodes];
+    REVERSE_OPS[code] = op;
+}
+
+export { OPS, REVERSE_OPS };

package/src/payments/bip341.ts

@@ -0,0 +1,140 @@
+import { Buffer as NBuffer } from 'buffer';
+import * as bcrypto from '../crypto.js';
+import { getEccLib } from '../ecc_lib.js';
+
+import { varuint } from '../bufferutils.js';
+import { isTapleaf, Tapleaf, Taptree } from '../types.js';
+
+export const LEAF_VERSION_TAPSCRIPT = 0xc0;
+export const MAX_TAPTREE_DEPTH = 128;
+
+interface HashLeaf {
+    hash: Buffer;
+}
+
+interface HashBranch {
+    hash: Buffer;
+    left: HashTree;
+    right: HashTree;
+}
+
+interface TweakedPublicKey {
+    parity: number;
+    x: Buffer;
+}
+
+const isHashBranch = (ht: HashTree): ht is HashBranch => 'left' in ht && 'right' in ht;
+
+/**
+ * Binary tree representing leaf, branch, and root node hashes of a Taptree.
+ * Each node contains a hash, and potentially left and right branch hashes.
+ * This tree is used for 2 purposes: Providing the root hash for tweaking,
+ * and calculating merkle inclusion proofs when constructing a control block.
+ */
+export type HashTree = HashLeaf | HashBranch;
+
+/**
+ * Calculates the root hash from a given control block and leaf hash.
+ * @param controlBlock - The control block buffer.
+ * @param leafHash - The leaf hash buffer.
+ * @returns The root hash buffer.
+ * @throws {TypeError} If the control block length is less than 33.
+ */
+export function rootHashFromPath(controlBlock: Buffer, leafHash: Buffer): Buffer {
+    if (controlBlock.length < 33)
+        throw new TypeError(
+            `The control-block length is too small. Got ${controlBlock.length}, expected min 33.`,
+        );
+    const m = (controlBlock.length - 33) / 32;
+
+    let kj = leafHash;
+    for (let j = 0; j < m; j++) {
+        const ej = controlBlock.slice(33 + 32 * j, 65 + 32 * j);
+        if (kj.compare(ej) < 0) {
+            kj = tapBranchHash(kj, ej);
+        } else {
+            kj = tapBranchHash(ej, kj);
+        }
+    }
+
+    return kj;
+}
+
+/**
+ * Build a hash tree of merkle nodes from the scripts binary tree.
+ * @param scriptTree - the tree of scripts to pairwise hash.
+ */
+export function toHashTree(scriptTree: Taptree): HashTree {
+    if (isTapleaf(scriptTree)) return { hash: tapleafHash(scriptTree) };
+
+    const hashes = [toHashTree(scriptTree[0]), toHashTree(scriptTree[1])];
+    hashes.sort((a, b) => a.hash.compare(b.hash));
+    const [left, right] = hashes;
+
+    return {
+        hash: tapBranchHash(left.hash, right.hash),
+        left,
+        right,
+    };
+}
+
+/**
+ * Given a HashTree, finds the path from a particular hash to the root.
+ * @param node - the root of the tree
+ * @param hash - the hash to search for
+ * @returns - array of sibling hashes, from leaf (inclusive) to root
+ * (exclusive) needed to prove inclusion of the specified hash. undefined if no
+ * path is found
+ */
+export function findScriptPath(node: HashTree, hash: Buffer): Buffer[] | undefined {
+    if (isHashBranch(node)) {
+        const leftPath = findScriptPath(node.left, hash);
+        if (leftPath !== undefined) return [...leftPath, node.right.hash];
+
+        const rightPath = findScriptPath(node.right, hash);
+        if (rightPath !== undefined) return [...rightPath, node.left.hash];
+    } else if (node.hash.equals(hash)) {
+        return [];
+    }
+
+    return undefined;
+}
+
+export function tapleafHash(leaf: Tapleaf): Buffer {
+    const version = leaf.version || LEAF_VERSION_TAPSCRIPT;
+    return bcrypto.taggedHash(
+        'TapLeaf',
+        NBuffer.concat([NBuffer.from([version]), serializeScript(leaf.output)]),
+    );
+}
+
+export function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
+    return bcrypto.taggedHash('TapTweak', NBuffer.concat(h ? [pubKey, h] : [pubKey]));
+}
+
+export function tweakKey(pubKey: Buffer, h: Buffer | undefined): TweakedPublicKey | null {
+    if (!NBuffer.isBuffer(pubKey)) return null;
+    if (pubKey.length !== 32) return null;
+    if (h && h.length !== 32) return null;
+
+    const tweakHash = tapTweakHash(pubKey, h);
+
+    const res = getEccLib().xOnlyPointAddTweak(pubKey, tweakHash);
+    if (!res || res.xOnlyPubkey === null) return null;
+
+    return {
+        parity: res.parity,
+        x: NBuffer.from(res.xOnlyPubkey),
+    };
+}
+
+function tapBranchHash(a: Buffer, b: Buffer): Buffer {
+    return bcrypto.taggedHash('TapBranch', NBuffer.concat([a, b]));
+}
+
+function serializeScript(s: Buffer): Buffer {
+    const varintLen = varuint.encodingLength(s.length);
+    const buffer = NBuffer.allocUnsafe(varintLen); // better
+    varuint.encode(s.length, buffer);
+    return NBuffer.concat([buffer, s]);
+}

package/src/payments/embed.ts

@@ -0,0 +1,55 @@
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { stacksEqual, typeforce as typef } from '../types.js';
+import { Payment, PaymentOpts, Stack } from './index.js';
+import * as lazy from './lazy.js';
+
+const OPS = bscript.OPS;
+
+// output: OP_RETURN ...
+/**
+ * Embeds data in a Bitcoin payment.
+ * @param a - The payment object.
+ * @param opts - Optional payment options.
+ * @returns The modified payment object.
+ * @throws {TypeError} If there is not enough data or if the output is invalid.
+ */
+export function p2data(a: Payment, opts?: PaymentOpts): Payment {
+    if (!a.data && !a.output) throw new TypeError('Not enough data');
+    opts = Object.assign({ validate: true }, opts || {});
+
+    typef(
+        {
+            network: typef.maybe(typef.Object),
+            output: typef.maybe(typef.Buffer),
+            data: typef.maybe(typef.arrayOf(typef.Buffer)),
+        },
+        a,
+    );
+
+    const network = a.network || BITCOIN_NETWORK;
+    const o = { name: 'embed', network } as Payment;
+
+    lazy.prop(o, 'output', () => {
+        if (!a.data) return;
+        return bscript.compile(([OPS.OP_RETURN] as Stack).concat(a.data));
+    });
+    lazy.prop(o, 'data', () => {
+        if (!a.output) return;
+        return bscript.decompile(a.output)!.slice(1);
+    });
+
+    // extended validation
+    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(typef.Buffer)) throw new TypeError('Output is invalid');
+
+            if (a.data && !stacksEqual(a.data, o.data as Buffer[]))
+                throw new TypeError('Data mismatch');
+        }
+    }
+
+    return Object.assign(o, a);
+}

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;
@@ -35,14 +39,24 @@ export interface Payment {
     redeemVersion?: number;
     scriptTree?: Taptree;
     witness?: Buffer[];
+
+    // NEW FIELDS
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
 }
+
 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);
+}