@btc-vision/bitcoin 6.4.0 → 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.d.ts

@@ -8,6 +8,7 @@ export interface Bech32Result {
     prefix: string;
     data: Buffer;
 }
+export declare function toFutureOPNetAddress(output: Buffer, network: Network): string;
 export declare function fromBase58Check(address: string): Base58CheckResult;
 export declare function fromBech32(address: string): Bech32Result;
 export declare function toBase58Check(hash: Buffer, version: number): string;

package/build/address.js

@@ -1,12 +1,13 @@
 import { bech32, bech32m } from 'bech32';
 import * as bs58check from 'bs58check';
-import { payments } from './index.js';
+import { opcodes, payments } from './index.js';
 import * as networks from './networks.js';
 import * as bscript from './script.js';
 import { Hash160bit, tuple, typeforce, UInt8 } from './types.js';
 const FUTURE_SEGWIT_MAX_SIZE = 40;
 const FUTURE_SEGWIT_MIN_SIZE = 2;
-const FUTURE_SEGWIT_MAX_VERSION = 16;
+const FUTURE_SEGWIT_MAX_VERSION = 15;
+const FUTURE_MAX_VERSION = 16;
 const FUTURE_OPNET_VERSION = 16;
 const FUTURE_SEGWIT_MIN_VERSION = 2;
 const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
@@ -14,15 +15,49 @@ const FUTURE_SEGWIT_VERSION_WARNING = 'WARNING: Sending to a future segwit versi
     'End users MUST be warned carefully in the GUI and asked if they wish to proceed ' +
     'with caution. Wallets should verify the segwit version from the output of fromBech32, ' +
     'then decide when it is safe to use which version of segwit.';
+export function toFutureOPNetAddress(output, network) {
+    if (!Buffer.isBuffer(output))
+        throw new TypeError('output must be a Buffer');
+    if (!network.bech32Opnet)
+        throw new Error('Network does not support opnet');
+    const opcode = output[0];
+    let pushPos = 1, progLen;
+    if (output[1] < 0x4c) {
+        progLen = output[1];
+        pushPos = 2;
+    }
+    else if (output[1] === 0x4c) {
+        progLen = output[2];
+        pushPos = 3;
+    }
+    else {
+        throw new TypeError('Unsupported push opcode in script');
+    }
+    const program = output.subarray(pushPos, pushPos + progLen);
+    if (program.length < FUTURE_SEGWIT_MIN_SIZE || program.length > FUTURE_SEGWIT_MAX_SIZE)
+        throw new TypeError('Invalid program length for segwit address');
+    const version = opcode === opcodes.OP_0
+        ? 0
+        : opcode >= opcodes.OP_1 && opcode <= opcodes.OP_16
+            ? opcode - (opcodes.OP_1 - 1)
+            : -1;
+    if (version < FUTURE_SEGWIT_MAX_VERSION || version > FUTURE_MAX_VERSION)
+        throw new TypeError(`Invalid segwit version ${version}`);
+    const words = [version, ...bech32m.toWords(program)];
+    return bech32m.encode(network.bech32Opnet, words);
+}
 function _toFutureSegwitAddress(output, network) {
-    const data = output.slice(2);
-    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE)
+    const data = output.subarray(2);
+    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE) {
         throw new TypeError('Invalid program length for segwit address');
+    }
     const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
