@btc-vision/bitcoin 6.3.2 → 6.3.4

package/browser/payments/index.d.ts

@@ -29,6 +29,8 @@ export interface Payment {
     redeemVersion?: number;
     scriptTree?: Taptree;
     witness?: Buffer[];
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
 }
 export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
 export type PaymentFunction = () => Payment;

package/browser/psbt.d.ts

@@ -53,7 +53,7 @@ export declare class Psbt {
     getFeeRate(disableOutputChecks?: boolean): number;
     getFee(disableOutputChecks?: boolean): number;
     finalizeAllInputs(): this;
-    finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc | FinalTaprootScriptsFunc): this;
+    finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc | FinalTaprootScriptsFunc, canRunChecks?: boolean): this;
     finalizeTaprootInput(inputIndex: number, tapLeafHashToFinalize?: Buffer, finalScriptsFunc?: FinalTaprootScriptsFunc): this;
     getInputType(inputIndex: number): AllScriptType;
     inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean;
@@ -148,14 +148,14 @@ export interface SignerAsync {
     signSchnorr?(hash: Buffer): Promise<Buffer>;
     getPublicKey?(): Buffer;
 }
-type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
+type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks: boolean) => {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };
 type FinalTaprootScriptsFunc = (inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer) => {
     finalScriptWitness: Buffer | undefined;
 };
-export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean): {
+export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean): {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };

package/build/payments/index.d.ts

@@ -29,6 +29,8 @@ export interface Payment {
     redeemVersion?: number;
     scriptTree?: Taptree;
     witness?: Buffer[];
+    useHybrid?: boolean;
+    useUncompressed?: boolean;
 }
 export type PaymentCreator = (a: Payment, opts?: PaymentOpts) => Payment;
 export type PaymentFunction = () => Payment;

package/build/payments/p2pkh.js

@@ -4,10 +4,12 @@ import { bitcoin as BITCOIN_NETWORK } from '../networks.js';
 import * as bscript from '../script.js';
 import { isPoint, typeforce as typef } from '../types.js';
 import * as lazy from './lazy.js';
