@btc-vision/bitcoin 6.4.1 → 6.4.3

package/browser/payments/embed.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2data(a: Payment, opts?: PaymentOpts): Payment;
+import { EmbedPayment, PaymentOpts } from './index.js';
+export declare function p2data(a: Omit<EmbedPayment, 'name'>, opts?: PaymentOpts): EmbedPayment;

package/browser/payments/index.d.ts

@@ -10,30 +10,79 @@ export * from './p2sh.js';
 export * from './p2tr.js';
 export * from './p2wpkh.js';
 export * from './p2wsh.js';
-export interface Payment {
+export * from './p2op.js';
+export interface BasePayment {
     name?: string;
     network?: Network;
     output?: Buffer;
-    data?: Buffer[];
+    input?: Buffer;
+    address?: string;
+    witness?: Buffer[];
+    redeem?: ScriptRedeem;
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
+}
+export interface ScriptRedeem extends BasePayment {
+    output?: Buffer;
+    redeemVersion?: number;
+    network?: Network;
+}
+export interface P2PKPayment extends BasePayment {
+    name: 'p2pk';
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2PKHPayment extends BasePayment {
+    name: 'p2pkh';
+    hash?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2SHPayment extends BasePayment {
+    name: 'p2sh';
+    hash?: Buffer;
+    signatures?: Buffer[];
+}
+export interface P2MSPayment extends BasePayment {
+    name: 'p2ms';
     m?: number;
     n?: number;
     pubkeys?: Buffer[];
-    input?: Buffer;
     signatures?: Buffer[];
-    internalPubkey?: Buffer;
+}
+export interface P2WPKHPayment extends BasePayment {
+    name: 'p2wpkh';
+    hash?: Buffer;
     pubkey?: Buffer;
     signature?: Buffer;
-    address?: string;
+}
+export interface P2WSHPayment extends BasePayment {
+    name: 'p2wsh';
+    hash?: Buffer;
+    redeem?: ScriptRedeem;
+}
+export interface P2TRPayment extends BasePayment {
+    name: 'p2tr';
+    pubkey?: Buffer;
+    internalPubkey?: Buffer;
     hash?: Buffer;
-    redeem?: Payment;
-    redeemVersion?: number;
     scriptTree?: Taptree;
-    witness?: Buffer[];
-    useHybrid?: boolean;
-    useUncompressed?: boolean;
+    signature?: Buffer;
+    redeemVersion?: number;
+    redeem?: ScriptRedeem;
+}
+export interface P2OPPayment extends BasePayment {
+    name: 'p2op';
+    program?: Buffer;
+    deploymentVersion: number | undefined;
+    hash160?: Buffer;
+}
+export interface EmbedPayment extends BasePayment {
+    name: 'embed';
+    data: Buffer[];
 }
-export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
-export type PaymentFunction = () => Payment;
+export type Payment = P2PKPayment | P2PKHPayment | P2SHPayment | P2MSPayment | P2WPKHPayment | P2WSHPayment | P2TRPayment | P2OPPayment | EmbedPayment | ScriptRedeem;
+export type PaymentCreator = <T extends BasePayment>(a: T, opts?: PaymentOpts) => T;
 export interface PaymentOpts {
     validate?: boolean;
     allowIncomplete?: boolean;

package/browser/payments/lazy.d.ts

@@ -1,2 +1,2 @@
-export declare function prop(object: {}, name: string, f: () => any): void;
+export declare function prop<T extends {}>(object: T, name: string, f: () => T[keyof T]): void;
 export declare function value<T>(f: () => T): () => T;

package/browser/payments/p2ms.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2ms(a: Payment, opts?: PaymentOpts): Payment;
+import { P2MSPayment, PaymentOpts } from './index.js';
+export declare function p2ms(a: Omit<P2MSPayment, 'name'>, opts?: PaymentOpts): P2MSPayment;

package/browser/payments/p2op.d.ts

@@ -0,0 +1,25 @@
+import { BasePayment, P2OPPayment, PaymentOpts } from './index.js';
+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;
+export declare function p2op(a: Omit<P2OPPaymentParams, 'name'>, opts?: PaymentOpts): P2OPPayment;
+export {};

package/browser/payments/p2pk.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2pk(a: Payment, opts?: PaymentOpts): Payment;
+import { P2PKPayment, PaymentOpts } from './index.js';
+export declare function p2pk(a: Omit<P2PKPayment, 'name'>, opts?: PaymentOpts): P2PKPayment;

package/browser/payments/p2pkh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2pkh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2PKHPayment, PaymentOpts } from './index.js';
+export declare function p2pkh(a: Omit<P2PKHPayment, 'name'>, opts?: PaymentOpts): P2PKHPayment;

package/browser/payments/p2sh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2sh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2SHPayment, PaymentOpts } from './index.js';
+export declare function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPayment;

package/browser/payments/p2tr.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2tr(a: Payment, opts?: PaymentOpts): Payment;
+import { P2TRPayment, PaymentOpts } from './index.js';
+export declare function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPayment;

package/browser/payments/p2wpkh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2wpkh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2WPKHPayment, PaymentOpts } from './index.js';
+export declare function p2wpkh(a: Omit<P2WPKHPayment, 'name'>, opts?: PaymentOpts): P2WPKHPayment;

package/browser/payments/p2wsh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2wsh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2WSHPayment, PaymentOpts } from './index.js';
+export declare function p2wsh(a: Omit<P2WSHPayment, 'name'>, opts?: PaymentOpts): P2WSHPayment;

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,10 @@ 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,
+                    network,
+                }).output;
             }
             else if (decodeBech32.version >= FUTURE_SEGWIT_MIN_VERSION &&
                 decodeBech32.version <= FUTURE_SEGWIT_MAX_VERSION &&

package/build/payments/embed.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2data(a: Payment, opts?: PaymentOpts): Payment;
+import { EmbedPayment, PaymentOpts } from './index.js';
+export declare function p2data(a: Omit<EmbedPayment, 'name'>, opts?: PaymentOpts): EmbedPayment;

package/build/payments/embed.js

@@ -13,7 +13,7 @@ export function p2data(a, opts) {
         data: typef.maybe(typef.arrayOf(typef.Buffer)),
     }, a);
     const network = a.network || BITCOIN_NETWORK;
