@btc-vision/bitcoin 6.4.1 → 6.4.2

package/browser/payments/index.d.ts

@@ -10,6 +10,7 @@ export * from './p2sh.js';
 export * from './p2tr.js';
 export * from './p2wpkh.js';
 export * from './p2wsh.js';
+export * from './p2op.js';
 export interface Payment {
     name?: string;
     network?: Network;
@@ -31,6 +32,9 @@ export interface Payment {
     witness?: Buffer[];
     useHybrid?: boolean;
     useUncompressed?: boolean;
+    program?: Buffer;
+    deploymentVersion?: number;
+    hash160?: Buffer;
 }
 export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
 export type PaymentFunction = () => Payment;

package/browser/payments/p2op.d.ts

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

package/browser/psbt/psbtutils.d.ts

@@ -6,6 +6,7 @@ export declare const isP2WPKH: (script: Buffer) => boolean;
 export declare const isP2WSHScript: (script: Buffer) => boolean;
 export declare const isP2SHScript: (script: Buffer) => boolean;
 export declare const isP2TR: (script: Buffer) => boolean;
+export declare const isP2OP: (script: Buffer) => boolean;
 export declare function witnessStackToScriptWitness(witness: Buffer[]): Buffer;
 export interface UncompressedPublicKey {
     hybrid: Buffer;

package/build/address.js

@@ -179,11 +179,11 @@ export function toOutputScript(address, network) {
             else if (decodeBech32.version === FUTURE_OPNET_VERSION) {
                 if (!network.bech32Opnet)
                     throw new Error(address + ' has an invalid prefix');
-                if (decodeBech32.data.length < FUTURE_SEGWIT_MIN_SIZE ||
-                    decodeBech32.data.length > FUTURE_SEGWIT_MAX_SIZE) {
-                    throw new Error('Invalid program length for opnet address');
-                }
-                return bscript.compile([opcodes.OP_16, decodeBech32.data]);
+                return payments.p2op({
+                    program: decodeBech32.data,
+                    deploymentVersion: decodeBech32.version,
+                    network,
+                }).output;
             }
             else if (decodeBech32.version >= FUTURE_SEGWIT_MIN_VERSION &&
                 decodeBech32.version <= FUTURE_SEGWIT_MAX_VERSION &&

package/build/payments/index.d.ts

@@ -10,6 +10,7 @@ export * from './p2sh.js';
 export * from './p2tr.js';
 export * from './p2wpkh.js';
 export * from './p2wsh.js';
+export * from './p2op.js';
 export interface Payment {
     name?: string;
     network?: Network;
@@ -31,6 +32,9 @@ export interface Payment {
     witness?: Buffer[];
     useHybrid?: boolean;
     useUncompressed?: boolean;
+    program?: Buffer;
+    deploymentVersion?: number;
+    hash160?: Buffer;
 }
 export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
 export type PaymentFunction = () => Payment;

package/build/payments/index.js

@@ -8,3 +8,4 @@ export * from './p2sh.js';
 export * from './p2tr.js';
 export * from './p2wpkh.js';
 export * from './p2wsh.js';
+export * from './p2op.js';

package/build/payments/p2op.d.ts

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

package/build/payments/p2op.js

@@ -0,0 +1,108 @@
+import { bech32m } from 'bech32';
+import { Buffer as NBuffer } from 'buffer';
+import { fromBech32 } from '../address.js';
+import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import * as bscript from '../script.js';
+import { typeforce as typef } from '../types.js';
+import * as lazy from './lazy.js';
+const OPS = bscript.OPS;
+const P2OP_WITNESS_VERSION = 0x10;
+const MIN_SIZE = 2;
+const MAX_SIZE = 40;
+export function p2op(a, opts) {
+    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 = a.network || BITCOIN_NETWORK;
+    const o = { 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;
+            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);
+    });
+    if (opts.validate) {
+        let prog = 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/build/psbt/psbtutils.d.ts

@@ -6,6 +6,7 @@ export declare const isP2WPKH: (script: Buffer) => boolean;
 export declare const isP2WSHScript: (script: Buffer) => boolean;
 export declare const isP2SHScript: (script: Buffer) => boolean;
 export declare const isP2TR: (script: Buffer) => boolean;
+export declare const isP2OP: (script: Buffer) => boolean;
 export declare function witnessStackToScriptWitness(witness: Buffer[]): Buffer;
 export interface UncompressedPublicKey {
     hybrid: Buffer;

package/build/psbt/psbtutils.js

@@ -11,6 +11,7 @@ import { p2wsh } from '../payments/p2wsh.js';
 import * as bscript from '../script.js';
 import { Transaction } from '../transaction.js';
 import { toXOnly } from './bip371.js';
+import { p2op } from '../payments/p2op.js';
 function isPaymentFactory(payment) {
     return (script) => {
         try {
@@ -29,6 +30,7 @@ export const isP2WPKH = isPaymentFactory(p2wpkh);
 export const isP2WSHScript = isPaymentFactory(p2wsh);
 export const isP2SHScript = isPaymentFactory(p2sh);
 export const isP2TR = isPaymentFactory(p2tr);
+export const isP2OP = isPaymentFactory(p2op);
 export function witnessStackToScriptWitness(witness) {
     let buffer = Buffer.allocUnsafe(0);
     function writeSlice(slice) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/bitcoin",
     "type": "module",
-    "version": "6.4.1",
+    "version": "6.4.2",
     "description": "Client-side Bitcoin JavaScript library",
     "engines": {
         "node": ">=16.0.0"

package/src/address.ts

@@ -257,14 +257,11 @@ export function toOutputScript(address: string, network?: Network): Buffer {
                     return payments.p2tr({ pubkey: decodeBech32.data }).output as Buffer;
             } else if (decodeBech32.version === FUTURE_OPNET_VERSION) {
                 if (!network.bech32Opnet) throw new Error(address + ' has an invalid prefix');
-                if (
-                    decodeBech32.data.length < FUTURE_SEGWIT_MIN_SIZE ||
-                    decodeBech32.data.length > FUTURE_SEGWIT_MAX_SIZE
-                ) {
-                    throw new Error('Invalid program length for opnet address');
-                }
-
-                return bscript.compile([opcodes.OP_16, decodeBech32.data]);
+                return payments.p2op({
+                    program: decodeBech32.data,
+                    deploymentVersion: decodeBech32.version,
+                    network,
+                }).output as Buffer;
             } else if (
                 decodeBech32.version >= FUTURE_SEGWIT_MIN_VERSION &&
                 decodeBech32.version <= FUTURE_SEGWIT_MAX_VERSION &&

package/src/payments/index.ts

@@ -1,62 +1,68 @@
-/**
- * Represents a payment object, which is used to create a payment.
- *
- * Supports P2PKH、P2SH、P2WPKH、P2WSH、P2TR and so on
- *
- * @packageDocumentation
- */
-
-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[];
-
-    // 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;
-
-// TODO
-// witness commitment
+/**
+ * Represents a payment object, which is used to create a payment.
+ *
+ * Supports P2PKH、P2SH、P2WPKH、P2WSH、P2TR and so on
+ *
+ * @packageDocumentation
+ */
+
+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 * from './p2op.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[];
+
+    // NEW FIELDS
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
+
+    // p2op
+    program?: Buffer;
+    deploymentVersion?: number;
+    hash160?: 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;
+
+// TODO
+// witness commitment

package/src/payments/p2op.ts

@@ -0,0 +1,136 @@
+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);
+}