@atomicfinance/bitcoin-dlc-provider 3.6.1 → 4.0.1

package/dist/BitcoinDlcProvider.js

@@ -28,19 +28,23 @@ 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"));
 const bignumber_js_1 = __importDefault(require("bignumber.js"));
 const bitcoin_networks_1 = require("bitcoin-networks");
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+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;
@@ -51,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;
     }
@@ -76,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 [];
@@ -83,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';
@@ -96,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);
@@ -106,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);
         }));
@@ -123,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);
         }));
@@ -155,73 +254,63 @@ class BitcoinDlcProvider extends provider_1.default {
      *   totalCollateral: bigint,
      * ): PayoutRequest[] {}
      */
-    GetPayoutsFromPayoutFunction(_dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
-        if (_dlcOffer.type !== messaging_1.MessageType.DlcOfferV0)
-            throw Error('DlcOffer must be V0');
-        const dlcOffer = _dlcOffer;
-        if (contractDescriptor.payoutFunction.type !== messaging_1.MessageType.PayoutFunctionV0)
-            throw Error('PayoutFunction must be V0');
+    GetPayoutsFromPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
         const payoutFunction = contractDescriptor.payoutFunction;
-        if (payoutFunction.pieces.length === 0)
+        if (payoutFunction.payoutFunctionPieces.length === 0)
             throw Error('PayoutFunction must have at least once PayoutCurvePiece');
-        if (payoutFunction.pieces.length > 1)
+        if (payoutFunction.payoutFunctionPieces.length > 1)
             throw Error('More than one PayoutCurvePiece not supported');
-        const payoutCurvePiece = payoutFunction.pieces[0]
+        const payoutCurvePiece = payoutFunction.payoutFunctionPieces[0]
             .payoutCurvePiece;
-        if (payoutCurvePiece.type !== messaging_1.MessageType.HyperbolaPayoutCurvePiece &&
-            payoutCurvePiece.type !== messaging_1.MessageType.OldHyperbolaPayoutCurvePiece)
+        if (payoutCurvePiece.payoutCurvePieceType !== messaging_1.PayoutCurvePieceType.Hyperbola)
             throw Error('Must be HyperbolaPayoutCurvePiece');
-        if (payoutCurvePiece.b !== BigInt(0) || payoutCurvePiece.c !== BigInt(0))
+        if (!payoutCurvePiece.b.eq(messaging_1.F64.ZERO) || !payoutCurvePiece.c.eq(messaging_1.F64.ZERO))
             throw Error('b and c HyperbolaPayoutCurvePiece values must be 0');
-        const eventDescriptor = oracleInfo.announcement.oracleEvent
+        // Cast to SingleOracleInfo to access announcement property
+        const singleOracleInfo = oracleInfo;
+        const eventDescriptor = singleOracleInfo.announcement.oracleEvent
             .eventDescriptor;
-        if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptorV0)
+        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(oracleInfo);
-        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateralSatoshis, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis, true);
+        const rValuesMessagesList = this.GenerateMessages(singleOracleInfo);
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateral, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, true);
         return { payouts, payoutGroups, messagesList };
     }
-    GetPayoutsFromPolynomialPayoutFunction(_dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
-        if (_dlcOffer.type !== messaging_1.MessageType.DlcOfferV0)
-            throw Error('DlcOffer must be V0');
-        const dlcOffer = _dlcOffer;
-        if (contractDescriptor.payoutFunction.type !== messaging_1.MessageType.PayoutFunctionV0)
-            throw Error('PayoutFunction must be V0');
+    GetPayoutsFromPolynomialPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
         const payoutFunction = contractDescriptor.payoutFunction;
-        if (payoutFunction.pieces.length === 0)
+        if (payoutFunction.payoutFunctionPieces.length === 0)
             throw Error('PayoutFunction must have at least once PayoutCurvePiece');
-        for (const piece of payoutFunction.pieces) {
+        for (const piece of payoutFunction.payoutFunctionPieces) {
             if (piece.payoutCurvePiece.type !== messaging_1.MessageType.PolynomialPayoutCurvePiece)
                 throw Error('Must be PolynomialPayoutCurvePiece');
         }
         const eventDescriptor = oracleInfo.announcement.oracleEvent
             .eventDescriptor;
-        if (eventDescriptor.type !== messaging_1.MessageType.DigitDecompositionEventDescriptorV0)
+        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);
-        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateralSatoshis, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis, true);
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateral, dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, true);
         return { payouts, payoutGroups, messagesList };
     }
-    GetPayouts(_dlcOffer) {
-        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+    GetPayouts(dlcOffer) {
         const contractInfo = dlcOffer.contractInfo;
         const totalCollateral = contractInfo.totalCollateral;
         const contractOraclePairs = this.GetContractOraclePairs(contractInfo);
@@ -247,127 +336,200 @@ class BitcoinDlcProvider extends provider_1.default {
             });
         }, [{ startingMessagesIndex: 0, startingPayoutGroupsIndex: 0 }]);
     }
+    GetPayoutsFromEnumeratedDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
+        const payoutGroups = [];
+        const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+        // For enumerated descriptors, each outcome creates one payout
+        // Each outcome maps to one index in the oracle's possible outcomes
+        contractDescriptor.outcomes.forEach((outcome, index) => {
+            payoutGroups.push({
+                payout: outcome.localPayout,
+                groups: [[index]], // Simple index-based grouping for enum outcomes
+            });
+        });
+        const { payouts, messagesList } = (0, Utils_1.outputsToPayouts)(payoutGroups, rValuesMessagesList, dlcOffer.offerCollateral, totalCollateral - dlcOffer.offerCollateral, true);
+        return { payouts, payoutGroups, messagesList };
+    }
     GetPayoutsFromContractDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral) {
-        switch (contractDescriptor.type) {
-            case messaging_1.MessageType.ContractDescriptorV0: {
-                throw Error('ContractDescriptorV0 not yet supported');
+        switch (contractDescriptor.contractDescriptorType) {
+            case messaging_1.ContractDescriptorType.Enumerated: {
+                return this.GetPayoutsFromEnumeratedDescriptor(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
             }
-            case messaging_1.MessageType.ContractDescriptorV1:
-                {
-                    const contractDescriptorV1 = contractDescriptor;
-                    const payoutFunction = contractDescriptorV1.payoutFunction;
-                    // TODO: add a better check for this
-                    const payoutCurvePiece = payoutFunction.pieces[0].payoutCurvePiece;
-                    switch (payoutCurvePiece.type) {
-                        case messaging_1.MessageType.HyperbolaPayoutCurvePiece:
-                            return this.GetPayoutsFromPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
-                        case messaging_1.MessageType.OldHyperbolaPayoutCurvePiece:
-                            return this.GetPayoutsFromPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
-                        case messaging_1.MessageType.PolynomialPayoutCurvePiece:
-                            return this.GetPayoutsFromPolynomialPayoutFunction(dlcOffer, contractDescriptor, oracleInfo, totalCollateral);
-                    }
+            case messaging_1.ContractDescriptorType.NumericOutcome: {
+                const numericalDescriptor = contractDescriptor;
+                const payoutFunction = numericalDescriptor.payoutFunction;
+                // TODO: add a better check for this
+                const payoutCurvePiece = payoutFunction.payoutFunctionPieces[0].payoutCurvePiece;
+                switch (payoutCurvePiece.payoutCurvePieceType) {
+                    case messaging_1.PayoutCurvePieceType.Hyperbola:
+                        return this.GetPayoutsFromPayoutFunction(dlcOffer, numericalDescriptor, oracleInfo, totalCollateral);
+                    case messaging_1.PayoutCurvePieceType.Polynomial:
+                        return this.GetPayoutsFromPolynomialPayoutFunction(dlcOffer, numericalDescriptor, oracleInfo, totalCollateral);
                 }
-                break;
-            default: {
-                throw Error('ContractDescriptor must be V0 or V1');
             }
         }
     }
-    async createDlcTxs(_dlcOffer, _dlcAccept) {
-        const { dlcOffer, dlcAccept } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-        });
-        const localFundPubkey = dlcOffer.fundingPubKey.toString('hex');
-        const remoteFundPubkey = dlcAccept.fundingPubKey.toString('hex');
-        const localFinalScriptPubkey = dlcOffer.payoutSPK.toString('hex');
-        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();
-        }));
+    async createDlcTxs(dlcOffer, dlcAccept) {
+        const localFundPubkey = dlcOffer.fundingPubkey.toString('hex');
+        const remoteFundPubkey = dlcAccept.fundingPubkey.toString('hex');
+        const localFinalScriptPubkey = dlcOffer.payoutSpk.toString('hex');
+        const remoteFinalScriptPubkey = dlcAccept.payoutSpk.toString('hex');
+        const localChangeScriptPubkey = dlcOffer.changeSpk.toString('hex');
+        const remoteChangeScriptPubkey = dlcAccept.changeSpk.toString('hex');
+        // 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 = [];
-        if (dlcOffer.contractInfo.type === messaging_1.MessageType.ContractInfoV0 &&
+        if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
             dlcOffer.contractInfo.contractDescriptor.type ===
-                messaging_1.MessageType.ContractDescriptorV0) {
+                messaging_1.ContractDescriptorType.Enumerated) {
             for (const outcome of dlcOffer.contractInfo
                 .contractDescriptor.outcomes) {
                 payouts.push({
                     local: outcome.localPayout,
-                    remote: dlcOffer.offerCollateralSatoshis +
-                        dlcAccept.acceptCollateralSatoshis -
+                    remote: dlcOffer.offerCollateral +
+                        dlcAccept.acceptCollateral -
                         outcome.localPayout,
                 });
-                messagesList.push({ messages: [outcome.outcome.toString('hex')] });
+                messagesList.push({ messages: [outcome.outcome] });
             }
         }
         else {
             const payoutResponses = this.GetPayouts(dlcOffer);
-            const { payouts: tempPayouts, messagesList: tempMessagesList, } = this.FlattenPayouts(payoutResponses);
+            const { payouts: tempPayouts, messagesList: tempMessagesList } = this.FlattenPayouts(payoutResponses);
             payouts = tempPayouts;
             messagesList = tempMessagesList;
         }
-        const dlcTxRequest = {
-            payouts,
-            localFundPubkey,
-            localFinalScriptPubkey,
-            remoteFundPubkey,
-            remoteFinalScriptPubkey,
-            localInputAmount,
-            localCollateralAmount: dlcOffer.offerCollateralSatoshis,
-            localPayoutSerialId: dlcOffer.payoutSerialId,
-            localChangeSerialId: dlcOffer.changeSerialId,
-            remoteInputAmount,
-            remoteCollateralAmount: dlcAccept.acceptCollateralSatoshis,
-            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);
-        const dlcTransactions = new messaging_1.DlcTransactionsV0();
+        // 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) {
-        const dlcOffers = _dlcOffers.map((dlcOffer) => {
-            return (0, Utils_1.checkTypes)({ _dlcOffer: dlcOffer }).dlcOffer;
-        });
-        const dlcAccepts = _dlcAccepts.map((dlcAccept) => {
-            return (0, Utils_1.checkTypes)({ _dlcAccept: dlcAccept }).dlcAccept;
-        });
-        const localFundPubkeys = dlcOffers.map((dlcOffer) => dlcOffer.fundingPubKey.toString('hex'));
-        const remoteFundPubkeys = dlcAccepts.map((dlcAccept) => dlcAccept.fundingPubKey.toString('hex'));
-        const localFinalScriptPubkeys = dlcOffers.map((dlcOffer) => dlcOffer.payoutSPK.toString('hex'));
-        const remoteFinalScriptPubkeys = dlcAccepts.map((dlcAccept) => dlcAccept.payoutSPK.toString('hex'));
-        const localChangeScriptPubkey = dlcOffers[0].changeSPK.toString('hex');
-        const remoteChangeScriptPubkey = dlcAccepts[0].changeSPK.toString('hex');
+    async createBatchDlcTxs(dlcOffers, dlcAccepts) {
+        const localFundPubkeys = dlcOffers.map((dlcOffer) => dlcOffer.fundingPubkey.toString('hex'));
+        const remoteFundPubkeys = dlcAccepts.map((dlcAccept) => dlcAccept.fundingPubkey.toString('hex'));
+        const localFinalScriptPubkeys = dlcOffers.map((dlcOffer) => dlcOffer.payoutSpk.toString('hex'));
+        const remoteFinalScriptPubkeys = dlcAccepts.map((dlcAccept) => dlcAccept.payoutSpk.toString('hex'));
+        const localChangeScriptPubkey = dlcOffers[0].changeSpk.toString('hex');
+        const remoteChangeScriptPubkey = dlcAccepts[0].changeSpk.toString('hex');
         const localInputs = await Promise.all(dlcOffers[0].fundingInputs.map(async (fundingInput) => {
             const input = await this.fundingInputToInput(fundingInput, false);
             return input.toUtxo();
@@ -402,11 +564,11 @@ class BitcoinDlcProvider extends provider_1.default {
             remoteFundPubkeys,
             remoteFinalScriptPubkeys,
             localInputAmount,
-            localCollateralAmounts: dlcOffers.map((dlcOffer) => dlcOffer.offerCollateralSatoshis),
+            localCollateralAmounts: dlcOffers.map((dlcOffer) => dlcOffer.offerCollateral),
             localPayoutSerialIds: dlcOffers.map((dlcOffer) => dlcOffer.payoutSerialId),
             localChangeSerialId: dlcOffers[0].changeSerialId,
             remoteInputAmount,
-            remoteCollateralAmounts: dlcAccepts.map((dlcAccept) => dlcAccept.acceptCollateralSatoshis),
+            remoteCollateralAmounts: dlcAccepts.map((dlcAccept) => dlcAccept.acceptCollateral),
             remotePayoutSerialIds: dlcAccepts.map((dlcAccept) => dlcAccept.payoutSerialId),
             remoteChangeSerialId: dlcAccepts[0].changeSerialId,
             refundLocktimes: dlcOffers.map((dlcOffer) => dlcOffer.refundLocktime),
@@ -422,7 +584,7 @@ class BitcoinDlcProvider extends provider_1.default {
         const dlcTransactionsList = [];
         let start = 0;
         for (let i = 0; i < dlcTxs.refundTxHexList.length; i++) {
-            const dlcTransactions = new messaging_1.DlcTransactionsV0();
+            const dlcTransactions = new messaging_1.DlcTransactions();
             dlcTransactions.fundTx = bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(dlcTxs.fundTxHex));
             dlcTransactions.fundTxVout = [
                 BigInt(dlcOffers[i].changeSerialId),
@@ -444,7 +606,13 @@ class BitcoinDlcProvider extends provider_1.default {
         return { dlcTransactionsList, nestedMessagesList };
     }
     GenerateEnumMessages(oracleEvent) {
-        throw Error('Only DigitDecomposition Oracle Events supported');
+        const eventDescriptor = oracleEvent.eventDescriptor;
+        // For enum events, each oracle has one nonce and can attest to one of the possible outcomes
+        const messagesList = [];
+        // For enum events, hash the outcomes to match the contract descriptor format
+        const messages = eventDescriptor.outcomes.map((outcome) => (0, crypto_1.sha256)(Buffer.from(outcome)).toString('hex'));
+        messagesList.push({ messages });
+        return messagesList;
     }
     GenerateDigitDecompositionMessages(oracleEvent) {
         const oracleNonces = oracleEvent.oracleNonces;
@@ -461,33 +629,61 @@ class BitcoinDlcProvider extends provider_1.default {
         return messagesList;
     }
     GenerateMessages(oracleInfo) {
-        const oracleEvent = oracleInfo.announcement.oracleEvent;
+        // Handle both SingleOracleInfo and MultiOracleInfo using type property instead of instanceof
+        let oracleEvent;
+        if (oracleInfo.type === messaging_1.MessageType.SingleOracleInfo) {
+            const singleOracleInfo = oracleInfo;
+            oracleEvent = singleOracleInfo.announcement.oracleEvent;
+        }
+        else if (oracleInfo.type === messaging_1.MessageType.MultiOracleInfo) {
+            const multiOracleInfo = oracleInfo;
+            // For multi-oracle, use the first announcement for now
+            // TODO: This might need more sophisticated handling for multi-oracle scenarios
+            if (multiOracleInfo.announcements.length === 0) {
+                throw Error('MultiOracleInfo must have at least one announcement');
+            }
+            oracleEvent = multiOracleInfo.announcements[0].oracleEvent;
+        }
+        else {
+            throw Error(`OracleInfo must be SingleOracleInfo or MultiOracleInfo, got type: ${oracleInfo.type}`);
+        }
         switch (oracleEvent.eventDescriptor.type) {
-            case messaging_1.MessageType.EnumEventDescriptorV0:
+            case messaging_1.MessageType.EnumEventDescriptor:
                 return this.GenerateEnumMessages(oracleEvent);
-            case messaging_1.MessageType.DigitDecompositionEventDescriptorV0:
+            case messaging_1.MessageType.DigitDecompositionEventDescriptor:
                 return this.GenerateDigitDecompositionMessages(oracleEvent);
             default:
                 throw Error('EventDescriptor must be Enum or DigitDecomposition');
         }
     }
     GetContractOraclePairs(_contractInfo) {
-        switch (_contractInfo.type) {
-            case messaging_1.MessageType.ContractInfoV0: {
-                const contractInfo = _contractInfo;
-                return [
-                    {
-                        contractDescriptor: contractInfo.contractDescriptor,
-                        oracleInfo: contractInfo.oracleInfo,
-                    },
-                ];
-            }
-            case messaging_1.MessageType.ContractInfoV1: {
-                return _contractInfo.contractOraclePairs;
-            }
-            default:
-                throw Error('ContractInfo must be V0 or V1');
+        // Use contractInfoType property instead of instanceof for more reliable type checking
+        if (_contractInfo.contractInfoType === messaging_1.ContractInfoType.Single) {
+            const singleInfo = _contractInfo;
+            return [
+                {
+                    contractDescriptor: singleInfo.contractDescriptor,
+                    oracleInfo: singleInfo.oracleInfo,
+                },
+            ];
+        }
+        else if (_contractInfo.contractInfoType === messaging_1.ContractInfoType.Disjoint) {
+            const disjointInfo = _contractInfo;
+            return disjointInfo.contractOraclePairs;
+        }
+        else {
+            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)({
@@ -497,7 +693,7 @@ class BitcoinDlcProvider extends provider_1.default {
         });
         const network = await this.getConnectedNetwork();
         const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
-        const fundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubKey : dlcAccept.fundingPubKey))
+        const fundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey))
             .serialize()
             .slice(1);
         const fundingAddress = bitcoinjs_lib_1.address.fromOutputScript(fundingSPK, network);
@@ -508,11 +704,15 @@ class BitcoinDlcProvider extends provider_1.default {
         const fundPrivateKey = Buffer.from(fundPrivateKeyPair.__D).toString('hex');
         const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
         const sigs = [];
-        if (dlcOffer.contractInfo.type === messaging_1.MessageType.ContractInfoV0 &&
+        if (dlcOffer.contractInfo.contractInfoType === messaging_1.ContractInfoType.Single &&
             dlcOffer.contractInfo.contractDescriptor.type ===
                 messaging_1.MessageType.ContractDescriptorV0) {
-            for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
-                const oracleAnnouncement = oracleInfo.announcement;
+            for (const { oracleInfo } of contractOraclePairs) {
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                const oracleAnnouncement = oracleInfo
+                    .announcement;
                 const adaptorSigRequestPromises = [];
                 const tempMessagesList = messagesList;
                 const tempCetsHex = cetsHex;
@@ -522,9 +722,9 @@ class BitcoinDlcProvider extends provider_1.default {
                     privkey: fundPrivateKey,
                     fundTxId: dlcTxs.fundTx.txId.toString(),
                     fundVout: dlcTxs.fundTxVout,
-                    localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                    remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
-                    fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                    localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+                    remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
+                    fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                     oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
                     oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
                 };
@@ -544,7 +744,11 @@ class BitcoinDlcProvider extends provider_1.default {
         else {
             const indices = this.GetIndicesFromPayouts(this.GetPayouts(_dlcOffer));
             for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
-                const oracleAnnouncement = oracleInfo.announcement;
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                const oracleAnnouncement = oracleInfo
+                    .announcement;
                 const startingIndex = indices[index].startingMessagesIndex, endingIndex = indices[index + 1].startingMessagesIndex;
                 const oracleEventMessagesList = messagesList.slice(startingIndex, endingIndex);
                 const oracleEventCetsHex = cetsHex.slice(startingIndex, endingIndex);
@@ -559,9 +763,9 @@ class BitcoinDlcProvider extends provider_1.default {
                         privkey: fundPrivateKey,
                         fundTxId: dlcTxs.fundTx.txId.toString(),
                         fundVout: dlcTxs.fundTxVout,
-                        localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                        remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
-                        fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+                        localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+                        remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
+                        fundInputAmount: this.getFundOutputValueSats(dlcTxs),
                         oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
                         oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
                     };
@@ -584,12 +788,12 @@ class BitcoinDlcProvider extends provider_1.default {
             privkey: fundPrivateKey,
             fundTxId: dlcTxs.fundTx.txId.toString(),
             fundVout: dlcTxs.fundTxVout,
-            localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-            remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
-            fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+            localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+            remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
+            fundInputAmount: this.getFundOutputValueSats(dlcTxs),
         };
         const refundSignature = Buffer.from((await this.GetRawRefundTxSignature(refundSignRequest)).hex, 'hex');
-        const cetSignatures = new messaging_1.CetAdaptorSignaturesV0();
+        const cetSignatures = new messaging_1.CetAdaptorSignatures();
         cetSignatures.sigs = sigs.flat();
         return { cetSignatures, refundSignature };
     }
@@ -602,15 +806,19 @@ class BitcoinDlcProvider extends provider_1.default {
         });
         const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
         const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
-        if (dlcOffer.contractInfo.type === messaging_1.MessageType.ContractInfoV0 &&
+        if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
             dlcOffer.contractInfo.contractDescriptor.type ===
                 messaging_1.MessageType.ContractDescriptorV0) {
-            for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
-                const oracleAnnouncement = oracleInfo.announcement;
+            for (const { oracleInfo } of contractOraclePairs) {
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                const oracleAnnouncement = oracleInfo
+                    .announcement;
                 const oracleEventCetsHex = cetsHex;
                 const oracleEventSigs = isOfferer
-                    ? dlcAccept.cetSignatures.sigs
-                    : dlcSign.cetSignatures.sigs;
+                    ? dlcAccept.cetAdaptorSignatures.sigs
+                    : dlcSign.cetAdaptorSignatures.sigs;
                 const sigsValidity = [];
                 const tempMessagesList = messagesList;
                 const tempCetsHex = oracleEventCetsHex;
@@ -627,11 +835,11 @@ class BitcoinDlcProvider extends provider_1.default {
                     oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
                     oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
                     adaptorPairs: tempAdaptorPairs,
-                    localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                    remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                    localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+                    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 () => {
@@ -644,11 +852,11 @@ class BitcoinDlcProvider extends provider_1.default {
                     signature: isOfferer
                         ? dlcAccept.refundSignature.toString('hex')
                         : dlcSign.refundSignature.toString('hex'),
-                    localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                    remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                    localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+                    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 =
@@ -663,13 +871,17 @@ class BitcoinDlcProvider extends provider_1.default {
             const chunk = 100;
             const indices = this.GetIndicesFromPayouts(this.GetPayouts(_dlcOffer));
             for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
-                const oracleAnnouncement = oracleInfo.announcement;
+                if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                    throw new Error('Only SingleOracleInfo supported in this context');
+                }
+                const oracleAnnouncement = oracleInfo
+                    .announcement;
                 const startingIndex = indices[index].startingMessagesIndex, endingIndex = indices[index + 1].startingMessagesIndex;
                 const oracleEventMessagesList = messagesList.slice(startingIndex, endingIndex);
                 const oracleEventCetsHex = cetsHex.slice(startingIndex, endingIndex);
                 const oracleEventSigs = (isOfferer
-                    ? dlcAccept.cetSignatures.sigs
-                    : dlcSign.cetSignatures.sigs).slice(startingIndex, endingIndex);
+                    ? dlcAccept.cetAdaptorSignatures.sigs
+                    : dlcSign.cetAdaptorSignatures.sigs).slice(startingIndex, endingIndex);
                 const sigsValidity = [];
                 for (let i = 0, j = oracleEventMessagesList.length; i < j; i += chunk) {
                     const tempMessagesList = oracleEventMessagesList.slice(i, i + chunk);
@@ -687,11 +899,11 @@ class BitcoinDlcProvider extends provider_1.default {
                         oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
                         oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map((nonce) => nonce.toString('hex')),
                         adaptorPairs: tempAdaptorPairs,
-                        localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                        remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                        localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+                        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 () => {
@@ -705,11 +917,11 @@ class BitcoinDlcProvider extends provider_1.default {
                     signature: isOfferer
                         ? dlcAccept.refundSignature.toString('hex')
                         : dlcSign.refundSignature.toString('hex'),
-                    localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                    remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                    localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+                    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 =
@@ -735,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 = {
@@ -760,17 +990,11 @@ class BitcoinDlcProvider extends provider_1.default {
             pubKeyWitness.witness = Buffer.from(inputPubKeys[i], 'hex');
             witnessElements.push([sigWitness, pubKeyWitness]);
         }
-        const fundingSignatures = new messaging_1.FundingSignaturesV0();
+        const fundingSignatures = new messaging_1.FundingSignatures();
         fundingSignatures.witnessElements = witnessElements;
         return fundingSignatures;
     }
-    async VerifyFundingSigs(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, isOfferer) {
-        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-            _dlcSign,
-            _dlcTxs,
-        });
+    async VerifyFundingSigs(dlcOffer, dlcAccept, dlcSign, dlcTxs, isOfferer) {
         const sigsValidity = [];
         for (let i = 0; i < dlcSign.fundingSignatures.witnessElements.length; i++) {
             const witnessElement = dlcSign.fundingSignatures.witnessElements[i];
@@ -779,31 +1003,46 @@ 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) {
             throw new Error('Invalid signatures received');
         }
     }
-    async CreateFundingTx(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, fundingSignatures) {
-        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-            _dlcSign,
-            _dlcTxs,
-        });
+    async CreateFundingTx(dlcOffer, dlcAccept, dlcSign, dlcTxs, fundingSignatures) {
         const witnessElements = [
             ...dlcSign.fundingSignatures.witnessElements,
             ...fundingSignatures.witnessElements,
@@ -813,39 +1052,67 @@ 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 { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
-        const polynomialCurve = core_1.PolynomialPayoutCurve.fromPayoutCurvePiece(polynomialPayoutCurvePiece);
+    async FindOutcomeIndexFromPolynomialPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, polynomialPayoutCurvePiece, oracleAttestation, outcome) {
+        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);
         const clampBN = (val) => bignumber_js_1.default.max(minPayout, bignumber_js_1.default.min(val, maxPayout));
         const payout = clampBN(polynomialCurve.getPayout(outcome));
         const payoutResponses = this.GetPayouts(dlcOffer);
-        const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[contractOraclePairIndex].startingMessagesIndex;
+        const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[contractOraclePairIndex]
+            .startingMessagesIndex;
         const { payoutGroups } = payoutResponses[contractOraclePairIndex];
         const intervalsSorted = [
             ...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;
@@ -873,17 +1140,18 @@ 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);
-        const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[contractOraclePairIndex].startingMessagesIndex;
+        const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[contractOraclePairIndex]
+            .startingMessagesIndex;
         const { payoutGroups } = payoutResponses[contractOraclePairIndex];
         const intervalsSorted = [
             ...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;
@@ -921,32 +1189,59 @@ Payout Group not found');
             }
         }
         if (groupIndex === -1) {
-            throw Error('Failed to Find OutcomeIndex From HyperbolaPayoutCurvePiece. \
-Payout Group not found');
+            // Fallback to brute force search if payout-based search fails
+            index = 0;
+            groupLength = 0;
+            for (const [, payoutGroup] of payoutGroups.entries()) {
+                groupIndex = payoutGroup.groups.findIndex((group) => {
+                    return group.every((msg, j) => msg === outcomesFormatted[j]);
+                });
+                if (groupIndex !== -1) {
+                    index += groupIndex;
+                    groupLength = payoutGroup.groups[groupIndex].length;
+                    break;
+                }
+                else {
+                    index += payoutGroup.groups.length;
+                }
+            }
+            if (groupIndex === -1) {
+                throw Error('Failed to Find OutcomeIndex From HyperbolaPayoutCurvePiece. \
+Payout Group not found even with brute force search');
+            }
         }
         return { index: payoutIndexOffset + index, groupLength };
     }
-    async FindOutcomeIndex(_dlcOffer, oracleAttestation) {
-        const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
+    async FindOutcomeIndex(dlcOffer, oracleAttestation) {
         const contractOraclePairs = this.GetContractOraclePairs(dlcOffer.contractInfo);
-        const contractOraclePairIndex = contractOraclePairs.findIndex(({ oracleInfo }) => oracleInfo.announcement.oracleEvent.eventId ===
-            oracleAttestation.eventId);
+        const contractOraclePairIndex = contractOraclePairs.findIndex(({ oracleInfo }) => {
+            if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo)
+                return false;
+            const singleOracleInfo = oracleInfo;
+            return (singleOracleInfo.announcement.oracleEvent.eventId ===
+                oracleAttestation.eventId);
+        });
         (0, assert_1.default)(contractOraclePairIndex !== -1, 'OracleAttestation must be for an existing OracleEvent');
         const contractOraclePair = contractOraclePairs[contractOraclePairIndex];
-        const { contractDescriptor: _contractDescriptor, oracleInfo, } = contractOraclePair;
-        (0, assert_1.default)(_contractDescriptor.type === messaging_1.MessageType.ContractDescriptorV1, 'ContractDescriptor must be V1');
+        const { contractDescriptor: _contractDescriptor, oracleInfo } = contractOraclePair;
+        (0, assert_1.default)(_contractDescriptor.contractDescriptorType ===
+            messaging_1.ContractDescriptorType.NumericOutcome, 'ContractDescriptor must be NumericOutcome');
         const contractDescriptor = _contractDescriptor;
         const _payoutFunction = contractDescriptor.payoutFunction;
-        (0, assert_1.default)(_payoutFunction.type === messaging_1.MessageType.PayoutFunctionV0, 'PayoutFunction must be V0');
-        const eventDescriptor = oracleInfo.announcement.oracleEvent
+        (0, assert_1.default)(_payoutFunction.type === messaging_1.MessageType.PayoutFunction, 'PayoutFunction must be V0');
+        if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+            throw new Error('Only SingleOracleInfo supported in this context');
+        }
+        const singleOracleInfo = oracleInfo;
+        const eventDescriptor = singleOracleInfo.announcement.oracleEvent
             .eventDescriptor;
         const payoutFunction = _payoutFunction;
         const base = eventDescriptor.base;
         const outcome = [...oracleAttestation.outcomes]
             .reverse()
             .reduce((acc, val, i) => acc + Number(val) * base ** i, 0);
-        const piecesSorted = payoutFunction.pieces.sort((a, b) => Number(a.endpoint) - Number(b.endpoint));
-        const piece = piecesSorted.find((piece) => outcome < piece.endpoint);
+        const piecesSorted = payoutFunction.payoutFunctionPieces.sort((a, b) => Number(a.endPoint.eventOutcome) - Number(b.endPoint.eventOutcome));
+        const piece = piecesSorted.find((piece) => outcome < piece.endPoint.eventOutcome);
         switch (piece.payoutCurvePiece.type) {
             case messaging_1.MessageType.PolynomialPayoutCurvePiece:
                 return this.FindOutcomeIndexFromPolynomialPayoutCurvePiece(dlcOffer, contractDescriptor, contractOraclePairIndex, piece.payoutCurvePiece, oracleAttestation, BigInt(outcome));
@@ -958,24 +1253,29 @@ Payout Group not found');
                 throw Error('Must be Hyperbola or Polynomial curve piece');
         }
     }
-    ValidateEvent(_dlcOffer, oracleAttestation) {
-        const { dlcOffer } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-        });
-        switch (dlcOffer.contractInfo.type) {
-            case messaging_1.MessageType.ContractInfoV0: {
+    ValidateEvent(dlcOffer, oracleAttestation) {
+        switch (dlcOffer.contractInfo.contractInfoType) {
+            case messaging_1.ContractInfoType.Single: {
                 const contractInfo = dlcOffer.contractInfo;
-                switch (contractInfo.contractDescriptor.type) {
-                    case messaging_1.MessageType.ContractDescriptorV0: {
+                switch (contractInfo.contractDescriptor.contractDescriptorType) {
+                    case messaging_1.ContractDescriptorType.Enumerated: {
                         const oracleInfo = contractInfo.oracleInfo;
-                        if (oracleInfo.announcement.oracleEvent.eventId !==
+                        if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                            throw Error('Only SingleOracleInfo supported in this context');
+                        }
+                        const singleOracleInfo = oracleInfo;
+                        if (singleOracleInfo.announcement.oracleEvent.eventId !==
                             oracleAttestation.eventId)
                             throw Error('Incorrect Oracle Attestation. Event Id must match.');
                         break;
                     }
-                    case messaging_1.MessageType.ContractDescriptorV1: {
+                    case messaging_1.ContractDescriptorType.NumericOutcome: {
                         const oracleInfo = contractInfo.oracleInfo;
-                        if (oracleInfo.announcement.oracleEvent.eventId !==
+                        if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo) {
+                            throw Error('Only SingleOracleInfo supported in this context');
+                        }
+                        const singleOracleInfo = oracleInfo;
+                        if (singleOracleInfo.announcement.oracleEvent.eventId !==
                             oracleAttestation.eventId)
                             throw Error('Incorrect Oracle Attestation. Event Id must match.');
                         break;
@@ -985,10 +1285,15 @@ Payout Group not found');
                 }
                 break;
             }
-            case messaging_1.MessageType.ContractInfoV1: {
+            case messaging_1.ContractInfoType.Disjoint: {
                 const contractInfo = dlcOffer.contractInfo;
-                const attestedOracleEvent = contractInfo.contractOraclePairs.find(({ oracleInfo }) => oracleInfo.announcement.oracleEvent.eventId ===
-                    oracleAttestation.eventId);
+                const attestedOracleEvent = contractInfo.contractOraclePairs.find(({ oracleInfo }) => {
+                    if (oracleInfo.type !== messaging_1.MessageType.SingleOracleInfo)
+                        return false;
+                    const singleOracleInfo = oracleInfo;
+                    return (singleOracleInfo.announcement.oracleEvent.eventId ===
+                        oracleAttestation.eventId);
+                });
                 if (!attestedOracleEvent)
                     throw Error('Oracle event of attestation not found.');
                 break;
@@ -997,35 +1302,29 @@ Payout Group not found');
                 throw Error('ContractInfo must be V0 or V1');
         }
     }
-    async FindAndSignCet(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, oracleAttestation, isOfferer) {
-        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-            _dlcSign,
-            _dlcTxs,
-        });
+    async FindAndSignCet(dlcOffer, dlcAccept, dlcSign, dlcTxs, oracleAttestation, isOfferer) {
         if (isOfferer === undefined)
             isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
         const fundPrivateKey = await this.GetFundPrivateKey(dlcOffer, dlcAccept, isOfferer);
         let signCetRequest;
-        if (dlcOffer.contractInfo.type === messaging_1.MessageType.ContractInfoV0 &&
-            dlcOffer.contractInfo.contractDescriptor.type ===
-                messaging_1.MessageType.ContractDescriptorV0) {
+        if (dlcOffer.contractInfo.contractInfoType === messaging_1.ContractInfoType.Single &&
+            dlcOffer.contractInfo.contractDescriptor
+                .contractDescriptorType === messaging_1.ContractDescriptorType.Enumerated) {
             const outcomeIndex = dlcOffer.contractInfo
-                .contractDescriptor.outcomes.findIndex((outcome) => outcome.outcome.toString('hex') ===
+                .contractDescriptor.outcomes.findIndex((outcome) => outcome.outcome ===
                 (0, crypto_1.sha256)(Buffer.from(oracleAttestation.outcomes[0])).toString('hex'));
             signCetRequest = {
                 cetHex: dlcTxs.cets[outcomeIndex].serialize().toString('hex'),
                 fundPrivkey: fundPrivateKey,
                 fundTxId: dlcTxs.fundTx.txId.toString(),
                 fundVout: dlcTxs.fundTxVout,
-                localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                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.cetSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
-                    : dlcSign.cetSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
+                    ? dlcAccept.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
+                    : dlcSign.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
             };
         }
         else {
@@ -1039,13 +1338,13 @@ Payout Group not found');
                 fundPrivkey: fundPrivateKey,
                 fundTxId: dlcTxs.fundTx.txId.toString(),
                 fundVout: dlcTxs.fundTxVout,
-                localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-                remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+                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.cetSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
-                    : dlcSign.cetSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
+                    ? dlcAccept.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex')
+                    : dlcSign.cetAdaptorSignatures.sigs[outcomeIndex].encryptedSig.toString('hex'),
             };
         }
         const finalCet = (await this.SignCet(signCetRequest)).hex;
@@ -1053,7 +1352,7 @@ Payout Group not found');
     }
     async GetFundAddress(dlcOffer, dlcAccept, isOfferer) {
         const network = await this.getConnectedNetwork();
-        const fundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubKey : dlcAccept.fundingPubKey))
+        const fundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey))
             .serialize()
             .slice(1);
         const fundingAddress = bitcoinjs_lib_1.address.fromOutputScript(fundingSPK, network);
@@ -1069,16 +1368,11 @@ Payout Group not found');
         const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, isOfferer);
         return Buffer.from(fundPrivateKeyPair.privateKey).toString('hex');
     }
-    async CreateCloseRawTxs(_dlcOffer, _dlcAccept, _dlcTxs, closeInputAmount, isOfferer, _dlcCloses = [], fundingInputs, initiatorPayouts) {
-        const { dlcOffer, dlcAccept, dlcTxs } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-            _dlcTxs,
-        });
+    async CreateCloseRawTxs(dlcOffer, dlcAccept, dlcTxs, closeInputAmount, isOfferer, _dlcCloses = [], fundingInputs, initiatorPayouts) {
         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 = [];
@@ -1109,13 +1403,13 @@ Payout Group not found');
             const txOuts = [];
             if (Number(offerPayoutValue) > 0) {
                 txOuts.push({
-                    address: bitcoinjs_lib_1.address.fromOutputScript(dlcOffer.payoutSPK, network),
+                    address: bitcoinjs_lib_1.address.fromOutputScript(dlcOffer.payoutSpk, network),
                     amount: Number(offerPayoutValue),
                 });
             }
             if (Number(acceptPayoutValue) > 0) {
                 txOuts.push({
-                    address: bitcoinjs_lib_1.address.fromOutputScript(dlcAccept.payoutSPK, network),
+                    address: bitcoinjs_lib_1.address.fromOutputScript(dlcAccept.payoutSpk, network),
                     amount: Number(acceptPayoutValue),
                 });
             }
@@ -1149,9 +1443,9 @@ Payout Group not found');
             _dlcTxs,
         });
         const network = await this.getConnectedNetwork();
-        const fundingPubKeys = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
-            ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
-            : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+        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,
@@ -1174,7 +1468,7 @@ Payout Group not found');
                         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,
@@ -1219,9 +1513,9 @@ Payout Group not found');
         });
         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 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,
@@ -1231,7 +1525,7 @@ Payout Group not found');
             redeem: p2ms,
             network,
         });
-        const pubkey = isOfferer ? dlcAccept.fundingPubKey : dlcOffer.fundingPubKey;
+        const pubkey = isOfferer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey;
         const sigsValidity = [];
         for (let i = 0; i < rawCloseTxs.length; i++) {
             const rawTx = rawCloseTxs[i];
@@ -1247,7 +1541,7 @@ Payout Group not found');
                     hashType: 'p2wsh',
                     sighashType: 'all',
                     sighashAnyoneCanPay: false,
-                    amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+                    amount: Number(this.getFundOutputValueSats(dlcTxs)),
                 },
             };
             sigsValidity.push((async () => {
@@ -1270,10 +1564,10 @@ Payout Group not found');
             _dlcAccept,
         });
         const network = await this.getConnectedNetwork();
-        const offerFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(dlcOffer.fundingPubKey))
+        const offerFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(dlcOffer.fundingPubkey))
             .serialize()
             .slice(1);
-        const acceptFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(dlcAccept.fundingPubKey))
+        const acceptFundingSPK = bitcoin_1.Script.p2wpkhLock((0, crypto_1.hash160)(dlcAccept.fundingPubkey))
             .serialize()
             .slice(1);
         const offerFundingAddress = bitcoinjs_lib_1.address.fromOutputScript(offerFundingSPK, network);
@@ -1297,14 +1591,50 @@ Payout Group not found');
      * @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.DlcOfferV0();
-        const { fundingPubKey, payoutSPK, payoutSerialId, fundingInputs: _fundingInputs, changeSPK, changeSerialId, } = await this.Initialize(offerCollateralSatoshis, feeRatePerVb, fixedInputs);
-        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        const dlcOffer = new messaging_1.DlcOffer();
+        // Generate a random 32-byte temporary contract ID
+        dlcOffer.temporaryContractId = crypto_2.default.randomBytes(32);
+        // 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));
         const fundOutputSerialId = (0, Utils_1.generateSerialId)();
@@ -1312,19 +1642,23 @@ Payout Group not found');
         dlcOffer.contractFlags = Buffer.from('00', 'hex');
         dlcOffer.chainHash = (0, bitcoin_networks_1.chainHashFromNetwork)(network);
         dlcOffer.contractInfo = contractInfo;
-        dlcOffer.fundingPubKey = fundingPubKey;
-        dlcOffer.payoutSPK = payoutSPK;
+        dlcOffer.fundingPubkey = fundingPubKey;
+        dlcOffer.payoutSpk = payoutSPK;
         dlcOffer.payoutSerialId = payoutSerialId;
-        dlcOffer.offerCollateralSatoshis = offerCollateralSatoshis;
+        dlcOffer.offerCollateral = offerCollateralSatoshis;
         dlcOffer.fundingInputs = fundingInputs;
-        dlcOffer.changeSPK = changeSPK;
+        dlcOffer.changeSpk = changeSPK;
         dlcOffer.changeSerialId = changeSerialId;
-        dlcOffer.fundOutputSerialId = dlcOffer.fundOutputSerialId = fundOutputSerialId;
+        dlcOffer.fundOutputSerialId = dlcOffer.fundOutputSerialId =
+            fundOutputSerialId;
         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));
@@ -1344,7 +1678,7 @@ Payout Group not found');
         }
         const network = await this.getConnectedNetwork();
         const { fundingInputs: _fundingInputs, changeSPK, changeSerialId, initializeResponses, } = await this.BatchInitialize(offerCollaterals, feeRatePerVb, fixedInputs);
-        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        _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 fundOutputsSerialIds = (0, Utils_1.generateSerialIds)(contractInfos.length);
@@ -1354,23 +1688,28 @@ Payout Group not found');
             const fundOutputSerialId = fundOutputsSerialIds[i];
             const { fundingPubKey, payoutSPK, payoutSerialId } = initializeResponses[i];
             const refundLocktime = refundLocktimes[i];
-            const dlcOffer = new messaging_1.DlcOfferV0();
+            const dlcOffer = new messaging_1.DlcOffer();
+            // Generate a random 32-byte temporary contract ID
+            dlcOffer.temporaryContractId = crypto_2.default.randomBytes(32);
             dlcOffer.contractFlags = Buffer.from('00', 'hex');
             dlcOffer.chainHash = (0, bitcoin_networks_1.chainHashFromNetwork)(network);
             dlcOffer.contractInfo = contractInfo;
-            dlcOffer.fundingPubKey = fundingPubKey;
-            dlcOffer.payoutSPK = payoutSPK;
+            dlcOffer.fundingPubkey = fundingPubKey;
+            dlcOffer.payoutSpk = payoutSPK;
             dlcOffer.payoutSerialId = payoutSerialId;
-            dlcOffer.offerCollateralSatoshis = offerCollateralSatoshis;
+            dlcOffer.offerCollateral = offerCollateralSatoshis;
             dlcOffer.fundingInputs = fundingInputs;
-            dlcOffer.changeSPK = changeSPK;
+            dlcOffer.changeSpk = changeSPK;
             dlcOffer.changeSerialId = changeSerialId;
             dlcOffer.fundOutputSerialId = fundOutputSerialId;
             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));
@@ -1382,7 +1721,7 @@ Payout Group not found');
         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}
@@ -1390,23 +1729,92 @@ Payout Group not found');
     async acceptDlcOffer(_dlcOffer, fixedInputs) {
         const { dlcOffer } = (0, Utils_1.checkTypes)({ _dlcOffer });
         dlcOffer.validate();
-        const acceptCollateralSatoshis = dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis;
+        const acceptCollateralSatoshis = dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral;
         (0, assert_1.default)(acceptCollateralSatoshis ===
-            dlcOffer.contractInfo.totalCollateral -
-                dlcOffer.offerCollateralSatoshis, 'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis');
-        const { fundingPubKey, payoutSPK, payoutSerialId, fundingInputs: _fundingInputs, changeSPK, changeSerialId, } = await this.Initialize(acceptCollateralSatoshis, dlcOffer.feeRatePerVb, fixedInputs);
-        (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.FundingInputV0, '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.DlcAcceptV0();
-        dlcAccept.tempContractId = (0, crypto_1.sha256)(dlcOffer.serialize());
-        dlcAccept.acceptCollateralSatoshis = acceptCollateralSatoshis;
-        dlcAccept.fundingPubKey = fundingPubKey;
-        dlcAccept.payoutSPK = payoutSPK;
+            dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral, 'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis');
+        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');
+        const dlcAccept = new messaging_1.DlcAccept();
+        dlcAccept.temporaryContractId = (0, crypto_1.sha256)(dlcOffer.serialize());
+        dlcAccept.acceptCollateral = acceptCollateralSatoshis;
+        dlcAccept.fundingPubkey = fundingPubKey;
+        dlcAccept.payoutSpk = payoutSPK;
         dlcAccept.payoutSerialId = dlcAccept.payoutSerialId = payoutSerialId;
         dlcAccept.fundingInputs = fundingInputs;
-        dlcAccept.changeSPK = changeSPK;
+        dlcAccept.changeSpk = changeSPK;
         dlcAccept.changeSerialId = dlcAccept.changeSerialId = changeSerialId;
         (0, assert_1.default)(dlcAccept.changeSerialId !== dlcOffer.fundOutputSerialId, 'changeSerialId cannot equal the fundOutputSerialId');
         (0, assert_1.default)(dlcOffer.payoutSerialId !== dlcAccept.payoutSerialId, 'offer.payoutSerialId cannot equal accept.payoutSerialId');
@@ -1418,23 +1826,26 @@ Payout Group not found');
             ];
             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);
-        (0, assert_1.default)(dlcTransactions.type === messaging_1.MessageType.DlcTransactionsV0, 'DlcTransactions must be V0');
+        const { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
         const _dlcTransactions = dlcTransactions;
-        const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.tempContractId);
+        const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.temporaryContractId);
         _dlcTransactions.contractId = contractId;
-        dlcAccept.cetSignatures = cetSignatures;
+        dlcAccept.cetAdaptorSignatures = cetSignatures;
         dlcAccept.refundSignature = refundSignature;
-        dlcAccept.negotiationFields = new messaging_1.NegotiationFieldsV0();
         return { dlcAccept, dlcTransactions: _dlcTransactions };
     }
     async batchAcceptDlcOffer(_dlcOffers, fixedInputs) {
@@ -1443,31 +1854,30 @@ Payout Group not found');
             dlcOffer.validate();
             return dlcOffer;
         });
-        const acceptCollaterals = dlcOffers.map((dlcOffer) => dlcOffer.contractInfo.totalCollateral -
-            dlcOffer.offerCollateralSatoshis);
+        const acceptCollaterals = dlcOffers.map((dlcOffer) => dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral);
         const { fundingInputs: _fundingInputs, changeSPK, changeSerialId, initializeResponses, } = await this.BatchInitialize(acceptCollaterals, dlcOffers[0].feeRatePerVb, fixedInputs);
         // Check that none of the funding pubkeys are the same between the
         // dlcOffers and the dlcAccepts (from initializeResponses)
         dlcOffers.forEach((dlcOffer) => {
             initializeResponses.forEach((initializeResponse) => {
-                (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubKey, initializeResponse.fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
+                (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubkey, initializeResponse.fundingPubKey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
             });
         });
-        _fundingInputs.forEach((input) => (0, assert_1.default)(input.type === messaging_1.MessageType.FundingInputV0, 'FundingInput must be V0'));
+        _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 dlcAccepts = [];
         initializeResponses.forEach((initializeResponse, i) => {
             const dlcOffer = dlcOffers[i];
-            const dlcAccept = new messaging_1.DlcAcceptV0();
+            const dlcAccept = new messaging_1.DlcAccept();
             const { fundingPubKey, payoutSPK, payoutSerialId } = initializeResponse;
-            dlcAccept.tempContractId = (0, crypto_1.sha256)(dlcOffers[i].serialize());
-            dlcAccept.acceptCollateralSatoshis = acceptCollaterals[i];
-            dlcAccept.fundingPubKey = fundingPubKey;
-            dlcAccept.payoutSPK = payoutSPK;
+            dlcAccept.temporaryContractId = (0, crypto_1.sha256)(dlcOffers[i].serialize());
+            dlcAccept.acceptCollateral = acceptCollaterals[i];
+            dlcAccept.fundingPubkey = fundingPubKey;
+            dlcAccept.payoutSpk = payoutSPK;
             dlcAccept.payoutSerialId = payoutSerialId;
             dlcAccept.fundingInputs = fundingInputs;
-            dlcAccept.changeSPK = changeSPK;
+            dlcAccept.changeSpk = changeSPK;
             dlcAccept.changeSerialId = changeSerialId;
             (0, assert_1.default)(dlcAccept.changeSerialId !== dlcOffer.fundOutputSerialId, 'changeSerialId cannot equal the fundOutputSerialId');
             (0, assert_1.default)(dlcOffer.payoutSerialId !== dlcAccept.payoutSerialId, 'offer.payoutSerialId cannot equal accept.payoutSerialId');
@@ -1481,7 +1891,7 @@ Payout Group not found');
             })(), '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));
@@ -1489,20 +1899,18 @@ Payout Group not found');
             })(), 'fundingInputs for dlcAccept must be greater than acceptCollateralSatoshis plus acceptFees');
             dlcAccepts.push(dlcAccept);
         });