+import { decompressPublicKey } from '../psbt/psbtutils.js';
 const OPS = bscript.OPS;
 export function p2pkh(a, opts) {
-    if (!a.address && !a.hash && !a.output && !a.pubkey && !a.input)
+    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),
@@ -71,7 +73,19 @@ export function p2pkh(a, opts) {
             return;
         if (!a.signature)
             return;
-        return bscript.compile([a.signature, a.pubkey]);
+        let pubKey = 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)
@@ -81,17 +95,21 @@ export function p2pkh(a, opts) {
     if (opts.validate) {
         let hash = Buffer.from([]);
         if (a.address) {
-            if (_address().version !== network.pubKeyHash)
+            if (_address().version !== network.pubKeyHash) {
                 throw new TypeError('Invalid version or Network mismatch');
-            if (_address().hash.length !== 20)
+            }
+            if (_address().hash.length !== 20) {
                 throw new TypeError('Invalid address');
+            }
             hash = _address().hash;
         }
         if (a.hash) {
-            if (hash.length > 0 && !hash.equals(a.hash))
+            if (hash.length > 0 && !hash.equals(a.hash)) {
                 throw new TypeError('Hash mismatch');
-            else
+            }
+            else {
                 hash = a.hash;
+            }
         }
         if (a.output) {
             if (a.output.length !== 25 ||
@@ -99,8 +117,9 @@ export function p2pkh(a, opts) {
                 a.output[1] !== OPS.OP_HASH160 ||
                 a.output[2] !== 0x14 ||
                 a.output[23] !== OPS.OP_EQUALVERIFY ||
-                a.output[24] !== OPS.OP_CHECKSIG)
+                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');
@@ -109,10 +128,33 @@ export function p2pkh(a, opts) {
         }
         if (a.pubkey) {
             const pkh = bcrypto.hash160(a.pubkey);
-            if (hash.length > 0 && !hash.equals(pkh))
+            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
+            }
+            else {
                 hash = pkh;
+            }
         }
         if (a.input) {
             const chunks = _chunks();
@@ -128,7 +170,7 @@ export function p2pkh(a, opts) {
                 throw new TypeError('Pubkey mismatch');
             const pkh = bcrypto.hash160(chunks[1]);
             if (hash.length > 0 && !hash.equals(pkh))
-                throw new TypeError('Hash mismatch');
+                throw new TypeError('Hash mismatch (input)');
         }
     }
     return Object.assign(o, a);

package/build/payments/p2sh.js

@@ -6,8 +6,9 @@ import { stacksEqual, typeforce as typef } from '../types.js';
 import * as lazy from './lazy.js';
 const OPS = bscript.OPS;
 export function p2sh(a, opts) {
-    if (!a.address && !a.hash && !a.output && !a.redeem && !a.input)
+    if (!a.address && !a.hash && !a.output && !a.redeem && !a.input) {
         throw new TypeError('Not enough data');
+    }
     opts = Object.assign({ validate: true }, opts || {});
     typef({
         network: typef.maybe(typef.Object),

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).`);
     }
@@ -99,12 +102,16 @@ export function pubkeysMatch(a, b) {
     return false;
 }
 export function pubkeyPositionInScript(pubkey, script) {
-    const pubkeyHash = hash160(pubkey);
-    const pubkeyXOnly = toXOnly(pubkey);
-    const uncompressed = decompressPublicKey(pubkey);
     const decompiled = bscript.decompile(script);
     if (decompiled === null)
         throw new Error('Unknown script error');
+    const pubkeyHash = hash160(pubkey);
+    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;
@@ -112,11 +119,19 @@ export function pubkeyPositionInScript(pubkey, script) {
             return true;
         if (pubkeysMatch(element, pubkeyXOnly))
             return true;
-        if (pubkeysMatch(element, uncompressed.uncompressed))
-            return true;
-        if (pubkeysMatch(element, uncompressed.hybrid))
+        if (element.equals(pubkeyHash)) {
             return true;
-        return element.equals(pubkeyHash);
+        }
+        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;
+            }
+        }
     });
 }
 export function pubkeyInScript(pubkey, script) {

package/build/psbt.d.ts

@@ -53,7 +53,7 @@ export declare class Psbt {
     getFeeRate(disableOutputChecks?: boolean): number;
     getFee(disableOutputChecks?: boolean): number;
     finalizeAllInputs(): this;
-    finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc | FinalTaprootScriptsFunc): this;
+    finalizeInput(inputIndex: number, finalScriptsFunc?: FinalScriptsFunc | FinalTaprootScriptsFunc, canRunChecks?: boolean): this;
     finalizeTaprootInput(inputIndex: number, tapLeafHashToFinalize?: Buffer, finalScriptsFunc?: FinalTaprootScriptsFunc): this;
     getInputType(inputIndex: number): AllScriptType;
     inputHasPubkey(inputIndex: number, pubkey: Buffer): boolean;
@@ -148,14 +148,14 @@ export interface SignerAsync {
     signSchnorr?(hash: Buffer): Promise<Buffer>;
     getPublicKey?(): Buffer;
 }
-type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
+type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks: boolean) => {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };
 type FinalTaprootScriptsFunc = (inputIndex: number, input: PsbtInput, tapLeafHashToFinalize?: Buffer) => {
     finalScriptWitness: Buffer | undefined;
 };
-export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean): {
+export declare function getFinalScripts(inputIndex: number, input: PsbtInput, script: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean, canRunChecks?: boolean): {
     finalScriptSig: Buffer | undefined;
     finalScriptWitness: Buffer | undefined;
 };

package/build/psbt.js

@@ -209,11 +209,12 @@ export class Psbt {
         range(this.data.inputs.length).forEach((idx) => this.finalizeInput(idx));
         return this;
     }
-    finalizeInput(inputIndex, finalScriptsFunc) {
+    finalizeInput(inputIndex, finalScriptsFunc, canRunChecks) {
         const input = checkForInput(this.data.inputs, inputIndex);
-        if (isTaprootInput(input))
+        if (isTaprootInput(input)) {
             return this._finalizeTaprootInput(inputIndex, input, undefined, finalScriptsFunc);
-        return this._finalizeInput(inputIndex, input, finalScriptsFunc);
+        }
+        return this._finalizeInput(inputIndex, input, finalScriptsFunc, canRunChecks ?? true);
     }
     finalizeTaprootInput(inputIndex, tapLeafHashToFinalize, finalScriptsFunc = tapScriptFinalizer) {
         const input = checkForInput(this.data.inputs, inputIndex);
@@ -456,12 +457,12 @@ export class Psbt {
             throw new Error(`Can not sign for input #${inputIndex} with the key ${keyPair.publicKey.toString('hex')}`);
         return hashesForSig;
     }
-    _finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts) {
+    _finalizeInput(inputIndex, input, finalScriptsFunc = getFinalScripts, canRunChecks = true) {
         const { script, isP2SH, isP2WSH, isSegwit } = getScriptFromInput(inputIndex, input, this.__CACHE);
         if (!script)
             throw new Error(`No script found for input #${inputIndex}`);
         checkPartialSigSighashes(input);
-        const { finalScriptSig, finalScriptWitness } = finalScriptsFunc(inputIndex, input, script, isSegwit, isP2SH, isP2WSH);
+        const { finalScriptSig, finalScriptWitness } = finalScriptsFunc(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks);
         if (finalScriptSig)
             this.data.updateInput(inputIndex, { finalScriptSig });
         if (finalScriptWitness)
@@ -819,10 +820,11 @@ function getTxCacheValue(key, name, inputs, c, disableOutputChecks = false) {
     else if (key === '__FEE')
         return c.__FEE;
 }
-export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH) {
+export function getFinalScripts(inputIndex, input, script, isSegwit, isP2SH, isP2WSH, canRunChecks = true) {
     const scriptType = classifyScript(script);
-    if (!canFinalize(input, script, scriptType))
+    if (!canFinalize(input, script, scriptType) && canRunChecks) {
         throw new Error(`Can not finalize input #${inputIndex}`);
+    }
     return prepareFinalScripts(script, scriptType, input.partialSig, isSegwit, isP2SH, isP2WSH);
 }
 export function prepareFinalScripts(script, scriptType, partialSig, isSegwit, isP2SH, isP2WSH) {