@dynamic-labs-wallet/btc-utils 1.0.106 → 1.0.108

package/index.cjs

@@ -1267,6 +1267,30 @@ function _instanceof$2(left, right) {
     };
 };
 
+/**
+ * Checks if an output script (scriptPubKey) is P2WSH: OP_0 <32-byte sha256(witnessScript)>
+ *
+ * ArrayLike keeps this callable with Buffer or Uint8Array — the iframe build
+ * compiles with browser typings where Buffer is not assignable to Uint8Array.
+ * @param script - The output script to check
+ * @returns True if the script has the P2WSH shape
+ */ var isP2wshOutputScript = function(script) {
+    return script.length === 34 && script[0] === 0x00 && script[1] === 0x20;
+};
+
+/**
+ * Constant-shape byte equality without Buffer — the iframe build compiles
+ * this package with browser typings where Buffer is not assignable to
+ * Uint8Array.
+ * @param a - First byte array
+ * @param b - Second byte array
+ * @returns True if both arrays have identical length and contents
+ */ var bytesEqual = function(a, b) {
+    return a.length === b.length && a.every(function(byte, index) {
+        return byte === b[index];
+    });
+};
+
 function _instanceof$1(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -1275,12 +1299,63 @@ function _instanceof$1(left, right) {
     }
 }
 /**
- * Checks if a PSBT input belongs to a specific address
+ * P2WSH ownership: the caller allowlisted the witnessScript, it hashes to the
+ * scriptPubKey commitment, and it is a canonical m-of-n CHECKMULTISIG with
+ * `publicKey` in a signing position.
+ */ var matchesAllowedP2wshMultisig = function(input, script, publicKey, allowedWitnessScripts) {
+    if (!publicKey || !input.witnessScript || !(allowedWitnessScripts === null || allowedWitnessScripts === void 0 ? void 0 : allowedWitnessScripts.length)) {
+        return false;
+    }
+    var witnessScript = Uint8Array.from(input.witnessScript);
+    // P2WSH co-signing is opt-in: the wallet only signs arrangements the
+    // caller explicitly named in this request.
+    var witnessScriptHex = Buffer.from(witnessScript).toString('hex');
+    if (!allowedWitnessScripts.some(function(hex) {
+        return hex.toLowerCase() === witnessScriptHex;
+    })) {
+        return false;
+    }
+    // The scriptPubKey commits to the witnessScript; a mismatch means the
+    // PSBT is lying about the script this signature would authorize.
+    if (!bytesEqual(sha256.sha256(witnessScript), Uint8Array.from(script).subarray(2))) {
+        return false;
+    }
+    // p2ms throws unless the script is exactly OP_m <keys...> OP_n
+    // OP_CHECKMULTISIG, so the key must occupy a signing position.
+    var multisigPubkeys;
+    try {
+        multisigPubkeys = bitcoin__namespace.payments.p2ms({
+            output: witnessScript
+        }).pubkeys;
+    } catch (e) {
+        return false;
+    }
+    if (!multisigPubkeys) {
+        return false;
+    }
+    var publicKeyBytes = Uint8Array.from(publicKey);
+    return multisigPubkeys.some(function(key) {
+        return bytesEqual(Uint8Array.from(key), publicKeyBytes);
+    });
+};
+/**
+ * Checks if a PSBT input belongs to a specific address.
+ *
+ * For P2WSH inputs address equality cannot work (the address commits to the
+ * script, not our key), so ownership is opt-in and means ALL of: the caller
+ * explicitly allowlisted the witnessScript, it hashes to the scriptPubKey
+ * commitment, and it is a canonical m-of-n CHECKMULTISIG script with
+ * `publicKey` in a signing position. Any other script shape is rejected even
+ * if the key appears in it, so a hostile PSBT cannot obtain a signature over
+ * an arbitrary script that merely name-drops the wallet key, and the wallet
+ * never co-signs a multisig arrangement the caller did not name.
  * @param input - The PSBT input (from psbt.data.inputs)
  * @param address - The address to check against
  * @param network - The Bitcoin network
- * @returns True if the input belongs to the address, false otherwise
- */ var doesInputBelongToAddress = function(input, address, network) {
+ * @param publicKey - The wallet's compressed ECDSA public key; required to match P2WSH inputs
+ * @param allowedWitnessScripts - Hex-encoded witnessScripts the caller consents to co-sign; required to match P2WSH inputs
+ * @returns True if the input belongs to the address (or public key, for P2WSH), false otherwise
+ */ var doesInputBelongToAddress = function(input, address, network, publicKey, allowedWitnessScripts) {
     if (!input.witnessUtxo) {
         return false;
     }
@@ -1304,6 +1379,10 @@ function _instanceof$1(left, right) {
                 }).address === address;
             });
         }
