@btc-vision/bitcoin 6.4.1 → 6.4.3

package/src/payments/embed.ts

@@ -1,55 +1,61 @@
-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);
-}
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { stacksEqual, typeforce as typef } from '../types.js';
+import { EmbedPayment, 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: Omit<EmbedPayment, 'name'>, opts?: PaymentOpts): EmbedPayment {
+    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: EmbedPayment = { name: 'embed', network, data: [] };
+
+    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;
+        const script = bscript.decompile(a.output);
+        if (script === null || script === undefined) {
+            return;
+        }
+
+        return script.slice(1) as Buffer[];
+    });
+
+    // 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.ts

@@ -19,35 +19,132 @@ export * from './p2sh.js';
 export * from './p2tr.js';
 export * from './p2wpkh.js';
 export * from './p2wsh.js';
+export * from './p2op.js';
 
-export interface Payment {
+export interface BasePayment {
+    /** Convenience label, also the discriminant for the union. */
     name?: string;
+    /** Network parameters (mainnet if omitted). */
     network?: Network;
+    /** Fully-assembled scriptPubKey (if already known). */
     output?: Buffer;
-    data?: Buffer[];
+    /** Raw scriptSig (legacy script types only). */
+    input?: Buffer;
+    /** Human-readable address (if already known). */
+    address?: string;
+    /** Segwit stack (empty for legacy). */
+    witness?: Buffer[];
+
+    /** Script template for P2SH, P2WSH, P2TR, etc. */
+    redeem?: ScriptRedeem;
+
+    /** Non-standard options used by some wallets. */
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
+}
+
+/** Helper used by redeeming script-template outputs (P2SH, P2WSH). */
+export interface ScriptRedeem extends BasePayment {
+    output?: Buffer;               // script template
+    redeemVersion?: number;       // tapscript leaves etc.
+    network?: Network; // network parameters (mainnet if omitted)
+}
+
+export interface P2PKPayment extends BasePayment {
+    name: 'p2pk';
+    pubkey?: Buffer;
+    /** DER-encoded sig – empty until signed. */
+    signature?: Buffer;
+}
+
+export interface P2PKHPayment extends BasePayment {
+    name: 'p2pkh';
+    /** RIPEMD-160(SHA-256(pubkey)) – 20 bytes. */
+    hash?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+
+export interface P2SHPayment extends BasePayment {
+    name: 'p2sh';
+    /** Hash160 of a redeem script. */
+    hash?: Buffer;
+
+    /** The entire signature stack when spending a P2SH (non-segwit). */
+    signatures?: Buffer[];
+}
+
+export interface P2MSPayment extends BasePayment {
+    name: 'p2ms';
+    /** M-of-N parameters. */
     m?: number;
     n?: number;
     pubkeys?: Buffer[];
-    input?: Buffer;
     signatures?: Buffer[];
-    internalPubkey?: Buffer;
+}
+
+export interface P2WPKHPayment extends BasePayment {
+    name: 'p2wpkh';
+    /** 20-byte witness program. */
+    hash?: Buffer;
     pubkey?: Buffer;
     signature?: Buffer;
-    address?: string;
+}
+
+export interface P2WSHPayment extends BasePayment {
+    name: 'p2wsh';
+    /** 32-byte witness program. */
     hash?: Buffer;
-    redeem?: Payment;
-    redeemVersion?: number;
+    redeem?: ScriptRedeem;
+}
+
+export interface P2TRPayment extends BasePayment {
+    name: 'p2tr';
+    /** x-only pubkey that commits to the tree. */
+    pubkey?: Buffer;
+    /** Internal (untweaked) x-only pubkey. */
+    internalPubkey?: Buffer;
+    /** Merkle-root tweak, present when a script path exists. */
+    hash?: Buffer;
+    /** Full taptree description (optional, dev-side). */
     scriptTree?: Taptree;
-    witness?: Buffer[];
+    /** Key-path sig or leading stack elem. */
+    signature?: Buffer;
 
-    // NEW FIELDS
-    useHybrid?: boolean;
-    useUncompressed?: boolean;
+    redeemVersion?: number; // tapscript leaves etc.
+    redeem?: ScriptRedeem;
+}
+
+export interface P2OPPayment extends BasePayment {
+    name: 'p2op';
+    /** <deploymentVersion || HASH160(payload)> (2–40 bytes). */
+    program?: Buffer;
+    deploymentVersion: number | undefined;
+    /** Convenience slice of `program` (20 bytes for current spec). */
+    hash160?: Buffer;
+}
+
+/** OP_RETURN data-carrying output */
+export interface EmbedPayment extends BasePayment {
+    name: 'embed';
+    /** Raw pushed chunks after OP_RETURN. */
+    data: Buffer[];
+    // `output` is automatically derived from `data` (or vice-versa)
 }
 
-export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
+export type Payment =
+    | P2PKPayment
+    | P2PKHPayment
+    | P2SHPayment
+    | P2MSPayment
+    | P2WPKHPayment
+    | P2WSHPayment
+    | P2TRPayment
+    | P2OPPayment
+    | EmbedPayment
+    | ScriptRedeem;
 
-export type PaymentFunction = () => Payment;
+export type PaymentCreator = <T extends BasePayment>(a: T, opts?: PaymentOpts) => T;
 
 export interface PaymentOpts {
     validate?: boolean;

package/src/payments/lazy.ts

@@ -1,28 +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;
-    };
-}
+export function prop<T extends {}>(object: T, name: string, f: () => T[keyof T]): void {
+    Object.defineProperty(object, name, {
+        configurable: true,
+        enumerable: true,
+        get(): unknown {
+            const _value = f.call(this);
+            this[name] = _value;
+            return _value;
+        },
+        set(_value: unknown): 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

@@ -1,7 +1,7 @@
 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 { P2MSPayment, PaymentOpts, Stack } from './index.js';
 import * as lazy from './lazy.js';
 
 const OPS = bscript.OPS;
@@ -17,7 +17,7 @@ const OP_INT_BASE = OPS.OP_RESERVED; // OP_1 - 1
  * @returns The created payment object.
  * @throws {TypeError} If the provided data is not valid.
  */
-export function p2ms(a: Payment, opts?: PaymentOpts): Payment {
+export function p2ms(a: Omit<P2MSPayment, 'name'>, opts?: PaymentOpts): P2MSPayment {
     if (!a.input && !a.output && !(a.pubkeys && a.m !== undefined) && !a.signatures)
         throw new TypeError('Not enough data');
     opts = Object.assign({ validate: true }, opts || {});
@@ -44,7 +44,10 @@ export function p2ms(a: Payment, opts?: PaymentOpts): Payment {
     );
 
     const network = a.network || BITCOIN_NETWORK;
-    const o: Payment = { network };
+    const o: P2MSPayment = {
+        network,
+        name: 'p2ms',
+    };
 
     let chunks: Stack = [];
     let decoded = false;
@@ -85,9 +88,12 @@ export function p2ms(a: Payment, opts?: PaymentOpts): Payment {
         decode(a.output);
         return o.pubkeys;
     });
-    lazy.prop(o, 'signatures', () => {
+    lazy.prop<P2MSPayment>(o, 'signatures', () => {
         if (!a.input) return;
-        return bscript.decompile(a.input)!.slice(1);
+        const decompiled = bscript.decompile(a.input);
+        if (decompiled === null || decompiled === undefined) return;
+
+        return decompiled.slice(1) as Buffer[];
     });
     lazy.prop(o, 'input', () => {
         if (!a.signatures) return;

package/src/payments/p2op.ts

@@ -0,0 +1,170 @@
+import { bech32m } from 'bech32';
+import { Buffer as NBuffer } from 'buffer';
+import { fromBech32 } from '../address.js';
+import { bitcoin as BITCOIN_NETWORK, Network } from '../networks.js';
+import * as bscript from '../script.js';
+import { typeforce as typef } from '../types.js';
+import * as lazy from './lazy.js';
+import { BasePayment, P2OPPayment, PaymentOpts } from './index.js';
+
+const OPS = bscript.OPS;
+const P2OP_WITNESS_VERSION = 0x10;
+const MIN_SIZE = 2;
+const MAX_SIZE = 40;
+
+interface P2OPBase extends BasePayment {
+    name: 'p2op';
+}
+
+interface P2OP_fromOutput extends P2OPBase {
+    output: Buffer;
+
+    program?: undefined;
+    deploymentVersion?: undefined;
+    hash160?: undefined;
+}
+
+interface P2OP_fromProgram extends P2OPBase {
+    program: Buffer;
+
+    output?: undefined;
+    deploymentVersion?: never;
+    hash160?: never;
+}
+
+interface P2OP_fromParts extends P2OPBase {
+    deploymentVersion: number;
+    hash160: Buffer;
+
+    output?: undefined;
+    program?: undefined;
+}
+
+export type P2OPPaymentParams = P2OP_fromOutput | P2OP_fromProgram | P2OP_fromParts;
+
+/**
+ * Pay-to-OPNet (P2OP) decoder / encoder.
+ *
+ *   ▪ witness program =    <deploymentVersion:uint8><hash160:20-bytes|...>
+ *   ▪ scriptPubKey   = OP_16 <program>
+ *   ▪ address HRP    = network.bech32Opnet, encoded with Bech32m
+ *
+ * Accepts any combination of { address, output, program }  and returns a
+ * fully lazy payment object, mirroring the style of `p2tr`.
+ */
+export function p2op(a: Omit<P2OPPaymentParams, 'name'>, opts?: PaymentOpts): P2OPPayment {
+    if (!a.address && !a.output && !a.program) throw new TypeError('Not enough data for p2op');
+
+    opts = Object.assign({ validate: true }, opts || {});
+
+    typef(
+        {
+            address: typef.maybe(typef.String),
+            output: typef.maybe(typef.Buffer),
+            program: typef.maybe(typef.Buffer),
+            network: typef.maybe(typef.Object),
+            deploymentVersion: typef.maybe(typef.Number),
+            hash160: typef.maybe(typef.BufferN(20)),
+        },
+        a,
+    );
+
+    const _address = lazy.value(() => fromBech32(a.address!));
+
+    const network: Network = a.network || BITCOIN_NETWORK;
+    const o: P2OPPayment = {
+        name: 'p2op',
+        network,
+        deploymentVersion: 0,
+    };
+
+    lazy.prop(o, 'program', () => {
+        if (a.program) return a.program;
+
+        if (a.output) {
+            if (a.output[0] !== OPS.OP_16) throw new TypeError('Invalid P2OP script');
+            let pushPos = 1,
+                progLen: number;
+            if (a.output[1] < 0x4c) {
+                progLen = a.output[1];
+                pushPos = 2;
+            } else if (a.output[1] === 0x4c) {
+                progLen = a.output[2];
+                pushPos = 3;
+            } else {
+                throw new TypeError('Unsupported push opcode in P2OP script');
+            }
+            return a.output.slice(pushPos, pushPos + progLen);
+        }
+
+        if (a.address) {
+            const dec = _address();
+            return dec.data;
+        }
+    });
+
+    lazy.prop(o, 'deploymentVersion', () => {
+        if (!o.program) return;
+        return o.program[0];
+    });
+
+    lazy.prop(o, 'hash160', () => {
+        if (!o.program) return;
+        return o.program.slice(1);
+    });
+
+    lazy.prop(o, 'output', () => {
+        if (!o.program) return;
+        return bscript.compile([OPS.OP_16, o.program]);
+    });
+
+    lazy.prop(o, 'address', () => {
+        if (!o.program) return;
+        if (!network.bech32Opnet) {
+            throw new TypeError('Network does not support opnet');
+        }
+
+        const words = bech32m.toWords(o.program);
+        words.unshift(P2OP_WITNESS_VERSION);
+
+        return bech32m.encode(network.bech32Opnet, words);
+    });
+
+    // extended validation
+    if (opts.validate) {
+        let prog: Buffer = NBuffer.alloc(0);
+
+        if (a.address) {
+            const dec = _address();
+            if (network.bech32Opnet !== dec.prefix)
+                throw new TypeError('Invalid prefix or network mismatch');
+            if (dec.version !== P2OP_WITNESS_VERSION)
+                throw new TypeError('Invalid witness version for p2op');
+            if (dec.data.length < MIN_SIZE || dec.data.length > MAX_SIZE)
+                throw new TypeError('Invalid witness program length');
+            prog = dec.data;
+        }
+
+        if (a.program) {
+            if (prog.length && !prog.equals(a.program)) throw new TypeError('Program mismatch');
+            prog = a.program;
+        }
+
+        if (a.output) {
+            const outProg = o.program!;
+            if (prog.length && !prog.equals(outProg))
+                throw new TypeError('Program mismatch (output vs other source)');
+            prog = outProg;
+        }
+
+        if (prog.length < MIN_SIZE || prog.length > MAX_SIZE)
+            throw new TypeError('Witness program must be 2–40 bytes');
+
+        if (a.deploymentVersion !== undefined && a.deploymentVersion !== prog[0])
+            throw new TypeError('deploymentVersion mismatch');
+
+        if (a.hash160 && !a.hash160.equals(prog.slice(1))) throw new TypeError('hash160 mismatch');
+    }
+
+    return Object.assign(o, a);
+}