-        const { dlcTransactionsList, nestedMessagesList, } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
+        const { dlcTransactionsList, nestedMessagesList } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
         for (let i = 0; i < dlcAccepts.length; i++) {
             const dlcOffer = dlcOffers[i];
             const dlcAccept = dlcAccepts[i];
             const dlcTransactions = dlcTransactionsList[i];
             const messagesList = nestedMessagesList[i];
-            const { cetSignatures, refundSignature, } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
-            (0, assert_1.default)(dlcTransactions.type === messaging_1.MessageType.DlcTransactionsV0, 'DlcTransactions must be V0');
+            const { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, false);
             const _dlcTransactions = dlcTransactions;
-            const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.tempContractId);
+            const contractId = (0, crypto_1.xor)(_dlcTransactions.fundTx.txId.serialize(), dlcAccept.temporaryContractId);
             _dlcTransactions.contractId = contractId;
-            dlcAccepts[i].cetSignatures = cetSignatures;
+            dlcAccepts[i].cetAdaptorSignatures = cetSignatures;
             dlcAccepts[i].refundSignature = refundSignature;
-            dlcAccepts[i].negotiationFields = new messaging_1.NegotiationFieldsV0();
         }
         return { dlcAccepts, dlcTransactionsList };
     }
@@ -1512,25 +1920,21 @@ Payout Group not found');
      * @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');
