@btc-vision/bitcoin 6.5.3 → 6.5.5

package/build/payments/p2wpkh.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 { 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;
 const EMPTY_BUFFER = Buffer.alloc(0);

package/build/payments/p2wsh.d.ts

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

package/build/payments/p2wsh.js

@@ -2,8 +2,8 @@ import { bech32 } from 'bech32';
 import * as bcrypto from '../crypto.js';
 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 { isPoint, stacksEqual, typeforce as typef, } from '../types.js';
+import { PaymentType } from './types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.opcodes;
 const EMPTY_BUFFER = Buffer.alloc(0);

package/build/payments/types.d.ts

@@ -0,0 +1,93 @@
+import type { Network } from '../networks.js';
+import type { 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/build/payments/types.js

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

package/build/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/build/psbt/bip371.js

@@ -1,12 +1,8 @@
-import { isTapleaf, isTaptree } from '../types.js';
-import { Transaction } from '../transaction.js';
 import { LEAF_VERSION_TAPSCRIPT, MAX_TAPTREE_DEPTH, rootHashFromPath, tapleafHash, tweakKey, } from '../payments/bip341.js';
 import { p2tr } from '../payments/p2tr.js';
+import { Transaction } from '../transaction.js';
+import { isTapleaf, isTaptree } from '../types.js';
 import { isP2TR, pubkeyPositionInScript, signatureBlocksAction, witnessStackToScriptWitness, } from './psbtutils.js';
-export const toXOnly = (pubKey) => {
-    const buffer = pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
-    return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
-};
 export function tapScriptFinalizer(inputIndex, input, tapLeafHashToFinalize) {
     const tapLeaf = findTapLeafToFinalize(input, inputIndex, tapLeafHashToFinalize);
     try {

package/build/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/build/psbt/psbtutils.js

@@ -1,4 +1,3 @@
-import { ProjectivePoint } from '@noble/secp256k1';
 import * as varuint from 'bip174/src/lib/converter/varint.js';
 import { hash160 } from '../crypto.js';
 import { p2ms } from '../payments/p2ms.js';
@@ -8,10 +7,10 @@ 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 { p2op } from '../payments/p2op.js';
+import { decompressPublicKey, pubkeysMatch, toXOnly } from '../pubkey.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 {
@@ -60,57 +59,6 @@ export function witnessStackToScriptWitness(witness) {
     writeVector(witness);
     return buffer;
 }
-export function decompressPublicKey(realPubKey) {
-    if (realPubKey.length === 32) {
-        return;
-    }
-    if (![33, 65].includes(realPubKey.length)) {
-        console.warn(`Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`);
-        return;
-    }
-    let point;
-    try {
-        point = ProjectivePoint.fromHex(realPubKey);
-    }
-    catch (err) {
-        throw new Error('Invalid secp256k1 public key bytes. Cannot parse.');
-    }
-    const xBuf = bigIntTo32Bytes(point.x);
-    const yBuf = bigIntTo32Bytes(point.y);
-    const isEven = point.y % 2n === 0n;
-    const prefix = isEven ? 0x06 : 0x07;
-    const hybridPubKey = Buffer.alloc(65);
-    hybridPubKey[0] = prefix;
-    xBuf.copy(hybridPubKey, 1);
-    yBuf.copy(hybridPubKey, 33);
-    const uncompressedPubKey = Buffer.concat([Buffer.from([0x04]), xBuf, yBuf]);
-    return {
-        hybrid: hybridPubKey,
-        uncompressed: uncompressedPubKey,
-    };
-}
-export function bigIntTo32Bytes(num) {
-    let hex = num.toString(16);
-    hex = hex.padStart(64, '0');
-    if (hex.length > 64) {
-        hex = hex.slice(-64);
-    }
-    return Buffer.from(hex, 'hex');
-}
-export function pubkeysMatch(a, b) {
-    if (a.equals(b))
-        return true;
-    if (a.length === 65 && b.length === 65) {
-        const aCopy = Buffer.from(a);
-        const bCopy = Buffer.from(b);
-        if (aCopy[0] === 0x06 || aCopy[0] === 0x07)
-            aCopy[0] = 0x04;
-        if (bCopy[0] === 0x06 || bCopy[0] === 0x07)
-            bCopy[0] = 0x04;
-        return aCopy.equals(bCopy);
-    }
-    return false;
-}
 export function pubkeyPositionInScript(pubkey, script) {
     const decompiled = bscript.decompile(script);
     if (decompiled === null)

package/build/psbt.js

@@ -4,10 +4,11 @@ const varuintDecode = varuint.decode;
 import { checkForInput, checkForOutput } from 'bip174/src/lib/utils.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';
+import * as payments from './payments/index.js';
 import { tapleafHash } from './payments/bip341.js';
-import { checkTaprootInputFields, checkTaprootInputForSigs, checkTaprootOutputFields, isTaprootInput, serializeTaprootSignature, tapScriptFinalizer, toXOnly, } from './psbt/bip371.js';
+import { checkTaprootInputFields, checkTaprootInputForSigs, checkTaprootOutputFields, isTaprootInput, serializeTaprootSignature, tapScriptFinalizer, } from './psbt/bip371.js';
+import { toXOnly } from './pubkey.js';
 import { checkInputForSig, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, pubkeyInScript, witnessStackToScriptWitness, } from './psbt/psbtutils.js';
 import * as bscript from './script.js';
 import { Transaction } from './transaction.js';

package/build/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/build/pubkey.js

@@ -0,0 +1,56 @@
+import { ProjectivePoint } from '@noble/secp256k1';
+export const toXOnly = (pubKey) => {
+    const buffer = pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
+    return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+};
+export function bigIntTo32Bytes(num) {
+    let hex = num.toString(16);
+    hex = hex.padStart(64, '0');
+    if (hex.length > 64) {
+        hex = hex.slice(-64);
+    }
+    return Buffer.from(hex, 'hex');
+}
+export function decompressPublicKey(realPubKey) {
+    if (realPubKey.length === 32) {
+        return;
+    }
+    if (![33, 65].includes(realPubKey.length)) {
+        console.warn(`Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`);
+        return;
+    }
+    let point;
+    try {
+        point = ProjectivePoint.fromHex(realPubKey);
+    }
+    catch (err) {
+        throw new Error('Invalid secp256k1 public key bytes. Cannot parse.');
+    }
+    const xBuf = bigIntTo32Bytes(point.x);
+    const yBuf = bigIntTo32Bytes(point.y);
+    const isEven = point.y % 2n === 0n;
+    const prefix = isEven ? 0x06 : 0x07;
+    const hybridPubKey = Buffer.alloc(65);
+    hybridPubKey[0] = prefix;
+    xBuf.copy(hybridPubKey, 1);
+    yBuf.copy(hybridPubKey, 33);
+    const uncompressedPubKey = Buffer.concat([Buffer.from([0x04]), xBuf, yBuf]);
+    return {
+        hybrid: hybridPubKey,
+        uncompressed: uncompressedPubKey,
+    };
+}
+export function pubkeysMatch(a, b) {
+    if (a.equals(b))
+        return true;
+    if (a.length === 65 && b.length === 65) {
+        const aCopy = Buffer.from(a);
+        const bCopy = Buffer.from(b);
+        if (aCopy[0] === 0x06 || aCopy[0] === 0x07)
+            aCopy[0] = 0x04;
+        if (bCopy[0] === 0x06 || bCopy[0] === 0x07)
+            bCopy[0] = 0x04;
+        return aCopy.equals(bCopy);
+    }
+    return false;
+}

package/build/script.d.ts

@@ -1,7 +1,7 @@
 import { opcodes } from './opcodes.js';
-import { Stack } from './payments/index.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
+import type { Stack } from './types.js';
 export { opcodes };
 export declare function isPushOnly(value: Stack): boolean;
 export declare function countNonPushOnlyOPs(value: Stack): number;
@@ -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/build/script.js

@@ -152,10 +152,7 @@ export function toStack(chunks) {
 export function isCanonicalPubKey(buffer) {
     return types.isPoint(buffer);
 }
-export function isDefinedHashType(hashType) {
-    const hashTypeMod = hashType & ~0x80;
-    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
-}
+import { isDefinedHashType } from './script_signature.js';
 export function isCanonicalScriptSignature(buffer) {
     if (!Buffer.isBuffer(buffer))
         return false;

package/build/script_signature.d.ts

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

package/build/script_signature.js

@@ -1,8 +1,11 @@
 import * as bip66 from './bip66.js';
-import { isDefinedHashType } from './script.js';
 import * as types from './types.js';
 const { typeforce } = types;
 const ZERO = Buffer.alloc(1, 0);
+export function isDefinedHashType(hashType) {
+    const hashTypeMod = hashType & ~0x80;
+    return hashTypeMod > 0x00 && hashTypeMod < 0x04;
+}
 function toDER(x) {
     let i = 0;
     while (x[i] === 0)