@atomicfinance/bitcoin-ddk-provider 4.1.12 → 4.2.0

package/dist/BitcoinDdkProvider.js

@@ -65,169 +65,6 @@ class BitcoinDdkProvider extends provider_1.default {
             await (0, utils_1.sleep)(10);
         }
     }
-    /**
-     * Helper function to ensure we have a Buffer object
-     * Handles cases where Buffer objects have been serialized/deserialized
-     */
-    ensureBuffer(bufferLike) {
-        if (Buffer.isBuffer(bufferLike)) {
-            return bufferLike;
-        }
-        if (bufferLike && bufferLike.type === 'Buffer' && bufferLike.data) {
-            return Buffer.from(bufferLike.data);
-        }
-        return bufferLike;
-    }
-    /**
-     * Detect if signature is in compact format (64 bytes) or DER format
-     * and convert compact to DER if needed, adding SIGHASH_ALL flag
-     */
-    ensureDerSignature(signature) {
-        // If signature is 64 bytes, it's likely compact format (32-byte r + 32-byte s)
-        if (signature.length === 64) {
-            // Convert compact signature to DER format
-            const r = signature.slice(0, 32);
-            const s = signature.slice(32, 64);
-            // Create DER encoding manually
-            // DER format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
-            // Remove leading zeros from r and s, but keep at least one byte
-            let rBytes = r;
-            while (rBytes.length > 1 &&
-                rBytes[0] === 0x00 &&
-                (rBytes[1] & 0x80) === 0) {
-                rBytes = rBytes.slice(1);
-            }
-            let sBytes = s;
-            while (sBytes.length > 1 &&
-                sBytes[0] === 0x00 &&
-                (sBytes[1] & 0x80) === 0) {
-                sBytes = sBytes.slice(1);
-            }
-            // Add padding byte if high bit is set (to keep numbers positive)
-            if ((rBytes[0] & 0x80) !== 0) {
-                rBytes = Buffer.concat([Buffer.from([0x00]), rBytes]);
-            }
-            if ((sBytes[0] & 0x80) !== 0) {
-                sBytes = Buffer.concat([Buffer.from([0x00]), sBytes]);
-            }
-            const totalLength = 2 + rBytes.length + 2 + sBytes.length;
-            const derSignature = Buffer.concat([
-                Buffer.from([0x30, totalLength]), // SEQUENCE tag and total length
-                Buffer.from([0x02, rBytes.length]), // INTEGER tag and R length
-                rBytes,
-                Buffer.from([0x02, sBytes.length]), // INTEGER tag and S length
-                sBytes,
-                Buffer.from([0x01]), // SIGHASH_ALL flag
-            ]);
-            return derSignature;
-        }
-        // If it's already DER format, check if it has SIGHASH flag
-        if (signature.length > 0 && signature[0] === 0x30) {
-            // Check if it already has a SIGHASH flag (last byte should be 0x01 for SIGHASH_ALL)
-            if (signature[signature.length - 1] !== 0x01) {
-                // Add SIGHASH_ALL flag
-                return Buffer.concat([signature, Buffer.from([0x01])]);
-            }
-            return signature;
-        }
-        // For other formats, return as-is
-        return signature;
-    }
-    /**
-     * Detect if signature is in DER format and convert to compact format (64 bytes)
-     * by extracting r and s values, removing SIGHASH flag if present
-     */
-    ensureCompactSignature(signature) {
-        // If signature is already 64 bytes, it's likely already compact format
-        if (signature.length === 64) {
-            return signature;
-        }
-        // Check if it's DER format (starts with 0x30)
-        if (signature.length > 6 && signature[0] === 0x30) {
-            let derSig = signature;
-            // Remove SIGHASH flag if present (last byte is typically 0x01 for SIGHASH_ALL)
-            if (signature[signature.length - 1] === 0x01) {
-                derSig = signature.slice(0, -1);
-            }
-            // Parse DER format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S]
-            if (derSig[0] !== 0x30) {
-                throw new Error('Invalid DER signature: missing SEQUENCE tag');
-            }
-            const totalLength = derSig[1];
-            if (derSig.length < totalLength + 2) {
-                throw new Error('Invalid DER signature: length mismatch');
-            }
-            let offset = 2;
-            // Parse R value
-            if (derSig[offset] !== 0x02) {
-                throw new Error('Invalid DER signature: missing INTEGER tag for R');
-            }
-            offset++;
-            const rLength = derSig[offset];
-            offset++;
-            if (offset + rLength > derSig.length) {
-                throw new Error('Invalid DER signature: R length exceeds signature length');
-            }
-            let rBytes = derSig.slice(offset, offset + rLength);
-            offset += rLength;
-            // Parse S value
-            if (derSig[offset] !== 0x02) {
-                throw new Error('Invalid DER signature: missing INTEGER tag for S');
-            }
-            offset++;
-            const sLength = derSig[offset];
-            offset++;
-            if (offset + sLength > derSig.length) {
-                throw new Error('Invalid DER signature: S length exceeds signature length');
-            }
-            let sBytes = derSig.slice(offset, offset + sLength);
-            // Remove leading zero padding from r and s (DER may pad to prevent negative interpretation)
-            while (rBytes.length > 1 && rBytes[0] === 0x00) {
-                rBytes = rBytes.slice(1);
-            }
-            while (sBytes.length > 1 && sBytes[0] === 0x00) {
-                sBytes = sBytes.slice(1);
-            }
-            // Pad to 32 bytes each (compact format requires exactly 32 bytes for r and s)
-            while (rBytes.length < 32) {
-                rBytes = Buffer.concat([Buffer.from([0x00]), rBytes]);
-            }
-            while (sBytes.length < 32) {
-                sBytes = Buffer.concat([Buffer.from([0x00]), sBytes]);
-            }
-            if (rBytes.length !== 32 || sBytes.length !== 32) {
-                throw new Error('Invalid signature values: r or s exceeds 32 bytes');
-            }
-            // Combine r and s into 64-byte compact format
-            return Buffer.concat([rBytes, sBytes]);
-        }
-        // For other formats, throw error as we can't convert
-        throw new Error('Unable to convert signature to compact format: unknown format');
-    }
-    /**
-     * Compute contract ID from fund transaction ID, output index, and temporary contract ID
-     * Matches the Rust implementation in rust-dlc
-     */
-    computeContractId(fundTxId, fundOutputIndex, temporaryContractId) {
-        if (fundTxId.length !== 32) {
-            throw new Error('Fund transaction ID must be 32 bytes');
-        }
-        if (temporaryContractId.length !== 32) {
-            throw new Error('Temporary contract ID must be 32 bytes');
-        }
-        if (fundOutputIndex > 0xffff) {
-            throw new Error('Fund output index must fit in 16 bits');
-        }
-        const result = Buffer.alloc(32);
-        // XOR fund_tx_id with temporary_id, with byte order reversal for fund_tx_id
-        for (let i = 0; i < 32; i++) {
-            result[i] = fundTxId[31 - i] ^ temporaryContractId[i];
-        }
-        // XOR the fund output index into the last two bytes
-        result[30] ^= (fundOutputIndex >> 8) & 0xff; // High byte
-        result[31] ^= fundOutputIndex & 0xff; // Low byte
-        return result;
-    }
     /**
      * Create refund signature using PSBT method instead of DDK
      */