+        // Try P2WSH - script is OP_0 <32-byte sha256(witnessScript)>
+        if (isP2wshOutputScript(script)) {
+            return matchesAllowedP2wshMultisig(input, script, publicKey, allowedWitnessScripts);
+        }
         // Try P2TR (Taproot) - script is OP_1 <32-byte x-only pubkey>
         if (script.length === 34 && script[0] === 0x51 && script[1] === 0x20) {
             return networksToTry.some(function(bitcoinNetwork) {
@@ -1325,6 +1404,73 @@ function _instanceof$1(left, right) {
     }
 };
 
+/**
+ * Resolves the BIP-143 scriptCode for a segwit v0 input. Shared by the signer
+ * and the sighash-verification helper so both derive the identical digest.
+ *
+ * P2WSH inputs sign over the full witnessScript, verified against the
+ * scriptPubKey commitment so a PSBT cannot substitute a script the UTXO does
+ * not commit to. P2WPKH inputs sign over the implied P2PKH script.
+ *
+ * @param input - The PSBT input (from psbt.data.inputs)
+ * @param script - The input's witnessUtxo scriptPubKey
+ * @param index - The input index (for error messages)
+ * @param bitcoinNetwork - The bitcoinjs-lib network for P2PKH reconstruction
+ * @returns The scriptCode to feed hashForWitnessV0
+ * @throws Error if a P2WSH input is missing its witnessScript, the witnessScript
+ *   does not hash to the scriptPubKey commitment, or scriptCode generation fails
+ */ var getSegwitV0ScriptCode = function(input, script, index, bitcoinNetwork) {
+    if (isP2wshOutputScript(script)) {
+        if (!input.witnessScript) {
+            throw new Error("Input ".concat(index, " is P2WSH but missing witnessScript"));
+        }
+        var witnessScript = Uint8Array.from(input.witnessScript);
+        // The scriptPubKey commits to the witnessScript; refuse to compute a
+        // sighash over a script the UTXO does not commit to.
+        if (!bytesEqual(sha256.sha256(witnessScript), Uint8Array.from(script).subarray(2))) {
+            throw new Error("Input ".concat(index, " witnessScript does not match the P2WSH scriptPubKey commitment"));
+        }
+        return witnessScript;
+    }
+    // Build P2PKH script code from the pubkey hash in the witness program
+    var p2pkh = bitcoin__namespace.payments.p2pkh({
+        hash: Uint8Array.from(script).subarray(2),
+        network: bitcoinNetwork
+    });
+    if (!p2pkh.output) {
+        throw new Error("Failed to generate scriptCode for input ".concat(index));
+    }
+    return p2pkh.output;
+};
+
+/**
+ * Restricts wallet-owned PSBT inputs to an explicitly requested subset.
+ *
+ * @param inputsToSign - Wallet-owned inputs, each carrying its PSBT index
+ * @param signingIndexes - Optional subset of input indexes the caller wants signed
+ * @returns The requested subset, or all inputs when signingIndexes is omitted/empty
+ * @throws Error if signingIndexes references an input the wallet does not own
+ */ var filterInputsBySigningIndexes = function(inputsToSign, signingIndexes) {
+    if (!(signingIndexes === null || signingIndexes === void 0 ? void 0 : signingIndexes.length)) {
+        return inputsToSign;
+    }
+    var walletOwnedIndexSet = new Set(inputsToSign.map(function(param) {
+        var index = param.index;
+        return index;
+    }));
+    var invalidIndexes = signingIndexes.filter(function(i) {
+        return !walletOwnedIndexSet.has(i);
+    });
+    if (invalidIndexes.length > 0) {
+        throw new Error("signingIndexes contains indexes that do not belong to the signing address: ".concat(invalidIndexes.join(', ')));
+    }
+    var requestedIndexSet = new Set(signingIndexes);
+    return inputsToSign.filter(function(param) {
+        var index = param.index;
+        return requestedIndexSet.has(index);
+    });
+};
+
 /**
  * Resolves the sighash type for a PSBT input.
  *
@@ -1477,9 +1623,13 @@ function _type_of(obj) {
  * Extracts sighashes from a PSBT for validation.
  * This is used to verify that the message being signed matches the PSBT context.
  *
+ * P2WSH inputs whose witnessScript is absent yield `null` instead of a hash:
+ * finalization strips witnessScript from completed inputs, so a co-signer's
+ * already-finalized input must not block validation of the remaining inputs.
+ *
  * @param psbtBase64 - PSBT in base64 format
  * @param network - 'mainnet' or 'testnet' or BitcoinNetwork enum (defaults to 'mainnet')
- * @returns Array of sighash hex strings for each input
+ * @returns Array of sighash hex strings, aligned by input index; `null` for inputs whose sighash cannot be derived
  */ var extractPsbtSighashes = function(psbtBase64) {
     var network = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'mainnet';
     // Convert string network to BitcoinNetwork enum
@@ -1501,23 +1651,19 @@ function _type_of(obj) {
             // sighash type, defaulting to SIGHASH_DEFAULT
             var hash = tx.hashForWitnessV1(i, prevOutScripts, values, getSigHashType(input, true));
             sighashes.push(Buffer.from(hash).toString('hex'));
-        } else {
-            // Native SegWit (BIP-143) - uses hashForWitnessV0 with the input's
-            // declared sighash type, defaulting to SIGHASH_ALL
-            // witnessUtxo is guaranteed to exist from collectPSBTInputData validation
-            var _input_witnessUtxo = input.witnessUtxo, script = _input_witnessUtxo.script, value = _input_witnessUtxo.value;
-            // Build P2PKH script code from the pubkey hash in the witness program
-            var p2pkh = bitcoin__namespace.payments.p2pkh({
-                hash: new Uint8Array(toBuffer(script).subarray(2)),
-                network: bitcoinNetwork
-            });
-            var scriptCode = p2pkh.output;
-            if (!scriptCode) {
-                throw new Error("Failed to generate scriptCode for input ".concat(i));
-            }
-            var hash1 = tx.hashForWitnessV0(i, scriptCode, value, getSigHashType(input, false));
-            sighashes.push(Buffer.from(hash1).toString('hex'));
+            continue;
+        }
+        // Native SegWit (BIP-143) - uses hashForWitnessV0 with the input's
+        // declared sighash type, defaulting to SIGHASH_ALL
+        // witnessUtxo is guaranteed to exist from collectPSBTInputData validation
+        var _input_witnessUtxo = input.witnessUtxo, script = _input_witnessUtxo.script, value = _input_witnessUtxo.value;
+        if (isP2wshOutputScript(script) && !input.witnessScript) {
+            sighashes.push(null);
+            continue;
         }
+        var scriptCode = getSegwitV0ScriptCode(input, script, i, bitcoinNetwork);
+        var hash1 = tx.hashForWitnessV0(i, scriptCode, value, getSigHashType(input, false));
+        sighashes.push(Buffer.from(hash1).toString('hex'));
     }
     return sighashes;
 };
@@ -1572,14 +1718,17 @@ exports.doesInputBelongToAddress = doesInputBelongToAddress;
 exports.encodeBip322Signature = encodeBip322Signature;
 exports.extractPsbtSighashes = extractPsbtSighashes;
 exports.extractPublicKeyHex = extractPublicKeyHex;
+exports.filterInputsBySigningIndexes = filterInputsBySigningIndexes;
 exports.getAddressTypeFromDerivationPath = getAddressTypeFromDerivationPath;
 exports.getBitcoinNetwork = getBitcoinNetwork;
 exports.getDefaultRpcUrl = getDefaultRpcUrl;
 exports.getFeeRates = getFeeRates;
 exports.getPublicKeyFromPrivateKey = getPublicKeyFromPrivateKey;
+exports.getSegwitV0ScriptCode = getSegwitV0ScriptCode;
 exports.getSigHashType = getSigHashType;
 exports.getUTXOs = getUTXOs;
 exports.initEccLib = initEccLib;
+exports.isP2wshOutputScript = isP2wshOutputScript;
 exports.normalizeForCompressed = normalizeForCompressed;
 exports.normalizeForTaproot = normalizeForTaproot;
 exports.normalizePublicKey = normalizePublicKey;

package/index.esm.js

@@ -1247,6 +1247,30 @@ function _instanceof$2(left, right) {
     };
 };
 
