@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.2

package/dist/BitcoinDlcProvider.js

@@ -28,10 +28,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const provider_1 = __importDefault(require("@atomicfinance/provider"));
 const types_1 = require("@atomicfinance/types");
+const Input_1 = require("@atomicfinance/types/lib/models/Input");
 const utils_1 = require("@atomicfinance/utils");
 const bitcoin_1 = require("@node-dlc/bitcoin");
 const bufio_1 = require("@node-dlc/bufio");
 const core_1 = require("@node-dlc/core");
+const core_2 = require("@node-dlc/core");
 const crypto_1 = require("@node-dlc/crypto");
 const messaging_1 = require("@node-dlc/messaging");
 const assert_1 = __importDefault(require("assert"));
@@ -42,6 +44,7 @@ const crypto_2 = __importDefault(require("crypto"));
 const ecc = __importStar(require("tiny-secp256k1"));
 const Utils_1 = require("./utils/Utils");
 class BitcoinDlcProvider extends provider_1.default {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     constructor(network, cfdDlcJs) {
         super();
         this._network = network;
@@ -52,17 +55,83 @@ class BitcoinDlcProvider extends provider_1.default {
             await (0, utils_1.sleep)(10);
         }
     }
+    /**
+     * Find private key for DLC funding pubkey by deriving wallet addresses
+     */
+    async findDlcFundingPrivateKey(localFundPubkey, remoteFundPubkey) {
+        const targetPubkeys = [localFundPubkey, remoteFundPubkey];
+        // First check existing wallet addresses
+        const addresses = await this.getMethod('getAddresses')();
+        for (const addressInfo of addresses) {
+            if (addressInfo.derivationPath) {
+                try {
+                    const keyPair = await this.getMethod('keyPair')(addressInfo.derivationPath);
+                    const pubkey = Buffer.from(keyPair.publicKey);
+                    const pubkeyHex = pubkey.toString('hex');
+                    if (targetPubkeys.includes(pubkeyHex)) {
+                        return Buffer.from(keyPair.privateKey).toString('hex');
+                    }
+                }
+                catch (error) {
+                    continue;
+                }
+            }
+        }
+        // If not found in existing addresses, do comprehensive search
+        // For DLC splicing, funding pubkeys can be at much higher derivation paths
+        console.log('Searching extensively for DLC funding private key...');
+        for (const isChange of [false, true]) {
+            for (let i = 0; i < 1000; i++) {
+                // Search up to 1000 addresses for DLC keys
+                try {
+                    const address = await this.client.wallet.getAddresses(i, 1, isChange);
+                    if (address && address.length > 0) {
+                        const addressInfo = address[0];
+                        if (addressInfo.derivationPath) {
+                            const keyPair = await this.getMethod('keyPair')(addressInfo.derivationPath);
+                            const pubkey = Buffer.from(keyPair.publicKey);
+                            const pubkeyHex = pubkey.toString('hex');
+                            if (targetPubkeys.includes(pubkeyHex)) {
+                                console.log(`Found DLC funding key at derivation path: ${addressInfo.derivationPath}`);
+                                return Buffer.from(keyPair.privateKey).toString('hex');
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    continue;
+                }
+            }
+        }
+        throw new Error(`Could not find private key for DLC funding pubkeys: local=${localFundPubkey}, remote=${remoteFundPubkey}`);
+    }
     async GetPrivKeysForInputs(inputs) {
         const privKeys = [];
         for (let i = 0; i < inputs.length; i++) {
             const input = inputs[i];
-            let derivationPath = input.derivationPath;
-            if (!derivationPath) {
-                derivationPath = (await this.getMethod('getWalletAddress')(input.address)).derivationPath;
+            if (input.isDlcInput()) {
+                // Handle DLC input - use the dedicated method to find the funding private key
+                const dlcInput = input.dlcInput;
+                const foundPrivKey = await this.findDlcFundingPrivateKey(dlcInput.localFundPubkey, dlcInput.remoteFundPubkey);
+                privKeys.push(foundPrivKey);
+            }
+            else {
+                // Handle regular input
+                let derivationPath = input.derivationPath;
+                if (!derivationPath) {
+                    try {
+                        derivationPath = (await this.getMethod('getWalletAddress')(input.address)).derivationPath;
+                    }
+                    catch (error) {
+                        throw new Error(`Unable to find address ${input.address} in wallet. ` +
+                            `This may happen when using derivation paths outside the normal range. ` +
+                            `Error: ${error.message}`);
+                    }
+                }
+                const keyPair = await this.getMethod('keyPair')(derivationPath);
+                const privKey = Buffer.from(keyPair.__D).toString('hex');
+                privKeys.push(privKey);
             }
-            const keyPair = await this.getMethod('keyPair')(derivationPath);
-            const privKey = Buffer.from(keyPair.__D).toString('hex');
-            privKeys.push(privKey);
         }
         return privKeys;
     }
@@ -77,6 +146,34 @@ class BitcoinDlcProvider extends provider_1.default {
                 return 'bitcoin';
         }
     }
+    /**
+     * Get inputs for amount with explicit supplementation control
+     */
+    async GetInputsForAmountWithMode(amounts, feeRatePerVb, fixedInputs = [], supplementation = Input_1.InputSupplementationMode.Required) {
+        if (amounts.length === 0)
+            return [];
+        // For "none" mode, use exactly the provided inputs
+        if (supplementation === Input_1.InputSupplementationMode.None) {
+            return fixedInputs;
+        }
+        // For "required" and "optional" modes, attempt supplementation
+        const fixedUtxos = fixedInputs.map((input) => input.toUtxo());
+        try {
+            const inputsForAmount = await this.getMethod('getInputsForDualFunding')(amounts, feeRatePerVb, fixedUtxos);
+            // Convert UTXO objects to Input class instances
+            return inputsForAmount.inputs.map((utxo) => types_1.Input.fromUTXO(utxo));
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+            if (supplementation === Input_1.InputSupplementationMode.Required) {
+                throw Error(`Not enough balance GetInputsForAmountWithMode. Error: ${errorMessage}`);
+            }
+            else {
+                // Optional mode: fallback to provided inputs
+                return fixedInputs;
+            }
+        }
+    }
     async GetInputsForAmount(amounts, feeRatePerVb, fixedInputs = []) {
         if (amounts.length === 0)
             return [];
@@ -84,7 +181,8 @@ class BitcoinDlcProvider extends provider_1.default {
         let inputs;
         try {
             const inputsForAmount = await this.getMethod('getInputsForDualFunding')(amounts, feeRatePerVb, fixedUtxos);
-            inputs = inputsForAmount.inputs;
+            // Convert UTXO objects to Input class instances
+            inputs = inputsForAmount.inputs.map((utxo) => types_1.Input.fromUTXO(utxo));
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : 'Unknown error';
@@ -97,7 +195,7 @@ class BitcoinDlcProvider extends provider_1.default {
         }
         return inputs;
     }
-    async Initialize(collateral, feeRatePerVb, fixedInputs) {
+    async Initialize(collateral, feeRatePerVb, fixedInputs, inputSupplementationMode = Input_1.InputSupplementationMode.Required) {
         const network = await this.getConnectedNetwork();
         const payoutAddress = await this.client.wallet.getUnusedAddress(false);
         const payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
@@ -107,7 +205,7 @@ class BitcoinDlcProvider extends provider_1.default {
         const fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
         if (fundingAddress.address === payoutAddress.address)
             throw Error('Address reuse');
-        const inputs = await this.GetInputsForAmount([collateral], feeRatePerVb, fixedInputs);
+        const inputs = await this.GetInputsForAmountWithMode([collateral], feeRatePerVb, fixedInputs, inputSupplementationMode);
         const fundingInputs = await Promise.all(inputs.map(async (input) => {
             return this.inputToFundingInput(input);
         }));
@@ -124,7 +222,7 @@ class BitcoinDlcProvider extends provider_1.default {
     }
     async BatchInitialize(collaterals, feeRatePerVb, fixedInputs) {
         const network = await this.getConnectedNetwork();
-        const inputs = await this.GetInputsForAmount(collaterals, feeRatePerVb, fixedInputs);
+        const inputs = await this.GetInputsForAmountWithMode(collaterals, feeRatePerVb, fixedInputs, Input_1.InputSupplementationMode.Required);
         const fundingInputs = await Promise.all(inputs.map(async (input) => {
             return this.inputToFundingInput(input);
         }));
@@ -175,12 +273,12 @@ class BitcoinDlcProvider extends provider_1.default {
         if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptor)
             throw Error('Only DigitDecomposition Oracle Events supported');
         const roundingIntervals = contractDescriptor.roundingIntervals;
-        const cetPayouts = core_1.HyperbolaPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
+        const cetPayouts = core_2.HyperbolaPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
         const payoutGroups = [];
         cetPayouts.forEach((p) => {
             payoutGroups.push({
                 payout: p.payout,
-                groups: (0, core_1.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
+                groups: (0, core_2.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
             });
         });
         const rValuesMessagesList = this.GenerateMessages(singleOracleInfo);
@@ -200,12 +298,12 @@ class BitcoinDlcProvider extends provider_1.default {
         if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptor)
             throw Error('Only DigitDecomposition Oracle Events supported');
         const roundingIntervals = contractDescriptor.roundingIntervals;
-        const cetPayouts = core_1.PolynomialPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
+        const cetPayouts = core_2.PolynomialPayoutCurve.computePayouts(payoutFunction, totalCollateral, roundingIntervals);
         const payoutGroups = [];
         cetPayouts.forEach((p) => {
             payoutGroups.push({
                 payout: p.payout,
-                groups: (0, core_1.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
+                groups: (0, core_2.groupByIgnoringDigits)(p.indexFrom, p.indexTo, eventDescriptor.base, contractDescriptor.numDigits),
             });
         });
         const rValuesMessagesList = this.GenerateMessages(oracleInfo);
@@ -278,15 +376,37 @@ class BitcoinDlcProvider extends provider_1.default {
         const remoteFinalScriptPubkey = dlcAccept.payoutSpk.toString('hex');
         const localChangeScriptPubkey = dlcOffer.changeSpk.toString('hex');
         const remoteChangeScriptPubkey = dlcAccept.changeSpk.toString('hex');
-        const localInputs = await Promise.all(dlcOffer.fundingInputs.map(async (fundingInput) => {
-            const input = await this.fundingInputToInput(fundingInput, false);
-            return input.toUtxo();
-        }));
+        // Separate regular inputs from DLC inputs (only from offeror side)
+        const localRegularInputs = [];
+        const localDlcInputs = [];
+        for (const fundingInput of dlcOffer.fundingInputs) {
+            if (fundingInput.dlcInput) {
+                // This is a DLC input for splicing
+                // The pubkeys should be from the original DLC to correctly spend its funding output
+                localDlcInputs.push({
+                    fundTxid: fundingInput.prevTx.txId.toString(),
+                    fundVout: fundingInput.prevTxVout,
+                    fundAmount: Number(fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats),
+                    localFundPubkey: fundingInput.dlcInput.localFundPubkey.toString('hex'),
+                    remoteFundPubkey: fundingInput.dlcInput.remoteFundPubkey.toString('hex'),
+                    contractId: fundingInput.dlcInput.contractId.toString('hex'),
+                    maxWitnessLength: fundingInput.maxWitnessLen,
+                    inputSerialId: fundingInput.inputSerialId,
+                });
+            }
+            else {
+                // Regular input
+                const input = await this.fundingInputToInput(fundingInput, false);
+                localRegularInputs.push(input.toUtxo());
+            }
+        }
+        // Process remote inputs (no DLC inputs from acceptor side)
         const remoteInputs = await Promise.all(dlcAccept.fundingInputs.map(async (fundingInput) => {
             const input = await this.fundingInputToInput(fundingInput, false);
             return input.toUtxo();
         }));
-        const localInputAmount = localInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
+        // Calculate input amounts
+        const localInputAmount = localRegularInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
         const remoteInputAmount = remoteInputs.reduce((prev, cur) => prev + cur.amount.GetSatoshiAmount(), 0);
         let payouts = [];
         let messagesList = [];
@@ -310,43 +430,97 @@ class BitcoinDlcProvider extends provider_1.default {
             payouts = tempPayouts;
             messagesList = tempMessagesList;
         }
-        const dlcTxRequest = {
-            payouts,
-            localFundPubkey,
-            localFinalScriptPubkey,
-            remoteFundPubkey,
-            remoteFinalScriptPubkey,
-            localInputAmount,
-            localCollateralAmount: dlcOffer.offerCollateral,
-            localPayoutSerialId: dlcOffer.payoutSerialId,
-            localChangeSerialId: dlcOffer.changeSerialId,
-            remoteInputAmount,
-            remoteCollateralAmount: dlcAccept.acceptCollateral,
-            remotePayoutSerialId: dlcAccept.payoutSerialId,
-            remoteChangeSerialId: dlcAccept.changeSerialId,
-            refundLocktime: dlcOffer.refundLocktime,
-            localInputs,
-            remoteInputs,
-            localChangeScriptPubkey,
-            remoteChangeScriptPubkey,
-            feeRate: Number(dlcOffer.feeRatePerVb),
-            cetLockTime: dlcOffer.cetLocktime,
-            fundOutputSerialId: dlcOffer.fundOutputSerialId,
-        };
-        const dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+        // Determine whether to use regular or spliced DLC transactions
+        const hasDlcInputs = localDlcInputs.length > 0;
+        let dlcTxs;
+        if (hasDlcInputs) {
+            // Use spliced DLC transactions when DLC inputs are present
+            const splicedDlcTxRequest = {
+                payouts,
+                localFundPubkey,
+                localFinalScriptPubkey,
+                remoteFundPubkey,
+                remoteFinalScriptPubkey,
+                localInputAmount,
+                localCollateralAmount: dlcOffer.offerCollateral,
+                localPayoutSerialId: dlcOffer.payoutSerialId,
+                localChangeSerialId: dlcOffer.changeSerialId,
+                remoteInputAmount,
+                remoteCollateralAmount: dlcAccept.acceptCollateral,
+                remotePayoutSerialId: dlcAccept.payoutSerialId,
+                remoteChangeSerialId: dlcAccept.changeSerialId,
+                refundLocktime: dlcOffer.refundLocktime,
+                localInputs: localRegularInputs,
+                localDlcInputs: localDlcInputs,
+                remoteInputs,
+                localChangeScriptPubkey,
+                remoteChangeScriptPubkey,
+                feeRate: Number(dlcOffer.feeRatePerVb),
+                cetLockTime: dlcOffer.cetLocktime,
+                fundOutputSerialId: dlcOffer.fundOutputSerialId,
+            };
+            dlcTxs = await this.CreateSplicedDlcTransactions(splicedDlcTxRequest);
+        }
+        else {
+            // Use regular DLC transactions when no DLC inputs
+            const dlcTxRequest = {
+                payouts,
+                localFundPubkey,
+                localFinalScriptPubkey,
+                remoteFundPubkey,
+                remoteFinalScriptPubkey,
+                localInputAmount,
+                localCollateralAmount: dlcOffer.offerCollateral,
+                localPayoutSerialId: dlcOffer.payoutSerialId,
+                localChangeSerialId: dlcOffer.changeSerialId,
+                remoteInputAmount,
+                remoteCollateralAmount: dlcAccept.acceptCollateral,
+                remotePayoutSerialId: dlcAccept.payoutSerialId,
+                remoteChangeSerialId: dlcAccept.changeSerialId,
+                refundLocktime: dlcOffer.refundLocktime,
+                localInputs: localRegularInputs,
+                remoteInputs,
+                localChangeScriptPubkey,
+                remoteChangeScriptPubkey,
+                feeRate: Number(dlcOffer.feeRatePerVb),
+                cetLockTime: dlcOffer.cetLocktime,
+                fundOutputSerialId: dlcOffer.fundOutputSerialId,
+            };
+            dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+        }
         const dlcTransactions = new messaging_1.DlcTransactions();
         dlcTransactions.fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.fundTxHex));
-        dlcTransactions.fundTxVout = [
-            BigInt(dlcOffer.changeSerialId),
-            BigInt(dlcAccept.changeSerialId),
-            BigInt(dlcTxRequest.fundOutputSerialId),
-        ]
+        // Build serial IDs based on actual outputs in the transaction
+        const actualOutputs = dlcTransactions.fundTx.outputs;
+        const serialIds = [];
+        // Always include the funding output serial ID
+        serialIds.push(BigInt(dlcOffer.fundOutputSerialId));
+        // Only include change serial IDs if there are actually change outputs
+        // For exact amount DLCs with no change, there will be only 1 output (the funding output)
+        if (actualOutputs.length > 1) {
+            // Multiple outputs means there are change outputs
+            if (dlcOffer.offerCollateral > 0n) {
+                serialIds.push(BigInt(dlcOffer.changeSerialId));
+            }
+            if (dlcAccept.acceptCollateral > 0n) {
+                serialIds.push(BigInt(dlcAccept.changeSerialId));
+            }
+        }
+        dlcTransactions.fundTxVout = serialIds
             .sort((a, b) => (a < b ? -1 : a > b ? 1 : 0))
-            .findIndex((i) => BigInt(i) === BigInt(dlcTxRequest.fundOutputSerialId));
+            .findIndex((i) => BigInt(i) === BigInt(dlcOffer.fundOutputSerialId));
+        // Validate that the calculated fundTxVout is valid
+        if (dlcTransactions.fundTxVout < 0 ||
+            dlcTransactions.fundTxVout >= dlcTransactions.fundTx.outputs.length) {
+            throw new Error(`Invalid fundTxVout calculation: calculated=${dlcTransactions.fundTxVout}, ` +
+                `fundTx.outputs.length=${dlcTransactions.fundTx.outputs.length}, ` +
+                `fundOutputSerialId=${dlcOffer.fundOutputSerialId}, ` +
+                `serialIds=[${serialIds.join(', ')}], ` +
+                `offerCollateral=${dlcOffer.offerCollateral}, ` +
+                `acceptCollateral=${dlcAccept.acceptCollateral}`);
+        }
+        dlcTransactions.cets = dlcTxs.cetsHex.map((cetHex) => bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cetHex)));
         dlcTransactions.refundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.refundTxHex));
-        dlcTransactions.cets = dlcTxs.cetsHex.map((cetHex) => {
-            return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(cetHex));
-        });
         return { dlcTransactions, messagesList };
     }
     async createBatchDlcTxs(dlcOffers, dlcAccepts) {
@@ -501,6 +675,16 @@ class BitcoinDlcProvider extends provider_1.default {
             throw Error('ContractInfo must be Single or Disjoint');
         }
     }
+    getFundOutputValueSats(dlcTxs) {
+        const fundOutput = dlcTxs.fundTx.outputs[dlcTxs.fundTxVout];
+        if (!fundOutput || !fundOutput.value) {
+            throw new Error(`Invalid fund output at vout ${dlcTxs.fundTxVout}: ` +
+                `outputs.length=${dlcTxs.fundTx.outputs.length}, ` +
+                `output exists=${!!fundOutput}, ` +
+                `output.value exists=${!!(fundOutput && fundOutput.value)}`);
+        }
+        return fundOutput.value.sats;
+    }
     async CreateCetAdaptorAndRefundSigs(_dlcOffer, _dlcAccept, _dlcTxs, messagesList, isOfferer) {
         const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
             _dlcOffer,
@@ -523,7 +707,7 @@ class BitcoinDlcProvider extends provider_1.default {
         if (dlcOffer.contractInfo.contractInfoType === messaging_1.ContractInfoType.Single &&
             dlcOffer.contractInfo.contractDescriptor.type ===
                 messaging_1.MessageType.ContractDescriptorV0) {
-            for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
+            for (const { oracleInfo } of contractOraclePairs) {
                 if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
                     throw new Error('Only SingleOracleInfo supported in this context');
                 }
@@ -540,7 +724,7 @@ class BitcoinDlcProvider extends provider_1.default {
                     fundVout: dlcTxs.fundTxVout,
                     localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
                     remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
-                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                     oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
                     oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
                 };
@@ -581,7 +765,7 @@ class BitcoinDlcProvider extends provider_1.default {
                         fundVout: dlcTxs.fundTxVout,
                         localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
                         remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
-                        fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                        fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                         oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
                         oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
                     };
@@ -606,7 +790,7 @@ class BitcoinDlcProvider extends provider_1.default {
             fundVout: dlcTxs.fundTxVout,
             localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
             remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
-            fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+            fundInputAmount: this.getFundOutputValueSats(dlcTxs),
         };
         const refundSignature = Buffer.from((await this.GetRawRefundTxSignature(refundSignRequest)).hex, 'hex');
         const cetSignatures = new messaging_1.CetAdaptorSignatures();
@@ -625,7 +809,7 @@ class BitcoinDlcProvider extends provider_1.default {
         if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
             dlcOffer.contractInfo.contractDescriptor.type ===
                 messaging_1.MessageType.ContractDescriptorV0) {
-            for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
+            for (const { oracleInfo } of contractOraclePairs) {
                 if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
                     throw new Error('Only SingleOracleInfo supported in this context');
                 }
@@ -655,7 +839,7 @@ class BitcoinDlcProvider extends provider_1.default {
                     remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
                     fundTxId: dlcTxs.fundTx.txId.toString(),
                     fundVout: dlcTxs.fundTxVout,
-                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                     verifyRemote: isOfferer,
                 };
                 sigsValidity.push((async () => {
@@ -672,7 +856,7 @@ class BitcoinDlcProvider extends provider_1.default {
                     remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
                     fundTxId: dlcTxs.fundTx.txId.toString(),
                     fundVout: dlcTxs.fundTxVout,
-                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                     verifyRemote: isOfferer,
                 };
                 areSigsValid =
@@ -719,7 +903,7 @@ class BitcoinDlcProvider extends provider_1.default {
                         remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
                         fundTxId: dlcTxs.fundTx.txId.toString(),
                         fundVout: dlcTxs.fundTxVout,
-                        fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                        fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                         verifyRemote: isOfferer,
                     };
                     sigsValidity.push((async () => {
@@ -737,7 +921,7 @@ class BitcoinDlcProvider extends provider_1.default {
                     remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
                     fundTxId: dlcTxs.fundTx.txId.toString(),
                     fundVout: dlcTxs.fundTxVout,
-                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                     verifyRemote: isOfferer,
                 };
                 areSigsValid =
@@ -763,14 +947,32 @@ class BitcoinDlcProvider extends provider_1.default {
         }));
         const inputPrivKeys = await this.GetPrivKeysForInputs(inputs);
         const fundTxSigs = await Promise.all(inputs.map(async (input, index) => {
-            const fundTxSignRequest = {
-                fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
-                privkey: inputPrivKeys[index],
-                prevTxId: input.txid,
-                prevVout: input.vout,
-                amount: input.value,
-            };
-            return (await this.GetRawFundTxSignature(fundTxSignRequest)).hex;
+            // Use DLC-specific signing for DLC inputs
+            if (input.isDlcInput()) {
+                const dlcInputInfo = input.dlcInput;
+                const dlcSignRequest = {
+                    fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+                    fundTxid: input.txid,
+                    fundVout: input.vout,
+                    fundAmount: input.value,
+                    localFundPubkey: dlcInputInfo.localFundPubkey,
+                    remoteFundPubkey: dlcInputInfo.remoteFundPubkey,
+                    privkey: inputPrivKeys[index],
+                };
+                return (await this.GetRawDlcFundingInputSignature(dlcSignRequest))
+                    .hex;
+            }
+            else {
+                // Use regular signing for non-DLC inputs
+                const fundTxSignRequest = {
+                    fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+                    privkey: inputPrivKeys[index],
+                    prevTxId: input.txid,
+                    prevVout: input.vout,
+                    amount: input.value,
+                };
+                return (await this.GetRawFundTxSignature(fundTxSignRequest)).hex;
+            }
         }));
         const inputPubKeys = await Promise.all(inputPrivKeys.map(async (privkey) => {
             const reqPrivKey = {
@@ -801,18 +1003,39 @@ class BitcoinDlcProvider extends provider_1.default {
             const fundingInput = isOfferer
                 ? dlcAccept.fundingInputs[i]
                 : dlcOffer.fundingInputs[i];
-            const verifyFundSigRequest = {
-                fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
-                signature,
-                pubkey,
-                prevTxId: fundingInput.prevTx.txId.toString(),
-                prevVout: fundingInput.prevTxVout,
-                fundInputAmount: fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats,
-            };
-            sigsValidity.push((async () => {
-                const response = await this.VerifyFundTxSignature(verifyFundSigRequest);
-                return response.valid;
-            })());
+            // Check if this is a DLC input and use appropriate verification
+            if (fundingInput.dlcInput) {
+                const dlcInput = fundingInput.dlcInput;
+                const verifyDlcSigRequest = {
+                    fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+                    fundTxid: fundingInput.prevTx.txId.toString(),
+                    fundVout: fundingInput.prevTxVout,
+                    fundAmount: Number(fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats),
+                    localFundPubkey: dlcInput.localFundPubkey.toString('hex'),
+                    remoteFundPubkey: dlcInput.remoteFundPubkey.toString('hex'),
+                    signature,
+                    pubkey,
+                };
+                sigsValidity.push((async () => {
+                    const response = await this.VerifyDlcFundingInputSignature(verifyDlcSigRequest);
+                    return response.valid;
+                })());
+            }
+            else {
+                // Regular input verification
+                const verifyFundSigRequest = {
+                    fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+                    signature,
+                    pubkey,
+                    prevTxId: fundingInput.prevTx.txId.toString(),
+                    prevVout: fundingInput.prevTxVout,
+                    fundInputAmount: fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats,
+                };
+                sigsValidity.push((async () => {
+                    const response = await this.VerifyFundTxSignature(verifyFundSigRequest);
+                    return response.valid;
+                })());
+            }
         }
         const areSigsValid = (await Promise.all(sigsValidity)).every((b) => b);
         if (!areSigsValid) {
@@ -829,25 +1052,53 @@ class BitcoinDlcProvider extends provider_1.default {
             ...dlcAccept.fundingInputs,
         ];
         let fundTxHex = dlcTxs.fundTx.serialize().toString('hex');
+        // Track processed DLC inputs to avoid double processing
+        const processedDlcInputs = new Set();
         await (0, Utils_1.asyncForEach)(witnessElements, async (witnessElement, i) => {
             const signature = witnessElement[0].witness.toString('hex');
             const pubkey = witnessElement[1].witness.toString('hex');
             const fundingInput = fundingInputs[i];
-            const addSignRequest = {
-                fundTxHex,
-                signature,
-                prevTxId: fundingInput.prevTx.txId.toString(),
-                prevVout: fundingInput.prevTxVout,
-                pubkey,
-            };
-            fundTxHex = (await this.AddSignatureToFundTransaction(addSignRequest))
-                .hex;
+            const inputKey = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
+            // Check if this is a DLC input
+            if (fundingInput.dlcInput && !processedDlcInputs.has(inputKey)) {
+                // Mark as processed to avoid double processing
+                processedDlcInputs.add(inputKey);
+                // For DLC inputs, use SignDlcFundingInput which properly combines signatures
+                // This is the correct CFD method for DLC funding inputs
+                const dlcInput = fundingInput.dlcInput;
+                // Find the private key for this DLC input
+                const privateKey = await this.findDlcFundingPrivateKey(dlcInput.localFundPubkey.toString('hex'), dlcInput.remoteFundPubkey.toString('hex'));
+                const signDlcRequest = {
+                    fundTxHex,
+                    fundTxid: fundingInput.prevTx.txId.toString(),
+                    fundVout: fundingInput.prevTxVout,
+                    fundAmount: Number(fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats),
+                    localFundPubkey: dlcInput.localFundPubkey.toString('hex'),
+                    remoteFundPubkey: dlcInput.remoteFundPubkey.toString('hex'),
+                    localPrivkey: privateKey,
+                    remoteSignature: signature,
+                };
+                fundTxHex = (await this.SignDlcFundingInput(signDlcRequest)).hex;
+            }
+            else if (!fundingInput.dlcInput) {
+                // Regular input - use standard signing
+                const addSignRequest = {
+                    fundTxHex,
+                    signature,
+                    prevTxId: fundingInput.prevTx.txId.toString(),
+                    prevVout: fundingInput.prevTxVout,
+                    pubkey,
+                };
+                fundTxHex = (await this.AddSignatureToFundTransaction(addSignRequest))
+                    .hex;
+            }
+            // If it's a DLC input but already processed, skip it
         });
         const fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(fundTxHex));
         return fundTx;
     }
     async FindOutcomeIndexFromPolynomialPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, polynomialPayoutCurvePiece, oracleAttestation, outcome) {
-        const polynomialCurve = core_1.PolynomialPayoutCurve.fromPayoutCurvePiece(polynomialPayoutCurvePiece);
+        const polynomialCurve = core_2.PolynomialPayoutCurve.fromPayoutCurvePiece(polynomialPayoutCurvePiece);
         const payouts = polynomialPayoutCurvePiece.points.map((point) => Number(point.outcomePayout));
         const minPayout = Math.min(...payouts);
         const maxPayout = Math.max(...payouts);
@@ -861,7 +1112,7 @@ class BitcoinDlcProvider extends provider_1.default {
             ...contractDescriptor.roundingIntervals.intervals,
         ].sort((a, b) => Number(b.beginInterval) - Number(a.beginInterval));
         const interval = intervalsSorted.find((interval) => Number(outcome) >= Number(interval.beginInterval));
-        const roundedPayout = BigInt(clampBN(new bignumber_js_1.default((0, core_1.roundPayout)(payout, interval.roundingMod).toString())).toString());
+        const roundedPayout = BigInt(clampBN(new bignumber_js_1.default((0, core_2.roundPayout)(payout, interval.roundingMod).toString())).toString());
         const outcomesFormatted = oracleAttestation.outcomes.map((outcome) => parseInt(outcome));
         let index = 0;
         let groupIndex = -1;
@@ -889,7 +1140,7 @@ Payout Group not found');
     }
     async FindOutcomeIndexFromHyperbolaPayoutCurvePiece(_dlcOffer, contractDescriptor, contractOraclePairIndex, hyperbolaPayoutCurvePiece, oracleAttestation, outcome) {
         const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
-        const hyperbolaCurve = core_1.HyperbolaPayoutCurve.fromPayoutCurvePiece(hyperbolaPayoutCurvePiece);
+        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));
         const payoutResponses = this.GetPayouts(dlcOffer);
@@ -900,7 +1151,7 @@ Payout Group not found');
             ...contractDescriptor.roundingIntervals.intervals,
         ].sort((a, b) => Number(b.beginInterval) - Number(a.beginInterval));
         const interval = intervalsSorted.find((interval) => Number(outcome) >= Number(interval.beginInterval));
-        const roundedPayout = BigInt(clampBN(new bignumber_js_1.default((0, core_1.roundPayout)(payout, interval.roundingMod).toString())).toString());
+        const roundedPayout = BigInt(clampBN(new bignumber_js_1.default((0, core_2.roundPayout)(payout, interval.roundingMod).toString())).toString());
         const outcomesFormatted = oracleAttestation.outcomes.map((outcome) => parseInt(outcome));
         let index = 0;
         let groupIndex = -1;
@@ -941,7 +1192,7 @@ Payout Group not found');
             // Fallback to brute force search if payout-based search fails
             index = 0;
             groupLength = 0;
-            for (const [i, payoutGroup] of payoutGroups.entries()) {
+            for (const [, payoutGroup] of payoutGroups.entries()) {
                 groupIndex = payoutGroup.groups.findIndex((group) => {
                     return group.every((msg, j) => msg === outcomesFormatted[j]);
                 });
@@ -1070,7 +1321,7 @@ Payout Group not found even with brute force search');
                 localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
                 remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
                 oracleSignatures: oracleAttestation.signatures.map((sig) => sig.toString('hex')),
-                fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                 adaptorSignature: isOfferer
                     ? dlcAccept.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
                     : dlcSign.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
@@ -1090,7 +1341,7 @@ Payout Group not found even with brute force search');
                 localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
                 remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
                 oracleSignatures: oracleSignatures.map((sig) => sig.toString('hex')),
-                fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                 adaptorSignature: isOfferer
                     ? dlcAccept.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
                     : dlcSign.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
@@ -1121,7 +1372,7 @@ Payout Group not found even with brute force search');
         const network = await this.getConnectedNetwork();
         let finalizer;
         if (_dlcCloses.length === 0) {
-            finalizer = new core_1.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSpk, dlcAccept.payoutSpk, dlcOffer.feeRatePerVb);
+            finalizer = new core_2.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSpk, dlcAccept.payoutSpk, dlcOffer.feeRatePerVb);
         }
         const rawTransactionRequestPromises = [];
         const rawCloseTxs = [];
@@ -1217,7 +1468,7 @@ Payout Group not found even with brute force search');
                         hex: paymentVariant.redeem.output.toString('hex'),
                         type: 'redeem_script',
                     },
-                    amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                    amount: Number(this.getFundOutputValueSats(dlcTxs)),
                     hashType: 'p2wsh',
                     sighashType: 'all',
                     sighashAnyoneCanPay: false,
@@ -1290,7 +1541,7 @@ Payout Group not found even with brute force search');
                     hashType: 'p2wsh',
                     sighashType: 'all',
                     sighashAnyoneCanPay: false,
-                    amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                    amount: Number(this.getFundOutputValueSats(dlcTxs)),
                 },
             };
             sigsValidity.push((async () => {
@@ -1340,15 +1591,49 @@ Payout Group not found even with brute force search');
      * @param feeRatePerVb Fee rate in satoshi per virtual byte that both sides use to compute fees in funding tx
      * @param cetLocktime The nLockTime to be put on CETs
      * @param refundLocktime The nLockTime to be put on the refund transaction
+     * @param fixedInputs Optional fixed inputs - can be Input[] for regular inputs or FundingInput[] for DLC inputs
      * @returns {Promise<DlcOffer>}
      */
-    async createDlcOffer(contractInfo, offerCollateralSatoshis, feeRatePerVb, cetLocktime, refundLocktime, fixedInputs) {
+    async createDlcOffer(contractInfo, offerCollateralSatoshis, feeRatePerVb, cetLocktime, refundLocktime, fixedInputs, inputSupplementationMode) {
         contractInfo.validate();
         const network = await this.getConnectedNetwork();
         const dlcOffer = new messaging_1.DlcOffer();
         // Generate a random 32-byte temporary contract ID
         dlcOffer.temporaryContractId = crypto_2.default.randomBytes(32);
-        const { fundingPubKey, payoutSPK, payoutSerialId, fundingInputs: _fundingInputs, changeSPK, changeSerialId, } = await this.Initialize(offerCollateralSatoshis, feeRatePerVb, fixedInputs);
+        // Check if we have FundingInput[] (DLC inputs) or Input[] (regular inputs)
+        const hasFundingInputs = fixedInputs && fixedInputs.length > 0 && 'prevTx' in fixedInputs[0]; // FundingInput has prevTx, Input doesn't
+        let fundingPubKey;
+        let payoutSPK;
+        let payoutSerialId;
+        let _fundingInputs;
+        let changeSPK;
+        let changeSerialId;
+        if (hasFundingInputs) {
+            // Handle FundingInput[] directly (for DLC inputs)
+            const fundingInputs = fixedInputs;
+            // Generate addresses directly since we're bypassing Initialize()
+            const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+            payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+            const changeAddress = await this.client.wallet.getUnusedAddress(true);
+            changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+            const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+            fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+            if (fundingAddress.address === payoutAddress.address)
+                throw Error('Address reuse');
+            payoutSerialId = (0, Utils_1.generateSerialId)();
+            changeSerialId = (0, Utils_1.generateSerialId)();
+            _fundingInputs = fundingInputs;
+        }
+        else {
+            // Handle Input[] through existing Initialize() flow
+            const initResult = await this.Initialize(offerCollateralSatoshis, feeRatePerVb, fixedInputs, inputSupplementationMode || Input_1.InputSupplementationMode.Required);
+            fundingPubKey = initResult.fundingPubKey;
+            payoutSPK = initResult.payoutSPK;
+            payoutSerialId = initResult.payoutSerialId;
+            _fundingInputs = initResult.fundingInputs;
+            changeSPK = initResult.changeSPK;
+            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));
@@ -1369,8 +1654,11 @@ Payout Group not found even with brute force search');
         dlcOffer.feeRatePerVb = feeRatePerVb;
         dlcOffer.cetLocktime = cetLocktime;
         dlcOffer.refundLocktime = refundLocktime;
+        if (offerCollateralSatoshis === dlcOffer.contractInfo.totalCollateral) {
+            dlcOffer.markAsSingleFunded();
+        }
         (0, assert_1.default)((() => {
-            const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, null, null, null, dlcOffer.feeRatePerVb);
+            const finalizer = new core_2.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, null, null, null, dlcOffer.feeRatePerVb);
             const funding = fundingInputs.reduce((total, input) => {
                 return total + input.prevTx.outputs[input.prevTxVout].value.sats;
             }, BigInt(0));
@@ -1417,8 +1705,11 @@ Payout Group not found even with brute force search');
             dlcOffer.feeRatePerVb = feeRatePerVb;
             dlcOffer.cetLocktime = cetLocktime;
             dlcOffer.refundLocktime = refundLocktime;
+            if (offerCollateralSatoshis === dlcOffer.contractInfo.totalCollateral) {
+                dlcOffer.markAsSingleFunded();
+            }
             (0, assert_1.default)((() => {
-                const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, null, null, null, dlcOffer.feeRatePerVb);
+                const finalizer = new core_2.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, null, null, null, dlcOffer.feeRatePerVb);
                 const funding = fundingInputs.reduce((total, input) => {
                     return total + input.prevTx.outputs[input.prevTxVout].value.sats;
                 }, BigInt(0));
@@ -1430,7 +1721,7 @@ Payout Group not found even with brute force search');
         return dlcOffers;
     }
     /**
-     * Accept DLC Offer
+     * Accept DLC Offer (supports single-funded DLCs when accept collateral is 0)
      * @param _dlcOffer Dlc Offer Message
      * @param fixedInputs Optional inputs to use for Funding Inputs
      * @returns {Promise<AcceptDlcOfferResponse}
@@ -1441,11 +1732,81 @@ Payout Group not found even with brute force search');
         const acceptCollateralSatoshis = dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral;
         (0, assert_1.default)(acceptCollateralSatoshis ===
             dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, 'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis');
-        const { fundingPubKey, payoutSPK, payoutSerialId, fundingInputs: _fundingInputs, changeSPK, changeSerialId, } = await this.Initialize(acceptCollateralSatoshis, dlcOffer.feeRatePerVb, fixedInputs);
+        let fundingPubKey;
+        let payoutSPK;
+        let payoutSerialId;
+        let fundingInputs;
+        let changeSPK;
+        let changeSerialId;
+        if (acceptCollateralSatoshis === BigInt(0)) {
+            // Single-funded DLC: accept side provides no funding
+            const network = await this.getConnectedNetwork();
+            // Still need payout address for receiving DLC outcomes
+            const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+            payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+            // Generate funding pubkey for DLC contract construction
+            const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+            fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+            // Generate change address (even though not used)
+            const changeAddress = await this.client.wallet.getUnusedAddress(true);
+            changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+            if (fundingAddress.address === payoutAddress.address)
+                throw Error('Address reuse');
+            // Generate serial IDs
+            payoutSerialId = (0, Utils_1.generateSerialId)();
+            changeSerialId = (0, Utils_1.generateSerialId)();
+            // No funding inputs for single-funded DLC
+            fundingInputs = [];
+        }
+        else {
+            // Standard DLC: accept side provides funding
+            // Check if we have FundingInput[] (DLC inputs) or Input[] (regular inputs)
+            const hasFundingInputs = fixedInputs && fixedInputs.length > 0 && 'prevTx' in fixedInputs[0]; // FundingInput has prevTx, Input doesn't
+            let initResult;
+            if (hasFundingInputs) {
+                // Handle FundingInput[] directly (for DLC inputs)
+                const fundingInputs = fixedInputs;
+                const network = await this.getConnectedNetwork();
+                // Generate addresses directly since we're bypassing Initialize()
+                const payoutAddress = await this.client.wallet.getUnusedAddress(false);
+                const payoutSPK = bitcoinjs_lib_1.address.toOutputScript(payoutAddress.address, network);
+                const changeAddress = await this.client.wallet.getUnusedAddress(true);
+                const changeSPK = bitcoinjs_lib_1.address.toOutputScript(changeAddress.address, network);
+                const fundingAddress = await this.client.wallet.getUnusedAddress(false);
+                const fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+                if (fundingAddress.address === payoutAddress.address)
+                    throw Error('Address reuse');
+                const payoutSerialId = (0, Utils_1.generateSerialId)();
+                const changeSerialId = (0, Utils_1.generateSerialId)();
+                initResult = {
+                    fundingPubKey,
+                    payoutSPK,
+                    payoutSerialId,
+                    fundingInputs,
+                    changeSPK,
+                    changeSerialId,
+                };
+            }
+            else {
+                // Handle Input[] through existing Initialize() flow
+                // Use InputSupplementationMode.None when fixed inputs are provided
+                // to avoid wallet lookup issues with unusual addresses
+                const supplementationMode = fixedInputs && fixedInputs.length > 0
+                    ? Input_1.InputSupplementationMode.None
+                    : Input_1.InputSupplementationMode.Required;
+                initResult = await this.Initialize(acceptCollateralSatoshis, dlcOffer.feeRatePerVb, fixedInputs, supplementationMode);
+            }
+            fundingPubKey = initResult.fundingPubKey;
+            payoutSPK = initResult.payoutSPK;
+            payoutSerialId = initResult.payoutSerialId;
+            changeSPK = initResult.changeSPK;
+            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));
+        }
         (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubkey, fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
-        _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 dlcAccept = new messaging_1.DlcAccept();
         dlcAccept.temporaryContractId = (0, crypto_1.sha256)(dlcOffer.serialize());
         dlcAccept.acceptCollateral = acceptCollateralSatoshis;
@@ -1465,14 +1826,19 @@ Payout Group not found even with brute force search');
             ];
             return new Set(ids).size === ids.length;
         })(), 'offer.changeSerialID, accept.changeSerialId and fundOutputSerialId must be unique');
+        if (dlcOffer.singleFunded)
+            dlcAccept.markAsSingleFunded();
         dlcAccept.validate();
-        (0, assert_1.default)((() => {
-            const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, dlcAccept.fundingInputs, dlcAccept.payoutSpk, dlcAccept.changeSpk, dlcOffer.feeRatePerVb);
-            const funding = fundingInputs.reduce((total, input) => {
-                return total + input.prevTx.outputs[input.prevTxVout].value.sats;
-            }, BigInt(0));
-            return funding >= acceptCollateralSatoshis + finalizer.acceptFees;
-        })(), 'fundingInputs for dlcAccept must be greater than acceptCollateralSatoshis plus acceptFees');
+        // Only validate funding requirements if accept side is providing collateral
+        if (acceptCollateralSatoshis > BigInt(0)) {
+            (0, assert_1.default)((() => {
+                const finalizer = new core_2.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, dlcAccept.fundingInputs, dlcAccept.payoutSpk, dlcAccept.changeSpk, dlcOffer.feeRatePerVb);
+                const funding = fundingInputs.reduce((total, input) => {
+                    return total + input.prevTx.outputs[input.prevTxVout].value.sats;
+                }, BigInt(0));
+                return funding >= acceptCollateralSatoshis + finalizer.acceptFees;
+            })(), 'fundingInputs for dlcAccept must be greater than acceptCollateralSatoshis plus acceptFees');
+        }
         const { dlcTransactions, messagesList } = await this.createDlcTxs(dlcOffer, dlcAccept);
         const { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
         const _dlcTransactions = dlcTransactions;
@@ -1525,7 +1891,7 @@ Payout Group not found even with brute force search');
             })(), 'offer.changeSerialID, accept.changeSerialId and fundOutputSerialId must be unique');
             dlcAccept.validate();
             (0, assert_1.default)((() => {
-                const finalizer = new core_1.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, dlcAccept.fundingInputs, dlcAccept.payoutSpk, dlcAccept.changeSpk, dlcOffer.feeRatePerVb);
+                const finalizer = new core_2.DualFundingTxFinalizer(dlcOffer.fundingInputs, dlcOffer.payoutSpk, dlcOffer.changeSpk, dlcAccept.fundingInputs, dlcAccept.payoutSpk, dlcAccept.changeSpk, dlcOffer.feeRatePerVb);
                 const funding = fundingInputs.reduce((total, input) => {
                     return total + input.prevTx.outputs[input.prevTxVout].value.sats;
                 }, BigInt(0));
@@ -1554,11 +1920,7 @@ Payout Group not found even with brute force search');
      * @param _dlcAccept Dlc Accept Message
      * @returns {Promise<SignDlcAcceptResponse}
      */
-    async signDlcAccept(_dlcOffer, _dlcAccept) {
-        const { dlcOffer, dlcAccept } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-        });
+    async signDlcAccept(dlcOffer, dlcAccept) {
         dlcOffer.validate();
         dlcAccept.validate();
         (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
@@ -1764,20 +2126,18 @@ Payout Group not found even with brute force search');
         // Initiate and build PSBT
         let inputs = _inputs;
         if (!_inputs) {
-            const tempInputs = await this.GetInputsForAmount([BigInt(20000)], dlcOffer.feeRatePerVb, _inputs);
+            const tempInputs = await this.GetInputsForAmountWithMode([BigInt(20000)], dlcOffer.feeRatePerVb, _inputs || [], Input_1.InputSupplementationMode.Required);
             _inputs = tempInputs;
         }
-        inputs = _inputs.map((input) => {
-            return {
-                ...input,
-                inputSerialId: input.inputSerialId || (0, Utils_1.generateSerialId)(),
-                toUtxo: input.toUtxo,
-            };
-        });
-        const pubkeys = await Promise.all(inputs.map(async (input) => {
+        // Ensure all inputs have derivation paths by fetching from wallet
+        const inputsWithPaths = await Promise.all(_inputs.map(async (input) => {
             const address = await this.getMethod('getWalletAddress')(input.address);
-            return Buffer.from(address.publicKey, 'hex');
+            const inputWithPath = new types_1.Input(input.txid, input.vout, input.address, input.amount, input.value, input.derivationPath || address.derivationPath, // Use derivationPath from wallet if not set
+            input.maxWitnessLength, input.redeemScript, input.inputSerialId || (0, Utils_1.generateSerialId)(), input.scriptPubKey, input.label, input.confirmations, input.spendable, input.solvable, input.safe, input.dlcInput);
+            return { input: inputWithPath, address };
         }));
+        inputs = inputsWithPaths.map((item) => item.input);
+        const pubkeys = inputsWithPaths.map((item) => Buffer.from(item.address.publicKey, 'hex'));
         const fundingInputSerialId = (0, Utils_1.generateSerialId)();
         // Make temporary array to hold all inputs and then sort them
         // this method can be improved later
@@ -1788,7 +2148,7 @@ Payout Group not found even with brute force search');
             sequence: 0,
             witnessUtxo: {
                 script: paymentVariant.output,
-                value: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                value: Number(this.getFundOutputValueSats(dlcTxs)),
             },
             witnessScript: paymentVariant.redeem.output,
             inputSerialId: fundingInputSerialId,
@@ -1817,11 +2177,11 @@ Payout Group not found even with brute force search');
         // Get index of fundingInput
         const fundingInputIndex = sortedPsbtInputs.findIndex((input) => input.inputSerialId === fundingInputSerialId);
         // add to psbt
-        sortedPsbtInputs.forEach((input, i) => psbt.addInput(input));
+        sortedPsbtInputs.forEach((input) => psbt.addInput(input));
         const fundingInputs = await Promise.all(inputs.map(async (input) => {
             return this.inputToFundingInput(input);
         }));
-        const finalizer = new core_1.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSpk, dlcAccept.payoutSpk, dlcOffer.feeRatePerVb);
+        const finalizer = new core_2.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSpk, dlcAccept.payoutSpk, dlcOffer.feeRatePerVb);
         const closeInputAmount = BigInt(inputs.reduce((acc, val) => acc + val.value, 0));
         const offerPayoutValue = isOfferer
             ? closeInputAmount +
@@ -1851,6 +2211,9 @@ Payout Group not found even with brute force search');
             if (i === fundingInputIndex)
                 return;
             // derive keypair
+            if (!input.derivationPath) {
+                throw new Error(`Missing derivation path for input ${i}`);
+            }
             const keyPair = await this.getMethod('keyPair')(input.derivationPath);
             psbt.signInput(i, keyPair);
         }));
@@ -1909,7 +2272,7 @@ Payout Group not found even with brute force search');
             throw Error('funding inputs not supported on BatchDlcClose'); // TODO support multiple funding inputs
         const fundingInputSerialId = (0, Utils_1.generateSerialId)();
         const fundingInputs = []; // TODO: support multiple funding inputs
-        const finalizer = new core_1.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSpk, dlcAccept.payoutSpk, dlcOffer.feeRatePerVb);
+        const finalizer = new core_2.DualClosingTxFinalizer(fundingInputs, dlcOffer.payoutSpk, dlcAccept.payoutSpk, dlcOffer.feeRatePerVb);
         // Generate keypair to sign inputs
         const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, isOfferer);
         const closeInputAmount = BigInt(0); // TODO support multiple funding inputs
@@ -2021,13 +2384,13 @@ Payout Group not found even with brute force search');
             sequence: 0,
             witnessUtxo: {
                 script: paymentVariant.output,
-                value: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                value: Number(this.getFundOutputValueSats(dlcTxs)),
             },
             witnessScript: paymentVariant.redeem.output,
             inputSerialId: dlcClose.fundInputSerialId,
         });
         // add all dlc close inputs
-        dlcClose.fundingInputs.forEach((input, i) => {
+        dlcClose.fundingInputs.forEach((input) => {
             psbtInputs.push({
                 hash: input.prevTx.txId.serialize(),
                 index: input.prevTxVout,
@@ -2062,7 +2425,7 @@ Payout Group not found even with brute force search');
             address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcAccept.payoutSpk : dlcOffer.payoutSpk, network),
         });
         // add to psbt
-        sortedPsbtInputs.forEach((input, i) => psbt.addInput(input));
+        sortedPsbtInputs.forEach((input) => psbt.addInput(input));
         const offerer = await this.isOfferer(dlcOffer, dlcAccept);
         // Generate keypair to sign inputs
         const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, offerer);
@@ -2167,6 +2530,22 @@ Payout Group not found even with brute force search');
         await this.CfdLoaded();
         return this._cfdDlcJs.VerifyRefundTxSignature(jsonObject);
     }
+    async CreateSplicedDlcTransactions(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.CreateSplicedDlcTransactions(jsonObject);
+    }
+    async GetRawDlcFundingInputSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.GetRawDlcFundingInputSignature(jsonObject);
+    }
+    async SignDlcFundingInput(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.SignDlcFundingInput(jsonObject);
+    }
+    async VerifyDlcFundingInputSignature(jsonObject) {
+        await this.CfdLoaded();
+        return this._cfdDlcJs.VerifyDlcFundingInputSignature(jsonObject);
+    }
     async fundingInputToInput(_input, findDerivationPath = true) {
         (0, assert_1.default)(_input.type === messaging_1.MessageType.FundingInput, 'FundingInput must be V0');
         const network = await this.getConnectedNetwork();
@@ -2184,21 +2563,22 @@ Payout Group not found even with brute force search');
                 derivationPath = inputAddress.derivationPath;
             }
         }
-        return {
-            txid: prevTx.txId.toString(),
-            vout: input.prevTxVout,
-            address: _address,
-            amount: prevTxOut.value.bitcoin,
-            value: Number(prevTxOut.value.sats),
-            derivationPath,
-            maxWitnessLength: input.maxWitnessLen,
-            redeemScript: input.redeemScript
-                ? input.redeemScript.toString('hex')
-                : '',
-            scriptPubKey: scriptPubKey.toString('hex'),
-            inputSerialId: input.inputSerialId,
-            toUtxo: types_1.Input.prototype.toUtxo,
-        };
+        // Check if this FundingInput has DLC input information to preserve
+        const dlcInputMessage = input.dlcInput;
+        let dlcInputInfo;
+        if (dlcInputMessage) {
+            dlcInputInfo = {
+                localFundPubkey: dlcInputMessage.localFundPubkey.toString('hex'),
+                remoteFundPubkey: dlcInputMessage.remoteFundPubkey.toString('hex'),
+                contractId: dlcInputMessage.contractId.toString('hex'),
+            };
+        }
+        return new types_1.Input(prevTx.txId.toString(), input.prevTxVout, _address, prevTxOut.value.bitcoin, Number(prevTxOut.value.sats), derivationPath, input.maxWitnessLen, input.redeemScript ? input.redeemScript.toString('hex') : '', input.inputSerialId, scriptPubKey.toString('hex'), undefined, // label
+        undefined, // confirmations
+        undefined, // spendable
+        undefined, // solvable
+        undefined, // safe
+        dlcInputInfo);
     }
     async inputToFundingInput(input) {
         const fundingInput = new messaging_1.FundingInput();
@@ -2228,12 +2608,99 @@ Payout Group not found even with brute force search');
         fundingInput.inputSerialId = input.inputSerialId
             ? input.inputSerialId
             : (0, Utils_1.generateSerialId)();
+        // Preserve DLC input information if present
+        if (input.isDlcInput()) {
+            const dlcInputInfo = input.dlcInput;
+            const dlcInput = new messaging_1.DlcInput();
+            dlcInput.localFundPubkey = Buffer.from(dlcInputInfo.localFundPubkey, 'hex');
+            dlcInput.remoteFundPubkey = Buffer.from(dlcInputInfo.remoteFundPubkey, 'hex');
+            dlcInput.contractId = Buffer.alloc(32); // Placeholder contract ID
+            fundingInput.dlcInput = dlcInput;
+        }
         return fundingInput;
     }
     async getConnectedNetwork() {
         return this._network;
     }
+    /**
+     * Calculate the maximum collateral possible with given inputs
+     * @param inputs Array of Input objects to use for funding
+     * @param feeRatePerVb Fee rate in satoshis per virtual byte
+     * @param contractCount Number of DLC contracts (default: 1)
+     * @returns Maximum collateral amount in satoshis
+     */
+    async calculateMaxCollateral(inputs, feeRatePerVb, contractCount = 1) {
+        if (inputs.length === 0) {
+            return BigInt(0);
+        }
+        try {
+            // Convert Input[] to FundingInput[]
+            const fundingInputs = await Promise.all(inputs.map((input) => this.inputToFundingInput(input)));
+            // Use node-dlc's calculateMaxCollateral function
+            // For single-funded DLC, pass only offerer inputs and fee rate
+            return core_1.BatchDlcTxBuilder.calculateMaxCollateral(fundingInputs, feeRatePerVb, contractCount);
+        }
+        catch (error) {
+            // If calculation fails, return 0 to indicate insufficient funds
+            console.warn('calculateMaxCollateral failed:', error);
+            return BigInt(0);
+        }
+    }
+    /**
+     * Create a funding input with DLC input information for splicing
+     * @param dlcInputInfo DLC input information
+     * @param fundingTxHex Raw transaction hex of the funding transaction
+     */
+    async createDlcFundingInput(dlcInputInfo, fundingTxHex) {
+        const fundingInput = new messaging_1.FundingInput();
+        const tx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(fundingTxHex));
+        fundingInput.prevTx = tx;
+        fundingInput.prevTxVout = dlcInputInfo.fundVout;
+        fundingInput.sequence = bitcoin_1.Sequence.default();
+        fundingInput.maxWitnessLen = dlcInputInfo.maxWitnessLength || 220;
+        fundingInput.redeemScript = Buffer.from('', 'hex'); // Empty for P2WSH
+        fundingInput.inputSerialId = BigInt(dlcInputInfo.inputSerialId || (0, Utils_1.generateSerialId)());
+        // Create the DLC multisig script for address generation
+        const localPubkey = Buffer.from(dlcInputInfo.localFundPubkey, 'hex');
+        const remotePubkey = Buffer.from(dlcInputInfo.remoteFundPubkey, 'hex');
+        // Use the same deterministic ordering as cfd-dlc-js: lexicographic by hex
+        // This matches GetOrderedPubkeys() in cfddlc_transactions.cpp
+        const orderedPubkeys = dlcInputInfo.localFundPubkey < dlcInputInfo.remoteFundPubkey
+            ? [localPubkey, remotePubkey]
+            : [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 multisigAddress = paymentVariant.address;
+        // Verify this matches the actual funding output address
+        const actualFundingOutput = tx.outputs[dlcInputInfo.fundVout];
+        const actualFundingAddress = bitcoinjs_lib_1.address.fromOutputScript(actualFundingOutput.scriptPubKey.serialize().slice(1), network);
+        if (actualFundingAddress !== multisigAddress) {
+            throw new Error(`DLC funding address mismatch. ` +
+                `Expected: ${actualFundingAddress}, ` +
+                `Constructed: ${multisigAddress}`);
+        }
+        // Add toUtxo method that's expected by GetInputsForAmount
+        fundingInput.toUtxo = () => {
+            return new types_1.Utxo(dlcInputInfo.fundTxid, dlcInputInfo.fundVout, types_1.Amount.FromSatoshis(Number(dlcInputInfo.fundAmount)), multisigAddress, dlcInputInfo.maxWitnessLength || 220, undefined, // DLC inputs don't have derivation paths
+            fundingInput.inputSerialId);
+        };
+        // Create proper DlcInput object for splicing detection and signing
+        const dlcInput = new messaging_1.DlcInput();
+        dlcInput.localFundPubkey = Buffer.from(dlcInputInfo.localFundPubkey, 'hex');
+        dlcInput.remoteFundPubkey = Buffer.from(dlcInputInfo.remoteFundPubkey, 'hex');
+        dlcInput.contractId = Buffer.from(dlcInputInfo.contractId, 'hex');
+        fundingInput.dlcInput = dlcInput;
+        return fundingInput;
+    }
 }
 exports.default = BitcoinDlcProvider;
-const BurnAddress = 'bcrt1qxcjufgh2jarkp2qkx68azh08w9v5gah8u6es8s';
 //# sourceMappingURL=BitcoinDlcProvider.js.map