-        const dlcSign = new messaging_1.DlcSignV0();
+        (0, assert_1.default)(Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) !== 0, 'DlcOffer and DlcAccept FundingPubKey cannot be the same');
+        const dlcSign = new messaging_1.DlcSign();
         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 { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, true);
         const fundingSignatures = await this.CreateFundingSigs(dlcOffer, dlcAccept, dlcTransactions, true);
         const dlcTxs = dlcTransactions;
-        const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId);
-        (0, assert_1.default)(Buffer.compare(contractId, (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId)) === 0, 'contractId must be the xor of funding txid, fundingOutputIndex and the tempContractId');
+        const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.temporaryContractId);
+        (0, assert_1.default)(Buffer.compare(contractId, (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.temporaryContractId)) === 0, 'contractId must be the xor of funding txid, fundingOutputIndex and the tempContractId');
         dlcTxs.contractId = contractId;
         dlcSign.contractId = contractId;
-        dlcSign.cetSignatures = cetSignatures;
+        dlcSign.cetAdaptorSignatures = cetSignatures;
         dlcSign.refundSignature = refundSignature;
         dlcSign.fundingSignatures = fundingSignatures;
         return { dlcSign, dlcTransactions: dlcTxs };
@@ -1546,7 +1950,7 @@ Payout Group not found');
             dlcAccept.validate();
             return dlcAccept;
         });
