@btc-vision/bitcoin 6.4.2 → 6.4.3

package/src/payments/p2op.ts

@@ -1,136 +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 { Payment, PaymentOpts } from './index.js';
-
-const OPS = bscript.OPS;
-const P2OP_WITNESS_VERSION = 0x10;
-const MIN_SIZE = 2;
-const MAX_SIZE = 40;
-
-/**
- * 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: Payment, opts?: PaymentOpts): Payment {
-    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: Payment = { name: 'p2op', network };
-
-    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);
-}
+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);
+}

package/src/payments/p2pk.ts

@@ -1,85 +1,93 @@
-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
-/**
- * Creates a pay-to-public-key (P2PK) payment object.
- *
- * @param a - The payment object containing the necessary data.
- * @param opts - Optional payment options.
- * @returns The P2PK payment object.
- * @throws {TypeError} If the required data is not provided or if the data is invalid.
- */
-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 || {});
-
-    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!);
-    }) 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]);
-    });
-    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] as Buffer;
-    });
-    lazy.prop(o, 'input', () => {
-        if (!a.signature) return;
-        return bscript.compile([a.signature]);
-    });
-    lazy.prop(o, 'witness', () => {
-        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 (!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);
-}
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { isPoint, typeforce as typef } from '../types.js';
+import { P2PKPayment, PaymentOpts, StackFunction } from './index.js';
+import * as lazy from './lazy.js';
+
+const OPS = bscript.OPS;
+
+// input: {signature}
+// output: {pubKey} OP_CHECKSIG
+/**
+ * Creates a pay-to-public-key (P2PK) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2PK payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+export function p2pk(a: Omit<P2PKPayment, 'name'>, opts?: PaymentOpts): P2PKPayment {
+    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!);
+    }) as StackFunction;
+
+    const network = a.network || BITCOIN_NETWORK;
+    const o: P2PKPayment = {
+        name: 'p2pk',
+        network,
+        pubkey: undefined,
+    };
+
+    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] as Buffer;
+    });
+
+    lazy.prop(o, 'input', () => {
+        if (!a.signature) return;
+        return bscript.compile([a.signature]);
+    });
+
+    lazy.prop(o, 'witness', () => {
+        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 (!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);
+}