-    const o = { name: 'embed', network };
+    const o = { name: 'embed', network, data: [] };
     lazy.prop(o, 'output', () => {
         if (!a.data)
             return;
@@ -22,7 +22,11 @@ export function p2data(a, opts) {
     lazy.prop(o, 'data', () => {
         if (!a.output)
             return;
-        return bscript.decompile(a.output).slice(1);
+        const script = bscript.decompile(a.output);
+        if (script === null || script === undefined) {
+            return;
+        }
+        return script.slice(1);
     });
     if (opts.validate) {
         if (a.output) {

package/build/payments/index.d.ts

@@ -10,30 +10,79 @@ export * from './p2sh.js';
 export * from './p2tr.js';
 export * from './p2wpkh.js';
 export * from './p2wsh.js';
-export interface Payment {
+export * from './p2op.js';
+export interface BasePayment {
     name?: string;
     network?: Network;
     output?: Buffer;
-    data?: Buffer[];
+    input?: Buffer;
+    address?: string;
+    witness?: Buffer[];
+    redeem?: ScriptRedeem;
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
+}
+export interface ScriptRedeem extends BasePayment {
+    output?: Buffer;
+    redeemVersion?: number;
+    network?: Network;
+}
+export interface P2PKPayment extends BasePayment {
+    name: 'p2pk';
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2PKHPayment extends BasePayment {
+    name: 'p2pkh';
+    hash?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2SHPayment extends BasePayment {
+    name: 'p2sh';
+    hash?: Buffer;
+    signatures?: Buffer[];
+}
+export interface P2MSPayment extends BasePayment {
+    name: 'p2ms';
     m?: number;
     n?: number;
     pubkeys?: Buffer[];
-    input?: Buffer;
     signatures?: Buffer[];
-    internalPubkey?: Buffer;
+}
+export interface P2WPKHPayment extends BasePayment {
+    name: 'p2wpkh';
+    hash?: Buffer;
     pubkey?: Buffer;
     signature?: Buffer;
-    address?: string;
+}
+export interface P2WSHPayment extends BasePayment {
+    name: 'p2wsh';
+    hash?: Buffer;
+    redeem?: ScriptRedeem;
+}
+export interface P2TRPayment extends BasePayment {
+    name: 'p2tr';
+    pubkey?: Buffer;
+    internalPubkey?: Buffer;
     hash?: Buffer;
-    redeem?: Payment;
-    redeemVersion?: number;
     scriptTree?: Taptree;
-    witness?: Buffer[];
-    useHybrid?: boolean;
-    useUncompressed?: boolean;
+    signature?: Buffer;
+    redeemVersion?: number;
+    redeem?: ScriptRedeem;
+}
+export interface P2OPPayment extends BasePayment {
+    name: 'p2op';
+    program?: Buffer;
+    deploymentVersion: number | undefined;
+    hash160?: Buffer;
+}
+export interface EmbedPayment extends BasePayment {
+    name: 'embed';
+    data: Buffer[];
 }
-export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
-export type PaymentFunction = () => Payment;
+export type Payment = P2PKPayment | P2PKHPayment | P2SHPayment | P2MSPayment | P2WPKHPayment | P2WSHPayment | P2TRPayment | P2OPPayment | EmbedPayment | ScriptRedeem;
+export type PaymentCreator = <T extends BasePayment>(a: T, opts?: PaymentOpts) => T;
 export interface PaymentOpts {
     validate?: boolean;
     allowIncomplete?: boolean;

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/lazy.d.ts

@@ -1,2 +1,2 @@
-export declare function prop(object: {}, name: string, f: () => any): void;
+export declare function prop<T extends {}>(object: T, name: string, f: () => T[keyof T]): void;
 export declare function value<T>(f: () => T): () => T;

package/build/payments/p2ms.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2ms(a: Payment, opts?: PaymentOpts): Payment;
+import { P2MSPayment, PaymentOpts } from './index.js';
+export declare function p2ms(a: Omit<P2MSPayment, 'name'>, opts?: PaymentOpts): P2MSPayment;

package/build/payments/p2ms.js

@@ -22,7 +22,10 @@ export function p2ms(a, opts) {
         input: typef.maybe(typef.Buffer),
     }, a);
     const network = a.network || BITCOIN_NETWORK;
-    const o = { network };
+    const o = {
+        network,
+        name: 'p2ms',
+    };
     let chunks = [];
     let decoded = false;
     function decode(output) {
@@ -63,7 +66,10 @@ export function p2ms(a, opts) {
     lazy.prop(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);
     });
     lazy.prop(o, 'input', () => {
         if (!a.signatures)

package/build/payments/p2op.d.ts

@@ -0,0 +1,25 @@
+import { BasePayment, P2OPPayment, PaymentOpts } from './index.js';
+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;
+export declare function p2op(a: Omit<P2OPPaymentParams, 'name'>, opts?: PaymentOpts): P2OPPayment;
+export {};

package/build/payments/p2op.js

@@ -0,0 +1,112 @@
+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,
+        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;
+            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/payments/p2pk.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2pk(a: Payment, opts?: PaymentOpts): Payment;
+import { P2PKPayment, PaymentOpts } from './index.js';
+export declare function p2pk(a: Omit<P2PKPayment, 'name'>, opts?: PaymentOpts): P2PKPayment;

package/build/payments/p2pk.js

@@ -18,7 +18,11 @@ export function p2pk(a, opts) {
         return bscript.decompile(a.input);
     });
     const network = a.network || BITCOIN_NETWORK;
-    const o = { name: 'p2pk', network };
+    const o = {
+        name: 'p2pk',
+        network,
+        pubkey: undefined,
+    };
     lazy.prop(o, 'output', () => {
         if (!a.pubkey)
             return;

package/build/payments/p2pkh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2pkh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2PKHPayment, PaymentOpts } from './index.js';
+export declare function p2pkh(a: Omit<P2PKHPayment, 'name'>, opts?: PaymentOpts): P2PKHPayment;

package/build/payments/p2pkh.js

@@ -30,7 +30,11 @@ export function p2pkh(a, opts) {
         return bscript.decompile(a.input);
     });
     const network = a.network || BITCOIN_NETWORK;
-    const o = { name: 'p2pkh', network };
+    const o = {
+        name: 'p2pkh',
+        network,
+        hash: undefined,
+    };
     lazy.prop(o, 'address', () => {
         if (!o.hash)
             return;

package/build/payments/p2sh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2sh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2SHPayment, PaymentOpts } from './index.js';
+export declare function p2sh(a: Omit<P2SHPayment, 'name'>, opts?: PaymentOpts): P2SHPayment;

package/build/payments/p2sh.js

@@ -28,7 +28,11 @@ export function p2sh(a, opts) {
     if (!network) {
         network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
     }
-    const o = { network };
+    const o = {
+        network,
+        name: 'p2sh',
+        hash: undefined,
+    };
     const _address = lazy.value(() => {
         const payload = Buffer.from(bs58check.default.decode(a.address));
         const version = payload.readUInt8(0);

package/build/payments/p2tr.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2tr(a: Payment, opts?: PaymentOpts): Payment;
+import { P2TRPayment, PaymentOpts } from './index.js';
+export declare function p2tr(a: Omit<P2TRPayment, 'name'>, opts?: PaymentOpts): P2TRPayment;

package/build/payments/p2tr.js

@@ -55,7 +55,10 @@ export function p2tr(a, opts) {
         return;
     });
     const network = a.network || BITCOIN_NETWORK;
-    const o = { name: 'p2tr', network };
+    const o = {
+        name: 'p2tr',
+        network,
+    };
     lazy.prop(o, 'address', () => {
         if (!o.pubkey)
             return;
@@ -78,7 +81,7 @@ export function p2tr(a, opts) {
             });
             return rootHashFromPath(controlBlock, leafHash);
         }
-        return null;
+        return undefined;
     });
     lazy.prop(o, 'output', () => {
         if (!o.pubkey)

package/build/payments/p2wpkh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2wpkh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2WPKHPayment, PaymentOpts } from './index.js';
+export declare function p2wpkh(a: Omit<P2WPKHPayment, 'name'>, opts?: PaymentOpts): P2WPKHPayment;

package/build/payments/p2wpkh.js

@@ -31,7 +31,11 @@ export function p2wpkh(a, opts) {
         };
     });
     const network = a.network || BITCOIN_NETWORK;
-    const o = { name: 'p2wpkh', network };
+    const o = {
+        name: 'p2wpkh',
+        network,
+        hash: undefined,
+    };
     lazy.prop(o, 'address', () => {
         if (!o.hash)
             return;

package/build/payments/p2wsh.d.ts

@@ -1,2 +1,2 @@
-import { Payment, PaymentOpts } from './index.js';
-export declare function p2wsh(a: Payment, opts?: PaymentOpts): Payment;
+import { P2WSHPayment, PaymentOpts } from './index.js';
+export declare function p2wsh(a: Omit<P2WSHPayment, 'name'>, opts?: PaymentOpts): P2WSHPayment;

package/build/payments/p2wsh.js

@@ -49,7 +49,11 @@ export function p2wsh(a, opts) {
     if (!network) {
         network = (a.redeem && a.redeem.network) || BITCOIN_NETWORK;
     }
-    const o = { network };
+    const o = {
+        network,
+        name: 'p2wsh',
+        hash: undefined,
+    };
     lazy.prop(o, 'address', () => {
         if (!o.hash)
             return;

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;