-        const { dlcTransactionsList, nestedMessagesList, } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
+        const { dlcTransactionsList, nestedMessagesList } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
         const dlcSigns = [];
         const fundingSignatures = await this.CreateFundingSigs(dlcOffers[0], dlcAccepts[0], dlcTransactionsList[0], true);
         for (let i = 0; i < dlcAccepts.length; i++) {
@@ -1554,14 +1958,14 @@ Payout Group not found');
             const dlcAccept = dlcAccepts[i];
             const dlcTransactions = dlcTransactionsList[i];
             const messagesList = nestedMessagesList[i];
-            const dlcSign = new messaging_1.DlcSignV0();
+            const dlcSign = new messaging_1.DlcSign();
             await this.VerifyCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcSign, dlcTransactions, messagesList, true);
-            const { cetSignatures, refundSignature, } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, true);
+            const { cetSignatures, refundSignature } = await this.CreateCetAdaptorAndRefundSigs(dlcOffer, dlcAccept, dlcTransactions, messagesList, true);
             const dlcTxs = dlcTransactions;
-            const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId);
+            const contractId = (0, crypto_1.xor)(dlcTxs.fundTx.txId.serialize(), dlcAccept.temporaryContractId);
             dlcTxs.contractId = contractId;
             dlcSign.contractId = contractId;
