@btc-vision/bitcoin 6.4.5 → 6.4.6

package/browser/psbt.d.ts

@@ -155,11 +155,11 @@ type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, i
 type FinalTaprootScriptsFunc = (inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer) => {
     finalScriptWitness: Buffer | undefined;
 };
-export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean): {
+export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean, solution?: Buffer[]): {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };
-export declare function prepareFinalScripts(script: Buffer, scriptType: string, partialSig: PartialSig[], isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean): {
+export declare function prepareFinalScripts(script: Buffer, scriptType: string, partialSig: PartialSig[], isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, solution?: Buffer[]): {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };

package/build/address.d.ts

@@ -8,7 +8,16 @@ export interface Bech32Result {
     prefix: string;
     data: Buffer;
 }
+export declare const FUTURE_SEGWIT_MAX_SIZE: number;
+export declare const FUTURE_SEGWIT_MIN_SIZE: number;
+export declare const FUTURE_SEGWIT_MAX_VERSION: number;
+export declare const FUTURE_MAX_VERSION: number;
+export declare const FUTURE_OPNET_VERSION: number;
+export declare const FUTURE_SEGWIT_MIN_VERSION: number;
+export declare const FUTURE_SEGWIT_VERSION_DIFF: number;
+export declare const isUnknownSegwitVersion: (output: Buffer) => boolean;
 export declare function toFutureOPNetAddress(output: Buffer, network: Network): string;
+export declare function _toFutureSegwitAddress(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

@@ -4,17 +4,34 @@ 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 = 15;
-const FUTURE_MAX_VERSION = 16;
-const FUTURE_OPNET_VERSION = 16;
-const FUTURE_SEGWIT_MIN_VERSION = 2;
-const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
+export const FUTURE_SEGWIT_MAX_SIZE = 40;
+export const FUTURE_SEGWIT_MIN_SIZE = 2;
+export const FUTURE_SEGWIT_MAX_VERSION = 15;
+export const FUTURE_MAX_VERSION = 16;
+export const FUTURE_OPNET_VERSION = 16;
+export const FUTURE_SEGWIT_MIN_VERSION = 2;
+export const FUTURE_SEGWIT_VERSION_DIFF = 0x50;
 const FUTURE_SEGWIT_VERSION_WARNING = 'WARNING: Sending to a future segwit version address can lead to loss of funds. ' +
     '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 const isUnknownSegwitVersion = (output) => {
+    try {
+        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 + 1) {
+            throw new TypeError('Invalid version for segwit address');
+        }
+        if (version === 1)
+            throw new TypeError('taproot');
+        return true;
+    }
+    catch (e) { }
+    return false;
+};
 export function toFutureOPNetAddress(output, network) {
     if (!Buffer.isBuffer(output))
         throw new TypeError('output must be a Buffer');
@@ -46,7 +63,7 @@ export function toFutureOPNetAddress(output, network) {
     const words = [version, ...bech32m.toWords(program)];
     return bech32m.encode(network.bech32Opnet, words);
 }
-function _toFutureSegwitAddress(output, network) {
+export function _toFutureSegwitAddress(output, network) {
     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');

package/build/psbt.d.ts

@@ -155,11 +155,11 @@ type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, i
 type FinalTaprootScriptsFunc = (inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer) => {
     finalScriptWitness: Buffer | undefined;
 };
-export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean): {
+export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean, solution?: Buffer[]): {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };
-export declare function prepareFinalScripts(script: Buffer, scriptType: string, partialSig: PartialSig[], isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean): {
+export declare function prepareFinalScripts(script: Buffer, scriptType: string, partialSig: PartialSig[], isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, solution?: Buffer[]): {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };

package/build/psbt.js

@@ -1,7 +1,7 @@
 import { Psbt as PsbtBase } from 'bip174';
 import * as varuint from 'bip174/src/lib/converter/varint.js';
 import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.js';
-import { fromOutputScript, toOutputScript } from './address.js';
+import { fromOutputScript, isUnknownSegwitVersion, toOutputScript } from './address.js';
 import { cloneBuffer, reverseBuffer } from './bufferutils.js';
 import { payments } from './index.js';
 import { bitcoin as btcNetwork } from './networks.js';
@@ -818,14 +818,14 @@ function getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
     else if (key === '__FEE')
         return c.__FEE;
 }
-export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true) {
+export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true, solution) {
     const scriptType = classifyScript(script);
     if (!canFinalize(input, script, scriptType) && canRunChecks) {
         throw new Error(`Can not finalize input #${inputIndex}`);
     }
-    return prepareFinalScripts(script, scriptType, input.partialSig, isSegwit, isP2SH, isP2WSH);
+    return prepareFinalScripts(script, scriptType, input.partialSig, isSegwit, isP2SH, isP2WSH, solution);
 }
-export function prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH) {
+export function prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH, solution) {
     let finalScriptSig;
     let finalScriptWitness;
     const payment = getPayment(script, scriptType, partialSig);
@@ -835,19 +835,28 @@ export function prepareFinalScripts(script, scriptType, partialSig, isSegwit, is
         if (p2wsh) {
             finalScriptWitness = witnessStackToScriptWitness(p2wsh.witness);
         }
-        else {
+        else if (payment) {
             finalScriptWitness = witnessStackToScriptWitness(payment.witness);
         }
+        else {
+            finalScriptWitness = witnessStackToScriptWitness(solution ?? [Buffer.from([0x00])]);
+        }
         if (p2sh) {
-            finalScriptSig = p2sh.input;
+            finalScriptSig = p2sh?.input;
         }
     }
     else {
         if (p2sh) {
-            finalScriptSig = p2sh.input;
+            finalScriptSig = p2sh?.input;
         }
         else {
-            finalScriptSig = payment.input;
+            if (!payment) {
+                finalScriptSig =
+                    Array.isArray(solution) && solution[0] ? solution[0] : Buffer.from([0x01]);
+            }
+            else {
+                finalScriptSig = payment.input;
+            }
         }
     }
     return {
@@ -1043,6 +1052,15 @@ function getScriptFromInput(inputIndex, input, cache) {
     if (input.witnessScript || isP2WPKH(res.script)) {
         res.isSegwit = true;
     }
+    else {
+        try {
+            const output = res.script;
+            if (!output)
+                throw new TypeError('Invalid script for segwit address');
+            res.isSegwit = isUnknownSegwitVersion(output);
+        }
+        catch (e) { }
+    }
     return res;
 }
 function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
@@ -1167,7 +1185,7 @@ function inputFinalizeGetAmts(inputs, tx, cache, mustFinalize, disableOutputChec
     const fee = inputAmount - outputAmount;
     if (!disableOutputChecks) {
         if (fee < 0) {
-            throw new Error('Outputs are spending more than Inputs');
+            throw new Error(`Outputs are spending more than Inputs ${inputAmount} < ${outputAmount}`);
         }
     }
     const bytes = tx.virtualSize();

package/package.json

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

package/src/address.ts

@@ -33,19 +33,39 @@ export interface Bech32Result {
     data: Buffer;
 }
 
-const FUTURE_SEGWIT_MAX_SIZE: number = 40;
-const FUTURE_SEGWIT_MIN_SIZE: number = 2;
-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;
+export const FUTURE_SEGWIT_MAX_SIZE: number = 40;
+export const FUTURE_SEGWIT_MIN_SIZE: number = 2;
+export const FUTURE_SEGWIT_MAX_VERSION: number = 15;
+export const FUTURE_MAX_VERSION: number = 16;
+export const FUTURE_OPNET_VERSION: number = 16;
+export const FUTURE_SEGWIT_MIN_VERSION: number = 2;
+export const FUTURE_SEGWIT_VERSION_DIFF: number = 0x50;
 const FUTURE_SEGWIT_VERSION_WARNING: string =
     'WARNING: Sending to a future segwit version address can lead to loss of funds. ' +
     '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 const isUnknownSegwitVersion = (output: Buffer): boolean => {
+    try {
+        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 + 1) {
+            throw new TypeError('Invalid version for segwit address');
+        }
+
+        if (version === 1) throw new TypeError('taproot');
+
+        return true;
+    } catch (e) {}
+
+    return false;
+};
+
 /**
  * Encode a future Taproot-style segwit address (SegWit v2 - v16) using bech32m.
  * Only for versions not yet assigned specific meanings (future use).
@@ -92,7 +112,7 @@ export function toFutureOPNetAddress(output: Buffer, network: Network): string {
     return bech32m.encode(network.bech32Opnet, words);
 }
 
-function _toFutureSegwitAddress(output: Buffer, network: Network): string {
+export 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');

package/src/payments/p2op.ts

@@ -1,195 +1,195 @@
-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, PaymentType } 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: PaymentType.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 &&
-        (typeof a.deploymentVersion === 'undefined' || !a.hash160)
-    ) {
-        throw new TypeError('At least one of address, output or program must be provided');
-    }
-
-    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 makeProgramFromParts = (): Buffer | undefined => {
-        if (typeof a.deploymentVersion !== 'undefined' && typeof a.hash160 !== 'undefined') {
-            if (a.hash160.length !== 20) throw new TypeError('hash160 must be exactly 20 bytes');
-            if (a.deploymentVersion < 0 || a.deploymentVersion > 0xff)
-                throw new TypeError('deploymentVersion must fit in one byte');
-            return Buffer.concat([Buffer.of(a.deploymentVersion), a.hash160]);
-        }
-        return undefined;
-    };
-
-    const _address = lazy.value(() => fromBech32(a.address!));
-
-    const network: Network = a.network || BITCOIN_NETWORK;
-    const o: P2OPPayment = {
-        name: PaymentType.P2OP,
-        network,
-        deploymentVersion: 0,
-    };
-
-    lazy.prop(o, 'program', () => {
-        if (a.program) return a.program;
-
-        // NEW: build from deploymentVersion+hash160
-        const fromParts = makeProgramFromParts();
-        if (fromParts) return fromParts;
-
-        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 (!prog.length && a.deploymentVersion !== undefined && a.hash160) {
-            prog = makeProgramFromParts()!;
-        }
-
-        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. Was ${prog.length} 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, PaymentType } 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: PaymentType.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 &&
+        (typeof a.deploymentVersion === 'undefined' || !a.hash160)
+    ) {
+        throw new TypeError('At least one of address, output or program must be provided');
+    }
+
+    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 makeProgramFromParts = (): Buffer | undefined => {
+        if (typeof a.deploymentVersion !== 'undefined' && typeof a.hash160 !== 'undefined') {
+            if (a.hash160.length !== 20) throw new TypeError('hash160 must be exactly 20 bytes');
+            if (a.deploymentVersion < 0 || a.deploymentVersion > 0xff)
+                throw new TypeError('deploymentVersion must fit in one byte');
+            return Buffer.concat([Buffer.of(a.deploymentVersion), a.hash160]);
+        }
+        return undefined;
+    };
+
+    const _address = lazy.value(() => fromBech32(a.address!));
+
+    const network: Network = a.network || BITCOIN_NETWORK;
+    const o: P2OPPayment = {
+        name: PaymentType.P2OP,
+        network,
+        deploymentVersion: 0,
+    };
+
+    lazy.prop(o, 'program', () => {
+        if (a.program) return a.program;
+
+        // NEW: build from deploymentVersion+hash160
+        const fromParts = makeProgramFromParts();
+        if (fromParts) return fromParts;
+
+        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 (!prog.length && a.deploymentVersion !== undefined && a.hash160) {
+            prog = makeProgramFromParts()!;
+        }
+
+        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. Was ${prog.length} 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);
+}