+/**
+ * Checks if an output script (scriptPubKey) is P2WSH: OP_0 <32-byte sha256(witnessScript)>
+ *
+ * ArrayLike keeps this callable with Buffer or Uint8Array — the iframe build
+ * compiles with browser typings where Buffer is not assignable to Uint8Array.
+ * @param script - The output script to check
+ * @returns True if the script has the P2WSH shape
+ */ var isP2wshOutputScript = function(script) {
+    return script.length === 34 && script[0] === 0x00 && script[1] === 0x20;
+};
+
+/**
+ * Constant-shape byte equality without Buffer — the iframe build compiles
+ * this package with browser typings where Buffer is not assignable to
+ * Uint8Array.
+ * @param a - First byte array
+ * @param b - Second byte array
+ * @returns True if both arrays have identical length and contents
+ */ var bytesEqual = function(a, b) {
+    return a.length === b.length && a.every(function(byte, index) {
+        return byte === b[index];
+    });
+};
+
 function _instanceof$1(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -1255,12 +1279,63 @@ function _instanceof$1(left, right) {
     }
 }
 /**
- * Checks if a PSBT input belongs to a specific address
+ * P2WSH ownership: the caller allowlisted the witnessScript, it hashes to the
+ * scriptPubKey commitment, and it is a canonical m-of-n CHECKMULTISIG with
+ * `publicKey` in a signing position.
+ */ var matchesAllowedP2wshMultisig = function(input, script, publicKey, allowedWitnessScripts) {
+    if (!publicKey || !input.witnessScript || !(allowedWitnessScripts === null || allowedWitnessScripts === void 0 ? void 0 : allowedWitnessScripts.length)) {
+        return false;
+    }
+    var witnessScript = Uint8Array.from(input.witnessScript);
+    // P2WSH co-signing is opt-in: the wallet only signs arrangements the
+    // caller explicitly named in this request.
+    var witnessScriptHex = Buffer.from(witnessScript).toString('hex');
+    if (!allowedWitnessScripts.some(function(hex) {
+        return hex.toLowerCase() === witnessScriptHex;
+    })) {
+        return false;
+    }
+    // The scriptPubKey commits to the witnessScript; a mismatch means the
+    // PSBT is lying about the script this signature would authorize.
+    if (!bytesEqual(sha256(witnessScript), Uint8Array.from(script).subarray(2))) {
+        return false;
+    }
+    // p2ms throws unless the script is exactly OP_m <keys...> OP_n
+    // OP_CHECKMULTISIG, so the key must occupy a signing position.
+    var multisigPubkeys;
+    try {
+        multisigPubkeys = bitcoin.payments.p2ms({
+            output: witnessScript
+        }).pubkeys;
+    } catch (e) {
+        return false;
+    }
+    if (!multisigPubkeys) {
+        return false;
+    }
+    var publicKeyBytes = Uint8Array.from(publicKey);
+    return multisigPubkeys.some(function(key) {
+        return bytesEqual(Uint8Array.from(key), publicKeyBytes);
+    });
+};
+/**
+ * Checks if a PSBT input belongs to a specific address.
+ *
+ * For P2WSH inputs address equality cannot work (the address commits to the
+ * script, not our key), so ownership is opt-in and means ALL of: the caller
+ * explicitly allowlisted the witnessScript, it hashes to the scriptPubKey
+ * commitment, and it is a canonical m-of-n CHECKMULTISIG script with
+ * `publicKey` in a signing position. Any other script shape is rejected even
+ * if the key appears in it, so a hostile PSBT cannot obtain a signature over
+ * an arbitrary script that merely name-drops the wallet key, and the wallet
+ * never co-signs a multisig arrangement the caller did not name.
  * @param input - The PSBT input (from psbt.data.inputs)
  * @param address - The address to check against
  * @param network - The Bitcoin network
- * @returns True if the input belongs to the address, false otherwise
- */ var doesInputBelongToAddress = function(input, address, network) {
+ * @param publicKey - The wallet's compressed ECDSA public key; required to match P2WSH inputs
+ * @param allowedWitnessScripts - Hex-encoded witnessScripts the caller consents to co-sign; required to match P2WSH inputs
+ * @returns True if the input belongs to the address (or public key, for P2WSH), false otherwise
+ */ var doesInputBelongToAddress = function(input, address, network, publicKey, allowedWitnessScripts) {
     if (!input.witnessUtxo) {
         return false;
     }
@@ -1284,6 +1359,10 @@ function _instanceof$1(left, right) {
                 }).address === address;
             });
         }