-            dlcSign.cetSignatures = cetSignatures;
+            dlcSign.cetAdaptorSignatures = cetSignatures;
             dlcSign.refundSignature = refundSignature;
             dlcSign.fundingSignatures = fundingSignatures;
             dlcSigns.push(dlcSign);
@@ -1570,26 +1974,20 @@ Payout Group not found');
     }
     /**
      * Finalize Dlc Sign
-     * @param _dlcOffer Dlc Offer Message
-     * @param _dlcAccept Dlc Accept Message
-     * @param _dlcSign Dlc Sign Message
-     * @param _dlcTxs Dlc Transactions Message
+     * @param dlcOffer Dlc Offer Message
+     * @param dlcAccept Dlc Accept Message
+     * @param dlcSign Dlc Sign Message
+     * @param dlcTxs Dlc Transactions Message
      * @returns {Promise<Tx>}
      */
-    async finalizeDlcSign(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs) {
-        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-            _dlcSign,
-            _dlcTxs,
-        });
+    async finalizeDlcSign(dlcOffer, dlcAccept, dlcSign, dlcTxs) {
         let messagesList = [];
-        if (dlcOffer.contractInfo.type === messaging_1.MessageType.ContractInfoV0 &&
+        if (dlcOffer.contractInfo.type === messaging_1.MessageType.SingleContractInfo &&
             dlcOffer.contractInfo.contractDescriptor.type ===
-                messaging_1.MessageType.ContractDescriptorV0) {
+                messaging_1.MessageType.SingleContractInfo) {
             for (const outcome of dlcOffer.contractInfo
                 .contractDescriptor.outcomes) {
-                messagesList.push({ messages: [outcome.outcome.toString('hex')] });
+                messagesList.push({ messages: [outcome.outcome] });
             }
         }
         else {
@@ -1646,13 +2044,7 @@ Payout Group not found');
      * @param isOfferer Whether party is Dlc Offerer
      * @returns {Promise<Tx>}
      */
-    async execute(_dlcOffer, _dlcAccept, _dlcSign, _dlcTxs, oracleAttestation, isOfferer) {
-        const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = (0, Utils_1.checkTypes)({
-            _dlcOffer,
-            _dlcAccept,
-            _dlcSign,
-            _dlcTxs,
-        });
+    async execute(dlcOffer, dlcAccept, dlcSign, dlcTxs, oracleAttestation, isOfferer) {
         if (isOfferer === undefined)
             isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
         this.ValidateEvent(dlcOffer, oracleAttestation);
@@ -1673,7 +2065,7 @@ Payout Group not found');
             _dlcSign,
             _dlcTxs,
         });
-        const signatures = Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+        const signatures = Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
             ? [
                 dlcSign.refundSignature.toString('hex'),
                 dlcAccept.refundSignature.toString('hex'),
@@ -1687,8 +2079,8 @@ Payout Group not found');
             signatures,
             fundTxId: dlcTxs.fundTx.txId.toString(),
             fundVout: dlcTxs.fundTxVout,
-            localFundPubkey: dlcOffer.fundingPubKey.toString('hex'),
-            remoteFundPubkey: dlcAccept.fundingPubKey.toString('hex'),
+            localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
+            remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
         };
         const refundHex = (await this.AddSignaturesToRefundTx(addSigsToRefundTxRequest)).hex;
         return bitcoin_1.Tx.decode(bufio_1.StreamReader.fromHex(refundHex));
@@ -1719,9 +2111,9 @@ Payout Group not found');
             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 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,
@@ -1734,20 +2126,18 @@ Payout Group not found');
         // 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
@@ -1758,7 +2148,7 @@ Payout Group not found');
             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,
@@ -1787,11 +2177,11 @@ Payout Group not found');
         // 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 +
@@ -1806,11 +2196,11 @@ Payout Group not found');
         const offerFirst = dlcOffer.payoutSerialId < dlcAccept.payoutSerialId;
         psbt.addOutput({
             value: Number(offerFirst ? offerPayoutValue : acceptPayoutValue),
-            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcOffer.payoutSPK : dlcAccept.payoutSPK, network),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcOffer.payoutSpk : dlcAccept.payoutSpk, network),
         });
         psbt.addOutput({
             value: Number(offerFirst ? acceptPayoutValue : offerPayoutValue),
-            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcAccept.payoutSPK : dlcOffer.payoutSPK, network),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcAccept.payoutSpk : dlcOffer.payoutSpk, network),
         });
         // Generate keypair to sign inputs
         const fundPrivateKeyPair = await this.GetFundKeyPair(dlcOffer, dlcAccept, isOfferer);
