@btc-vision/bitcoin 6.3.3 → 6.3.5

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,7 +52,11 @@ export function witnessStackToScriptWitness(witness) {
     return buffer;
 }
 export function decompressPublicKey(realPubKey) {
+    if (realPubKey.length === 32) {
+        return;
+    }
     if (![33, 65].includes(realPubKey.length)) {
+        console.trace(`Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`);
         throw new Error(`Unsupported key length=${realPubKey.length}. Must be 33 (compressed) or 65 (uncompressed).`);
     }
     let point;
@@ -105,8 +109,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 +123,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.5",
     "description": "Client-side Bitcoin JavaScript library",
     "engines": {
         "node": ">=16.0.0"
@@ -91,7 +91,6 @@
         "@types/proxyquire": "^1.3.31",
         "@types/randombytes": "^2.0.3",
         "better-npm-audit": "^3.11.0",
-        "bip32": "^4.0.0",
         "bip39": "^3.1.0",
         "bip65": "^1.0.3",
         "bip68": "^1.0.4",
@@ -135,6 +134,7 @@
         "babel-plugin-transform-import-meta": "^2.2.1",
         "babel-preset-react": "^6.24.1",
         "babelify": "^10.0.0",
+        "bip32": "^4.0.0",
         "bech32": "^2.0.0",
         "bip174": "^2.1.1",
         "browserify-zlib": "^0.2.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);
+}