+        // Try P2WSH - script is OP_0 <32-byte sha256(witnessScript)>
+        if (isP2wshOutputScript(script)) {
+            return matchesAllowedP2wshMultisig(input, script, publicKey, allowedWitnessScripts);
+        }
         // Try P2TR (Taproot) - script is OP_1 <32-byte x-only pubkey>
         if (script.length === 34 && script[0] === 0x51 && script[1] === 0x20) {
             return networksToTry.some(function(bitcoinNetwork) {
@@ -1305,6 +1384,73 @@ function _instanceof$1(left, right) {
     }
 };
 
+/**
+ * Resolves the BIP-143 scriptCode for a segwit v0 input. Shared by the signer
+ * and the sighash-verification helper so both derive the identical digest.
+ *
+ * P2WSH inputs sign over the full witnessScript, verified against the
+ * scriptPubKey commitment so a PSBT cannot substitute a script the UTXO does
+ * not commit to. P2WPKH inputs sign over the implied P2PKH script.
+ *
+ * @param input - The PSBT input (from psbt.data.inputs)
+ * @param script - The input's witnessUtxo scriptPubKey
+ * @param index - The input index (for error messages)
+ * @param bitcoinNetwork - The bitcoinjs-lib network for P2PKH reconstruction
+ * @returns The scriptCode to feed hashForWitnessV0
+ * @throws Error if a P2WSH input is missing its witnessScript, the witnessScript
+ *   does not hash to the scriptPubKey commitment, or scriptCode generation fails
+ */ var getSegwitV0ScriptCode = function(input, script, index, bitcoinNetwork) {
+    if (isP2wshOutputScript(script)) {
+        if (!input.witnessScript) {
+            throw new Error("Input ".concat(index, " is P2WSH but missing witnessScript"));
+        }
+        var witnessScript = Uint8Array.from(input.witnessScript);
+        // The scriptPubKey commits to the witnessScript; refuse to compute a
+        // sighash over a script the UTXO does not commit to.
+        if (!bytesEqual(sha256(witnessScript), Uint8Array.from(script).subarray(2))) {
+            throw new Error("Input ".concat(index, " witnessScript does not match the P2WSH scriptPubKey commitment"));
+        }
+        return witnessScript;
+    }
+    // Build P2PKH script code from the pubkey hash in the witness program
+    var p2pkh = bitcoin.payments.p2pkh({
+        hash: Uint8Array.from(script).subarray(2),
+        network: bitcoinNetwork
+    });
+    if (!p2pkh.output) {
+        throw new Error("Failed to generate scriptCode for input ".concat(index));
+    }
+    return p2pkh.output;
+};
+
+/**
+ * Restricts wallet-owned PSBT inputs to an explicitly requested subset.
+ *
+ * @param inputsToSign - Wallet-owned inputs, each carrying its PSBT index
+ * @param signingIndexes - Optional subset of input indexes the caller wants signed
+ * @returns The requested subset, or all inputs when signingIndexes is omitted/empty
+ * @throws Error if signingIndexes references an input the wallet does not own
+ */ var filterInputsBySigningIndexes = function(inputsToSign, signingIndexes) {
+    if (!(signingIndexes === null || signingIndexes === void 0 ? void 0 : signingIndexes.length)) {
+        return inputsToSign;
+    }
+    var walletOwnedIndexSet = new Set(inputsToSign.map(function(param) {
+        var index = param.index;
+        return index;
+    }));
+    var invalidIndexes = signingIndexes.filter(function(i) {
+        return !walletOwnedIndexSet.has(i);
+    });
+    if (invalidIndexes.length > 0) {
+        throw new Error("signingIndexes contains indexes that do not belong to the signing address: ".concat(invalidIndexes.join(', ')));
+    }
+    var requestedIndexSet = new Set(signingIndexes);
+    return inputsToSign.filter(function(param) {
+        var index = param.index;
+        return requestedIndexSet.has(index);
+    });
+};
+
 /**
  * Resolves the sighash type for a PSBT input.
  *
@@ -1457,9 +1603,13 @@ function _type_of(obj) {
  * Extracts sighashes from a PSBT for validation.
  * This is used to verify that the message being signed matches the PSBT context.
  *
+ * P2WSH inputs whose witnessScript is absent yield `null` instead of a hash:
+ * finalization strips witnessScript from completed inputs, so a co-signer's
+ * already-finalized input must not block validation of the remaining inputs.
+ *
  * @param psbtBase64 - PSBT in base64 format
  * @param network - 'mainnet' or 'testnet' or BitcoinNetwork enum (defaults to 'mainnet')
- * @returns Array of sighash hex strings for each input
+ * @returns Array of sighash hex strings, aligned by input index; `null` for inputs whose sighash cannot be derived
  */ var extractPsbtSighashes = function(psbtBase64) {
     var network = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'mainnet';
     // Convert string network to BitcoinNetwork enum
@@ -1481,23 +1631,19 @@ function _type_of(obj) {
             // sighash type, defaulting to SIGHASH_DEFAULT
             var hash = tx.hashForWitnessV1(i, prevOutScripts, values, getSigHashType(input, true));
             sighashes.push(Buffer.from(hash).toString('hex'));
-        } else {
-            // Native SegWit (BIP-143) - uses hashForWitnessV0 with the input's
-            // declared sighash type, defaulting to SIGHASH_ALL
-            // witnessUtxo is guaranteed to exist from collectPSBTInputData validation
-            var _input_witnessUtxo = input.witnessUtxo, script = _input_witnessUtxo.script, value = _input_witnessUtxo.value;
-            // Build P2PKH script code from the pubkey hash in the witness program
-            var p2pkh = bitcoin.payments.p2pkh({
-                hash: new Uint8Array(toBuffer(script).subarray(2)),
-                network: bitcoinNetwork
-            });
-            var scriptCode = p2pkh.output;
-            if (!scriptCode) {
-                throw new Error("Failed to generate scriptCode for input ".concat(i));
-            }
-            var hash1 = tx.hashForWitnessV0(i, scriptCode, value, getSigHashType(input, false));
-            sighashes.push(Buffer.from(hash1).toString('hex'));
+            continue;
+        }
+        // Native SegWit (BIP-143) - uses hashForWitnessV0 with the input's
+        // declared sighash type, defaulting to SIGHASH_ALL
+        // witnessUtxo is guaranteed to exist from collectPSBTInputData validation
+        var _input_witnessUtxo = input.witnessUtxo, script = _input_witnessUtxo.script, value = _input_witnessUtxo.value;
+        if (isP2wshOutputScript(script) && !input.witnessScript) {
+            sighashes.push(null);
+            continue;
         }
+        var scriptCode = getSegwitV0ScriptCode(input, script, i, bitcoinNetwork);
+        var hash1 = tx.hashForWitnessV0(i, scriptCode, value, getSigHashType(input, false));
+        sighashes.push(Buffer.from(hash1).toString('hex'));
     }
     return sighashes;
 };
@@ -1537,4 +1683,4 @@ function _type_of(obj) {
     return Buffer.from(formattedMessage).toString('hex');
 };
 
-export { assertSighashAllowed, calculateBip322Hash, calculateTaprootTweak, collectPSBTInputData, computeBip322HashHex, convertSignatureToDER, convertSignatureToTaprootBuffer, createLegacyAddress, createNativeSegWitAddress, createSegWitAddress, createTaprootAddress, doesInputBelongToAddress, encodeBip322Signature, extractPsbtSighashes, extractPublicKeyHex, getAddressTypeFromDerivationPath, getBitcoinNetwork, getDefaultRpcUrl, getFeeRates, getPublicKeyFromPrivateKey, getSigHashType, getUTXOs, initEccLib, normalizeForCompressed, normalizeForTaproot, normalizePublicKey, privateKeyToWIF, publicKeyToBitcoinAddress, selectUTXOs, toBitcoinNetwork, toBuffer, wifToPrivateKey };
+export { assertSighashAllowed, calculateBip322Hash, calculateTaprootTweak, collectPSBTInputData, computeBip322HashHex, convertSignatureToDER, convertSignatureToTaprootBuffer, createLegacyAddress, createNativeSegWitAddress, createSegWitAddress, createTaprootAddress, doesInputBelongToAddress, encodeBip322Signature, extractPsbtSighashes, extractPublicKeyHex, filterInputsBySigningIndexes, getAddressTypeFromDerivationPath, getBitcoinNetwork, getDefaultRpcUrl, getFeeRates, getPublicKeyFromPrivateKey, getSegwitV0ScriptCode, getSigHashType, getUTXOs, initEccLib, isP2wshOutputScript, normalizeForCompressed, normalizeForTaproot, normalizePublicKey, privateKeyToWIF, publicKeyToBitcoinAddress, selectUTXOs, toBitcoinNetwork, toBuffer, wifToPrivateKey };

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dynamic-labs-wallet/btc-utils",
-  "version": "1.0.106",
+  "version": "1.0.108",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dynamic-labs-wallet/core": "1.0.106",
+    "@dynamic-labs-wallet/core": "1.0.108",
     "bitcoinjs-lib": "^7.0.0",
     "bip322-js": "^3.0.0",
     "@noble/hashes": "1.7.1",

package/src/bytesEqual/bytesEqual.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Constant-shape byte equality without Buffer — the iframe build compiles
+ * this package with browser typings where Buffer is not assignable to
+ * Uint8Array.
+ * @param a - First byte array
+ * @param b - Second byte array
+ * @returns True if both arrays have identical length and contents
+ */
+export declare const bytesEqual: (a: Uint8Array, b: Uint8Array) => boolean;
+//# sourceMappingURL=bytesEqual.d.ts.map

package/src/bytesEqual/bytesEqual.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytesEqual.d.ts","sourceRoot":"","sources":["../../src/bytesEqual/bytesEqual.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,MAAO,UAAU,KAAK,UAAU,KAAG,OACY,CAAC"}

package/src/bytesEqual/index.d.ts

@@ -0,0 +1,2 @@
+export { bytesEqual } from './bytesEqual.js';
+//# sourceMappingURL=index.d.ts.map

package/src/bytesEqual/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bytesEqual/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC"}

package/src/doesInputBelongToAddress/doesInputBelongToAddress.d.ts

@@ -1,11 +1,22 @@
 import type { Psbt } from 'bitcoinjs-lib';
 import { BitcoinNetwork } from '@dynamic-labs-wallet/core';
 /**
- * Checks if a PSBT input belongs to a specific address
+ * Checks if a PSBT input belongs to a specific address.
+ *
+ * For P2WSH inputs address equality cannot work (the address commits to the
+ * script, not our key), so ownership is opt-in and means ALL of: the caller
+ * explicitly allowlisted the witnessScript, it hashes to the scriptPubKey
+ * commitment, and it is a canonical m-of-n CHECKMULTISIG script with
+ * `publicKey` in a signing position. Any other script shape is rejected even
+ * if the key appears in it, so a hostile PSBT cannot obtain a signature over
+ * an arbitrary script that merely name-drops the wallet key, and the wallet
+ * never co-signs a multisig arrangement the caller did not name.
  * @param input - The PSBT input (from psbt.data.inputs)
  * @param address - The address to check against
  * @param network - The Bitcoin network
- * @returns True if the input belongs to the address, false otherwise
+ * @param publicKey - The wallet's compressed ECDSA public key; required to match P2WSH inputs
+ * @param allowedWitnessScripts - Hex-encoded witnessScripts the caller consents to co-sign; required to match P2WSH inputs
+ * @returns True if the input belongs to the address (or public key, for P2WSH), false otherwise
  */
-export declare const doesInputBelongToAddress: (input: Psbt["data"]["inputs"][number], address: string, network: BitcoinNetwork) => boolean;
+export declare const doesInputBelongToAddress: (input: Psbt["data"]["inputs"][number], address: string, network: BitcoinNetwork, publicKey?: ArrayLike<number>, allowedWitnessScripts?: string[]) => boolean;
 //# sourceMappingURL=doesInputBelongToAddress.d.ts.map

package/src/doesInputBelongToAddress/doesInputBelongToAddress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doesInputBelongToAddress.d.ts","sourceRoot":"","sources":["../../src/doesInputBelongToAddress/doesInputBelongToAddress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAG3D;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,UAC5B,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,WAC5B,MAAM,WACN,cAAc,KACtB,OAkDF,CAAC"}
+{"version":3,"file":"doesInputBelongToAddress.d.ts","sourceRoot":"","sources":["../../src/doesInputBelongToAddress/doesInputBelongToAddress.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAmD3D;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,wBAAwB,UAC5B,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,WAC5B,MAAM,WACN,cAAc,cACX,SAAS,CAAC,MAAM,CAAC,0BACL,MAAM,EAAE,KAC/B,OAuDF,CAAC"}

package/src/extractPsbtSighashes/extractPsbtSighashes.d.ts

@@ -3,9 +3,13 @@ import type { BitcoinNetwork } from '@dynamic-labs-wallet/core';
  * Extracts sighashes from a PSBT for validation.
  * This is used to verify that the message being signed matches the PSBT context.
  *
+ * P2WSH inputs whose witnessScript is absent yield `null` instead of a hash:
+ * finalization strips witnessScript from completed inputs, so a co-signer's
+ * already-finalized input must not block validation of the remaining inputs.
+ *
  * @param psbtBase64 - PSBT in base64 format
  * @param network - 'mainnet' or 'testnet' or BitcoinNetwork enum (defaults to 'mainnet')
- * @returns Array of sighash hex strings for each input
+ * @returns Array of sighash hex strings, aligned by input index; `null` for inputs whose sighash cannot be derived
  */
-export declare const extractPsbtSighashes: (psbtBase64: string, network?: BitcoinNetwork | "mainnet" | "testnet") => string[];
+export declare const extractPsbtSighashes: (psbtBase64: string, network?: BitcoinNetwork | "mainnet" | "testnet") => (string | null)[];
 //# sourceMappingURL=extractPsbtSighashes.d.ts.map

package/src/extractPsbtSighashes/extractPsbtSighashes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extractPsbtSighashes.d.ts","sourceRoot":"","sources":["../../src/extractPsbtSighashes/extractPsbtSighashes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAOhE;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,eACnB,MAAM,YACT,cAAc,GAAG,SAAS,GAAG,SAAS,KAC9C,MAAM,EA8CR,CAAC"}
+{"version":3,"file":"extractPsbtSighashes.d.ts","sourceRoot":"","sources":["../../src/extractPsbtSighashes/extractPsbtSighashes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAQhE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,eACnB,MAAM,YACT,cAAc,GAAG,SAAS,GAAG,SAAS,KAC9C,CAAC,MAAM,GAAG,IAAI,CAAC,EA2CjB,CAAC"}

package/src/filterInputsBySigningIndexes/filterInputsBySigningIndexes.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Restricts wallet-owned PSBT inputs to an explicitly requested subset.
+ *
+ * @param inputsToSign - Wallet-owned inputs, each carrying its PSBT index
+ * @param signingIndexes - Optional subset of input indexes the caller wants signed
+ * @returns The requested subset, or all inputs when signingIndexes is omitted/empty
+ * @throws Error if signingIndexes references an input the wallet does not own
+ */
+export declare const filterInputsBySigningIndexes: <T extends {
+    index: number;
+}>(inputsToSign: T[], signingIndexes?: number[]) => T[];
+//# sourceMappingURL=filterInputsBySigningIndexes.d.ts.map

package/src/filterInputsBySigningIndexes/filterInputsBySigningIndexes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filterInputsBySigningIndexes.d.ts","sourceRoot":"","sources":["../../src/filterInputsBySigningIndexes/filterInputsBySigningIndexes.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,4BAA4B,GAAI,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,gBACxD,CAAC,EAAE,mBACA,MAAM,EAAE,KACxB,CAAC,EAeH,CAAC"}

package/src/filterInputsBySigningIndexes/index.d.ts

@@ -0,0 +1,2 @@
+export { filterInputsBySigningIndexes } from './filterInputsBySigningIndexes.js';
+//# sourceMappingURL=index.d.ts.map

package/src/filterInputsBySigningIndexes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/filterInputsBySigningIndexes/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,mCAAmC,CAAC"}

package/src/getSegwitV0ScriptCode/getSegwitV0ScriptCode.d.ts

@@ -0,0 +1,20 @@
+import * as bitcoin from 'bitcoinjs-lib';
+import type { Psbt } from 'bitcoinjs-lib';
+/**
+ * Resolves the BIP-143 scriptCode for a segwit v0 input. Shared by the signer
+ * and the sighash-verification helper so both derive the identical digest.
+ *
+ * P2WSH inputs sign over the full witnessScript, verified against the
+ * scriptPubKey commitment so a PSBT cannot substitute a script the UTXO does
+ * not commit to. P2WPKH inputs sign over the implied P2PKH script.
+ *
+ * @param input - The PSBT input (from psbt.data.inputs)
+ * @param script - The input's witnessUtxo scriptPubKey
+ * @param index - The input index (for error messages)
+ * @param bitcoinNetwork - The bitcoinjs-lib network for P2PKH reconstruction
+ * @returns The scriptCode to feed hashForWitnessV0
+ * @throws Error if a P2WSH input is missing its witnessScript, the witnessScript
+ *   does not hash to the scriptPubKey commitment, or scriptCode generation fails
+ */
+export declare const getSegwitV0ScriptCode: (input: Psbt["data"]["inputs"][number], script: ArrayLike<number>, index: number, bitcoinNetwork: bitcoin.networks.Network) => Uint8Array;
+//# sourceMappingURL=getSegwitV0ScriptCode.d.ts.map

package/src/getSegwitV0ScriptCode/getSegwitV0ScriptCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSegwitV0ScriptCode.d.ts","sourceRoot":"","sources":["../../src/getSegwitV0ScriptCode/getSegwitV0ScriptCode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAK1C;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,UACzB,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,UAC7B,SAAS,CAAC,MAAM,CAAC,SAClB,MAAM,kBACG,OAAO,CAAC,QAAQ,CAAC,OAAO,KACvC,UAyBF,CAAC"}

package/src/getSegwitV0ScriptCode/index.d.ts

@@ -0,0 +1,2 @@
+export { getSegwitV0ScriptCode } from './getSegwitV0ScriptCode.js';
+//# sourceMappingURL=index.d.ts.map

package/src/getSegwitV0ScriptCode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/getSegwitV0ScriptCode/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC"}

package/src/index.d.ts

@@ -15,6 +15,9 @@ export { calculateTaprootTweak } from './calculateTaprootTweak/index.js';
 export { convertSignatureToTaprootBuffer } from './convertSignatureToTaprootBuffer/index.js';
 export { collectPSBTInputData } from './collectPSBTInputData/index.js';
 export { doesInputBelongToAddress } from './doesInputBelongToAddress/index.js';
+export { isP2wshOutputScript } from './isP2wshOutputScript/index.js';
+export { getSegwitV0ScriptCode } from './getSegwitV0ScriptCode/index.js';
+export { filterInputsBySigningIndexes } from './filterInputsBySigningIndexes/index.js';
 export { getBitcoinNetwork } from './getBitcoinNetwork/index.js';
 export { getSigHashType } from './getSigHashType/index.js';
 export { assertSighashAllowed } from './assertSighashAllowed/index.js';

package/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,+BAA+B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,YAAY,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAGvE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAG/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../packages/src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,gCAAgC,EAAE,MAAM,6CAA6C,CAAC;AAC/F,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AACnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,+BAA+B,EAAE,MAAM,4CAA4C,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AACzE,OAAO,EAAE,4BAA4B,EAAE,MAAM,yCAAyC,CAAC;AACvF,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,YAAY,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AACjF,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AAGvE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAG/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAC"}

package/src/isP2wshOutputScript/index.d.ts

@@ -0,0 +1,2 @@
+export { isP2wshOutputScript } from './isP2wshOutputScript.js';
+//# sourceMappingURL=index.d.ts.map

package/src/isP2wshOutputScript/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/isP2wshOutputScript/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC"}

package/src/isP2wshOutputScript/isP2wshOutputScript.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Checks if an output script (scriptPubKey) is P2WSH: OP_0 <32-byte sha256(witnessScript)>
+ *
+ * ArrayLike keeps this callable with Buffer or Uint8Array — the iframe build
+ * compiles with browser typings where Buffer is not assignable to Uint8Array.
+ * @param script - The output script to check
+ * @returns True if the script has the P2WSH shape
+ */
+export declare const isP2wshOutputScript: (script: ArrayLike<number>) => boolean;
+//# sourceMappingURL=isP2wshOutputScript.d.ts.map

package/src/isP2wshOutputScript/isP2wshOutputScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isP2wshOutputScript.d.ts","sourceRoot":"","sources":["../../src/isP2wshOutputScript/isP2wshOutputScript.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,WAAY,SAAS,CAAC,MAAM,CAAC,KAAG,OACE,CAAC"}