@@ -1821,6 +2211,9 @@ Payout Group not found');
             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);
         }));
@@ -1843,10 +2236,10 @@ Payout Group not found');
             pubKeyWitness.witness = inputSigs[i].pubkey;
             witnessElements.push([sigWitness, pubKeyWitness]);
         }
-        const fundingSignatures = new messaging_1.FundingSignaturesV0();
+        const fundingSignatures = new messaging_1.FundingSignatures();
         fundingSignatures.witnessElements = witnessElements;
         // Create DlcClose
-        const dlcClose = new messaging_1.DlcCloseV0();
+        const dlcClose = new messaging_1.DlcClose();
         dlcClose.contractId = dlcTxs.contractId;
         dlcClose.offerPayoutSatoshis = BigInt(psbt.txOutputs[offerFirst ? 0 : 1].value); // You give collateral back to users
         dlcClose.acceptPayoutSatoshis = BigInt(psbt.txOutputs[offerFirst ? 1 : 0].value); // give collateral back to users
@@ -1879,7 +2272,7 @@ Payout Group not found');
             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
@@ -1902,8 +2295,8 @@ Payout Group not found');
             const acceptPayoutValue = isOfferer
                 ? collateralMinusPayout
                 : closeInputAmount + payoutMinusOfferFees;
