@dynamic-labs-wallet/btc-utils 1.0.105 → 1.0.107

package/index.cjs

@@ -726,8 +726,12 @@ function _instanceof$3(left, right) {
  * Converts an ECDSA signature to DER format
  *
  * @param signature - The ECDSA signature
+ * @param sighashType - The sighash type to append as the DER trailing byte.
+ *   Must match the type the signing hash was built with, or the signature will
+ *   fail verification at finalize/broadcast. Defaults to SIGHASH_ALL.
  * @returns The DER encoded signature
  */ var convertSignatureToDER = function(signature) {
+    var sighashType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : bitcoin__namespace.Transaction.SIGHASH_ALL;
     var r = _instanceof$3(signature.r, Uint8Array) ? signature.r : new Uint8Array(signature.r);
     var s = _instanceof$3(signature.s, Uint8Array) ? signature.s : new Uint8Array(signature.s);
     var r32 = new Uint8Array(32);
@@ -739,7 +743,7 @@ function _instanceof$3(left, right) {
     var rawSignature = new Uint8Array(64);
     rawSignature.set(r32, 0);
     rawSignature.set(s32, 32);
-    var derSignature = bitcoin__namespace.script.signature.encode(rawSignature, bitcoin__namespace.Transaction.SIGHASH_ALL);
+    var derSignature = bitcoin__namespace.script.signature.encode(rawSignature, sighashType);
     return derSignature;
 };
 
@@ -1210,19 +1214,34 @@ function _instanceof$2(left, right) {
  * Converts a signature to a Buffer format suitable for Taproot (BIP340/Schnorr)
  *
  * @param signature - The signature from MPC (can be Uint8Array, Buffer, or EcdsaSignature object)
- * @returns A Buffer containing the 64-byte Schnorr signature
+ * @param sighashType - The sighash type the signing hash was built with. Per
+ *   BIP-341 the signature stays 64 bytes for SIGHASH_DEFAULT and gains the
+ *   sighash type as a 65th byte for any other type. Defaults to SIGHASH_DEFAULT.
+ * @returns A Buffer containing the 64-byte (or 65-byte) Schnorr signature
  */ var convertSignatureToTaprootBuffer = function(signature) {
+    var sighashType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : bitcoin__namespace.Transaction.SIGHASH_DEFAULT;
+    var schnorrSignature;
     if (_instanceof$2(signature, Uint8Array) || Buffer.isBuffer(signature)) {
-        return Buffer.from(signature);
+        schnorrSignature = Buffer.from(signature);
+    } else {
+        var r = signature.r;
+        var s = signature.s;
+        var rBuf = Buffer.isBuffer(r) ? r : Buffer.from(r);
+        var sBuf = Buffer.isBuffer(s) ? s : Buffer.from(s);
+        // Safe: creates Uint8Array views over Buffer's underlying memory without copying
+        schnorrSignature = Buffer.concat([
+            new Uint8Array(rBuf),
+            new Uint8Array(sBuf)
+        ]);
+    }
+    if (sighashType === bitcoin__namespace.Transaction.SIGHASH_DEFAULT) {
+        return schnorrSignature;
     }
-    var r = signature.r;
-    var s = signature.s;
-    var rBuf = Buffer.isBuffer(r) ? r : Buffer.from(r);
-    var sBuf = Buffer.isBuffer(s) ? s : Buffer.from(s);
-    // Safe: creates Uint8Array views over Buffer's underlying memory without copying
     return Buffer.concat([
-        new Uint8Array(rBuf),
-        new Uint8Array(sBuf)
+        new Uint8Array(schnorrSignature),
+        new Uint8Array([
+            sighashType
+        ])
     ]);
 };
 
@@ -1248,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);
@@ -1256,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;
     }
@@ -1285,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) {
@@ -1306,6 +1404,139 @@ 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.
+ *
+ * The type is read from the PSBT itself (BIP-174 `PSBT_IN_SIGHASH_TYPE`), never
+ * supplied by the caller — the signing hash and the policy layer's verification
+ * hash must be derived from the same bytes, or every non-default signature
+ * would be rejected as tampered.
+ *
+ * When the input declares nothing, falls back to the historical default:
+ * SIGHASH_DEFAULT (0x00) for Taproot, SIGHASH_ALL (0x01) otherwise.
+ *
+ * @param input - The PSBT input to resolve the sighash type for
+ * @param isTaproot - Whether the input is spent as Taproot. Defaults to
+ *   detecting `tapInternalKey`; pass explicitly when the caller already knows
+ *   which signing branch it is on, so the fallback matches the hash function
+ *   actually used.
+ * @returns The sighash type to build and encode the signature with
+ */ var getSigHashType = function(input) {
+    var isTaproot = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Boolean(input.tapInternalKey);
+    var _input_sighashType;
+    return (_input_sighashType = input.sighashType) !== null && _input_sighashType !== void 0 ? _input_sighashType : isTaproot ? bitcoin__namespace.Transaction.SIGHASH_DEFAULT : bitcoin__namespace.Transaction.SIGHASH_ALL;
+};
+
+/**
+ * Throws unless every input's PSBT-declared sighash type is in the allow-list.
+ *
+ * Call this before any signing begins — inputs are signed in parallel, so
+ * throwing partway through would leave a partially signed PSBT behind.
+ *
+ * An empty array permits nothing rather than everything: a caller whose
+ * allow-list computes to empty must not silently get the guard disabled. Omit
+ * the parameter entirely to permit any declared type.
+ *
+ * @param inputsToSign - The wallet-owned inputs about to be signed, with their PSBT indexes
+ * @param isTaproot - Whether signing takes the Taproot branch, so the fallback
+ *   sighash type matches the hash function actually used
+ * @param allowedSighash - Optional allow-list of permitted sighash types
+ */ var assertSighashAllowed = function(inputsToSign, isTaproot, allowedSighash) {
+    if (!allowedSighash) {
+        return;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = inputsToSign[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _step.value, input = _step_value.input, index = _step_value.index;
+            var sigHashType = getSigHashType(input, isTaproot);
+            if (!allowedSighash.includes(sigHashType)) {
+                throw new Error("Input ".concat(index, " declares sighash type ").concat(sigHashType, ", which is not in allowedSighash: ").concat(allowedSighash.join(', ') || '(empty)'));
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+};
+
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -1392,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
@@ -1412,25 +1647,23 @@ function _type_of(obj) {
     for(var i = 0; i < psbt.inputCount; i++){
         var input = psbt.data.inputs[i];
         if (input.tapInternalKey) {
-            // Taproot (BIP-341) - uses hashForWitnessV1 with SIGHASH_DEFAULT
-            var hash = tx.hashForWitnessV1(i, prevOutScripts, values, bitcoin__namespace.Transaction.SIGHASH_DEFAULT);
+            // Taproot (BIP-341) - uses hashForWitnessV1 with the input's declared
+            // 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 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, bitcoin__namespace.Transaction.SIGHASH_ALL);
-            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;
 };
@@ -1470,6 +1703,7 @@ function _type_of(obj) {
     return Buffer.from(formattedMessage).toString('hex');
 };
 
+exports.assertSighashAllowed = assertSighashAllowed;
 exports.calculateBip322Hash = calculateBip322Hash;
 exports.calculateTaprootTweak = calculateTaprootTweak;
 exports.collectPSBTInputData = collectPSBTInputData;
@@ -1484,13 +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

@@ -706,8 +706,12 @@ function _instanceof$3(left, right) {
  * Converts an ECDSA signature to DER format
  *
  * @param signature - The ECDSA signature
+ * @param sighashType - The sighash type to append as the DER trailing byte.
+ *   Must match the type the signing hash was built with, or the signature will
+ *   fail verification at finalize/broadcast. Defaults to SIGHASH_ALL.
  * @returns The DER encoded signature
  */ var convertSignatureToDER = function(signature) {
+    var sighashType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : bitcoin.Transaction.SIGHASH_ALL;
     var r = _instanceof$3(signature.r, Uint8Array) ? signature.r : new Uint8Array(signature.r);
     var s = _instanceof$3(signature.s, Uint8Array) ? signature.s : new Uint8Array(signature.s);
     var r32 = new Uint8Array(32);
@@ -719,7 +723,7 @@ function _instanceof$3(left, right) {
     var rawSignature = new Uint8Array(64);
     rawSignature.set(r32, 0);
     rawSignature.set(s32, 32);
-    var derSignature = bitcoin.script.signature.encode(rawSignature, bitcoin.Transaction.SIGHASH_ALL);
+    var derSignature = bitcoin.script.signature.encode(rawSignature, sighashType);
     return derSignature;
 };
 
@@ -1190,19 +1194,34 @@ function _instanceof$2(left, right) {
  * Converts a signature to a Buffer format suitable for Taproot (BIP340/Schnorr)
  *
  * @param signature - The signature from MPC (can be Uint8Array, Buffer, or EcdsaSignature object)
- * @returns A Buffer containing the 64-byte Schnorr signature
+ * @param sighashType - The sighash type the signing hash was built with. Per
+ *   BIP-341 the signature stays 64 bytes for SIGHASH_DEFAULT and gains the
+ *   sighash type as a 65th byte for any other type. Defaults to SIGHASH_DEFAULT.
+ * @returns A Buffer containing the 64-byte (or 65-byte) Schnorr signature
  */ var convertSignatureToTaprootBuffer = function(signature) {
+    var sighashType = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : bitcoin.Transaction.SIGHASH_DEFAULT;
+    var schnorrSignature;
     if (_instanceof$2(signature, Uint8Array) || Buffer.isBuffer(signature)) {
-        return Buffer.from(signature);
+        schnorrSignature = Buffer.from(signature);
+    } else {
+        var r = signature.r;
+        var s = signature.s;
+        var rBuf = Buffer.isBuffer(r) ? r : Buffer.from(r);
+        var sBuf = Buffer.isBuffer(s) ? s : Buffer.from(s);
+        // Safe: creates Uint8Array views over Buffer's underlying memory without copying
+        schnorrSignature = Buffer.concat([
+            new Uint8Array(rBuf),
+            new Uint8Array(sBuf)
+        ]);
+    }
+    if (sighashType === bitcoin.Transaction.SIGHASH_DEFAULT) {
+        return schnorrSignature;
     }
-    var r = signature.r;
-    var s = signature.s;
-    var rBuf = Buffer.isBuffer(r) ? r : Buffer.from(r);
-    var sBuf = Buffer.isBuffer(s) ? s : Buffer.from(s);
-    // Safe: creates Uint8Array views over Buffer's underlying memory without copying
     return Buffer.concat([
-        new Uint8Array(rBuf),
-        new Uint8Array(sBuf)
+        new Uint8Array(schnorrSignature),
+        new Uint8Array([
+            sighashType
+        ])
     ]);
 };
 
@@ -1228,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);
@@ -1236,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;
     }
@@ -1265,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) {
@@ -1286,6 +1384,139 @@ 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.
+ *
+ * The type is read from the PSBT itself (BIP-174 `PSBT_IN_SIGHASH_TYPE`), never
+ * supplied by the caller — the signing hash and the policy layer's verification
+ * hash must be derived from the same bytes, or every non-default signature
+ * would be rejected as tampered.
+ *
+ * When the input declares nothing, falls back to the historical default:
+ * SIGHASH_DEFAULT (0x00) for Taproot, SIGHASH_ALL (0x01) otherwise.
+ *
+ * @param input - The PSBT input to resolve the sighash type for
+ * @param isTaproot - Whether the input is spent as Taproot. Defaults to
+ *   detecting `tapInternalKey`; pass explicitly when the caller already knows
+ *   which signing branch it is on, so the fallback matches the hash function
+ *   actually used.
+ * @returns The sighash type to build and encode the signature with
+ */ var getSigHashType = function(input) {
+    var isTaproot = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Boolean(input.tapInternalKey);
+    var _input_sighashType;
+    return (_input_sighashType = input.sighashType) !== null && _input_sighashType !== void 0 ? _input_sighashType : isTaproot ? bitcoin.Transaction.SIGHASH_DEFAULT : bitcoin.Transaction.SIGHASH_ALL;
+};
+
+/**
+ * Throws unless every input's PSBT-declared sighash type is in the allow-list.
+ *
+ * Call this before any signing begins — inputs are signed in parallel, so
+ * throwing partway through would leave a partially signed PSBT behind.
+ *
+ * An empty array permits nothing rather than everything: a caller whose
+ * allow-list computes to empty must not silently get the guard disabled. Omit
+ * the parameter entirely to permit any declared type.
+ *
+ * @param inputsToSign - The wallet-owned inputs about to be signed, with their PSBT indexes
+ * @param isTaproot - Whether signing takes the Taproot branch, so the fallback
+ *   sighash type matches the hash function actually used
+ * @param allowedSighash - Optional allow-list of permitted sighash types
+ */ var assertSighashAllowed = function(inputsToSign, isTaproot, allowedSighash) {
+    if (!allowedSighash) {
+        return;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = inputsToSign[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _step.value, input = _step_value.input, index = _step_value.index;
+            var sigHashType = getSigHashType(input, isTaproot);
+            if (!allowedSighash.includes(sigHashType)) {
+                throw new Error("Input ".concat(index, " declares sighash type ").concat(sigHashType, ", which is not in allowedSighash: ").concat(allowedSighash.join(', ') || '(empty)'));
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+};
+
 function _instanceof(left, right) {
     if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
         return !!right[Symbol.hasInstance](left);
@@ -1372,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
@@ -1392,25 +1627,23 @@ function _type_of(obj) {
     for(var i = 0; i < psbt.inputCount; i++){
         var input = psbt.data.inputs[i];
         if (input.tapInternalKey) {
-            // Taproot (BIP-341) - uses hashForWitnessV1 with SIGHASH_DEFAULT
-            var hash = tx.hashForWitnessV1(i, prevOutScripts, values, bitcoin.Transaction.SIGHASH_DEFAULT);
+            // Taproot (BIP-341) - uses hashForWitnessV1 with the input's declared
+            // 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 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, bitcoin.Transaction.SIGHASH_ALL);
-            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;
 };
@@ -1450,4 +1683,4 @@ function _type_of(obj) {
     return Buffer.from(formattedMessage).toString('hex');
 };
 
-export { calculateBip322Hash, calculateTaprootTweak, collectPSBTInputData, computeBip322HashHex, convertSignatureToDER, convertSignatureToTaprootBuffer, createLegacyAddress, createNativeSegWitAddress, createSegWitAddress, createTaprootAddress, doesInputBelongToAddress, encodeBip322Signature, extractPsbtSighashes, extractPublicKeyHex, getAddressTypeFromDerivationPath, getBitcoinNetwork, getDefaultRpcUrl, getFeeRates, getPublicKeyFromPrivateKey, 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.105",
+  "version": "1.0.107",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dynamic-labs-wallet/core": "1.0.105",
+    "@dynamic-labs-wallet/core": "1.0.107",
     "bitcoinjs-lib": "^7.0.0",
     "bip322-js": "^3.0.0",
     "@noble/hashes": "1.7.1",

package/src/assertSighashAllowed/assertSighashAllowed.d.ts

@@ -0,0 +1,21 @@
+import type * as bitcoin from 'bitcoinjs-lib';
+/**
+ * Throws unless every input's PSBT-declared sighash type is in the allow-list.
+ *
+ * Call this before any signing begins — inputs are signed in parallel, so
+ * throwing partway through would leave a partially signed PSBT behind.
+ *
+ * An empty array permits nothing rather than everything: a caller whose
+ * allow-list computes to empty must not silently get the guard disabled. Omit
+ * the parameter entirely to permit any declared type.
+ *
+ * @param inputsToSign - The wallet-owned inputs about to be signed, with their PSBT indexes
+ * @param isTaproot - Whether signing takes the Taproot branch, so the fallback
+ *   sighash type matches the hash function actually used
+ * @param allowedSighash - Optional allow-list of permitted sighash types
+ */
+export declare const assertSighashAllowed: (inputsToSign: {
+    input: bitcoin.Psbt["data"]["inputs"][number];
+    index: number;
+}[], isTaproot: boolean, allowedSighash?: number[]) => void;
+//# sourceMappingURL=assertSighashAllowed.d.ts.map

package/src/assertSighashAllowed/assertSighashAllowed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertSighashAllowed.d.ts","sourceRoot":"","sources":["../../src/assertSighashAllowed/assertSighashAllowed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,OAAO,MAAM,eAAe,CAAC;AAG9C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,iBACjB;IAAE,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,aACrE,OAAO,mBACD,MAAM,EAAE,KACxB,IAgBF,CAAC"}

package/src/assertSighashAllowed/index.d.ts

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

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

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

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/convertSignatureToDER/convertSignatureToDER.d.ts

@@ -3,7 +3,10 @@ import type { EcdsaSignature } from '#internal/core';
  * Converts an ECDSA signature to DER format
  *
  * @param signature - The ECDSA signature
+ * @param sighashType - The sighash type to append as the DER trailing byte.
+ *   Must match the type the signing hash was built with, or the signature will
+ *   fail verification at finalize/broadcast. Defaults to SIGHASH_ALL.
  * @returns The DER encoded signature
  */
-export declare const convertSignatureToDER: (signature: EcdsaSignature) => Uint8Array;
+export declare const convertSignatureToDER: (signature: EcdsaSignature, sighashType?: number) => Uint8Array;
 //# sourceMappingURL=convertSignatureToDER.d.ts.map

package/src/convertSignatureToDER/convertSignatureToDER.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertSignatureToDER.d.ts","sourceRoot":"","sources":["../../src/convertSignatureToDER/convertSignatureToDER.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,cAAe,cAAc,eAmB9D,CAAC"}
+{"version":3,"file":"convertSignatureToDER.d.ts","sourceRoot":"","sources":["../../src/convertSignatureToDER/convertSignatureToDER.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,cACrB,cAAc,gBACZ,MAAM,eAoBpB,CAAC"}

package/src/convertSignatureToTaprootBuffer/convertSignatureToTaprootBuffer.d.ts

@@ -3,7 +3,10 @@ import type { EcdsaSignature } from '#internal/core';
  * Converts a signature to a Buffer format suitable for Taproot (BIP340/Schnorr)
  *
  * @param signature - The signature from MPC (can be Uint8Array, Buffer, or EcdsaSignature object)
- * @returns A Buffer containing the 64-byte Schnorr signature
+ * @param sighashType - The sighash type the signing hash was built with. Per
+ *   BIP-341 the signature stays 64 bytes for SIGHASH_DEFAULT and gains the
+ *   sighash type as a 65th byte for any other type. Defaults to SIGHASH_DEFAULT.
+ * @returns A Buffer containing the 64-byte (or 65-byte) Schnorr signature
  */
-export declare const convertSignatureToTaprootBuffer: (signature: EcdsaSignature | Uint8Array | Buffer) => Buffer;
+export declare const convertSignatureToTaprootBuffer: (signature: EcdsaSignature | Uint8Array | Buffer, sighashType?: number) => Buffer;
 //# sourceMappingURL=convertSignatureToTaprootBuffer.d.ts.map

package/src/convertSignatureToTaprootBuffer/convertSignatureToTaprootBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convertSignatureToTaprootBuffer.d.ts","sourceRoot":"","sources":["../../src/convertSignatureToTaprootBuffer/convertSignatureToTaprootBuffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,cAAe,cAAc,GAAG,UAAU,GAAG,MAAM,KAAG,MAWjG,CAAC"}
+{"version":3,"file":"convertSignatureToTaprootBuffer.d.ts","sourceRoot":"","sources":["../../src/convertSignatureToTaprootBuffer/convertSignatureToTaprootBuffer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,cAC/B,cAAc,GAAG,UAAU,GAAG,MAAM,gBAClC,MAAM,KAClB,MAmBF,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;AAMhE;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,eACnB,MAAM,YACT,cAAc,GAAG,SAAS,GAAG,SAAS,KAC9C,MAAM,EA4CR,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/getSigHashType/getSigHashType.d.ts

@@ -0,0 +1,21 @@
+import * as bitcoin from 'bitcoinjs-lib';
+/**
+ * Resolves the sighash type for a PSBT input.
+ *
+ * The type is read from the PSBT itself (BIP-174 `PSBT_IN_SIGHASH_TYPE`), never
+ * supplied by the caller — the signing hash and the policy layer's verification
+ * hash must be derived from the same bytes, or every non-default signature
+ * would be rejected as tampered.
+ *
+ * When the input declares nothing, falls back to the historical default:
+ * SIGHASH_DEFAULT (0x00) for Taproot, SIGHASH_ALL (0x01) otherwise.
+ *
+ * @param input - The PSBT input to resolve the sighash type for
+ * @param isTaproot - Whether the input is spent as Taproot. Defaults to
+ *   detecting `tapInternalKey`; pass explicitly when the caller already knows
+ *   which signing branch it is on, so the fallback matches the hash function
+ *   actually used.
+ * @returns The sighash type to build and encode the signature with
+ */
+export declare const getSigHashType: (input: bitcoin.Psbt["data"]["inputs"][number], isTaproot?: boolean) => number;
+//# sourceMappingURL=getSigHashType.d.ts.map

package/src/getSigHashType/getSigHashType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getSigHashType.d.ts","sourceRoot":"","sources":["../../src/getSigHashType/getSigHashType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AAEzC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc,UAClB,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,0BAE5C,MAAkH,CAAC"}

package/src/getSigHashType/index.d.ts

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

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

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

package/src/index.d.ts

@@ -15,7 +15,12 @@ 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';
 export { initEccLib } from './initEccLib/index.js';
 export { extractPublicKeyHex } from './extractPublicKeyHex/index.js';
 export type { UTXO } from './types.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,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"}