@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.2

package/lib/BitcoinDlcProvider.ts

@@ -6,6 +6,7 @@ import {
   AddSignaturesToRefundTxResponse,
   AddSignatureToFundTransactionRequest,
   AddSignatureToFundTransactionResponse,
+  Amount,
   CalculateEcSignatureRequest,
   CreateBatchDlcTransactionsRequest,
   CreateBatchDlcTransactionsResponse,
@@ -25,7 +26,12 @@ import {
   CreateRefundTransactionRequest,
   CreateRefundTransactionResponse,
   CreateSignatureHashRequest,
+  CreateSplicedDlcTransactionsRequest,
+  CreateSplicedDlcTransactionsResponse,
+  DlcInputInfoRequest,
   DlcProvider,
+  GetRawDlcFundingInputSignatureRequest,
+  GetRawDlcFundingInputSignatureResponse,
   GetRawFundTxSignatureRequest,
   GetRawFundTxSignatureResponse,
   GetRawRefundTxSignatureRequest,
@@ -35,6 +41,8 @@ import {
   PayoutRequest,
   SignCetRequest,
   SignCetResponse,
+  SignDlcFundingInputRequest,
+  SignDlcFundingInputResponse,
   SignFundTransactionRequest,
   SignFundTransactionResponse,
   Utxo,
@@ -42,15 +50,22 @@ import {
   VerifyCetAdaptorSignatureResponse,
   VerifyCetAdaptorSignaturesRequest,
   VerifyCetAdaptorSignaturesResponse,
+  VerifyDlcFundingInputSignatureRequest,
+  VerifyDlcFundingInputSignatureResponse,
   VerifyFundTxSignatureRequest,
   VerifyFundTxSignatureResponse,
   VerifyRefundTxSignatureRequest,
   VerifyRefundTxSignatureResponse,
   VerifySignatureRequest,
 } from '@atomicfinance/types';
+import {
+  DlcInputInfo,
+  InputSupplementationMode,
+} from '@atomicfinance/types/lib/models/Input';
 import { sleep } from '@atomicfinance/utils';
 import { Script, Sequence, Tx } from '@node-dlc/bitcoin';
 import { StreamReader } from '@node-dlc/bufio';
+import { BatchDlcTxBuilder } from '@node-dlc/core';
 import {
   DualClosingTxFinalizer,
   DualFundingTxFinalizer,
@@ -71,6 +86,7 @@ import {
   DlcAccept,
   DlcClose,
   DlcCloseMetadata,
+  DlcInput,
   DlcOffer,
   DlcSign,
   DlcTransactions,
@@ -115,8 +131,10 @@ export default class BitcoinDlcProvider
   implements Partial<DlcProvider>
 {
   _network: BitcoinNetwork;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   _cfdDlcJs: any;
 
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(network: BitcoinNetwork, cfdDlcJs?: any) {
     super();
 
@@ -130,22 +148,110 @@ export default class BitcoinDlcProvider
     }
   }
 
+  /**
+   * Find private key for DLC funding pubkey by deriving wallet addresses
+   */
+  private async findDlcFundingPrivateKey(
+    localFundPubkey: string,
+    remoteFundPubkey: string,
+  ): Promise<string> {
+    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}`,
+    );
+  }
+
   private async GetPrivKeysForInputs(inputs: Input[]): Promise<string[]> {
     const privKeys: string[] = [];
 
     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;
@@ -164,6 +270,46 @@ export default class BitcoinDlcProvider
     }
   }
 
+  /**
+   * Get inputs for amount with explicit supplementation control
+   */
+  async GetInputsForAmountWithMode(
+    amounts: bigint[],
+    feeRatePerVb: bigint,
+    fixedInputs: Input[] = [],
+    supplementation: InputSupplementationMode = InputSupplementationMode.Required,
+  ): Promise<Input[]> {
+    if (amounts.length === 0) return [];
+
+    // For "none" mode, use exactly the provided inputs
+    if (supplementation === InputSupplementationMode.None) {
+      return fixedInputs;
+    }
+
+    // For "required" and "optional" modes, attempt supplementation
+    const fixedUtxos = fixedInputs.map((input) => input.toUtxo());
+
+    try {
+      const inputsForAmount: InputsForDualAmountResponse = await this.getMethod(
+        'getInputsForDualFunding',
+      )(amounts, feeRatePerVb, fixedUtxos);
+
+      // Convert UTXO objects to Input class instances
+      return inputsForAmount.inputs.map((utxo) => Input.fromUTXO(utxo));
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : 'Unknown error';
+
+      if (supplementation === InputSupplementationMode.Required) {
+        throw Error(
+          `Not enough balance GetInputsForAmountWithMode. Error: ${errorMessage}`,
+        );
+      } else {
+        // Optional mode: fallback to provided inputs
+        return fixedInputs;
+      }
+    }
+  }
+
   async GetInputsForAmount(
     amounts: bigint[],
     feeRatePerVb: bigint,
@@ -179,7 +325,8 @@ export default class BitcoinDlcProvider
         'getInputsForDualFunding',
       )(amounts, feeRatePerVb, fixedUtxos);
 
-      inputs = inputsForAmount.inputs;
+      // Convert UTXO objects to Input class instances
+      inputs = inputsForAmount.inputs.map((utxo) => Input.fromUTXO(utxo));
     } catch (e) {
       const errorMessage = e instanceof Error ? e.message : 'Unknown error';
       if (fixedInputs.length === 0) {
@@ -198,6 +345,7 @@ export default class BitcoinDlcProvider
     collateral: bigint,
     feeRatePerVb: bigint,
     fixedInputs: Input[],
+    inputSupplementationMode: InputSupplementationMode = InputSupplementationMode.Required,
   ): Promise<InitializeResponse> {
     const network = await this.getConnectedNetwork();
     const payoutAddress: Address =
@@ -220,10 +368,11 @@ export default class BitcoinDlcProvider
     if (fundingAddress.address === payoutAddress.address)
       throw Error('Address reuse');
 
-    const inputs: Input[] = await this.GetInputsForAmount(
+    const inputs: Input[] = await this.GetInputsForAmountWithMode(
       [collateral],
       feeRatePerVb,
       fixedInputs,
+      inputSupplementationMode,
     );
     const fundingInputs: FundingInput[] = await Promise.all(
       inputs.map(async (input) => {
@@ -251,10 +400,11 @@ export default class BitcoinDlcProvider
   ): Promise<BatchInitializeResponse> {
     const network = await this.getConnectedNetwork();
 
-    const inputs: Input[] = await this.GetInputsForAmount(
+    const inputs: Input[] = await this.GetInputsForAmountWithMode(
       collaterals,
       feeRatePerVb,
       fixedInputs,
+      InputSupplementationMode.Required,
     );
 
     const fundingInputs: FundingInput[] = await Promise.all(
@@ -556,13 +706,45 @@ export default class BitcoinDlcProvider
     const localChangeScriptPubkey = dlcOffer.changeSpk.toString('hex');
     const remoteChangeScriptPubkey = dlcAccept.changeSpk.toString('hex');
 
-    const localInputs: Utxo[] = await Promise.all(
-      dlcOffer.fundingInputs.map(async (fundingInput) => {
+    // Separate regular inputs from DLC inputs (only from offeror side)
+    const localRegularInputs: Utxo[] = [];
+    const localDlcInputs: {
+      fundTxid: string;
+      fundVout: number;
+      fundAmount: number;
+      localFundPubkey: string;
+      remoteFundPubkey: string;
+      contractId: string;
+      maxWitnessLength: number;
+      inputSerialId?: bigint;
+    }[] = [];
+
+    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);
-        return input.toUtxo();
-      }),
-    );
+        localRegularInputs.push(input.toUtxo());
+      }
+    }
 
+    // Process remote inputs (no DLC inputs from acceptor side)
     const remoteInputs: Utxo[] = await Promise.all(
       dlcAccept.fundingInputs.map(async (fundingInput) => {
         const input = await this.fundingInputToInput(fundingInput, false);
@@ -570,7 +752,8 @@ export default class BitcoinDlcProvider
       }),
     );
 
-    const localInputAmount = localInputs.reduce<number>(
+    // Calculate input amounts
+    const localInputAmount = localRegularInputs.reduce<number>(
       (prev, cur) => prev + cur.amount.GetSatoshiAmount(),
       0,
     );
@@ -609,47 +792,117 @@ export default class BitcoinDlcProvider
       messagesList = tempMessagesList;
     }
 
-    const dlcTxRequest: CreateDlcTransactionsRequest = {
-      payouts,
-      localFundPubkey,
-      localFinalScriptPubkey,
-      remoteFundPubkey,
-      remoteFinalScriptPubkey,
-      localInputAmount,
-      localCollateralAmount: dlcOffer.offerCollateral,
-      localPayoutSerialId: dlcOffer.payoutSerialId,
-      localChangeSerialId: dlcOffer.changeSerialId,
-      remoteInputAmount,
-      remoteCollateralAmount: dlcAccept.acceptCollateral,
-      remotePayoutSerialId: dlcAccept.payoutSerialId,
-      remoteChangeSerialId: dlcAccept.changeSerialId,
-      refundLocktime: dlcOffer.refundLocktime,
-      localInputs,
-      remoteInputs,
-      localChangeScriptPubkey,
-      remoteChangeScriptPubkey,
-      feeRate: Number(dlcOffer.feeRatePerVb),
-      cetLockTime: dlcOffer.cetLocktime,
-      fundOutputSerialId: dlcOffer.fundOutputSerialId,
-    };
+    // Determine whether to use regular or spliced DLC transactions
+    const hasDlcInputs = localDlcInputs.length > 0;
+
+    let dlcTxs:
+      | CreateDlcTransactionsResponse
+      | CreateSplicedDlcTransactionsResponse;
+
+    if (hasDlcInputs) {
+      // Use spliced DLC transactions when DLC inputs are present
+      const splicedDlcTxRequest: CreateSplicedDlcTransactionsRequest = {
+        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: CreateDlcTransactionsRequest = {
+        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,
+      };
 
-    const dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+      dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+    }
 
     const dlcTransactions = new DlcTransactions();
     dlcTransactions.fundTx = Tx.decode(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: bigint[] = [];
+
+    // 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) =>
+      Tx.decode(StreamReader.fromHex(cetHex)),
+    );
     dlcTransactions.refundTx = Tx.decode(
       StreamReader.fromHex(dlcTxs.refundTxHex),
     );
-    dlcTransactions.cets = dlcTxs.cetsHex.map((cetHex) => {
-      return Tx.decode(StreamReader.fromHex(cetHex));
-    });
 
     return { dlcTransactions, messagesList };
   }
@@ -877,6 +1130,19 @@ export default class BitcoinDlcProvider
     }
   }
 
+  private getFundOutputValueSats(dlcTxs: DlcTransactions): bigint {
+    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;
+  }
+
   private async CreateCetAdaptorAndRefundSigs(
     _dlcOffer: DlcOffer,
     _dlcAccept: DlcAccept,
@@ -922,7 +1188,7 @@ export default class BitcoinDlcProvider
       (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor.type ===
         MessageType.ContractDescriptorV0
     ) {
-      for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
+      for (const { oracleInfo } of contractOraclePairs) {
         if (oracleInfo.type !== MessageType.SingleOracleInfo) {
           throw new Error('Only SingleOracleInfo supported in this context');
         }
@@ -942,7 +1208,7 @@ export default class BitcoinDlcProvider
           fundVout: dlcTxs.fundTxVout,
           localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
           remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
-          fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+          fundInputAmount: this.getFundOutputValueSats(dlcTxs),
           oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
           oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map(
             (nonce) => nonce.toString('hex'),
@@ -1004,8 +1270,7 @@ export default class BitcoinDlcProvider
             fundVout: dlcTxs.fundTxVout,
             localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
             remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
-            fundInputAmount:
-              dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+            fundInputAmount: this.getFundOutputValueSats(dlcTxs),
             oraclePubkey: oracleAnnouncement.oraclePubkey.toString('hex'),
             oracleRValues: oracleAnnouncement.oracleEvent.oracleNonces.map(
               (nonce) => nonce.toString('hex'),
@@ -1043,7 +1308,7 @@ export default class BitcoinDlcProvider
       fundVout: dlcTxs.fundTxVout,
       localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
       remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
-      fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+      fundInputAmount: this.getFundOutputValueSats(dlcTxs),
     };
 
     const refundSignature = Buffer.from(
@@ -1083,7 +1348,7 @@ export default class BitcoinDlcProvider
       (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor.type ===
         MessageType.ContractDescriptorV0
     ) {
-      for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
+      for (const { oracleInfo } of contractOraclePairs) {
         if (oracleInfo.type !== MessageType.SingleOracleInfo) {
           throw new Error('Only SingleOracleInfo supported in this context');
         }
@@ -1120,8 +1385,7 @@ export default class BitcoinDlcProvider
             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,
           };
 
@@ -1145,7 +1409,7 @@ export default class BitcoinDlcProvider
           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,
         };
 
@@ -1209,8 +1473,7 @@ export default class BitcoinDlcProvider
               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,
             };
 
@@ -1235,7 +1498,7 @@ export default class BitcoinDlcProvider
           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,
         };
 
@@ -1276,15 +1539,34 @@ export default class BitcoinDlcProvider
 
     const fundTxSigs = await Promise.all(
       inputs.map(async (input, index) => {
-        const fundTxSignRequest: GetRawFundTxSignatureRequest = {
-          fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
-          privkey: inputPrivKeys[index],
-          prevTxId: input.txid,
-          prevVout: input.vout,
-          amount: input.value,
-        };
+        // Use DLC-specific signing for DLC inputs
+        if (input.isDlcInput()) {
+          const dlcInputInfo = input.dlcInput!;
+
+          const dlcSignRequest: GetRawDlcFundingInputSignatureRequest = {
+            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: GetRawFundTxSignatureRequest = {
+            fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
+            privkey: inputPrivKeys[index],
+            prevTxId: input.txid,
+            prevVout: input.vout,
+            amount: input.value,
+          };
 
-        return (await this.GetRawFundTxSignature(fundTxSignRequest)).hex;
+          return (await this.GetRawFundTxSignature(fundTxSignRequest)).hex;
+        }
       }),
     );
 
@@ -1332,23 +1614,49 @@ export default class BitcoinDlcProvider
         ? (dlcAccept.fundingInputs[i] as FundingInput)
         : (dlcOffer.fundingInputs[i] as FundingInput);
 
-      const verifyFundSigRequest: VerifyFundTxSignatureRequest = {
-        fundTxHex: dlcTxs.fundTx.serialize().toString('hex'),
-        signature,
-        pubkey,
-        prevTxId: fundingInput.prevTx.txId.toString(),
-        prevVout: fundingInput.prevTxVout,
-        fundInputAmount:
-          fundingInput.prevTx.outputs[fundingInput.prevTxVout].value.sats,
-      };
+      // Check if this is a DLC input and use appropriate verification
+      if (fundingInput.dlcInput) {
+        const dlcInput = fundingInput.dlcInput;
+        const verifyDlcSigRequest: VerifyDlcFundingInputSignatureRequest = {
+          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.VerifyFundTxSignature(verifyFundSigRequest);
-          return response.valid;
-        })(),
-      );
+        sigsValidity.push(
+          (async () => {
+            const response =
+              await this.VerifyDlcFundingInputSignature(verifyDlcSigRequest);
+            return response.valid;
+          })(),
+        );
+      } else {
+        // Regular input verification
+        const verifyFundSigRequest: VerifyFundTxSignatureRequest = {
+          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);
@@ -1376,6 +1684,9 @@ export default class BitcoinDlcProvider
 
     let fundTxHex = dlcTxs.fundTx.serialize().toString('hex');
 
+    // Track processed DLC inputs to avoid double processing
+    const processedDlcInputs = new Set<string>();
+
     await asyncForEach(
       witnessElements,
       async (witnessElement: ScriptWitnessV0, i: number) => {
@@ -1383,16 +1694,49 @@ export default class BitcoinDlcProvider
         const pubkey = witnessElement[1].witness.toString('hex');
 
         const fundingInput = fundingInputs[i] as FundingInput;
+        const inputKey = `${fundingInput.prevTx.txId.toString()}:${fundingInput.prevTxVout}`;
 
-        const addSignRequest: AddSignatureToFundTransactionRequest = {
-          fundTxHex,
-          signature,
-          prevTxId: fundingInput.prevTx.txId.toString(),
-          prevVout: fundingInput.prevTxVout,
-          pubkey,
-        };
-        fundTxHex = (await this.AddSignatureToFundTransaction(addSignRequest))
-          .hex;
+        // 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: SignDlcFundingInputRequest = {
+            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: AddSignatureToFundTransactionRequest = {
+            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
       },
     );
 
@@ -1570,7 +1914,7 @@ Payout Group not found',
       index = 0;
       groupLength = 0;
 
-      for (const [i, payoutGroup] of payoutGroups.entries()) {
+      for (const [, payoutGroup] of payoutGroups.entries()) {
         groupIndex = payoutGroup.groups.findIndex((group) => {
           return group.every((msg, j) => msg === outcomesFormatted[j]);
         });
@@ -1794,7 +2138,7 @@ Payout Group not found even with brute force search',
         oracleSignatures: oracleAttestation.signatures.map((sig) =>
           sig.toString('hex'),
         ),
-        fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+        fundInputAmount: this.getFundOutputValueSats(dlcTxs),
         adaptorSignature: isOfferer
           ? dlcAccept.cetAdaptorSignatures.sigs[
               outcomeIndex
@@ -1824,7 +2168,7 @@ Payout Group not found even with brute force search',
         localFundPubkey: dlcOffer.fundingPubkey.toString('hex'),
         remoteFundPubkey: dlcAccept.fundingPubkey.toString('hex'),
         oracleSignatures: oracleSignatures.map((sig) => sig.toString('hex')),
-        fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
+        fundInputAmount: this.getFundOutputValueSats(dlcTxs),
         adaptorSignature: isOfferer
           ? dlcAccept.cetAdaptorSignatures.sigs[
               outcomeIndex
@@ -2044,7 +2388,7 @@ Payout Group not found even with brute force search',
             hex: paymentVariant.redeem.output.toString('hex'),
             type: 'redeem_script',
           },
-          amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+          amount: Number(this.getFundOutputValueSats(dlcTxs)),
           hashType: 'p2wsh',
           sighashType: 'all',
           sighashAnyoneCanPay: false,
@@ -2159,7 +2503,7 @@ Payout Group not found even with brute force search',
           hashType: 'p2wsh',
           sighashType: 'all',
           sighashAnyoneCanPay: false,
-          amount: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+          amount: Number(this.getFundOutputValueSats(dlcTxs)),
         },
       };
 
@@ -2229,6 +2573,7 @@ Payout Group not found even with brute force search',
    * @param feeRatePerVb Fee rate in satoshi per virtual byte that both sides use to compute fees in funding tx
    * @param cetLocktime The nLockTime to be put on CETs
    * @param refundLocktime The nLockTime to be put on the refund transaction
+   * @param fixedInputs Optional fixed inputs - can be Input[] for regular inputs or FundingInput[] for DLC inputs
    * @returns {Promise<DlcOffer>}
    */
   async createDlcOffer(
@@ -2237,7 +2582,8 @@ Payout Group not found even with brute force search',
     feeRatePerVb: bigint,
     cetLocktime: number,
     refundLocktime: number,
-    fixedInputs?: Input[],
+    fixedInputs?: Input[] | FundingInput[],
+    inputSupplementationMode?: InputSupplementationMode,
   ): Promise<DlcOffer> {
     contractInfo.validate();
     const network = await this.getConnectedNetwork();
@@ -2247,18 +2593,56 @@ Payout Group not found even with brute force search',
     // Generate a random 32-byte temporary contract ID
     dlcOffer.temporaryContractId = crypto.randomBytes(32);
 
-    const {
-      fundingPubKey,
-      payoutSPK,
-      payoutSerialId,
-      fundingInputs: _fundingInputs,
-      changeSPK,
-      changeSerialId,
-    } = await this.Initialize(
-      offerCollateralSatoshis,
-      feeRatePerVb,
-      fixedInputs,
-    );
+    // Check if we have FundingInput[] (DLC inputs) or Input[] (regular inputs)
+    const hasFundingInputs =
+      fixedInputs && fixedInputs.length > 0 && 'prevTx' in fixedInputs[0]; // FundingInput has prevTx, Input doesn't
+
+    let fundingPubKey: Buffer;
+    let payoutSPK: Buffer;
+    let payoutSerialId: bigint;
+    let _fundingInputs: FundingInput[];
+    let changeSPK: Buffer;
+    let changeSerialId: bigint;
+
+    if (hasFundingInputs) {
+      // Handle FundingInput[] directly (for DLC inputs)
+      const fundingInputs = fixedInputs as FundingInput[];
+
+      // Generate addresses directly since we're bypassing Initialize()
+      const payoutAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
+      payoutSPK = address.toOutputScript(payoutAddress.address, network);
+
+      const changeAddress: Address =
+        await this.client.wallet.getUnusedAddress(true);
+      changeSPK = address.toOutputScript(changeAddress.address, network);
+
+      const fundingAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
+      fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+
+      if (fundingAddress.address === payoutAddress.address)
+        throw Error('Address reuse');
+
+      payoutSerialId = generateSerialId();
+      changeSerialId = generateSerialId();
+      _fundingInputs = fundingInputs;
+    } else {
+      // Handle Input[] through existing Initialize() flow
+      const initResult = await this.Initialize(
+        offerCollateralSatoshis,
+        feeRatePerVb,
+        fixedInputs as Input[],
+        inputSupplementationMode || InputSupplementationMode.Required,
+      );
+
+      fundingPubKey = initResult.fundingPubKey;
+      payoutSPK = initResult.payoutSPK;
+      payoutSerialId = initResult.payoutSerialId;
+      _fundingInputs = initResult.fundingInputs;
+      changeSPK = initResult.changeSPK;
+      changeSerialId = initResult.changeSerialId;
+    }
 
     _fundingInputs.forEach((input) =>
       assert(
@@ -2298,6 +2682,10 @@ Payout Group not found even with brute force search',
     dlcOffer.cetLocktime = cetLocktime;
     dlcOffer.refundLocktime = refundLocktime;
 
+    if (offerCollateralSatoshis === dlcOffer.contractInfo.totalCollateral) {
+      dlcOffer.markAsSingleFunded();
+    }
+
     assert(
       (() => {
         const finalizer = new DualFundingTxFinalizer(
@@ -2400,6 +2788,10 @@ Payout Group not found even with brute force search',
       dlcOffer.cetLocktime = cetLocktime;
       dlcOffer.refundLocktime = refundLocktime;
 
+      if (offerCollateralSatoshis === dlcOffer.contractInfo.totalCollateral) {
+        dlcOffer.markAsSingleFunded();
+      }
+
       assert(
         (() => {
           const finalizer = new DualFundingTxFinalizer(
@@ -2429,14 +2821,14 @@ Payout Group not found even with brute force search',
   }
 
   /**
-   * 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}
    */
   async acceptDlcOffer(
     _dlcOffer: DlcOffer,
-    fixedInputs?: Input[],
+    fixedInputs?: Input[] | FundingInput[],
   ): Promise<AcceptDlcOfferResponse> {
     const { dlcOffer } = checkTypes({ _dlcOffer });
     dlcOffer.validate();
@@ -2450,37 +2842,130 @@ Payout Group not found even with brute force search',
       'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis',
     );
 
-    const {
-      fundingPubKey,
-      payoutSPK,
-      payoutSerialId,
-      fundingInputs: _fundingInputs,
-      changeSPK,
-      changeSerialId,
-    } = await this.Initialize(
-      acceptCollateralSatoshis,
-      dlcOffer.feeRatePerVb,
-      fixedInputs,
-    );
+    let fundingPubKey: Buffer;
+    let payoutSPK: Buffer;
+    let payoutSerialId: bigint;
+    let fundingInputs: FundingInput[];
+    let changeSPK: Buffer;
+    let changeSerialId: bigint;
 
-    assert(
-      Buffer.compare(dlcOffer.fundingPubkey, fundingPubKey) !== 0,
-      'DlcOffer and DlcAccept FundingPubKey cannot be the same',
-    );
+    if (acceptCollateralSatoshis === BigInt(0)) {
+      // Single-funded DLC: accept side provides no funding
+      const network = await this.getConnectedNetwork();
 
-    _fundingInputs.forEach((input) =>
-      assert(
-        input.type === MessageType.FundingInput,
-        'FundingInput must be V0',
-      ),
-    );
+      // Still need payout address for receiving DLC outcomes
+      const payoutAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
+      payoutSPK = address.toOutputScript(payoutAddress.address, network);
 
-    const fundingInputs: FundingInput[] = _fundingInputs.map(
-      (input) => input as FundingInput,
-    );
+      // Generate funding pubkey for DLC contract construction
+      const fundingAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
+      fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
 
-    fundingInputs.sort(
-      (a, b) => Number(a.inputSerialId) - Number(b.inputSerialId),
+      // Generate change address (even though not used)
+      const changeAddress: Address =
+        await this.client.wallet.getUnusedAddress(true);
+      changeSPK = address.toOutputScript(changeAddress.address, network);
+
+      if (fundingAddress.address === payoutAddress.address)
+        throw Error('Address reuse');
+
+      // Generate serial IDs
+      payoutSerialId = generateSerialId();
+      changeSerialId = 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: InitializeResponse;
+
+      if (hasFundingInputs) {
+        // Handle FundingInput[] directly (for DLC inputs)
+        const fundingInputs = fixedInputs as FundingInput[];
+        const network = await this.getConnectedNetwork();
+
+        // Generate addresses directly since we're bypassing Initialize()
+        const payoutAddress: Address =
+          await this.client.wallet.getUnusedAddress(false);
+        const payoutSPK = address.toOutputScript(
+          payoutAddress.address,
+          network,
+        );
+
+        const changeAddress: Address =
+          await this.client.wallet.getUnusedAddress(true);
+        const changeSPK = address.toOutputScript(
+          changeAddress.address,
+          network,
+        );
+
+        const fundingAddress: Address =
+          await this.client.wallet.getUnusedAddress(false);
+        const fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+
+        if (fundingAddress.address === payoutAddress.address)
+          throw Error('Address reuse');
+
+        const payoutSerialId = generateSerialId();
+        const changeSerialId = 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
+            ? InputSupplementationMode.None
+            : InputSupplementationMode.Required;
+
+        initResult = await this.Initialize(
+          acceptCollateralSatoshis,
+          dlcOffer.feeRatePerVb,
+          fixedInputs as Input[],
+          supplementationMode,
+        );
+      }
+
+      fundingPubKey = initResult.fundingPubKey;
+      payoutSPK = initResult.payoutSPK;
+      payoutSerialId = initResult.payoutSerialId;
+      changeSPK = initResult.changeSPK;
+      changeSerialId = initResult.changeSerialId;
+
+      const _fundingInputs = initResult.fundingInputs;
+
+      _fundingInputs.forEach((input) =>
+        assert(
+          input.type === MessageType.FundingInput,
+          'FundingInput must be V0',
+        ),
+      );
+
+      fundingInputs = _fundingInputs.map((input) => input as FundingInput);
+
+      fundingInputs.sort(
+        (a, b) => Number(a.inputSerialId) - Number(b.inputSerialId),
+      );
+    }
+
+    assert(
+      Buffer.compare(dlcOffer.fundingPubkey, fundingPubKey) !== 0,
+      'DlcOffer and DlcAccept FundingPubKey cannot be the same',
     );
 
     const dlcAccept = new DlcAccept();
@@ -2516,27 +3001,32 @@ Payout Group not found even with brute force search',
       'offer.changeSerialID, accept.changeSerialId and fundOutputSerialId must be unique',
     );
 
+    if (dlcOffer.singleFunded) dlcAccept.markAsSingleFunded();
+
     dlcAccept.validate();
 
-    assert(
-      (() => {
-        const finalizer = new 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));
+    // Only validate funding requirements if accept side is providing collateral
+    if (acceptCollateralSatoshis > BigInt(0)) {
+      assert(
+        (() => {
+          const finalizer = new 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',
-    );
+          return funding >= acceptCollateralSatoshis + finalizer.acceptFees;
+        })(),
+        'fundingInputs for dlcAccept must be greater than acceptCollateralSatoshis plus acceptFees',
+      );
+    }
 
     const { dlcTransactions, messagesList } = await this.createDlcTxs(
       dlcOffer,
@@ -2725,13 +3215,9 @@ Payout Group not found even with brute force search',
    * @returns {Promise<SignDlcAcceptResponse}
    */
   async signDlcAccept(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
   ): Promise<SignDlcAcceptResponse> {
-    const { dlcOffer, dlcAccept } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-    });
     dlcOffer.validate();
     dlcAccept.validate();
 
@@ -3144,28 +3630,46 @@ Payout Group not found even with brute force search',
     // Initiate and build PSBT
     let inputs: Input[] = _inputs;
     if (!_inputs) {
-      const tempInputs = await this.GetInputsForAmount(
+      const tempInputs = await this.GetInputsForAmountWithMode(
         [BigInt(20000)],
         dlcOffer.feeRatePerVb,
-        _inputs,
+        _inputs || [],
+        InputSupplementationMode.Required,
       );
       _inputs = tempInputs;
     }
-    inputs = _inputs.map((input) => {
-      return {
-        ...input,
-        inputSerialId: input.inputSerialId || generateSerialId(),
-        toUtxo: input.toUtxo,
-      };
-    });
+    // Ensure all inputs have derivation paths by fetching from wallet
+    const inputsWithPaths: { input: Input; address: Address }[] =
+      await Promise.all(
+        _inputs.map(async (input) => {
+          const address: Address = await this.getMethod('getWalletAddress')(
+            input.address,
+          );
+          const inputWithPath = new 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 || generateSerialId(),
+            input.scriptPubKey,
+            input.label,
+            input.confirmations,
+            input.spendable,
+            input.solvable,
+            input.safe,
+            input.dlcInput,
+          );
+          return { input: inputWithPath, address };
+        }),
+      );
 
-    const pubkeys: Buffer[] = await Promise.all(
-      inputs.map(async (input) => {
-        const address: Address = await this.getMethod('getWalletAddress')(
-          input.address,
-        );
-        return Buffer.from(address.publicKey, 'hex');
-      }),
+    inputs = inputsWithPaths.map((item) => item.input);
+    const pubkeys: Buffer[] = inputsWithPaths.map((item) =>
+      Buffer.from(item.address.publicKey, 'hex'),
     );
 
     const fundingInputSerialId = generateSerialId();
@@ -3179,7 +3683,7 @@ Payout Group not found even with brute force search',
       sequence: 0,
       witnessUtxo: {
         script: paymentVariant.output,
-        value: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+        value: Number(this.getFundOutputValueSats(dlcTxs)),
       },
       witnessScript: paymentVariant.redeem.output,
       inputSerialId: fundingInputSerialId,
@@ -3217,7 +3721,7 @@ Payout Group not found even with brute force search',
     );
 
     // add to psbt
-    sortedPsbtInputs.forEach((input, i) => psbt.addInput(input));
+    sortedPsbtInputs.forEach((input) => psbt.addInput(input));
 
     const fundingInputs: FundingInput[] = await Promise.all(
       inputs.map(async (input) => {
@@ -3282,6 +3786,9 @@ Payout Group not found even with brute force search',
         if (i === fundingInputIndex) return;
 
         // derive keypair
+        if (!input.derivationPath) {
+          throw new Error(`Missing derivation path for input ${i}`);
+        }
         const keyPair = await this.getMethod('keyPair')(input.derivationPath);
         psbt.signInput(i, keyPair);
       }),
@@ -3581,14 +4088,14 @@ Payout Group not found even with brute force search',
       sequence: 0,
       witnessUtxo: {
         script: paymentVariant.output,
-        value: Number(dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats),
+        value: Number(this.getFundOutputValueSats(dlcTxs)),
       },
       witnessScript: paymentVariant.redeem.output,
       inputSerialId: dlcClose.fundInputSerialId,
     });
 
     // add all dlc close inputs
-    dlcClose.fundingInputs.forEach((input, i) => {
+    dlcClose.fundingInputs.forEach((input) => {
       psbtInputs.push({
         hash: input.prevTx.txId.serialize(),
         index: input.prevTxVout,
@@ -3643,7 +4150,7 @@ Payout Group not found even with brute force search',
     });
 
     // add to psbt
-    sortedPsbtInputs.forEach((input, i) => psbt.addInput(input));
+    sortedPsbtInputs.forEach((input) => psbt.addInput(input));
 
     const offerer = await this.isOfferer(dlcOffer, dlcAccept);
 
@@ -3839,6 +4346,38 @@ Payout Group not found even with brute force search',
     return this._cfdDlcJs.VerifyRefundTxSignature(jsonObject);
   }
 
+  async CreateSplicedDlcTransactions(
+    jsonObject: CreateSplicedDlcTransactionsRequest,
+  ): Promise<CreateSplicedDlcTransactionsResponse> {
+    await this.CfdLoaded();
+
+    return this._cfdDlcJs.CreateSplicedDlcTransactions(jsonObject);
+  }
+
+  async GetRawDlcFundingInputSignature(
+    jsonObject: GetRawDlcFundingInputSignatureRequest,
+  ): Promise<GetRawDlcFundingInputSignatureResponse> {
+    await this.CfdLoaded();
+
+    return this._cfdDlcJs.GetRawDlcFundingInputSignature(jsonObject);
+  }
+
+  async SignDlcFundingInput(
+    jsonObject: SignDlcFundingInputRequest,
+  ): Promise<SignDlcFundingInputResponse> {
+    await this.CfdLoaded();
+
+    return this._cfdDlcJs.SignDlcFundingInput(jsonObject);
+  }
+
+  async VerifyDlcFundingInputSignature(
+    jsonObject: VerifyDlcFundingInputSignatureRequest,
+  ): Promise<VerifyDlcFundingInputSignatureResponse> {
+    await this.CfdLoaded();
+
+    return this._cfdDlcJs.VerifyDlcFundingInputSignature(jsonObject);
+  }
+
   async fundingInputToInput(
     _input: FundingInput,
     findDerivationPath = true,
@@ -3861,21 +4400,36 @@ Payout Group not found even with brute force search',
       }
     }
 
-    return {
-      txid: prevTx.txId.toString(),
-      vout: input.prevTxVout,
-      address: _address,
-      amount: prevTxOut.value.bitcoin,
-      value: Number(prevTxOut.value.sats),
+    // Check if this FundingInput has DLC input information to preserve
+    const dlcInputMessage = input.dlcInput;
+
+    let dlcInputInfo: DlcInputInfo | undefined;
+    if (dlcInputMessage) {
+      dlcInputInfo = {
+        localFundPubkey: dlcInputMessage.localFundPubkey.toString('hex'),
+        remoteFundPubkey: dlcInputMessage.remoteFundPubkey.toString('hex'),
+        contractId: dlcInputMessage.contractId.toString('hex'),
+      };
+    }
+
+    return new Input(
+      prevTx.txId.toString(),
+      input.prevTxVout,
+      _address,
+      prevTxOut.value.bitcoin,
+      Number(prevTxOut.value.sats),
       derivationPath,
-      maxWitnessLength: input.maxWitnessLen,
-      redeemScript: input.redeemScript
-        ? input.redeemScript.toString('hex')
-        : '',
-      scriptPubKey: scriptPubKey.toString('hex'),
-      inputSerialId: input.inputSerialId,
-      toUtxo: Input.prototype.toUtxo,
-    };
+      input.maxWitnessLen,
+      input.redeemScript ? input.redeemScript.toString('hex') : '',
+      input.inputSerialId,
+      scriptPubKey.toString('hex'),
+      undefined, // label
+      undefined, // confirmations
+      undefined, // spendable
+      undefined, // solvable
+      undefined, // safe
+      dlcInputInfo, // Preserve DLC input information if present
+    );
   }
 
   async inputToFundingInput(input: Input): Promise<FundingInput> {
@@ -3910,12 +4464,155 @@ Payout Group not found even with brute force search',
       ? input.inputSerialId
       : generateSerialId();
 
+    // Preserve DLC input information if present
+    if (input.isDlcInput()) {
+      const dlcInputInfo = input.dlcInput!;
+      const dlcInput = new 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(): Promise<BitcoinNetwork> {
     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: Input[],
+    feeRatePerVb: bigint,
+    contractCount: number = 1,
+  ): Promise<bigint> {
+    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 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: DlcInputInfoRequest,
+    fundingTxHex: string,
+  ): Promise<FundingInput> {
+    const fundingInput = new FundingInput();
+    const tx = Tx.decode(StreamReader.fromHex(fundingTxHex));
+
+    fundingInput.prevTx = tx;
+    fundingInput.prevTxVout = dlcInputInfo.fundVout;
+    fundingInput.sequence = Sequence.default();
+    fundingInput.maxWitnessLen = dlcInputInfo.maxWitnessLength || 220;
+    fundingInput.redeemScript = Buffer.from('', 'hex'); // Empty for P2WSH
+    fundingInput.inputSerialId = BigInt(
+      dlcInputInfo.inputSerialId || 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 = payments.p2ms({
+      m: 2,
+      pubkeys: orderedPubkeys,
+      network,
+    });
+
+    const paymentVariant = 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 = 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 as FundingInput & { toUtxo: () => Utxo }).toUtxo = () => {
+      return new Utxo(
+        dlcInputInfo.fundTxid,
+        dlcInputInfo.fundVout,
+        Amount.FromSatoshis(Number(dlcInputInfo.fundAmount)),
+        multisigAddress,
+        dlcInputInfo.maxWitnessLength || 220,
+        undefined, // DLC inputs don't have derivation paths
+        fundingInput.inputSerialId,
+      );
+    };
+
+    // Create proper DlcInput object for splicing detection and signing
+    const dlcInput = new 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;
+  }
 }
 
 export interface BasicInitializeResponse {
@@ -4019,5 +4716,3 @@ export interface InputsForDualAmountResponse {
   inputs: Input[];
   fee: number;
 }
-
-const BurnAddress = 'bcrt1qxcjufgh2jarkp2qkx68azh08w9v5gah8u6es8s';