-            const fundingSignatures = new messaging_1.FundingSignaturesV0();
-            const dlcClose = new messaging_1.DlcCloseV0();
+            const fundingSignatures = new messaging_1.FundingSignatures();
+            const dlcClose = new messaging_1.DlcClose();
             dlcClose.contractId = dlcTxs.contractId;
             dlcClose.offerPayoutSatoshis = offerPayoutValue;
             dlcClose.acceptPayoutSatoshis = acceptPayoutValue;
@@ -1970,9 +2363,9 @@ Payout Group not found');
         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 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,
@@ -1991,13 +2384,13 @@ Payout Group not found');
             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,
@@ -2023,16 +2416,16 @@ Payout Group not found');
             value: Number(offerFirst
                 ? dlcClose.offerPayoutSatoshis
                 : dlcClose.acceptPayoutSatoshis),
-            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcOffer.payoutSPK : dlcAccept.payoutSPK, network),
+            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcOffer.payoutSpk : dlcAccept.payoutSpk, network),
         });
         psbt.addOutput({
             value: Number(offerFirst
                 ? dlcClose.acceptPayoutSatoshis
                 : dlcClose.offerPayoutSatoshis),
-            address: bitcoinjs_lib_1.address.fromOutputScript(offerFirst ? dlcAccept.payoutSPK : dlcOffer.payoutSPK, network),
+            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);
@@ -2040,7 +2433,7 @@ Payout Group not found');
         psbt.signInput(fundingInputIndex, fundPrivateKeyPair);
         const partialSig = [
             {
-                pubkey: offerer ? dlcAccept.fundingPubKey : dlcOffer.fundingPubKey,
+                pubkey: offerer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey,
                 signature: await bitcoinjs_lib_1.script.signature.encode(dlcClose.closeSignature, 1), // encode using SIGHASH_ALL
             },
         ];
@@ -2137,8 +2530,24 @@ Payout Group not found');
         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.FundingInputV0, 'FundingInput must be V0');
+        (0, assert_1.default)(_input.type === messaging_1.MessageType.FundingInput, 'FundingInput must be V0');
         const network = await this.getConnectedNetwork();
         const input = _input;
         const prevTx = input.prevTx;
@@ -2154,24 +2563,25 @@ Payout Group not found');
                 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.FundingInputV0();
+        const fundingInput = new messaging_1.FundingInput();
         fundingInput.prevTxVout = input.vout;
         let txRaw = '';
         try {
@@ -2198,12 +2608,99 @@ Payout Group not found');
         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, '', // DLC inputs don't have derivation paths
+            dlcInputInfo.maxWitnessLength || 220, 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