@btc-vision/bitcoin 6.5.3 → 6.5.5

package/browser/payments/types.d.ts

@@ -0,0 +1,93 @@
+import { Network } from '../networks.js';
+import { Taptree } from '../types.js';
+export declare enum PaymentType {
+    P2PK = "p2pk",
+    P2PKH = "p2pkh",
+    P2SH = "p2sh",
+    P2MS = "p2ms",
+    P2WPKH = "p2wpkh",
+    P2WSH = "p2wsh",
+    P2TR = "p2tr",
+    P2OP = "p2op",
+    Embed = "embed",
+    ScriptRedeem = "scriptRedeem"
+}
+export interface BasePayment {
+    name?: PaymentType;
+    network?: Network;
+    output?: 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: PaymentType.P2PK;
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2PKHPayment extends BasePayment {
+    name: PaymentType.P2PKH;
+    hash?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2SHPayment extends BasePayment {
+    name: PaymentType.P2SH;
+    hash?: Buffer;
+    signatures?: Buffer[];
+}
+export interface P2MSPayment extends BasePayment {
+    name: PaymentType.P2MS;
+    m?: number;
+    n?: number;
+    pubkeys?: Buffer[];
+    signatures?: Buffer[];
+}
+export interface P2WPKHPayment extends BasePayment {
+    name: PaymentType.P2WPKH;
+    hash?: Buffer;
+    pubkey?: Buffer;
+    signature?: Buffer;
+}
+export interface P2WSHPayment extends BasePayment {
+    name: PaymentType.P2WSH;
+    hash?: Buffer;
+    redeem?: ScriptRedeem;
+}
+export interface P2TRPayment extends BasePayment {
+    name: PaymentType.P2TR;
+    pubkey?: Buffer;
+    internalPubkey?: Buffer;
+    hash?: Buffer;
+    scriptTree?: Taptree;
+    signature?: Buffer;
+    redeemVersion?: number;
+    redeem?: ScriptRedeem;
+}
+export interface P2OPPayment extends BasePayment {
+    name: PaymentType.P2OP;
+    program?: Buffer;
+    deploymentVersion: number | undefined;
+    hash160?: Buffer;
+}
+export interface P2OPPaymentParams extends Omit<P2OPPayment, 'name' | 'deploymentVersion'> {
+    deploymentVersion?: number;
+}
+export interface EmbedPayment extends BasePayment {
+    name: PaymentType.Embed;
+    data: Buffer[];
+}
+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/psbt/bip371.d.ts

@@ -3,7 +3,6 @@ import { Taptree } from '../types.js';
 interface PsbtOutputWithScript extends PsbtOutput {
     script?: Buffer;
 }
-export declare const toXOnly: (pubKey: Buffer | Uint8Array) => Buffer;
 export declare function tapScriptFinalizer(inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer): {
     finalScriptWitness: Buffer | undefined;
 };

package/browser/psbt/psbtutils.d.ts

@@ -9,13 +9,6 @@ export declare const isP2TR: (script: Buffer) => boolean;
 export declare const isP2OP: (script: Buffer) => boolean;
 export declare const isP2A: (script: Buffer) => boolean;
 export declare function witnessStackToScriptWitness(witness: Buffer[]): Buffer;
-export interface UncompressedPublicKey {
-    hybrid: Buffer;
-    uncompressed: Buffer;
-}
-export declare function decompressPublicKey(realPubKey: Uint8Array | Buffer): UncompressedPublicKey | undefined;
-export declare function bigIntTo32Bytes(num: bigint): Buffer;
-export declare function pubkeysMatch(a: Buffer, b: Buffer): boolean;
 export declare function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number;
 export declare function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean;
 export declare function checkInputForSig(input: PsbtInput, action: string): boolean;

package/browser/pubkey.d.ts

@@ -0,0 +1,8 @@
+export declare const toXOnly: (pubKey: Buffer | Uint8Array) => Buffer;
+export interface UncompressedPublicKey {
+    hybrid: Buffer;
+    uncompressed: Buffer;
+}
+export declare function bigIntTo32Bytes(num: bigint): Buffer;
+export declare function decompressPublicKey(realPubKey: Uint8Array | Buffer): UncompressedPublicKey | undefined;
+export declare function pubkeysMatch(a: Buffer, b: Buffer): boolean;

package/browser/script.d.ts

@@ -1,5 +1,5 @@
 import { opcodes } from './opcodes.js';
-import { Stack } from './payments/index.js';
+import { Stack } from './types.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
 export { opcodes };
@@ -11,7 +11,6 @@ export declare function toASM(chunks: Buffer | Array<number | Buffer>): string;
 export declare function fromASM(asm: string): Buffer;
 export declare function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[];
 export declare function isCanonicalPubKey(buffer: Buffer): boolean;
-export declare function isDefinedHashType(hashType: number): boolean;
 export declare function isCanonicalScriptSignature(buffer: Buffer): boolean;
 export declare const number: typeof scriptNumber;
 export declare const signature: typeof scriptSignature;

package/browser/script_signature.d.ts

@@ -1,3 +1,4 @@
+export declare function isDefinedHashType(hashType: number): boolean;
 interface ScriptSignature {
     signature: Buffer;
     hashType: number;

package/browser/types.d.ts

@@ -37,3 +37,6 @@ export declare const Function: TypeforceValidator;
 export declare const BufferN: (n: number) => TypeforceValidator;
 export declare const Null: TypeforceValidator;
 export declare const oneOf: (...types: unknown[]) => TypeforceValidator;
+export type StackElement = globalThis.Buffer | number;
+export type Stack = StackElement[];
+export type StackFunction = () => Stack;

package/build/address.d.ts

@@ -1,13 +1,10 @@
+import { fromBech32, type Bech32Result } from './bech32utils.js';
 import { Network } from './networks.js';
+export { fromBech32, type Bech32Result };
 export interface Base58CheckResult {
     hash: Buffer;
     version: number;
 }
-export interface Bech32Result {
-    version: number;
-    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;
@@ -19,7 +16,6 @@ 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;
 export declare function toBech32(data: Buffer, version: number, prefix: string, prefixOpnet?: string): string;
 export declare function fromOutputScript(output: Buffer, network?: Network): string;

package/build/address.js

@@ -1,10 +1,17 @@
 import { bech32, bech32m } from 'bech32';
 import * as bs58check from 'bs58check';
+import { fromBech32 } from './bech32utils.js';
 import * as networks from './networks.js';
+import { p2op } from './payments/p2op.js';
+import { p2pkh } from './payments/p2pkh.js';
+import { p2sh } from './payments/p2sh.js';
+import { p2tr } from './payments/p2tr.js';
+import { p2wpkh } from './payments/p2wpkh.js';
+import { p2wsh } from './payments/p2wsh.js';
 import * as bscript from './script.js';
 import { opcodes } from './script.js';
 import { Hash160bit, tuple, typeforce, UInt8 } from './types.js';
-import { payments } from './index.js';
+export { fromBech32 };
 export const FUTURE_SEGWIT_MAX_SIZE = 40;
 export const FUTURE_SEGWIT_MIN_SIZE = 2;
 export const FUTURE_SEGWIT_MAX_VERSION = 15;
@@ -88,31 +95,6 @@ export function fromBase58Check(address) {
     const hash = Buffer.from(payload.subarray(1));
     return { version, hash };
 }
-export function fromBech32(address) {
-    let result;
-    let version;
-    try {
-        result = bech32.decode(address);
-    }
-    catch (e) { }
-    if (result) {
-        version = result.words[0];
-        if (version !== 0)
-            throw new TypeError(address + ' uses wrong encoding');
-    }
-    else {
-        result = bech32m.decode(address);
-        version = result.words[0];
-        if (version === 0)
-            throw new TypeError(address + ' uses wrong encoding');
-    }
-    const data = bech32.fromWords(result.words.slice(1));
-    return {
-        version,
-        prefix: result.prefix,
-        data: Buffer.from(data),
-    };
-}
 export function toBase58Check(hash, version) {
     typeforce(tuple(Hash160bit, UInt8), [hash, version]);
     const payload = Buffer.allocUnsafe(21);
@@ -131,23 +113,23 @@ export function toBech32(data, version, prefix, prefixOpnet) {
 export function fromOutputScript(output, network) {
     network = network || networks.bitcoin;
     try {
-        return payments.p2pkh({ output, network }).address;
+        return p2pkh({ output, network }).address;
     }
     catch (e) { }
     try {
-        return payments.p2sh({ output, network }).address;
+        return p2sh({ output, network }).address;
     }
     catch (e) { }
     try {
-        return payments.p2wpkh({ output, network }).address;
+        return p2wpkh({ output, network }).address;
     }
     catch (e) { }
     try {
-        return payments.p2wsh({ output, network }).address;
+        return p2wsh({ output, network }).address;
     }
     catch (e) { }
     try {
-        return payments.p2tr({ output, network }).address;
+        return p2tr({ output, network }).address;
     }
     catch (e) { }
     try {
@@ -170,9 +152,9 @@ export function toOutputScript(address, network) {
     catch (e) { }
     if (decodeBase58) {
         if (decodeBase58.version === network.pubKeyHash)
-            return payments.p2pkh({ hash: decodeBase58.hash }).output;
+            return p2pkh({ hash: decodeBase58.hash }).output;
         if (decodeBase58.version === network.scriptHash)
-            return payments.p2sh({ hash: decodeBase58.hash }).output;
+            return p2sh({ hash: decodeBase58.hash }).output;
     }
     else {
         try {
@@ -186,18 +168,18 @@ export function toOutputScript(address, network) {
                 throw new Error(address + ' has an invalid prefix');
             if (decodeBech32.version === 0) {
                 if (decodeBech32.data.length === 20)
-                    return payments.p2wpkh({ hash: decodeBech32.data }).output;
+                    return p2wpkh({ hash: decodeBech32.data }).output;
                 if (decodeBech32.data.length === 32)
-                    return payments.p2wsh({ hash: decodeBech32.data }).output;
+                    return p2wsh({ hash: decodeBech32.data }).output;
             }
             else if (decodeBech32.version === 1) {
                 if (decodeBech32.data.length === 32)
-                    return payments.p2tr({ pubkey: decodeBech32.data }).output;
+                    return 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({
+                return p2op({
                     program: decodeBech32.data,
                     network,
                 }).output;

package/build/bech32utils.d.ts

@@ -0,0 +1,6 @@
+export interface Bech32Result {
+    version: number;
+    prefix: string;
+    data: Buffer;
+}
+export declare function fromBech32(address: string): Bech32Result;

package/build/bech32utils.js

@@ -0,0 +1,26 @@
+import { bech32, bech32m } from 'bech32';
+export function fromBech32(address) {
+    let result;
+    let version;
+    try {
+        result = bech32.decode(address);
+    }
+    catch (e) { }
+    if (result) {
+        version = result.words[0];
+        if (version !== 0)
+            throw new TypeError(address + ' uses wrong encoding');
+    }
+    else {
+        result = bech32m.decode(address);
+        version = result.words[0];
+        if (version === 0)
+            throw new TypeError(address + ' uses wrong encoding');
+    }
+    const data = bech32.fromWords(result.words.slice(1));
+    return {
+        version,
+        prefix: result.prefix,
+        data: Buffer.from(data),
+    };
+}

package/build/index.d.ts

@@ -18,7 +18,8 @@ export { Transaction } from './transaction.js';
 export type { Network } from './networks.js';
 export { initEccLib } from './ecc_lib.js';
 export { PaymentType } from './payments/index.js';
-export type { Payment, PaymentCreator, PaymentOpts, Stack, StackElement, P2WSHPayment, P2PKPayment, BasePayment, P2SHPayment, P2TRPayment, P2WPKHPayment, P2PKHPayment, P2MSPayment, EmbedPayment, P2OPPayment, P2OPPaymentParams, StackFunction, } from './payments/index.js';
+export type { Payment, PaymentCreator, PaymentOpts, P2WSHPayment, P2PKPayment, BasePayment, P2SHPayment, P2TRPayment, P2WPKHPayment, P2PKHPayment, P2MSPayment, EmbedPayment, P2OPPayment, P2OPPaymentParams, } from './payments/index.js';
+export type { Stack, StackElement, StackFunction } from './types.js';
 export type { Input as TxInput, Output as TxOutput } from './transaction.js';
 export interface PsbtInput extends _PsbtInput {
 }
@@ -47,6 +48,7 @@ export * from './address.js';
 export * from './bufferutils.js';
 export * from './payments/bip341.js';
 export * from './psbt/psbtutils.js';
+export { toXOnly, decompressPublicKey, pubkeysMatch, type UncompressedPublicKey } from './pubkey.js';
 export { TAPLEAF_VERSION_MASK } from './types.js';
 export type { Taptree, XOnlyPointAddTweakResult, Tapleaf, TinySecp256k1Interface, } from './types.js';
 declare const bitcoin: {

package/build/index.js

@@ -21,6 +21,7 @@ export * from './address.js';
 export * from './bufferutils.js';
 export * from './payments/bip341.js';
 export * from './psbt/psbtutils.js';
+export { toXOnly, decompressPublicKey, pubkeysMatch } from './pubkey.js';
 export { TAPLEAF_VERSION_MASK } from './types.js';
 const bitcoin = {
     networks,

package/build/payments/embed.d.ts

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

package/build/payments/embed.js

@@ -1,7 +1,7 @@
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { stacksEqual, typeforce as typef } from '../types.js';
-import { PaymentType } from './index.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.opcodes;
 export function p2data(a, opts) {

package/build/payments/index.d.ts

@@ -1,104 +1,12 @@
-import type { Network } from '../networks.js';
-import type { Taptree } from '../types.js';
-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 declare enum PaymentType {
-    P2PK = "p2pk",
-    P2PKH = "p2pkh",
-    P2SH = "p2sh",
-    P2MS = "p2ms",
-    P2WPKH = "p2wpkh",
-    P2WSH = "p2wsh",
-    P2TR = "p2tr",
-    P2OP = "p2op",
-    Embed = "embed",
-    ScriptRedeem = "scriptRedeem"
-}
-export interface BasePayment {
-    name?: PaymentType;
-    network?: Network;
-    output?: 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: PaymentType.P2PK;
-    pubkey?: Buffer;
-    signature?: Buffer;
-}
-export interface P2PKHPayment extends BasePayment {
-    name: PaymentType.P2PKH;
-    hash?: Buffer;
-    pubkey?: Buffer;
-    signature?: Buffer;
-}
-export interface P2SHPayment extends BasePayment {
-    name: PaymentType.P2SH;
-    hash?: Buffer;
-    signatures?: Buffer[];
-}
-export interface P2MSPayment extends BasePayment {
-    name: PaymentType.P2MS;
-    m?: number;
-    n?: number;
-    pubkeys?: Buffer[];
-    signatures?: Buffer[];
-}
-export interface P2WPKHPayment extends BasePayment {
-    name: PaymentType.P2WPKH;
-    hash?: Buffer;
-    pubkey?: Buffer;
-    signature?: Buffer;
-}
-export interface P2WSHPayment extends BasePayment {
-    name: PaymentType.P2WSH;
-    hash?: Buffer;
-    redeem?: ScriptRedeem;
-}
-export interface P2TRPayment extends BasePayment {
-    name: PaymentType.P2TR;
-    pubkey?: Buffer;
-    internalPubkey?: Buffer;
-    hash?: Buffer;
-    scriptTree?: Taptree;
-    signature?: Buffer;
-    redeemVersion?: number;
-    redeem?: ScriptRedeem;
-}
-export interface P2OPPayment extends BasePayment {
-    name: PaymentType.P2OP;
-    program?: Buffer;
-    deploymentVersion: number | undefined;
-    hash160?: Buffer;
-}
-export interface EmbedPayment extends BasePayment {
-    name: PaymentType.Embed;
-    data: Buffer[];
-}
-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;
-}
-export type StackElement = Buffer | number;
-export type Stack = StackElement[];
-export type StackFunction = () => Stack;
+export { PaymentType, type BasePayment, type ScriptRedeem, type P2PKPayment, type P2PKHPayment, type P2SHPayment, type P2MSPayment, type P2WPKHPayment, type P2WSHPayment, type P2TRPayment, type P2OPPayment, type P2OPPaymentParams, type EmbedPayment, type Payment, type PaymentCreator, type PaymentOpts, } from './types.js';
+export { p2data } from './embed.js';
+export { prop, value } from './lazy.js';
+export { p2ms } from './p2ms.js';
+export { p2pk } from './p2pk.js';
+export { p2pkh } from './p2pkh.js';
+export { p2sh } from './p2sh.js';
+export { p2tr } from './p2tr.js';
+export { p2wpkh } from './p2wpkh.js';
+export { p2wsh } from './p2wsh.js';
+export { p2op } from './p2op.js';
+export { findScriptPath, LEAF_VERSION_TAPSCRIPT, MAX_TAPTREE_DEPTH, rootHashFromPath, tapleafHash, toHashTree, tweakKey, type HashTree, } from './bip341.js';

package/build/payments/index.js

@@ -1,24 +1,12 @@
-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 var PaymentType;
-(function (PaymentType) {
-    PaymentType["P2PK"] = "p2pk";
-    PaymentType["P2PKH"] = "p2pkh";
-    PaymentType["P2SH"] = "p2sh";
-    PaymentType["P2MS"] = "p2ms";
-    PaymentType["P2WPKH"] = "p2wpkh";
-    PaymentType["P2WSH"] = "p2wsh";
-    PaymentType["P2TR"] = "p2tr";
-    PaymentType["P2OP"] = "p2op";
-    PaymentType["Embed"] = "embed";
-    PaymentType["ScriptRedeem"] = "scriptRedeem";
-})(PaymentType || (PaymentType = {}));
+export { PaymentType, } from './types.js';
+export { p2data } from './embed.js';
+export { prop, value } from './lazy.js';
+export { p2ms } from './p2ms.js';
+export { p2pk } from './p2pk.js';
+export { p2pkh } from './p2pkh.js';
+export { p2sh } from './p2sh.js';
+export { p2tr } from './p2tr.js';
+export { p2wpkh } from './p2wpkh.js';
+export { p2wsh } from './p2wsh.js';
+export { p2op } from './p2op.js';
+export { findScriptPath, LEAF_VERSION_TAPSCRIPT, MAX_TAPTREE_DEPTH, rootHashFromPath, tapleafHash, toHashTree, tweakKey, } from './bip341.js';

package/build/payments/p2ms.d.ts

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

package/build/payments/p2ms.js

@@ -1,7 +1,7 @@
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { isPoint, stacksEqual, typeforce as typef } from '../types.js';
-import { PaymentType } from './index.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.opcodes;
 const OP_INT_BASE = OPS.OP_RESERVED;

package/build/payments/p2op.d.ts

@@ -1,4 +1,4 @@
-import { BasePayment, P2OPPayment, PaymentOpts, PaymentType } from './index.js';
+import { BasePayment, P2OPPayment, PaymentOpts, PaymentType } from './types.js';
 interface P2OPBase extends BasePayment {
     name: PaymentType.P2OP;
 }

package/build/payments/p2op.js

@@ -1,11 +1,11 @@
 import { bech32m } from 'bech32';
 import { Buffer as NBuffer } from 'buffer';
-import { fromBech32 } from '../address.js';
+import { fromBech32 } from '../bech32utils.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { typeforce as typef } from '../types.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
-import { PaymentType } from './index.js';
 const OPS = bscript.opcodes;
 const P2OP_WITNESS_VERSION = 0x10;
 const MIN_SIZE = 2;

package/build/payments/p2pk.d.ts

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

package/build/payments/p2pk.js

@@ -1,7 +1,7 @@
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { isPoint, typeforce as typef } from '../types.js';
-import { PaymentType } from './index.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.opcodes;
 export function p2pk(a, opts) {

package/build/payments/p2pkh.d.ts

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

package/build/payments/p2pkh.js

@@ -1,11 +1,11 @@
 import * as bs58check from 'bs58check';
 import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
+import { decompressPublicKey } from '../pubkey.js';
 import * as bscript from '../script.js';
 import { isPoint, typeforce as typef } from '../types.js';
-import { PaymentType } from './index.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
-import { decompressPublicKey } from '../psbt/psbtutils.js';
 const OPS = bscript.opcodes;
 export function p2pkh(a, opts) {
     if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input) {

package/build/payments/p2sh.d.ts

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

package/build/payments/p2sh.js

@@ -3,7 +3,7 @@ import * as bcrypto from '../crypto.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { stacksEqual, typeforce as typef } from '../types.js';
-import { PaymentType, } from './index.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.opcodes;
 export function p2sh(a, opts) {

package/build/payments/p2tr.d.ts

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

package/build/payments/p2tr.js

@@ -1,12 +1,12 @@
 import { bech32m } from 'bech32';
 import { Buffer as NBuffer } from 'buffer';
-import { fromBech32 } from '../address.js';
+import { fromBech32 } from '../bech32utils.js';
 import { getEccLib } from '../ecc_lib.js';
 import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { isTaptree, stacksEqual, TAPLEAF_VERSION_MASK, typeforce as typef } from '../types.js';
 import { findScriptPath, LEAF_VERSION_TAPSCRIPT, rootHashFromPath, tapleafHash, toHashTree, tweakKey, } from './bip341.js';
-import { PaymentType } from './index.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.opcodes;
 const TAPROOT_WITNESS_VERSION = 0x01;
@@ -188,10 +188,6 @@ export function p2tr(a, opts) {
             else
                 pubkey = tweakedKey.x;
         }
-        if (pubkey && pubkey.length) {
-            if (!getEccLib().isXOnlyPoint(pubkey))
-                throw new TypeError('Invalid pubkey for p2tr');
-        }
         const hashTree = _hashTree();
         if (a.hash && hashTree) {
             if (!a.hash.equals(hashTree.hash))

package/build/payments/p2wpkh.d.ts

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