-    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION)
+    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION) {
         throw new TypeError('Invalid version for segwit address');
-    if (output[1] !== data.length)
-        throw new TypeError('Invalid script for segwit address');
+    }
+    if (output[1] !== data.length) {
+        throw new TypeError(`Invalid script for segwit address ${output[1]} !== ${data.length}`);
+    }
     return toBech32(data, version, network.bech32, network.bech32Opnet);
 }
 export function fromBase58Check(address) {
@@ -32,7 +67,7 @@ export function fromBase58Check(address) {
     if (payload.length > 21)
         throw new TypeError(address + ' is too long');
     const version = payload.readUInt8(0);
-    const hash = payload.slice(1);
+    const hash = payload.subarray(1);
     return { version, hash };
 }
 export function fromBech32(address) {
@@ -97,6 +132,10 @@ export function fromOutputScript(output, network) {
         return payments.p2tr({ output, network }).address;
     }
     catch (e) { }
+    try {
+        return toFutureOPNetAddress(output, network);
+    }
+    catch (e) { }
     try {
         return _toFutureSegwitAddress(output, network);
     }
@@ -137,6 +176,15 @@ export function toOutputScript(address, network) {
                 if (decodeBech32.data.length === 32)
                     return payments.p2tr({ pubkey: decodeBech32.data }).output;
             }
+            else if (decodeBech32.version === FUTURE_OPNET_VERSION) {
+                if (!network.bech32Opnet)
+                    throw new Error(address + ' has an invalid prefix');
+                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 &&
                 decodeBech32.data.length >= FUTURE_SEGWIT_MIN_SIZE &&

package/build/networks.js

@@ -1,7 +1,7 @@
 export const bitcoin = {
     messagePrefix: '\x18Bitcoin Signed Message:\n',
     bech32: 'bc',
-    bech32Opnet: 'opnet',
+    bech32Opnet: 'op',
     bip32: {
         public: 0x0488b21e,
         private: 0x0488ade4,
@@ -13,7 +13,7 @@ export const bitcoin = {
 export const regtest = {
     messagePrefix: '\x18Bitcoin Signed Message:\n',
     bech32: 'bcrt',
-    bech32Opnet: 'opreg',
+    bech32Opnet: 'opr',
     bip32: {
         public: 0x043587cf,
         private: 0x04358394,
@@ -25,7 +25,7 @@ export const regtest = {
 export const testnet = {
     messagePrefix: '\x18Bitcoin Signed Message:\n',
     bech32: 'tb',
-    bech32Opnet: 'optest',
+    bech32Opnet: 'opt',
     bip32: {
         public: 0x043587cf,
         private: 0x04358394,
@@ -61,7 +61,7 @@ export const dogecoinTestnet = {
 export const litecoin = {
     messagePrefix: '\x19Litecoin Signed Message:\n',
     bech32: 'ltc',
-    bech32Opnet: 'opltc',
+    bech32Opnet: 'opl',
     bip32: {
         public: 0x019da462,
         private: 0x019d9cfe,
@@ -73,7 +73,7 @@ export const litecoin = {
 export const litecoinTestnet = {
     messagePrefix: '\x19Litecoin Signed Message:\n',
     bech32: 'tltc',
-    bech32Opnet: 'opltct',
+    bech32Opnet: 'oplt',
     bip32: {
         public: 0x0436ef7d,
         private: 0x0436f6e1,
@@ -97,7 +97,7 @@ export const bitcoinCash = {
 export const bitcoinCashTestnet = {
     messagePrefix: '\x18Bitcoin Signed Message:\n',
     bech32: 'bchtest',
-    bech32Opnet: 'opbchtest',
+    bech32Opnet: 'opbcht',
     bip32: {
         public: 0x043587cf,
         private: 0x04358394,

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.0",
+    "version": "6.4.2",
     "description": "Client-side Bitcoin JavaScript library",
     "engines": {
         "node": ">=16.0.0"

package/src/address.ts

@@ -9,7 +9,7 @@
  */
 import { bech32, bech32m } from 'bech32';
 import * as bs58check from 'bs58check';
-import { payments } from './index.js';
+import { opcodes, payments } from './index.js';
 import * as networks from './networks.js';
 import { Network } from './networks.js';
 import * as bscript from './script.js';
@@ -35,7 +35,8 @@ export interface Bech32Result {
 
 const FUTURE_SEGWIT_MAX_SIZE: number = 40;
 const FUTURE_SEGWIT_MIN_SIZE: number = 2;
-const FUTURE_SEGWIT_MAX_VERSION: number = 16;
+const FUTURE_SEGWIT_MAX_VERSION: number = 15;
+const FUTURE_MAX_VERSION: number = 16;
 const FUTURE_OPNET_VERSION: number = 16;
 const FUTURE_SEGWIT_MIN_VERSION: number = 2;
 const FUTURE_SEGWIT_VERSION_DIFF: number = 0x50;
@@ -45,18 +46,66 @@ const FUTURE_SEGWIT_VERSION_WARNING: string =
     'with caution. Wallets should verify the segwit version from the output of fromBech32, ' +
     'then decide when it is safe to use which version of segwit.';
 
-function _toFutureSegwitAddress(output: Buffer, network: Network): string {
-    const data = output.slice(2);
+/**
+ * Encode a future Taproot-style segwit address (SegWit v2 - v16) using bech32m.
+ * Only for versions not yet assigned specific meanings (future use).
+ *
+ * @param output - Output script buffer containing the version and witness program
+ * @param network - Network object containing bech32 and optional bech32Opnet prefix
+ * @returns Bech32m-encoded future Taproot-style address
+ */
+export function toFutureOPNetAddress(output: Buffer, network: Network): string {
+    if (!Buffer.isBuffer(output)) throw new TypeError('output must be a Buffer');
+    if (!network.bech32Opnet) throw new Error('Network does not support opnet');
+
+    const opcode = output[0];
+
+    // work out where the push-data really starts
+    let pushPos = 1,
+        progLen: number;
+    if (output[1] < 0x4c) {
+        progLen = output[1];
+        pushPos = 2;
+    } else if (output[1] === 0x4c) {
+        progLen = output[2];
+        pushPos = 3;
+    } else {
+        throw new TypeError('Unsupported push opcode in script');
+    }
+
+    const program = output.subarray(pushPos, pushPos + progLen);
 
-    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE)
+    if (program.length < FUTURE_SEGWIT_MIN_SIZE || program.length > FUTURE_SEGWIT_MAX_SIZE)
         throw new TypeError('Invalid program length for segwit address');
 
-    const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
+    const version =
+        opcode === opcodes.OP_0
+            ? 0
+            : opcode >= opcodes.OP_1 && opcode <= opcodes.OP_16
+              ? opcode - (opcodes.OP_1 - 1)
+              : -1;
+
+    if (version < FUTURE_SEGWIT_MAX_VERSION || version > FUTURE_MAX_VERSION)
+        throw new TypeError(`Invalid segwit version ${version}`);
+
+    const words = [version, ...bech32m.toWords(program)];
+    return bech32m.encode(network.bech32Opnet, words);
+}
+
+function _toFutureSegwitAddress(output: Buffer, network: Network): string {
+    const data = output.subarray(2);
+    if (data.length < FUTURE_SEGWIT_MIN_SIZE || data.length > FUTURE_SEGWIT_MAX_SIZE) {
+        throw new TypeError('Invalid program length for segwit address');
+    }
 
-    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION)
+    const version = output[0] - FUTURE_SEGWIT_VERSION_DIFF;
+    if (version < FUTURE_SEGWIT_MIN_VERSION || version > FUTURE_SEGWIT_MAX_VERSION) {
         throw new TypeError('Invalid version for segwit address');
+    }
 
-    if (output[1] !== data.length) throw new TypeError('Invalid script for segwit address');
+    if (output[1] !== data.length) {
+        throw new TypeError(`Invalid script for segwit address ${output[1]} !== ${data.length}`);
+    }
 
     return toBech32(data, version, network.bech32, network.bech32Opnet);
 }
@@ -72,7 +121,7 @@ export function fromBase58Check(address: string): Base58CheckResult {
     if (payload.length > 21) throw new TypeError(address + ' is too long');
 
     const version = payload.readUInt8(0);
-    const hash = payload.slice(1);
+    const hash = payload.subarray(1);
 
     return { version, hash };
 }
@@ -159,6 +208,9 @@ export function fromOutputScript(output: Buffer, network?: Network): string {
     try {
         return payments.p2tr({ output, network }).address as string;
     } catch (e) {}
+    try {
+        return toFutureOPNetAddress(output, network);
+    } catch (e) {}
     try {
         return _toFutureSegwitAddress(output, network);
     } catch (e) {}
@@ -203,6 +255,13 @@ export function toOutputScript(address: string, network?: Network): Buffer {
             } else if (decodeBech32.version === 1) {
                 if (decodeBech32.data.length === 32)
                     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');
+                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 &&