@btc-vision/bitcoin 6.3.3 → 6.3.4

package/build/payments/p2pkh.js

@@ -76,11 +76,13 @@ export function p2pkh(a, opts) {
         let pubKey = a.pubkey;
         if (a.useHybrid || a.useUncompressed) {
             const decompressed = decompressPublicKey(a.pubkey);
-            if (a.useUncompressed) {
-                pubKey = decompressed.uncompressed;
-            }
-            else {
-                pubKey = decompressed.hybrid;
+            if (decompressed) {
+                if (a.useUncompressed) {
+                    pubKey = decompressed.uncompressed;
+                }
+                else {
+                    pubKey = decompressed.hybrid;
+                }
             }
         }
         return bscript.compile([a.signature, pubKey]);
@@ -131,17 +133,19 @@ export function p2pkh(a, opts) {
                 if ((a.pubkey.length === 33 && (a.pubkey[0] === 0x02 || a.pubkey[0] === 0x03)) ||
                     (a.pubkey.length === 65 && a.pubkey[0] === 0x04)) {
                     const uncompressed = decompressPublicKey(a.pubkey);
-                    const pkh2 = bcrypto.hash160(uncompressed.uncompressed);
-                    if (!hash.equals(pkh2)) {
-                        const pkh3 = bcrypto.hash160(uncompressed.hybrid);
-                        badHash = !hash.equals(pkh3);
-                        if (!badHash) {
-                            a.useHybrid = true;
+                    if (uncompressed) {
+                        const pkh2 = bcrypto.hash160(uncompressed.uncompressed);
+                        if (!hash.equals(pkh2)) {
+                            const pkh3 = bcrypto.hash160(uncompressed.hybrid);
+                            badHash = !hash.equals(pkh3);
+                            if (!badHash) {
+                                a.useHybrid = true;
+                            }
+                        }
+                        else {
+                            badHash = false;
+                            a.useUncompressed = true;
                         }
-                    }
-                    else {
-                        badHash = false;
-                        a.useUncompressed = true;
                     }
                 }
             }

package/build/psbt/psbtutils.d.ts

@@ -11,7 +11,7 @@ export interface UncompressedPublicKey {
     hybrid: Buffer;
     uncompressed: Buffer;
 }
-export declare function decompressPublicKey(realPubKey: Uint8Array | Buffer): UncompressedPublicKey;
+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;

package/build/psbt/psbtutils.js

@@ -52,6 +52,9 @@ export function witnessStackToScriptWitness(witness) {
     return buffer;
 }
 export function decompressPublicKey(realPubKey) {
+    if (realPubKey.length === 32) {
+        return;
+    }
     if (![33, 65].includes(realPubKey.length)) {
         throw new Error(`Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`);
     }
@@ -105,8 +108,10 @@ export function pubkeyPositionInScript(pubkey, script) {
     const pubkeyHash = hash160(pubkey);
     const pubkeyXOnly = toXOnly(pubkey);
     const uncompressed = decompressPublicKey(pubkey);
-    const pubkeyHybridHash = hash160(uncompressed.hybrid);
-    const pubkeyUncompressedHash = hash160(uncompressed.uncompressed);
+    const pubkeyHybridHash = uncompressed?.hybrid ? hash160(uncompressed.hybrid) : undefined;
+    const pubkeyUncompressedHash = uncompressed?.uncompressed
+        ? hash160(uncompressed.uncompressed)
+        : undefined;
     return decompiled.findIndex((element) => {
         if (typeof element === 'number')
             return false;
@@ -117,12 +122,15 @@ export function pubkeyPositionInScript(pubkey, script) {
         if (element.equals(pubkeyHash)) {
             return true;
         }
-        if (pubkeysMatch(element, uncompressed.uncompressed))
-            return true;
-        if (pubkeysMatch(element, uncompressed.hybrid))
-            return true;
-        if (element.equals(pubkeyHybridHash) || element.equals(pubkeyUncompressedHash)) {
-            return true;
+        if (uncompressed) {
+            if (pubkeysMatch(element, uncompressed.uncompressed))
+                return true;
+            if (pubkeysMatch(element, uncompressed.hybrid))
+                return true;
+            if ((pubkeyHybridHash && element.equals(pubkeyHybridHash)) ||
+                (pubkeyUncompressedHash && element.equals(pubkeyUncompressedHash))) {
+                return true;
+            }
         }
     });
 }

package/package.json

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

package/src/payments/p2pkh.ts

@@ -1,206 +1,210 @@
-import * as bs58check from 'bs58check';
-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 { Payment, PaymentOpts, StackFunction } from './index.js';
-import * as lazy from './lazy.js';
-import { decompressPublicKey } from '../psbt/psbtutils.js';
-
-const OPS = bscript.OPS;
-
-// input: {signature} {pubkey}
-// output: OP_DUP OP_HASH160 {hash160(pubkey)} OP_EQUALVERIFY OP_CHECKSIG
-/**
- * Creates a Pay-to-Public-Key-Hash (P2PKH) payment object.
- *
- * @param a - The payment object containing the necessary data.
- * @param opts - Optional payment options.
- * @returns The P2PKH payment object.
- * @throws {TypeError} If the required data is not provided or if the data is invalid.
- */
-export function p2pkh(a: Payment, opts?: PaymentOpts): Payment {
-    if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input) {
-        throw new TypeError('Not enough data');
-    }
-
-    opts = Object.assign({ validate: true }, opts || {});
-
-    typef(
-        {
-            network: typef.maybe(typef.Object),
-            address: typef.maybe(typef.String),
-            hash: typef.maybe(typef.BufferN(20)),
-            output: typef.maybe(typef.BufferN(25)),
-
-            pubkey: typef.maybe(isPoint),
-            signature: typef.maybe(bscript.isCanonicalScriptSignature),
-            input: typef.maybe(typef.Buffer),
-        },
-        a,
-    );
-
-    const _address = lazy.value(() => {
-        const payload = Buffer.from(bs58check.default.decode(a.address!));
-        const version = payload.readUInt8(0);
-        const hash = payload.slice(1);
-        return { version, hash };
-    });
-
-    const _chunks = lazy.value(() => {
-        return bscript.decompile(a.input!);
-    }) as StackFunction;
-
-    const network = a.network || BITCOIN_NETWORK;
-    const o: Payment = { name: 'p2pkh', network };
-
-    lazy.prop(o, 'address', () => {
-        if (!o.hash) return;
-
-        const payload = Buffer.allocUnsafe(21);
-        payload.writeUInt8(network.pubKeyHash, 0);
-        o.hash.copy(payload, 1);
-        return bs58check.default.encode(payload);
-    });
-
-    lazy.prop(o, 'hash', () => {
-        if (a.output) return a.output.slice(3, 23);
-        if (a.address) return _address().hash;
-        if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!);
-    });
-
-    lazy.prop(o, 'output', () => {
-        if (!o.hash) return;
-        return bscript.compile([
-            OPS.OP_DUP,
-            OPS.OP_HASH160,
-            o.hash,
-            OPS.OP_EQUALVERIFY,
-            OPS.OP_CHECKSIG,
-        ]);
-    });
-
-    lazy.prop(o, 'pubkey', () => {
-        if (!a.input) return;
-        return _chunks()[1] as Buffer;
-    });
-
-    lazy.prop(o, 'signature', () => {
-        if (!a.input) return;
-        return _chunks()[0] as Buffer;
-    });
-
-    lazy.prop(o, 'input', () => {
-        if (!a.pubkey) return;
-        if (!a.signature) return;
-
-        let pubKey: Buffer = a.pubkey;
-        if (a.useHybrid || a.useUncompressed) {
-            const decompressed = decompressPublicKey(a.pubkey);
-            if (a.useUncompressed) {
-                pubKey = decompressed.uncompressed;
-            } else {
-                pubKey = decompressed.hybrid;
-            }
-        }
-
-        return bscript.compile([a.signature, pubKey]);
-    });
-
-    lazy.prop(o, 'witness', () => {
-        if (!o.input) return;
-        return [];
-    });
-
-    // extended validation
-    if (opts.validate) {
-        let hash: Buffer = Buffer.from([]);
-        if (a.address) {
-            if (_address().version !== network.pubKeyHash) {
-                throw new TypeError('Invalid version or Network mismatch');
-            }
-
-            if (_address().hash.length !== 20) {
-                throw new TypeError('Invalid address');
-            }
-
-            hash = _address().hash;
-        }
-
-        if (a.hash) {
-            if (hash.length > 0 && !hash.equals(a.hash)) {
-                throw new TypeError('Hash mismatch');
-            } else {
-                hash = a.hash;
-            }
-        }
-
-        if (a.output) {
-            if (
-                a.output.length !== 25 ||
-                a.output[0] !== OPS.OP_DUP ||
-                a.output[1] !== OPS.OP_HASH160 ||
-                a.output[2] !== 0x14 ||
-                a.output[23] !== OPS.OP_EQUALVERIFY ||
-                a.output[24] !== OPS.OP_CHECKSIG
-            ) {
-                throw new TypeError('Output is invalid');
-            }
-
-            const hash2 = a.output.slice(3, 23);
-            if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
-            else hash = hash2;
-        }
-
-        if (a.pubkey) {
-            const pkh = bcrypto.hash160(a.pubkey);
-
-            let badHash = hash.length > 0 && !hash.equals(pkh);
-            if (badHash) {
-                if (
-                    (a.pubkey.length === 33 && (a.pubkey[0] === 0x02 || a.pubkey[0] === 0x03)) ||
-                    (a.pubkey.length === 65 && a.pubkey[0] === 0x04)
-                ) {
-                    const uncompressed = decompressPublicKey(a.pubkey);
-                    const pkh2 = bcrypto.hash160(uncompressed.uncompressed);
-
-                    if (!hash.equals(pkh2)) {
-                        const pkh3 = bcrypto.hash160(uncompressed.hybrid);
-                        badHash = !hash.equals(pkh3);
-
-                        if (!badHash) {
-                            a.useHybrid = true;
-                        }
-                    } else {
-                        badHash = false;
-                        a.useUncompressed = true;
-                    }
-                }
-            }
-
-            if (badHash) {
-                throw new TypeError('Hash mismatch');
-            } else {
-                hash = pkh;
-            }
-        }
-
-        if (a.input) {
-            const chunks = _chunks();
-            if (chunks.length !== 2) throw new TypeError('Input is invalid');
-            if (!bscript.isCanonicalScriptSignature(chunks[0] as Buffer))
-                throw new TypeError('Input has invalid signature');
-            if (!isPoint(chunks[1])) throw new TypeError('Input has invalid pubkey');
-
-            if (a.signature && !a.signature.equals(chunks[0] as Buffer))
-                throw new TypeError('Signature mismatch');
-            if (a.pubkey && !a.pubkey.equals(chunks[1] as Buffer))
-                throw new TypeError('Pubkey mismatch');
-
-            const pkh = bcrypto.hash160(chunks[1] as Buffer);
-            if (hash.length > 0 && !hash.equals(pkh)) throw new TypeError('Hash mismatch (input)');
-        }
-    }
-
-    return Object.assign(o, a);
-}
+import * as bs58check from 'bs58check';
+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 { Payment, PaymentOpts, StackFunction } from './index.js';
+import * as lazy from './lazy.js';
+import { decompressPublicKey } from '../psbt/psbtutils.js';
+
+const OPS = bscript.OPS;
+
+// input: {signature} {pubkey}
+// output: OP_DUP OP_HASH160 {hash160(pubkey)} OP_EQUALVERIFY OP_CHECKSIG
+/**
+ * Creates a Pay-to-Public-Key-Hash (P2PKH) payment object.
+ *
+ * @param a - The payment object containing the necessary data.
+ * @param opts - Optional payment options.
+ * @returns The P2PKH payment object.
+ * @throws {TypeError} If the required data is not provided or if the data is invalid.
+ */
+export function p2pkh(a: Payment, opts?: PaymentOpts): Payment {
+    if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input) {
+        throw new TypeError('Not enough data');
+    }
+
+    opts = Object.assign({ validate: true }, opts || {});
+
+    typef(
+        {
+            network: typef.maybe(typef.Object),
+            address: typef.maybe(typef.String),
+            hash: typef.maybe(typef.BufferN(20)),
+            output: typef.maybe(typef.BufferN(25)),
+
+            pubkey: typef.maybe(isPoint),
+            signature: typef.maybe(bscript.isCanonicalScriptSignature),
+            input: typef.maybe(typef.Buffer),
+        },
+        a,
+    );
+
+    const _address = lazy.value(() => {
+        const payload = Buffer.from(bs58check.default.decode(a.address!));
+        const version = payload.readUInt8(0);
+        const hash = payload.slice(1);
+        return { version, hash };
+    });
+
+    const _chunks = lazy.value(() => {
+        return bscript.decompile(a.input!);
+    }) as StackFunction;
+
+    const network = a.network || BITCOIN_NETWORK;
+    const o: Payment = { name: 'p2pkh', network };
+
+    lazy.prop(o, 'address', () => {
+        if (!o.hash) return;
+
+        const payload = Buffer.allocUnsafe(21);
+        payload.writeUInt8(network.pubKeyHash, 0);
+        o.hash.copy(payload, 1);
+        return bs58check.default.encode(payload);
+    });
+
+    lazy.prop(o, 'hash', () => {
+        if (a.output) return a.output.slice(3, 23);
+        if (a.address) return _address().hash;
+        if (a.pubkey || o.pubkey) return bcrypto.hash160(a.pubkey! || o.pubkey!);
+    });
+
+    lazy.prop(o, 'output', () => {
+        if (!o.hash) return;
+        return bscript.compile([
+            OPS.OP_DUP,
+            OPS.OP_HASH160,
+            o.hash,
+            OPS.OP_EQUALVERIFY,
+            OPS.OP_CHECKSIG,
+        ]);
+    });
+
+    lazy.prop(o, 'pubkey', () => {
+        if (!a.input) return;
+        return _chunks()[1] as Buffer;
+    });
+
+    lazy.prop(o, 'signature', () => {
+        if (!a.input) return;
+        return _chunks()[0] as Buffer;
+    });
+
+    lazy.prop(o, 'input', () => {
+        if (!a.pubkey) return;
+        if (!a.signature) return;
+
+        let pubKey: Buffer = a.pubkey;
+        if (a.useHybrid || a.useUncompressed) {
+            const decompressed = decompressPublicKey(a.pubkey);
+            if (decompressed) {
+                if (a.useUncompressed) {
+                    pubKey = decompressed.uncompressed;
+                } else {
+                    pubKey = decompressed.hybrid;
+                }
+            }
+        }
+
+        return bscript.compile([a.signature, pubKey]);
+    });
+
+    lazy.prop(o, 'witness', () => {
+        if (!o.input) return;
+        return [];
+    });
+
+    // extended validation
+    if (opts.validate) {
+        let hash: Buffer = Buffer.from([]);
+        if (a.address) {
+            if (_address().version !== network.pubKeyHash) {
+                throw new TypeError('Invalid version or Network mismatch');
+            }
+
+            if (_address().hash.length !== 20) {
+                throw new TypeError('Invalid address');
+            }
+
+            hash = _address().hash;
+        }
+
+        if (a.hash) {
+            if (hash.length > 0 && !hash.equals(a.hash)) {
+                throw new TypeError('Hash mismatch');
+            } else {
+                hash = a.hash;
+            }
+        }
+
+        if (a.output) {
+            if (
+                a.output.length !== 25 ||
+                a.output[0] !== OPS.OP_DUP ||
+                a.output[1] !== OPS.OP_HASH160 ||
+                a.output[2] !== 0x14 ||
+                a.output[23] !== OPS.OP_EQUALVERIFY ||
+                a.output[24] !== OPS.OP_CHECKSIG
+            ) {
+                throw new TypeError('Output is invalid');
+            }
+
+            const hash2 = a.output.slice(3, 23);
+            if (hash.length > 0 && !hash.equals(hash2)) throw new TypeError('Hash mismatch');
+            else hash = hash2;
+        }
+
+        if (a.pubkey) {
+            const pkh = bcrypto.hash160(a.pubkey);
+
+            let badHash = hash.length > 0 && !hash.equals(pkh);
+            if (badHash) {
+                if (
+                    (a.pubkey.length === 33 && (a.pubkey[0] === 0x02 || a.pubkey[0] === 0x03)) ||
+                    (a.pubkey.length === 65 && a.pubkey[0] === 0x04)
+                ) {
+                    const uncompressed = decompressPublicKey(a.pubkey);
+                    if (uncompressed) {
+                        const pkh2 = bcrypto.hash160(uncompressed.uncompressed);
+
+                        if (!hash.equals(pkh2)) {
+                            const pkh3 = bcrypto.hash160(uncompressed.hybrid);
+                            badHash = !hash.equals(pkh3);
+
+                            if (!badHash) {
+                                a.useHybrid = true;
+                            }
+                        } else {
+                            badHash = false;
+                            a.useUncompressed = true;
+                        }
+                    }
+                }
+            }
+
+            if (badHash) {
+                throw new TypeError('Hash mismatch');
+            } else {
+                hash = pkh;
+            }
+        }
+
+        if (a.input) {
+            const chunks = _chunks();
+            if (chunks.length !== 2) throw new TypeError('Input is invalid');
+            if (!bscript.isCanonicalScriptSignature(chunks[0] as Buffer))
+                throw new TypeError('Input has invalid signature');
+            if (!isPoint(chunks[1])) throw new TypeError('Input has invalid pubkey');
+
+            if (a.signature && !a.signature.equals(chunks[0] as Buffer))
+                throw new TypeError('Signature mismatch');
+            if (a.pubkey && !a.pubkey.equals(chunks[1] as Buffer))
+                throw new TypeError('Pubkey mismatch');
+
+            const pkh = bcrypto.hash160(chunks[1] as Buffer);
+            if (hash.length > 0 && !hash.equals(pkh)) throw new TypeError('Hash mismatch (input)');
+        }
+    }
+
+    return Object.assign(o, a);
+}

package/src/psbt/psbtutils.ts

@@ -1,301 +1,315 @@
-import { ProjectivePoint } from '@noble/secp256k1';
-import * as varuint from 'bip174/src/lib/converter/varint.js';
-import { PartialSig, PsbtInput } from 'bip174/src/lib/interfaces.js';
-import { hash160 } from '../crypto.js';
-import { p2ms } from '../payments/p2ms.js';
-import { p2pk } from '../payments/p2pk.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 { Transaction } from '../transaction.js';
-import { toXOnly } from './bip371.js';
-
-function isPaymentFactory(payment: any): (script: Buffer) => boolean {
-    return (script: Buffer): boolean => {
-        try {
-            payment({ output: script });
-            return true;
-        } catch (err) {
-            return false;
-        }
-    };
-}
-
-export const isP2MS = isPaymentFactory(p2ms);
-export const isP2PK = isPaymentFactory(p2pk);
-export const isP2PKH = isPaymentFactory(p2pkh);
-export const isP2WPKH = isPaymentFactory(p2wpkh);
-export const isP2WSHScript = isPaymentFactory(p2wsh);
-export const isP2SHScript = isPaymentFactory(p2sh);
-export const isP2TR = isPaymentFactory(p2tr);
-
-/**
- * Converts a witness stack to a script witness.
- * @param witness The witness stack to convert.
- * @returns The script witness as a Buffer.
- */
-/**
- * Converts a witness stack to a script witness.
- * @param witness The witness stack to convert.
- * @returns The converted script witness.
- */
-export function witnessStackToScriptWitness(witness: Buffer[]): Buffer {
-    let buffer = Buffer.allocUnsafe(0);
-
-    function writeSlice(slice: Buffer): void {
-        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
-    }
-
-    function writeVarInt(i: number): void {
-        const currentLen = buffer.length;
-        const varintLen = varuint.encodingLength(i);
-
-        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-        varuint.encode(i, buffer, currentLen);
-    }
-
-    function writeVarSlice(slice: Buffer): void {
-        writeVarInt(slice.length);
-        writeSlice(slice);
-    }
-
-    function writeVector(vector: Buffer[]): void {
-        writeVarInt(vector.length);
-        vector.forEach(writeVarSlice);
-    }
-
-    writeVector(witness);
-
-    return buffer;
-}
-
-export interface UncompressedPublicKey {
-    hybrid: Buffer;
-    uncompressed: Buffer;
-}
-
-/**
- * Converts an existing real Bitcoin public key (compressed or uncompressed)
- * to its "hybrid" form (prefix 0x06/0x07), then derives a P2PKH address from it.
- *
- * @param realPubKey - 33-byte compressed (0x02/0x03) or 65-byte uncompressed (0x04) pubkey
- * @returns Buffer
- */
-export function decompressPublicKey(realPubKey: Uint8Array | Buffer): UncompressedPublicKey {
-    if (![33, 65].includes(realPubKey.length)) {
-        throw new Error(
-            `Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`,
-        );
-    }
-
-    // 1) Parse the public key to get an actual Point on secp256k1
-    //    If it fails, the pubkey is invalid/corrupted.
-    let point: ProjectivePoint;
-    try {
-        point = ProjectivePoint.fromHex(realPubKey);
-    } catch (err) {
-        throw new Error('Invalid secp256k1 public key bytes. Cannot parse.');
-    }
-
-    // 2) Extract X and Y as 32-byte big-endian buffers
-    const xBuf = bigIntTo32Bytes(point.x);
-    const yBuf = bigIntTo32Bytes(point.y);
-
-    // 3) Determine if Y is even or odd. That decides the hybrid prefix:
-    //    - 0x06 => "uncompressed + even Y"
-    //    - 0x07 => "uncompressed + odd Y"
-    const isEven = point.y % 2n === 0n;
-    const prefix = isEven ? 0x06 : 0x07;
-
-    // 4) Construct 65-byte hybrid pubkey
-    //    [prefix(1) || X(32) || Y(32)]
-    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,
-    };
-}
-
-/****************************************
- * Convert bigint -> 32-byte Buffer
- ****************************************/
-export function bigIntTo32Bytes(num: bigint): Buffer {
-    let hex = num.toString(16);
-    // Pad to 64 hex chars => 32 bytes
-    hex = hex.padStart(64, '0');
-    // In case it's bigger than 64 chars, slice the rightmost 64 (mod 2^256)
-    if (hex.length > 64) {
-        hex = hex.slice(-64);
-    }
-    return Buffer.from(hex, 'hex');
-}
-
-/**
- * Compare two potential pubkey Buffers, treating hybrid keys (0x06/0x07)
- * as equivalent to uncompressed (0x04).
- */
-export function pubkeysMatch(a: Buffer, b: Buffer): boolean {
-    // If they’re literally the same bytes, no further check needed
-    if (a.equals(b)) return true;
-
-    // If both are 65 bytes, see if one is hybrid and the other is uncompressed
-    if (a.length === 65 && b.length === 65) {
-        const aCopy = Buffer.from(a);
-        const bCopy = Buffer.from(b);
-
-        // Convert 0x06/0x07 to 0x04
-        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;
-}
-
-/**
- * Finds the position of a public key in a script.
- * @param pubkey The public key to search for.
- * @param script The script to search in.
- * @returns The index of the public key in the script, or -1 if not found.
- * @throws {Error} If there is an unknown script error.
- */
-export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
-    const decompiled = bscript.decompile(script);
-    if (decompiled === null) throw new Error('Unknown script error');
-
-    // For P2PKH or P2PK
-    const pubkeyHash = hash160(pubkey);
-
-    // For Taproot or some cases, we might also check the x-only
-    const pubkeyXOnly = toXOnly(pubkey);
-    const uncompressed = decompressPublicKey(pubkey);
-    const pubkeyHybridHash = hash160(uncompressed.hybrid);
-    const pubkeyUncompressedHash = hash160(uncompressed.uncompressed);
-
-    return decompiled.findIndex((element) => {
-        if (typeof element === 'number') return false;
-
-        if (pubkeysMatch(element, pubkey)) return true;
-
-        if (pubkeysMatch(element, pubkeyXOnly)) return true;
-
-        if (element.equals(pubkeyHash)) {
-            return true;
-        }
-
-        if (pubkeysMatch(element, uncompressed.uncompressed)) return true;
-
-        if (pubkeysMatch(element, uncompressed.hybrid)) return true;
-
-        if (element.equals(pubkeyHybridHash) || element.equals(pubkeyUncompressedHash)) {
-            return true;
-        }
-    });
-}
-
-/**
- * Checks if a public key is present in a script.
- * @param pubkey The public key to check.
- * @param script The script to search in.
- * @returns A boolean indicating whether the public key is present in the script.
- */
-export function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
-    return pubkeyPositionInScript(pubkey, script) !== -1;
-}
-
-/**
- * Checks if an input contains a signature for a specific action.
- * @param input - The input to check.
- * @param action - The action to check for.
- * @returns A boolean indicating whether the input contains a signature for the specified action.
- */
-export function checkInputForSig(input: PsbtInput, action: string): boolean {
-    const pSigs = extractPartialSigs(input);
-    return pSigs.some((pSig) => signatureBlocksAction(pSig, bscript.signature.decode, action));
-}
-
-type SignatureDecodeFunc = (buffer: Buffer) => {
-    signature: Buffer;
-    hashType: number;
-};
-
-/**
- * Determines if a given action is allowed for a signature block.
- * @param signature - The signature block.
- * @param signatureDecodeFn - The function used to decode the signature.
- * @param action - The action to be checked.
- * @returns True if the action is allowed, false otherwise.
- */
-export function signatureBlocksAction(
-    signature: Buffer,
-    signatureDecodeFn: SignatureDecodeFunc,
-    action: string,
-): boolean {
-    const { hashType } = signatureDecodeFn(signature);
-    const whitelist: string[] = [];
-    const isAnyoneCanPay = hashType & Transaction.SIGHASH_ANYONECANPAY;
-    if (isAnyoneCanPay) whitelist.push('addInput');
-    const hashMod = hashType & 0x1f;
-    switch (hashMod) {
-        case Transaction.SIGHASH_ALL:
-            break;
-        case Transaction.SIGHASH_SINGLE:
-        case Transaction.SIGHASH_NONE:
-            whitelist.push('addOutput');
-            whitelist.push('setInputSequence');
-            break;
-    }
-    return whitelist.indexOf(action) === -1;
-}
-
-/**
- * Extracts the signatures from a PsbtInput object.
- * If the input has partial signatures, it returns an array of the signatures.
- * If the input does not have partial signatures, it checks if it has a finalScriptSig or finalScriptWitness.
- * If it does, it extracts the signatures from the final scripts and returns them.
- * If none of the above conditions are met, it returns an empty array.
- *
- * @param input - The PsbtInput object from which to extract the signatures.
- * @returns An array of signatures extracted from the PsbtInput object.
- */
-function extractPartialSigs(input: PsbtInput): Buffer[] {
-    let pSigs: PartialSig[] = [];
-    if ((input.partialSig || []).length === 0) {
-        if (!input.finalScriptSig && !input.finalScriptWitness) return [];
-        pSigs = getPsigsFromInputFinalScripts(input);
-    } else {
-        pSigs = input.partialSig!;
-    }
-    return pSigs.map((p) => p.signature);
-}
-
-/**
- * Retrieves the partial signatures (Psigs) from the input's final scripts.
- * Psigs are extracted from both the final scriptSig and final scriptWitness of the input.
- * Only canonical script signatures are considered.
- *
- * @param input - The PsbtInput object representing the input.
- * @returns An array of PartialSig objects containing the extracted Psigs.
- */
-export function getPsigsFromInputFinalScripts(input: PsbtInput): PartialSig[] {
-    const scriptItems = !input.finalScriptSig ? [] : bscript.decompile(input.finalScriptSig) || [];
-    const witnessItems = !input.finalScriptWitness
-        ? []
-        : bscript.decompile(input.finalScriptWitness) || [];
-    return scriptItems
-        .concat(witnessItems)
-        .filter((item) => {
-            return Buffer.isBuffer(item) && bscript.isCanonicalScriptSignature(item);
-        })
-        .map((sig) => ({ signature: sig })) as PartialSig[];
-}
+import { ProjectivePoint } from '@noble/secp256k1';
+import * as varuint from 'bip174/src/lib/converter/varint.js';
+import { PartialSig, PsbtInput } from 'bip174/src/lib/interfaces.js';
+import { hash160 } from '../crypto.js';
+import { p2ms } from '../payments/p2ms.js';
+import { p2pk } from '../payments/p2pk.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 { Transaction } from '../transaction.js';
+import { toXOnly } from './bip371.js';
+
+function isPaymentFactory(payment: any): (script: Buffer) => boolean {
+    return (script: Buffer): boolean => {
+        try {
+            payment({ output: script });
+            return true;
+        } catch (err) {
+            return false;
+        }
+    };
+}
+
+export const isP2MS = isPaymentFactory(p2ms);
+export const isP2PK = isPaymentFactory(p2pk);
+export const isP2PKH = isPaymentFactory(p2pkh);
+export const isP2WPKH = isPaymentFactory(p2wpkh);
+export const isP2WSHScript = isPaymentFactory(p2wsh);
+export const isP2SHScript = isPaymentFactory(p2sh);
+export const isP2TR = isPaymentFactory(p2tr);
+
+/**
+ * Converts a witness stack to a script witness.
+ * @param witness The witness stack to convert.
+ * @returns The script witness as a Buffer.
+ */
+/**
+ * Converts a witness stack to a script witness.
+ * @param witness The witness stack to convert.
+ * @returns The converted script witness.
+ */
+export function witnessStackToScriptWitness(witness: Buffer[]): Buffer {
+    let buffer = Buffer.allocUnsafe(0);
+
+    function writeSlice(slice: Buffer): void {
+        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+    }
+
+    function writeVarInt(i: number): void {
+        const currentLen = buffer.length;
+        const varintLen = varuint.encodingLength(i);
+
+        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+        varuint.encode(i, buffer, currentLen);
+    }
+
+    function writeVarSlice(slice: Buffer): void {
+        writeVarInt(slice.length);
+        writeSlice(slice);
+    }
+
+    function writeVector(vector: Buffer[]): void {
+        writeVarInt(vector.length);
+        vector.forEach(writeVarSlice);
+    }
+
+    writeVector(witness);
+
+    return buffer;
+}
+
+export interface UncompressedPublicKey {
+    hybrid: Buffer;
+    uncompressed: Buffer;
+}
+
+/**
+ * Converts an existing real Bitcoin public key (compressed or uncompressed)
+ * to its "hybrid" form (prefix 0x06/0x07), then derives a P2PKH address from it.
+ *
+ * @param realPubKey - 33-byte compressed (0x02/0x03) or 65-byte uncompressed (0x04) pubkey
+ * @returns Buffer | undefined
+ */
+export function decompressPublicKey(
+    realPubKey: Uint8Array | Buffer,
+): UncompressedPublicKey | undefined {
+    if (realPubKey.length === 32) {
+        return;
+    }
+
+    if (![33, 65].includes(realPubKey.length)) {
+        throw new Error(
+            `Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`,
+        );
+    }
+
+    // 1) Parse the public key to get an actual Point on secp256k1
+    //    If it fails, the pubkey is invalid/corrupted.
+    let point: ProjectivePoint;
+    try {
+        point = ProjectivePoint.fromHex(realPubKey);
+    } catch (err) {
+        throw new Error('Invalid secp256k1 public key bytes. Cannot parse.');
+    }
+
+    // 2) Extract X and Y as 32-byte big-endian buffers
+    const xBuf = bigIntTo32Bytes(point.x);
+    const yBuf = bigIntTo32Bytes(point.y);
+
+    // 3) Determine if Y is even or odd. That decides the hybrid prefix:
+    //    - 0x06 => "uncompressed + even Y"
+    //    - 0x07 => "uncompressed + odd Y"
+    const isEven = point.y % 2n === 0n;
+    const prefix = isEven ? 0x06 : 0x07;
+
+    // 4) Construct 65-byte hybrid pubkey
+    //    [prefix(1) || X(32) || Y(32)]
+    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,
+    };
+}
+
+/****************************************
+ * Convert bigint -> 32-byte Buffer
+ ****************************************/
+export function bigIntTo32Bytes(num: bigint): Buffer {
+    let hex = num.toString(16);
+    // Pad to 64 hex chars => 32 bytes
+    hex = hex.padStart(64, '0');
+    // In case it's bigger than 64 chars, slice the rightmost 64 (mod 2^256)
+    if (hex.length > 64) {
+        hex = hex.slice(-64);
+    }
+    return Buffer.from(hex, 'hex');
+}
+
+/**
+ * Compare two potential pubkey Buffers, treating hybrid keys (0x06/0x07)
+ * as equivalent to uncompressed (0x04).
+ */
+export function pubkeysMatch(a: Buffer, b: Buffer): boolean {
+    // If they’re literally the same bytes, no further check needed
+    if (a.equals(b)) return true;
+
+    // If both are 65 bytes, see if one is hybrid and the other is uncompressed
+    if (a.length === 65 && b.length === 65) {
+        const aCopy = Buffer.from(a);
+        const bCopy = Buffer.from(b);
+
+        // Convert 0x06/0x07 to 0x04
+        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;
+}
+
+/**
+ * Finds the position of a public key in a script.
+ * @param pubkey The public key to search for.
+ * @param script The script to search in.
+ * @returns The index of the public key in the script, or -1 if not found.
+ * @throws {Error} If there is an unknown script error.
+ */
+export function pubkeyPositionInScript(pubkey: Buffer, script: Buffer): number {
+    const decompiled = bscript.decompile(script);
+    if (decompiled === null) throw new Error('Unknown script error');
+
+    // For P2PKH or P2PK
+    const pubkeyHash = hash160(pubkey);
+
+    // For Taproot or some cases, we might also check the x-only
+    const pubkeyXOnly = toXOnly(pubkey);
+    const uncompressed = decompressPublicKey(pubkey);
+
+    const pubkeyHybridHash = uncompressed?.hybrid ? hash160(uncompressed.hybrid) : undefined;
+    const pubkeyUncompressedHash = uncompressed?.uncompressed
+        ? hash160(uncompressed.uncompressed)
+        : undefined;
+
+    return decompiled.findIndex((element) => {
+        if (typeof element === 'number') return false;
+
+        if (pubkeysMatch(element, pubkey)) return true;
+
+        if (pubkeysMatch(element, pubkeyXOnly)) return true;
+
+        if (element.equals(pubkeyHash)) {
+            return true;
+        }
+
+        if (uncompressed) {
+            if (pubkeysMatch(element, uncompressed.uncompressed)) return true;
+
+            if (pubkeysMatch(element, uncompressed.hybrid)) return true;
+
+            if (
+                (pubkeyHybridHash && element.equals(pubkeyHybridHash)) ||
+                (pubkeyUncompressedHash && element.equals(pubkeyUncompressedHash))
+            ) {
+                return true;
+            }
+        }
+    });
+}
+
+/**
+ * Checks if a public key is present in a script.
+ * @param pubkey The public key to check.
+ * @param script The script to search in.
+ * @returns A boolean indicating whether the public key is present in the script.
+ */
+export function pubkeyInScript(pubkey: Buffer, script: Buffer): boolean {
+    return pubkeyPositionInScript(pubkey, script) !== -1;
+}
+
+/**
+ * Checks if an input contains a signature for a specific action.
+ * @param input - The input to check.
+ * @param action - The action to check for.
+ * @returns A boolean indicating whether the input contains a signature for the specified action.
+ */
+export function checkInputForSig(input: PsbtInput, action: string): boolean {
+    const pSigs = extractPartialSigs(input);
+    return pSigs.some((pSig) => signatureBlocksAction(pSig, bscript.signature.decode, action));
+}
+
+type SignatureDecodeFunc = (buffer: Buffer) => {
+    signature: Buffer;
+    hashType: number;
+};
+
+/**
+ * Determines if a given action is allowed for a signature block.
+ * @param signature - The signature block.
+ * @param signatureDecodeFn - The function used to decode the signature.
+ * @param action - The action to be checked.
+ * @returns True if the action is allowed, false otherwise.
+ */
+export function signatureBlocksAction(
+    signature: Buffer,
+    signatureDecodeFn: SignatureDecodeFunc,
+    action: string,
+): boolean {
+    const { hashType } = signatureDecodeFn(signature);
+    const whitelist: string[] = [];
+    const isAnyoneCanPay = hashType & Transaction.SIGHASH_ANYONECANPAY;
+    if (isAnyoneCanPay) whitelist.push('addInput');
+    const hashMod = hashType & 0x1f;
+    switch (hashMod) {
+        case Transaction.SIGHASH_ALL:
+            break;
+        case Transaction.SIGHASH_SINGLE:
+        case Transaction.SIGHASH_NONE:
+            whitelist.push('addOutput');
+            whitelist.push('setInputSequence');
+            break;
+    }
+    return whitelist.indexOf(action) === -1;
+}
+
+/**
+ * Extracts the signatures from a PsbtInput object.
+ * If the input has partial signatures, it returns an array of the signatures.
+ * If the input does not have partial signatures, it checks if it has a finalScriptSig or finalScriptWitness.
+ * If it does, it extracts the signatures from the final scripts and returns them.
+ * If none of the above conditions are met, it returns an empty array.
+ *
+ * @param input - The PsbtInput object from which to extract the signatures.
+ * @returns An array of signatures extracted from the PsbtInput object.
+ */
+function extractPartialSigs(input: PsbtInput): Buffer[] {
+    let pSigs: PartialSig[] = [];
+    if ((input.partialSig || []).length === 0) {
+        if (!input.finalScriptSig && !input.finalScriptWitness) return [];
+        pSigs = getPsigsFromInputFinalScripts(input);
+    } else {
+        pSigs = input.partialSig!;
+    }
+    return pSigs.map((p) => p.signature);
+}
+
+/**
+ * Retrieves the partial signatures (Psigs) from the input's final scripts.
+ * Psigs are extracted from both the final scriptSig and final scriptWitness of the input.
+ * Only canonical script signatures are considered.
+ *
+ * @param input - The PsbtInput object representing the input.
+ * @returns An array of PartialSig objects containing the extracted Psigs.
+ */
+export function getPsigsFromInputFinalScripts(input: PsbtInput): PartialSig[] {
+    const scriptItems = !input.finalScriptSig ? [] : bscript.decompile(input.finalScriptSig) || [];
+    const witnessItems = !input.finalScriptWitness
+        ? []
+        : bscript.decompile(input.finalScriptWitness) || [];
+    return scriptItems
+        .concat(witnessItems)
+        .filter((item) => {
+            return Buffer.isBuffer(item) && bscript.isCanonicalScriptSignature(item);
+        })
+        .map((sig) => ({ signature: sig })) as PartialSig[];
+}