@@ -238,19 +75,7 @@ class BitcoinDdkProvider extends provider_1.default {
         if (Number(dlcTxs.refundTx.locktime) !== dlcOffer.refundLocktime) {
             throw new Error(`Refund transaction locktime ${dlcTxs.refundTx.locktime} does not match expected ${dlcOffer.refundLocktime}`);
         }
-        // Create the same funding script as createDlcClose
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const paymentVariant = (0, Utils_1.createP2WSHMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
         // Add the funding input with sequence from refund transaction
         psbt.addInput({
             hash: dlcTxs.fundTx.txId.serialize(),
@@ -283,7 +108,7 @@ class BitcoinDdkProvider extends provider_1.default {
         const partialSig = psbt.data.inputs[0].partialSig[0];
         const derSignature = partialSig.signature;
         // Convert DER signature to compact format
-        return this.ensureCompactSignature(derSignature);
+        return (0, Utils_1.ensureCompactSignature)(derSignature);
     }
     /**
      * Find private key for DLC funding pubkey by deriving wallet addresses
@@ -632,8 +457,10 @@ class BitcoinDdkProvider extends provider_1.default {
             const input = await this.fundingInputToInput(fundingInput, false);
             return input.toUtxo();
         }));
-        // Calculate input amounts
-        const localInputAmount = localRegularInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        // Calculate input amounts (including both regular inputs and DLC inputs)
+        const localRegularInputAmount = localRegularInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        const localDlcInputAmount = localDlcInputs.reduce((prev, cur) => prev + Number(cur.fundAmount), 0);
+        const localInputAmount = localRegularInputAmount + localDlcInputAmount;
         const remoteInputAmount = remoteInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
         let payouts = [];
         let messagesList = [];
@@ -688,7 +515,7 @@ class BitcoinDdkProvider extends provider_1.default {
         let dlcTxs;
         if (hasDlcInputs) {
             // Use spliced DLC transactions when DLC inputs are present
-            dlcTxs = await this._ddk.createSplicedDlcTransactions(outcomes, localParams, remoteParams, dlcOffer.refundLocktime, BigInt(dlcOffer.feeRatePerVb), 0, dlcOffer.cetLocktime, dlcOffer.fundOutputSerialId);
+            dlcTxs = await this._ddk.createSplicedDlcTransactions(outcomes, localParams, remoteParams, dlcOffer.refundLocktime, BigInt(dlcOffer.feeRatePerVb), 0, dlcOffer.cetLocktime, BigInt(dlcOffer.fundOutputSerialId));
         }
         else {
             // Use regular DLC transactions when no DLC inputs
@@ -860,16 +687,8 @@ class BitcoinDdkProvider extends provider_1.default {
     async CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTxs, messagesList, isOfferer) {
         const network = await this.getConnectedNetwork();
         const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
-        // Create the correct P2WSH multisig funding script
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
         // We need the redeem script (multisig), not the P2WSH output
+        const p2ms = (0, Utils_1.createP2MSMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
         const fundingSPK = p2ms.output;
         // For finding the private key, we still need the individual P2WPKH address
         const individualFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey))
@@ -980,14 +799,7 @@ class BitcoinDdkProvider extends provider_1.default {
                 });
                 // Create the correct P2WSH multisig funding script for verification
                 const network = await this.getConnectedNetwork();
-                const verifyFundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-                    ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-                    : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-                const verifyP2ms = bitcoinjs_lib_1.payments.p2ms({
-                    m: 2,
-                    pubkeys: verifyFundingPubKeys,
-                    network,
-                });
+                const verifyP2ms = (0, Utils_1.createP2MSMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
                 // We need the redeem script (multisig), not the P2WSH output
                 const fundingSPK = verifyP2ms.output;
                 const ddkOracleInfo = {
@@ -1070,17 +882,14 @@ class BitcoinDdkProvider extends provider_1.default {
             }
         }
     }
-    async CreateFundingSigsAlt(dlcOffer, dlcAccept, dlcTxs, isOfferer) {
+    async CreateFundingSigs(dlcOffer, dlcAccept, dlcTxs, isOfferer) {
         const transaction = bitcoinjs_lib_1.Transaction.fromBuffer(Buffer.from(dlcTxs.fundTx.serialize()));
         const network = await this.getConnectedNetwork();
         const psbt = new bitcoinjs_lib_1.Psbt({ network });
-        // Combine all funding inputs from both parties
-        const allFundingInputs = [
+        const allFundingInputs = (0, Utils_1.sortFundingInputsBySerialId)([
             ...dlcOffer.fundingInputs,
             ...dlcAccept.fundingInputs,
-        ];
-        // Sort by inputSerialId to reconstruct proper transaction order
-        allFundingInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        ]);
         // Add all inputs to PSBT with proper witnessUtxo
         for (const fundingInput of allFundingInputs) {
             const prevOut = fundingInput.prevTx.outputs[fundingInput.prevTxVout];
@@ -1137,9 +946,26 @@ class BitcoinDdkProvider extends provider_1.default {
                 const keyPair = ECPair.fromPrivateKey(Buffer.from(privKey, 'hex'));
                 // Check if this is a DLC input (2-of-2 multisig from previous DLC)
                 if (fundingInput.dlcInput) {
-                    // For DLC inputs, we'll need to handle 2-of-2 multisig signing differently
-                    // For now, throw an error as this requires implementing multisig support
-                    throw new Error('DLC input signing not yet implemented in CreateFundingSigsAlt');
+                    const paymentVariant = (0, Utils_1.createP2WSHMultisig)(fundingInput.dlcInput.localFundPubkey, fundingInput.dlcInput.remoteFundPubkey, network);
+                    const redeemScript = paymentVariant.redeem.output;
+                    // Find the correct private key for this DLC input
+                    const dlcPrivKey = await this.findDlcFundingPrivateKey(fundingInput.dlcInput.localFundPubkey.toString('hex'), fundingInput.dlcInput.remoteFundPubkey.toString('hex'));
+                    const keyPair = ECPair.fromPrivateKey(Buffer.from(dlcPrivKey, 'hex'));
+                    // Update the input with the witnessScript before signing
+                    psbt.updateInput(inputIndex, {
+                        witnessScript: redeemScript,
+                    });
+                    psbt.signInput(inputIndex, keyPair);
+                    const inputData = psbt.data.inputs[inputIndex];
+                    const partialSigs = inputData.partialSig;
+                    if (!partialSigs || partialSigs.length === 0) {
+                        throw new Error(`No signatures found for input ${inputIndex} after signing`);
+                    }
+                    const sigWitness = new messaging_1.ScriptWitnessV0();
+                    sigWitness.witness = (0, Utils_1.ensureBuffer)(partialSigs[0].signature);
+                    const pubKeyWitness = new messaging_1.ScriptWitnessV0();
+                    pubKeyWitness.witness = keyPair.publicKey;
+                    witnessElements.push([sigWitness, pubKeyWitness]);
                 }
                 else {
                     // For P2WPKH inputs, use PSBT signing
@@ -1152,7 +978,7 @@ class BitcoinDdkProvider extends provider_1.default {
                     }
                     // For P2WPKH, create witness manually: [signature, publicKey]
                     const sigWitness = new messaging_1.ScriptWitnessV0();
-                    sigWitness.witness = this.ensureBuffer(partialSigs[0].signature);
+                    sigWitness.witness = (0, Utils_1.ensureBuffer)(partialSigs[0].signature);
                     const pubKeyWitness = new messaging_1.ScriptWitnessV0();
                     pubKeyWitness.witness = keyPair.publicKey;
                     witnessElements.push([sigWitness, pubKeyWitness]);
@@ -1164,7 +990,7 @@ class BitcoinDdkProvider extends provider_1.default {
         fundingSignatures.witnessElements = witnessElements;
         return fundingSignatures;
     }
-    async VerifyFundingSigsAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer) {
+    async VerifyFundingSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer) {
         const network = await this.getConnectedNetwork();
         const transaction = bitcoinjs_lib_1.Transaction.fromBuffer(Buffer.from(dlcTxs.fundTx.serialize()));
         // Get the party whose signatures we're verifying
@@ -1173,12 +999,10 @@ class BitcoinDdkProvider extends provider_1.default {
         const signingPartyInputs = isOfferer
             ? dlcAccept.fundingInputs
             : dlcOffer.fundingInputs;
-        // Combine all inputs to get the correct ordering
-        const allFundingInputs = [
+        const allFundingInputs = (0, Utils_1.sortFundingInputsBySerialId)([
             ...dlcOffer.fundingInputs,
             ...dlcAccept.fundingInputs,
-        ];
-        allFundingInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        ]);
         // Compare transaction IDs
         const dlcFundTxId = dlcTxs.fundTx.txId.toString();
         const psbtBuilderTxId = transaction.getId();
@@ -1188,10 +1012,16 @@ class BitcoinDdkProvider extends provider_1.default {
         // Add all inputs (needed for proper sighash calculation)
         for (const input of allFundingInputs) {
             const prevOutput = input.prevTx.outputs[input.prevTxVout];
+            // Use sequence from the original transaction to ensure consistency with CreateFundingTx
+            const originalInput = transaction.ins.find((txInput) => txInput.hash.reverse().toString('hex') ===
+                input.prevTx.txId.toString() && txInput.index === input.prevTxVout);
+            const sequenceValue = originalInput
+                ? originalInput.sequence
+                : Number(input.sequence);
             psbt.addInput({
                 hash: input.prevTx.txId.toString(),
                 index: input.prevTxVout,
-                sequence: 0,
+                sequence: sequenceValue,
                 witnessUtxo: {
                     script: Buffer.from(prevOutput.scriptPubKey.serialize().subarray(1)),
                     value: Number(prevOutput.value.sats),
@@ -1212,8 +1042,40 @@ class BitcoinDdkProvider extends provider_1.default {
         // Add the funding signatures to the PSBT as partial signatures
         let witnessIndex = 0;
         for (const fundingInput of signingPartyInputs) {
-            // Skip DLC inputs for now (same as CreateFundingSigsAlt)
+            // Handle DLC inputs with multisig verification
             if (fundingInput.dlcInput) {
+                const dlcInput = fundingInput.dlcInput;
+                const paymentVariant = (0, Utils_1.createP2WSHMultisig)(dlcInput.localFundPubkey, dlcInput.remoteFundPubkey, network);
+                // Find this input's index in the sorted transaction
+                const inputIndex = allFundingInputs.findIndex((input) => input.prevTx.txId.toString() ===
+                    fundingInput.prevTx.txId.toString() &&
+                    input.prevTxVout === fundingInput.prevTxVout);
+                if (inputIndex === -1) {
+                    throw new Error(`DLC input not found in transaction: ${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`);
+                }
+                // Update the input with the witnessScript for verification
+                psbt.updateInput(inputIndex, {
+                    witnessScript: paymentVariant.redeem.output,
+                });
+                // Add the DLC signature from witness elements if available
+                if (witnessIndex < dlcSign.fundingSignatures.witnessElements.length) {
+                    const witnessElement = dlcSign.fundingSignatures.witnessElements[witnessIndex];
+                    const signature = witnessElement[0].witness;
+                    const publicKey = witnessElement[1].witness;
+                    psbt.updateInput(inputIndex, {
+                        partialSig: [
+                            {
+                                pubkey: publicKey,
+                                signature: (0, Utils_1.ensureDerSignature)(signature),
+                            },
+                        ],
+                    });
+                    // Verify the signature for this DLC input
+                    psbt.validateSignaturesOfInput(inputIndex, (pubkey, msghash, signature) => {
+                        return ecc.verify(msghash, pubkey, signature);
+                    });
+                    witnessIndex++;
+                }
                 continue;
             }
             if (witnessIndex >= dlcSign.fundingSignatures.witnessElements.length) {
@@ -1233,7 +1095,7 @@ class BitcoinDdkProvider extends provider_1.default {
                 partialSig: [
                     {
                         pubkey: publicKey,
-                        signature: this.ensureDerSignature(signature),
+                        signature: (0, Utils_1.ensureDerSignature)(signature),
                     },
                 ],
             });
@@ -1243,6 +1105,67 @@ class BitcoinDdkProvider extends provider_1.default {
             witnessIndex++;
         }
     }
+    /**
+     * Get sighash for funding transaction inputs
+     * @param dlcOffer DLC Offer
+     * @param dlcAccept DLC Accept
+     * @param dlcTxs DLC Transactions
+     * @param inputIndex Index of the input to get sighash for (optional, if not provided returns all)
+     * @returns Array of sighashes for each input or single sighash if inputIndex specified
+     */
+    async getFundingTransactionSighash(dlcOffer, dlcAccept, dlcTxs, inputIndex) {
+        // Use the detailed function to ensure consistency
+        const details = await this.getFundingTransactionSighashDetails(dlcOffer, dlcAccept, dlcTxs);
+        if (inputIndex !== undefined) {
+            // Return sighash for specific input
+            if (inputIndex >= details.length) {
+                throw new Error(`Input index ${inputIndex} out of range. Total inputs: ${details.length}`);
+            }
+            return details[inputIndex].sighash;
+        }
+        else {
+            // Return sighashes for all inputs
+            return details.map((detail) => detail.sighash);
+        }
+    }
+    /**
+     * Get detailed sighash information for funding transaction (useful for debugging)
+     * @param dlcOffer DLC Offer
+     * @param dlcAccept DLC Accept
+     * @param dlcTxs DLC Transactions
+     * @returns Detailed sighash information for each input
+     */
+    async getFundingTransactionSighashDetails(dlcOffer, dlcAccept, dlcTxs) {
+        const transaction = bitcoinjs_lib_1.Transaction.fromBuffer(Buffer.from(dlcTxs.fundTx.serialize()));
+        const allFundingInputs = (0, Utils_1.sortFundingInputsBySerialId)([
+            ...dlcOffer.fundingInputs,
+            ...dlcAccept.fundingInputs,
+        ]);
+        // Calculate detailed sighash information
+        const details = [];
+        for (let i = 0; i < allFundingInputs.length; i++) {
+            const input = allFundingInputs[i];
+            const prevOutput = input.prevTx.outputs[input.prevTxVout];
+            const originalInput = transaction.ins.find((txInput) => txInput.hash.reverse().toString('hex') ===
+                input.prevTx.txId.toString() && txInput.index === input.prevTxVout);
+            const sequenceValue = originalInput
+                ? originalInput.sequence
+                : Number(input.sequence);
+            const script = Buffer.from(prevOutput.scriptPubKey.serialize().subarray(1));
+            const value = Number(prevOutput.value.sats);
+            const sighash = transaction.hashForWitnessV0(i, script, value, bitcoinjs_lib_1.Transaction.SIGHASH_ALL);
+            details.push({
+                inputIndex: i,
+                txid: input.prevTx.txId.toString(),
+                vout: input.prevTxVout,
+                sequence: sequenceValue,
+                scriptPubKey: script.toString('hex'),
+                value: value,
+                sighash: sighash.toString('hex'),
+            });
+        }
+        return details;
+    }
     async VerifyRefundSignatureAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer) {
         const network = await this.getConnectedNetwork();
         // Get the refund signature we need to verify
@@ -1252,7 +1175,7 @@ class BitcoinDdkProvider extends provider_1.default {
             ? dlcAccept.refundSignature
             : dlcSign.refundSignature;
         // Ensure signature is in DER format (convert from compact if needed)
-        const refundSignature = this.ensureDerSignature(rawRefundSignature);
+        const refundSignature = (0, Utils_1.ensureDerSignature)(rawRefundSignature);
         const signingPubkey = isOfferer
             ? dlcAccept.fundingPubkey
             : dlcOffer.fundingPubkey;
@@ -1262,19 +1185,7 @@ class BitcoinDdkProvider extends provider_1.default {
         }
         // Create a PSBT for the refund transaction verification using same approach as createDlcClose
         const psbt = new bitcoinjs_lib_1.Psbt({ network });
-        // Create the same funding script as createDlcClose
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const paymentVariant = (0, Utils_1.createP2WSHMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
         // Add the funding input with sequence from refund transaction
         psbt.addInput({
             hash: dlcTxs.fundTx.txId.serialize(),
@@ -1311,55 +1222,32 @@ class BitcoinDdkProvider extends provider_1.default {
     }
     CreateFundingScript(dlcOffer, dlcAccept) {
         const network = this.getBitcoinJsNetwork();
-        // Sort funding pubkeys in lexicographical order as per DLC spec
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        // Create 2-of-2 multisig script
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const paymentVariant = (0, Utils_1.createP2WSHMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
         return paymentVariant.redeem.output;
     }
     async CreateFundingTx(dlcOffer, dlcAccept, dlcSign, dlcTxs, fundingSignatures) {
         const network = await this.getConnectedNetwork();
         const psbt = new bitcoinjs_lib_1.Psbt({ network });
-        // Combine and sort all funding inputs by serial ID (same as CreateFundingSigsAlt)
-        const allFundingInputs = [
+        const allFundingInputs = (0, Utils_1.sortFundingInputsBySerialId)([
             ...dlcOffer.fundingInputs,
             ...dlcAccept.fundingInputs,
-        ];
-        allFundingInputs.sort((a, b) => Number(a.inputSerialId - b.inputSerialId));
+        ]);
         // Create a map of input txid:vout to witness elements
         const witnessMap = new Map();
-        // Map witness elements correctly - CreateFundingSigsAlt only creates witness elements
+        // Map witness elements correctly - CreateFundingSigs only creates witness elements
         // for the party's own inputs, so we need to map them correctly
-        // For dlcSign (offerer's signatures), map to offerer's inputs only
+        // For dlcSign (offerer's signatures), map to offerer's inputs (including DLC inputs)
         let offererWitnessIndex = 0;
         dlcOffer.fundingInputs.forEach((fundingInput) => {
-            // Skip DLC inputs for now as in CreateFundingSigsAlt
-            if (fundingInput.dlcInput) {
-                return;
-            }
             if (offererWitnessIndex < dlcSign.fundingSignatures.witnessElements.length) {
                 const key = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
                 witnessMap.set(key, dlcSign.fundingSignatures.witnessElements[offererWitnessIndex]);
                 offererWitnessIndex++;
             }
         });
-        // For fundingSignatures (accepter's signatures), map to accepter's inputs only
+        // For fundingSignatures (accepter's signatures), map to accepter's inputs (including DLC inputs)
         let accepterWitnessIndex = 0;
         dlcAccept.fundingInputs.forEach((fundingInput) => {
-            // Skip DLC inputs for now as in CreateFundingSigsAlt
-            if (fundingInput.dlcInput) {
-                return;
-            }
             if (accepterWitnessIndex < fundingSignatures.witnessElements.length) {
                 const key = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
                 witnessMap.set(key, fundingSignatures.witnessElements[accepterWitnessIndex]);
@@ -1370,12 +1258,12 @@ class BitcoinDdkProvider extends provider_1.default {
         const originalTransaction = bitcoinjs_lib_1.Transaction.fromBuffer(Buffer.from(dlcTxs.fundTx.serialize()));
         for (const fundingInput of allFundingInputs) {
             const prevOut = fundingInput.prevTx.outputs[fundingInput.prevTxVout];
-            // Use same script handling as CreateFundingSigsAlt
+            // Use same script handling as CreateFundingSigs
             const witnessUtxo = {
                 script: Buffer.from(prevOut.scriptPubKey.serialize().subarray(1)),
                 value: Number(prevOut.value.sats),
             };
-            // Use sequence from the original transaction (same as CreateFundingSigsAlt)
+            // Use sequence from the original transaction (same as CreateFundingSigs)
             const originalInput = originalTransaction.ins.find((input) => input.hash.reverse().toString('hex') ===
                 fundingInput.prevTx.txId.toString() &&
                 input.index === fundingInput.prevTxVout);
@@ -1402,12 +1290,57 @@ class BitcoinDdkProvider extends provider_1.default {
             const inputKey = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
             const witnessElements = witnessMap.get(inputKey);
             if (witnessElements && witnessElements.length === 2) {
-                // Skip DLC inputs for now as requested
+                // Handle DLC inputs with multisig finalization
                 if (fundingInput.dlcInput) {
+                    const dlcInput = fundingInput.dlcInput;
+                    // Create the multisig script for finalization
+                    // Use lexicographic ordering to match DDK library behavior
+                    const orderedPubkeys = (0, Utils_1.orderPubkeysLexicographically)(dlcInput.localFundPubkey, dlcInput.remoteFundPubkey);
+                    const paymentVariant = (0, Utils_1.createP2WSHMultisigFromOrdered)(orderedPubkeys, network);
+                    // Update the input with the witnessScript
+                    psbt.updateInput(inputIndex, {
+                        witnessScript: paymentVariant.redeem.output,
+                    });
+                    // Sign this DLC input ourselves
+                    const dlcPrivKey = await this.findDlcFundingPrivateKey(dlcInput.localFundPubkey.toString('hex'), dlcInput.remoteFundPubkey.toString('hex'));
+                    const keyPair = ECPair.fromPrivateKey(Buffer.from(dlcPrivKey, 'hex'));
+                    psbt.signInput(inputIndex, keyPair);
+                    // Get our signature and determine which pubkey it corresponds to
+                    const ourPartialSig = psbt.data.inputs[inputIndex].partialSig[0];
+                    const ourSig = (0, Utils_1.ensureDerSignature)(ourPartialSig.signature);
+                    const ourPubkey = ourPartialSig.pubkey;
+                    // Get the other party's signature from witnessElements
+                    const otherPartySig = (0, Utils_1.ensureDerSignature)(witnessElements[0].witness);
+                    // Order signatures according to the lexicographic pubkey order used in the multisig script
+                    let sig1, sig2;
+                    if (Buffer.compare(ourPubkey, orderedPubkeys[0]) === 0) {
+                        // Our signature corresponds to the first pubkey in lexicographic order
+                        sig1 = ourSig;
+                        sig2 = otherPartySig;
+                    }
+                    else {
+                        // Our signature corresponds to the second pubkey in lexicographic order
+                        sig1 = otherPartySig;
+                        sig2 = ourSig;
+                    }
+                    // Finalize with proper multisig witness: [OP_0, sig1, sig2, redeemScript]
+                    psbt.finalizeInput(inputIndex, () => ({
+                        finalScriptSig: Buffer.alloc(0),
+                        finalScriptWitness: Buffer.concat([
+                            Buffer.from([0x04]), // witness stack count
+                            Buffer.from([0x00]), // OP_0 (Bitcoin multisig bug)
+                            Buffer.from([sig1.length]),
+                            sig1,
+                            Buffer.from([sig2.length]),
+                            sig2,
+                            Buffer.from([paymentVariant.redeem.output.length]),
+                            paymentVariant.redeem.output,
+                        ]),
+                    }));
                     continue;
                 }
                 // For P2WPKH inputs, finalize the input with witness data
-                const signature = this.ensureDerSignature(witnessElements[0].witness);
+                const signature = (0, Utils_1.ensureDerSignature)(witnessElements[0].witness);
                 const publicKey = witnessElements[1].witness;
                 // Try a simpler approach - let bitcoinjs-lib handle witness construction
                 psbt.finalizeInput(inputIndex, () => ({
@@ -1468,8 +1401,7 @@ Payout Group found but incorrect group index');
 Payout Group not found');
         return { index: payoutIndexOffset + index, groupLength };
     }
-    async FindOutcomeIndexFromHyperbolaPayoutCurvePiece(_dlcOffer, contractDescriptor, contractOraclePairIndex, hyperbolaPayoutCurvePiece, oracleAttestation, outcome) {
-        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+    async FindOutcomeIndexFromHyperbolaPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, hyperbolaPayoutCurvePiece, oracleAttestation, outcome) {
         const hyperbolaCurve = core_2.HyperbolaPayoutCurve.fromPayoutCurvePiece(hyperbolaPayoutCurvePiece);
         const clampBN = (val) => bignumber_js_1.default.max(0, bignumber_js_1.default.min(val, dlcOffer.contractInfo.totalCollateral.toString()));
         const payout = clampBN(hyperbolaCurve.getPayout(outcome));
@@ -1767,18 +1699,8 @@ Payout Group not found even with brute force search');
             _dlcTxs,
         });
         const network = await this.getConnectedNetwork();
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const fundingPubKeys = (0, Utils_1.orderPubkeysLexicographically)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey);
+        const paymentVariant = (0, Utils_1.createP2WSHMultisigFromOrdered)(fundingPubKeys, network);
         const sigHashRequestPromises = [];
         const sigHashes = [];
         for (let i = 0; i < rawCloseTxs.length; i++) {
@@ -1837,18 +1759,8 @@ Payout Group not found even with brute force search');
         });
         const dlcCloses = _dlcCloses.map((_dlcClose) => (0, Utils_1.checkTypes)({ _dlcClose }).dlcClose);
         const network = await this.getConnectedNetwork();
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const fundingPubKeys = (0, Utils_1.orderPubkeysLexicographically)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey);
+        const paymentVariant = (0, Utils_1.createP2WSHMultisigFromOrdered)(fundingPubKeys, network);
         const pubkey = isOfferer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey;
         const sigsValidity = [];
         for (let i = 0; i < rawCloseTxs.length; i++) {
@@ -1959,8 +1871,7 @@ Payout Group not found even with brute force search');
             changeSerialId = initResult.changeSerialId;
         }
         _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInput, 'FundingInput must be V0'));
-        const fundingInputs = _fundingInputs.map((input) => input);
-        fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+        const fundingInputs = (0, Utils_1.sortFundingInputsBySerialId)(_fundingInputs);
         const fundOutputSerialId = (0, Utils_1.generateSerialId)();
         (0, assert_1.default)(changeSerialId !== fundOutputSerialId, 'changeSerialId cannot equal the fundOutputSerialId');
         dlcOffer.contractFlags = Buffer.from('00', 'hex');
@@ -2074,8 +1985,7 @@ Payout Group not found even with brute force search');
             changeSerialId = initResult.changeSerialId;
             const _fundingInputs = initResult.fundingInputs;
             _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInput, 'FundingInput must be V0'));
-            fundingInputs = _fundingInputs.map((input) => input);
-            fundingInputs.sort((a, b) => Number(a.inputSerialId) - Number(b.inputSerialId));
+            fundingInputs = (0, Utils_1.sortFundingInputsBySerialId)(_fundingInputs.map((input) => input));
         }
         (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubkey, fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
         const dlcAccept = new messaging_1.DlcAccept();
@@ -2113,7 +2023,7 @@ Payout Group not found even with brute force search');
         const { dlcTransactions, messagesList } = await this.createDlcTxs(dlcOffer, dlcAccept);
         const { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
         const _dlcTransactions = dlcTransactions;
-        const contractId = this.computeContractId(_dlcTransactions.fundTx.txId.serialize(), _dlcTransactions.fundTxVout, dlcOffer.temporaryContractId);
+        const contractId = (0, Utils_1.computeContractId)(_dlcTransactions.fundTx.txId.serialize(), _dlcTransactions.fundTxVout, dlcOffer.temporaryContractId);
         _dlcTransactions.contractId = contractId;
         dlcAccept.cetAdaptorSignatures = cetSignatures;
         dlcAccept.refundSignature = refundSignature;
@@ -2133,10 +2043,9 @@ Payout Group not found even with brute force search');
         const { dlcTransactions, messagesList } = await this.createDlcTxs(dlcOffer, dlcAccept);
         await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTransactions, messagesList, true);
         const { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, true);
-        const fundingSignatures = await this.CreateFundingSigsAlt(dlcOffer, dlcAccept, dlcTransactions, true);
+        const fundingSignatures = await this.CreateFundingSigs(dlcOffer, dlcAccept, dlcTransactions, true);
         const dlcTxs = dlcTransactions;
-        const contractId = this.computeContractId(dlcTxs.fundTx.txId.serialize(), dlcTxs.fundTxVout, dlcOffer.temporaryContractId);
-        (0, assert_1.default)(Buffer.compare(contractId, this.computeContractId(dlcTxs.fundTx.txId.serialize(), dlcTxs.fundTxVout, dlcOffer.temporaryContractId)) === 0, 'contractId must be the xor of funding txid, fundingOutputIndex and the tempContractId');
+        const contractId = (0, Utils_1.computeContractId)(dlcTxs.fundTx.txId.serialize(), dlcTxs.fundTxVout, dlcOffer.temporaryContractId);
         dlcTxs.contractId = contractId;
         dlcSign.contractId = contractId;
         dlcSign.cetAdaptorSignatures = cetSignatures;
@@ -2154,6 +2063,8 @@ Payout Group not found even with brute force search');
      */
     async finalizeDlcSign(dlcOffer, dlcAccept, dlcSign, dlcTxs) {
         let messagesList = [];
+        const contractId = (0, Utils_1.computeContractId)(dlcTxs.fundTx.txId.serialize(), dlcTxs.fundTxVout, dlcOffer.temporaryContractId);
+        (0, assert_1.default)(Buffer.compare(contractId, dlcSign.contractId) === 0, `Finalize Dlc Sign Contract ID mismatch: ${contractId.toString('hex')} !== ${dlcSign.contractId.toString('hex')}`);
         if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
             dlcOffer.contractInfo.contractDescriptor.type ===
                 messaging_1.MessageType.SingleContractInfo) {
@@ -2168,8 +2079,8 @@ Payout Group not found even with brute force search');
             messagesList = oracleEventMessagesList;
         }
         await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, messagesList, false);
-        await this.VerifyFundingSigsAlt(dlcOffer, dlcAccept, dlcSign, dlcTxs, false);
-        const fundingSignatures = await this.CreateFundingSigsAlt(dlcOffer, dlcAccept, dlcTxs, false);
+        await this.VerifyFundingSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, false);
+        const fundingSignatures = await this.CreateFundingSigs(dlcOffer, dlcAccept, dlcTxs, false);
         const fundTx = await this.CreateFundingTx(dlcOffer, dlcAccept, dlcSign, dlcTxs, fundingSignatures);
         return fundTx;
     }
@@ -2204,19 +2115,8 @@ Payout Group not found even with brute force search');
         if (Number(dlcTxs.refundTx.locktime) !== dlcOffer.refundLocktime) {
             throw new Error(`Refund transaction locktime ${dlcTxs.refundTx.locktime} does not match expected ${dlcOffer.refundLocktime}`);
         }
-        // Create the same funding script as createDlcClose
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const fundingPubKeys = (0, Utils_1.orderPubkeysLexicographically)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey);
+        const paymentVariant = (0, Utils_1.createP2WSHMultisigFromOrdered)(fundingPubKeys, network);
         // Add the funding input with sequence from refund transaction
         psbt.addInput({
             hash: dlcTxs.fundTx.txId.serialize(),
@@ -2246,14 +2146,14 @@ Payout Group not found even with brute force search');
                 // This is the offerer's pubkey, use dlcSign.refundSignature
                 partialSigs.push({
                     pubkey: pubkey,
-                    signature: this.ensureDerSignature(dlcSign.refundSignature),
+                    signature: (0, Utils_1.ensureDerSignature)(dlcSign.refundSignature),
                 });
             }
             else if (Buffer.compare(pubkey, dlcAccept.fundingPubkey) === 0) {
                 // This is the accepter's pubkey, use dlcAccept.refundSignature
                 partialSigs.push({
                     pubkey: pubkey,
-                    signature: this.ensureDerSignature(dlcAccept.refundSignature),
+                    signature: (0, Utils_1.ensureDerSignature)(dlcAccept.refundSignature),
                 });
             }
         }
@@ -2303,18 +2203,7 @@ Payout Group not found even with brute force search');
             isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
         const network = await this.getConnectedNetwork();
         const psbt = new bitcoinjs_lib_1.Psbt({ network });
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const paymentVariant = (0, Utils_1.createP2WSHMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
         // Initiate and build PSBT
         let inputs = _inputs;
         if (!_inputs) {
@@ -2414,7 +2303,7 @@ Payout Group not found even with brute force search');
             return ecc.verify(msghash, pubkey, signature);
         });
         // Extract close signature from psbt and decode it to only extract r and s values
-        const closeSignature = await bitcoinjs_lib_1.script.signature.decode(this.ensureBuffer(psbt.data.inputs[fundingInputIndex].partialSig[0].signature)).signature;
+        const closeSignature = await bitcoinjs_lib_1.script.signature.decode((0, Utils_1.ensureBuffer)(psbt.data.inputs[fundingInputIndex].partialSig[0].signature)).signature;
         // Extract funding signatures from psbt
         const inputSigs = psbt.data.inputs
             .filter((input) => input !== fundingInputIndex)
@@ -2423,9 +2312,9 @@ Payout Group not found even with brute force search');
         const witnessElements = [];
         for (let i = 0; i < inputSigs.length; i++) {
             const sigWitness = new messaging_1.ScriptWitnessV0();
-            sigWitness.witness = this.ensureBuffer(inputSigs[i].signature);
+            sigWitness.witness = (0, Utils_1.ensureBuffer)(inputSigs[i].signature);
             const pubKeyWitness = new messaging_1.ScriptWitnessV0();
-            pubKeyWitness.witness = this.ensureBuffer(inputSigs[i].pubkey);
+            pubKeyWitness.witness = (0, Utils_1.ensureBuffer)(inputSigs[i].pubkey);
             witnessElements.push([sigWitness, pubKeyWitness]);
         }
         const fundingSignatures = new messaging_1.FundingSignatures();
@@ -2555,18 +2444,7 @@ Payout Group not found even with brute force search');
         dlcClose.validate();
         const network = await this.getConnectedNetwork();
         const psbt = new bitcoinjs_lib_1.Psbt({ network });
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
-            ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
-            : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: fundingPubKeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const paymentVariant = (0, Utils_1.createP2WSHMultisig)(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey, network);
         // Make temporary array to hold all inputs and then sort them
         // this method can be improved later
         const psbtInputs = [];
@@ -2793,15 +2671,7 @@ Payout Group not found even with brute force search');
             : [remotePubkey, localPubkey];
         const network = await this.getConnectedNetwork();
         // Create 2-of-2 multisig payment using deterministic ordering
-        const p2ms = bitcoinjs_lib_1.payments.p2ms({
-            m: 2,
-            pubkeys: orderedPubkeys,
-            network,
-        });
-        const paymentVariant = bitcoinjs_lib_1.payments.p2wsh({
-            redeem: p2ms,
-            network,
-        });
+        const paymentVariant = (0, Utils_1.createP2WSHMultisigFromOrdered)(orderedPubkeys, network);
         const multisigAddress = paymentVariant.address;
         // Verify this matches the actual funding output address
         const actualFundingOutput = tx.outputs[dlcInputInfo.fundVout];