@bitcoinerlab/descriptors 3.0.1 → 3.0.3

package/dist/bitcoinjs-lib-internals.js

@@ -6,9 +6,41 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTaprootInput = exports.witnessStackToScriptWitness = exports.tweakKey = exports.toHashTree = exports.tapTweakHash = exports.tapleafHash = exports.findScriptPath = void 0;
-const bip341 = require('bitcoinjs-lib/src/payments/bip341');
-const bip371 = require('bitcoinjs-lib/src/psbt/bip371');
-const psbtUtils = require('bitcoinjs-lib/src/psbt/psbtutils');
+function resolveAbsoluteCjsPath(relativePath) {
+    try {
+        const entryPoint = require.resolve('bitcoinjs-lib');
+        const root = entryPoint.replace(/src[\\/]+cjs[\\/]+index\.cjs$/, '');
+        if (root === entryPoint)
+            return undefined;
+        return `${root}src/cjs/${relativePath}.cjs`;
+    }
+    catch (_err) {
+        void _err;
+        return undefined;
+    }
+}
+function requireBitcoinJsInternal(relativePath) {
+    const candidatePaths = [
+        `bitcoinjs-lib/src/${relativePath}`,
+        `bitcoinjs-lib/src/cjs/${relativePath}.cjs`
+    ];
+    const absoluteCjsPath = resolveAbsoluteCjsPath(relativePath);
+    if (absoluteCjsPath)
+        candidatePaths.push(absoluteCjsPath);
+    let lastError;
+    for (const modulePath of candidatePaths) {
+        try {
+            return require(modulePath);
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    throw lastError;
+}
+const bip341 = requireBitcoinJsInternal('payments/bip341');
+const bip371 = requireBitcoinJsInternal('psbt/bip371');
+const psbtUtils = requireBitcoinJsInternal('psbt/psbtutils');
 exports.findScriptPath = bip341.findScriptPath;
 exports.tapleafHash = bip341.tapleafHash;
 exports.tapTweakHash = bip341.tapTweakHash;

package/dist/descriptors.js

@@ -1162,24 +1162,56 @@ expansion=${expansion}, isPKH=${isPKH}, isWPKH=${isWPKH}, isSH=${isSH}, isTR=${i
                 return (0, varuint_bitcoin_1.encodingLength)(length) + length;
             };
             const resolveMiniscriptSignatures = () => {
-                if (signatures !== 'DANGEROUSLY_USE_FAKE_SIGNATURES')
-                    return signatures;
-                return __classPrivateFieldGet(this, _Output_instances, "m", _Output_resolveMiniscriptSignersPubKeys).call(this).map(pubkey => ({
-                    pubkey,
-                    // https://transactionfee.info/charts/bitcoin-script-ecdsa-length/
-                    signature: new Uint8Array(ECDSA_FAKE_SIGNATURE_SIZE)
-                }));
+                const signerPubKeys = __classPrivateFieldGet(this, _Output_instances, "m", _Output_resolveMiniscriptSignersPubKeys).call(this);
+                if (signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES') {
+                    return signerPubKeys.map(pubkey => ({
+                        pubkey,
+                        // https://transactionfee.info/charts/bitcoin-script-ecdsa-length/
+                        signature: new Uint8Array(ECDSA_FAKE_SIGNATURE_SIZE)
+                    }));
+                }
+                const providedSignerPubKeysSet = new Set(signatures.map(sig => (0, uint8array_tools_1.toHex)(sig.pubkey)));
+                const missingSignerPubKeys = signerPubKeys.filter(pubkey => !providedSignerPubKeysSet.has((0, uint8array_tools_1.toHex)(pubkey)));
+                if (missingSignerPubKeys.length > 0)
+                    throw new Error(`Error: inputWeight expected signatures for all planned miniscript signers. Missing ${missingSignerPubKeys.length} signer(s)`);
+                const signerPubKeysSet = new Set(signerPubKeys.map(pubkey => (0, uint8array_tools_1.toHex)(pubkey)));
+                return signatures.filter(sig => signerPubKeysSet.has((0, uint8array_tools_1.toHex)(sig.pubkey)));
             };
             const taprootFakeSignatureSize = taprootSighash === 'SIGHASH_DEFAULT'
                 ? TAPROOT_FAKE_SIGNATURE_SIZE
                 : TAPROOT_FAKE_SIGNATURE_SIZE + 1;
-            const resolveTaprootSignatures = () => {
-                if (signatures !== 'DANGEROUSLY_USE_FAKE_SIGNATURES')
-                    return signatures;
-                return __classPrivateFieldGet(this, _Output_instances, "m", _Output_resolveTapTreeSignersPubKeys).call(this).map(pubkey => ({
+            const resolvePlannedTaprootRequiredPubKeys = () => {
+                const tapTreeSignerPubKeys = __classPrivateFieldGet(this, _Output_instances, "m", _Output_resolveTapTreeSignersPubKeys).call(this).map(tapMiniscript_1.normalizeTaprootPubkey);
+                const taggedFakeSignatures = tapTreeSignerPubKeys.map((pubkey, index) => ({
                     pubkey,
-                    signature: new Uint8Array(taprootFakeSignatureSize)
+                    signature: new Uint8Array(taprootFakeSignatureSize).fill(index + 1)
+                }));
+                const plannedTaprootSatisfaction = this.getTapScriptSatisfaction(taggedFakeSignatures);
+                const requiredPubkeys = taggedFakeSignatures
+                    .filter(fakeSignature => plannedTaprootSatisfaction.stackItems.some(stackItem => (0, uint8array_tools_1.compare)(stackItem, fakeSignature.signature) === 0))
+                    .map(fakeSignature => fakeSignature.pubkey);
+                return Array.from(new Set(requiredPubkeys.map(pubkey => (0, uint8array_tools_1.toHex)(pubkey))))
+                    .map(hex => (0, uint8array_tools_1.fromHex)(hex))
+                    .map(tapMiniscript_1.normalizeTaprootPubkey);
+            };
+            const resolveTaprootSignatures = () => {
+                if (signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES') {
+                    return __classPrivateFieldGet(this, _Output_instances, "m", _Output_resolveTapTreeSignersPubKeys).call(this).map(pubkey => ({
+                        pubkey,
+                        signature: new Uint8Array(taprootFakeSignatureSize)
+                    }));
+                }
+                const normalizedSignatures = signatures.map(sig => ({
+                    pubkey: (0, tapMiniscript_1.normalizeTaprootPubkey)(sig.pubkey),
+                    signature: sig.signature
                 }));
+                const plannedRequiredPubKeys = resolvePlannedTaprootRequiredPubKeys();
+                const providedTapTreeSignerPubKeysSet = new Set(normalizedSignatures.map(sig => (0, uint8array_tools_1.toHex)(sig.pubkey)));
+                const missingTapTreeSignerPubKeys = plannedRequiredPubKeys.filter(pubkey => !providedTapTreeSignerPubKeysSet.has((0, uint8array_tools_1.toHex)(pubkey)));
+                if (missingTapTreeSignerPubKeys.length > 0)
+                    throw new Error(`Error: inputWeight expected signatures for the planned taproot script-path satisfaction. Missing ${missingTapTreeSignerPubKeys.length} signer(s)`);
+                const plannedRequiredPubKeysSet = new Set(plannedRequiredPubKeys.map(pubkey => (0, uint8array_tools_1.toHex)(pubkey)));
+                return normalizedSignatures.filter(sig => plannedRequiredPubKeysSet.has((0, uint8array_tools_1.toHex)(sig.pubkey)));
             };
             const resolveTaprootSignatureSize = () => {
                 let length;
@@ -1187,9 +1219,26 @@ expansion=${expansion}, isPKH=${isPKH}, isWPKH=${isWPKH}, isSH=${isSH}, isTR=${i
                     length = taprootFakeSignatureSize;
                 }
                 else {
-                    if (signatures.length !== 1)
+                    const normalizedSignatures = signatures.map(sig => ({
+                        pubkey: (0, tapMiniscript_1.normalizeTaprootPubkey)(sig.pubkey),
+                        signature: sig.signature
+                    }));
+                    const internalPubkey = this.getPayment().internalPubkey;
+                    if (!internalPubkey) {
+                        //addr() of tr addresses may not have internalPubkey
+                        if (normalizedSignatures.length !== 1)
+                            throw new Error('Error: inputWeight for addr(TR_ADDRESS) requires exactly one signature. Internal taproot pubkey is unavailable in addr() descriptors; use tr(KEY) for strict key matching.');
+                        const singleSignature = normalizedSignatures[0];
+                        if (!singleSignature)
+                            throw new Error('Signatures not present');
+                        length = singleSignature.signature.length;
+                        return (0, varuint_bitcoin_1.encodingLength)(length) + length;
+                    }
+                    const normalizedInternalPubkey = (0, tapMiniscript_1.normalizeTaprootPubkey)(internalPubkey);
+                    const keyPathSignatures = normalizedSignatures.filter(sig => (0, uint8array_tools_1.compare)(sig.pubkey, normalizedInternalPubkey) === 0);
+                    if (keyPathSignatures.length !== 1)
                         throw new Error('More than one signture was not expected');
-                    const singleSignature = signatures[0];
+                    const singleSignature = keyPathSignatures[0];
                     if (!singleSignature)
                         throw new Error('Signatures not present');
                     length = singleSignature.signature.length;
@@ -1197,7 +1246,6 @@ expansion=${expansion}, isPKH=${isPKH}, isWPKH=${isWPKH}, isSH=${isSH}, isTR=${i
                 return (0, varuint_bitcoin_1.encodingLength)(length) + length;
             };
             const taprootSpendPath = __classPrivateFieldGet(this, _Output_taprootSpendPath, "f");
-            const tapLeaf = __classPrivateFieldGet(this, _Output_tapLeaf, "f");
             if (expansion ? expansion.startsWith('pkh(') : isPKH) {
                 return (
                 // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1) + (sig:73) + (pubkey:34)
@@ -1295,15 +1343,7 @@ expansion=${expansion}, isPKH=${isPKH}, isWPKH=${isWPKH}, isSH=${isSH}, isTR=${i
                     throw new Error('Should be SegwitTx');
                 if (taprootSpendPath === 'key')
                     return 41 * 4 + (0, varuint_bitcoin_1.encodingLength)(1) + resolveTaprootSignatureSize();
-                const resolvedTapTreeInfo = __classPrivateFieldGet(this, _Output_tapTreeInfo, "f");
-                if (!resolvedTapTreeInfo)
-                    throw new Error(`Error: taproot tree info not available`);
-                const taprootSatisfaction = (0, tapMiniscript_1.satisfyTapTree)({
-                    tapTreeInfo: resolvedTapTreeInfo,
-                    preimages: __classPrivateFieldGet(this, _Output_preimages, "f"),
-                    signatures: resolveTaprootSignatures(),
-                    ...(tapLeaf !== undefined ? { tapLeaf } : {})
-                });
+                const taprootSatisfaction = this.getTapScriptSatisfaction(resolveTaprootSignatures());
                 return 41 * 4 + taprootSatisfaction.totalWitnessSize;
             }
             else if (isTR && (!expansion || expansion === 'tr(@0)')) {

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bitcoinerlab/descriptors",
   "description": "This library parses and creates Bitcoin Miniscript Descriptors and generates Partially Signed Bitcoin Transactions (PSBTs). It provides PSBT finalizers and signers for single-signature, BIP32 and Hardware Wallets.",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "author": "Jose-Luis Landabaso",
   "license": "MIT",
   "repository": {
@@ -69,7 +69,7 @@
   "dependencies": {
     "@bitcoinerlab/miniscript": "^2.0.0",
     "@bitcoinerlab/secp256k1": "^1.2.0",
-    "bip32": "^4.0.0",
+    "bip32": "^5.0.1",
     "bitcoinjs-lib": "^7.0.1",
     "ecpair": "^3.0.1",
     "lodash.memoize": "^4.1.2",