@atomicfinance/bitcoin-dlc-provider 3.6.1 → 4.0.1

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,
@@ -61,42 +76,45 @@ import {
 } from '@node-dlc/core';
 import { hash160, sha256, xor } from '@node-dlc/crypto';
 import {
-  CetAdaptorSignaturesV0,
+  CetAdaptorSignatures,
   ContractDescriptor,
-  ContractDescriptorV0,
-  ContractDescriptorV1,
+  ContractDescriptorType,
   ContractInfo,
-  ContractInfoV0,
-  ContractInfoV1,
-  DigitDecompositionEventDescriptorV0,
+  ContractInfoType,
+  DigitDecompositionEventDescriptor,
+  DisjointContractInfo,
   DlcAccept,
-  DlcAcceptV0,
   DlcClose,
   DlcCloseMetadata,
-  DlcCloseV0,
+  DlcInput,
   DlcOffer,
-  DlcOfferV0,
   DlcSign,
-  DlcSignV0,
   DlcTransactions,
-  DlcTransactionsV0,
+  EnumeratedDescriptor,
+  EnumEventDescriptor,
+  F64,
   FundingInput,
-  FundingInputV0,
-  FundingSignaturesV0,
+  FundingSignatures,
   HyperbolaPayoutCurvePiece,
   MessageType,
-  NegotiationFieldsV0,
-  OracleAttestationV0,
-  OracleEventV0,
-  OracleInfoV0,
+  MultiOracleInfo,
+  NumericalDescriptor,
+  OracleAttestation,
+  OracleEvent,
+  OracleInfo,
+  PayoutCurvePieceType,
+  PayoutFunction,
   PayoutFunctionV0,
   PolynomialPayoutCurvePiece,
   ScriptWitnessV0,
+  SingleContractInfo,
+  SingleOracleInfo,
 } from '@node-dlc/messaging';
 import assert from 'assert';
 import BigNumber from 'bignumber.js';
 import { BitcoinNetwork, chainHashFromNetwork } from 'bitcoin-networks';
 import { address, payments, Psbt, script } from 'bitcoinjs-lib';
+import crypto from 'crypto';
 import { ECPairInterface } from 'ecpair';
 import * as ecc from 'tiny-secp256k1';
 
@@ -110,10 +128,13 @@ import {
 
 export default class BitcoinDlcProvider
   extends Provider
-  implements Partial<DlcProvider> {
+  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();
 
@@ -127,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;
@@ -161,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,
@@ -176,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) {
@@ -195,35 +345,34 @@ export default class BitcoinDlcProvider
     collateral: bigint,
     feeRatePerVb: bigint,
     fixedInputs: Input[],
+    inputSupplementationMode: InputSupplementationMode = InputSupplementationMode.Required,
   ): Promise<InitializeResponse> {
     const network = await this.getConnectedNetwork();
-    const payoutAddress: Address = await this.client.wallet.getUnusedAddress(
-      false,
-    );
+    const payoutAddress: Address =
+      await this.client.wallet.getUnusedAddress(false);
     const payoutSPK: Buffer = address.toOutputScript(
       payoutAddress.address,
       network,
     );
-    const changeAddress: Address = await this.client.wallet.getUnusedAddress(
-      true,
-    );
+    const changeAddress: Address =
+      await this.client.wallet.getUnusedAddress(true);
     const changeSPK: Buffer = address.toOutputScript(
       changeAddress.address,
       network,
     );
 
-    const fundingAddress: Address = await this.client.wallet.getUnusedAddress(
-      false,
-    );
+    const fundingAddress: Address =
+      await this.client.wallet.getUnusedAddress(false);
     const fundingPubKey: Buffer = Buffer.from(fundingAddress.publicKey, 'hex');
 
     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(
@@ -267,26 +417,23 @@ export default class BitcoinDlcProvider
 
     const changeSerialId: bigint = generateSerialId();
 
-    const changeAddress: Address = await this.client.wallet.getUnusedAddress(
-      true,
-    );
+    const changeAddress: Address =
+      await this.client.wallet.getUnusedAddress(true);
     const changeSPK: Buffer = address.toOutputScript(
       changeAddress.address,
       network,
     );
 
     for (let i = 0; i < collaterals.length; i++) {
-      const payoutAddress: Address = await this.client.wallet.getUnusedAddress(
-        false,
-      );
+      const payoutAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
       const payoutSPK: Buffer = address.toOutputScript(
         payoutAddress.address,
         network,
       );
 
-      const fundingAddress: Address = await this.client.wallet.getUnusedAddress(
-        false,
-      );
+      const fundingAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
       const fundingPubKey: Buffer = Buffer.from(
         fundingAddress.publicKey,
         'hex',
@@ -317,35 +464,29 @@ export default class BitcoinDlcProvider
    */
 
   private GetPayoutsFromPayoutFunction(
-    _dlcOffer: DlcOffer,
-    contractDescriptor: ContractDescriptorV1,
-    oracleInfo: OracleInfoV0,
+    dlcOffer: DlcOffer,
+    contractDescriptor: NumericalDescriptor,
+    oracleInfo: OracleInfo,
     totalCollateral: bigint,
   ): GetPayoutsResponse {
-    if (_dlcOffer.type !== MessageType.DlcOfferV0)
-      throw Error('DlcOffer must be V0');
-    const dlcOffer = _dlcOffer as DlcOfferV0;
-    if (contractDescriptor.payoutFunction.type !== MessageType.PayoutFunctionV0)
-      throw Error('PayoutFunction must be V0');
-    const payoutFunction = contractDescriptor.payoutFunction as PayoutFunctionV0;
-    if (payoutFunction.pieces.length === 0)
+    const payoutFunction = contractDescriptor.payoutFunction as PayoutFunction;
+    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 as HyperbolaPayoutCurvePiece;
     if (
-      payoutCurvePiece.type !== MessageType.HyperbolaPayoutCurvePiece &&
-      payoutCurvePiece.type !== MessageType.OldHyperbolaPayoutCurvePiece
+      payoutCurvePiece.payoutCurvePieceType !== PayoutCurvePieceType.Hyperbola
     )
       throw Error('Must be HyperbolaPayoutCurvePiece');
-    if (payoutCurvePiece.b !== BigInt(0) || payoutCurvePiece.c !== BigInt(0))
+    if (!payoutCurvePiece.b.eq(F64.ZERO) || !payoutCurvePiece.c.eq(F64.ZERO))
       throw Error('b and c HyperbolaPayoutCurvePiece values must be 0');
-    const eventDescriptor = oracleInfo.announcement.oracleEvent
-      .eventDescriptor as DigitDecompositionEventDescriptorV0;
-    if (
-      eventDescriptor.type !== MessageType.DigitDecompositionEventDescriptorV0
-    )
+    // Cast to SingleOracleInfo to access announcement property
+    const singleOracleInfo = oracleInfo as SingleOracleInfo;
+    const eventDescriptor = singleOracleInfo.announcement.oracleEvent
+      .eventDescriptor as DigitDecompositionEventDescriptor;
+    if (eventDescriptor.type !== MessageType.DigitDecompositionEventDescriptor)
       throw Error('Only DigitDecomposition Oracle Events supported');
 
     const roundingIntervals = contractDescriptor.roundingIntervals;
@@ -368,13 +509,13 @@ export default class BitcoinDlcProvider
       });
     });
 
-    const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+    const rValuesMessagesList = this.GenerateMessages(singleOracleInfo);
 
     const { payouts, messagesList } = outputsToPayouts(
       payoutGroups,
       rValuesMessagesList,
-      dlcOffer.offerCollateralSatoshis,
-      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis,
+      dlcOffer.offerCollateral,
+      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral,
       true,
     );
 
@@ -382,30 +523,23 @@ export default class BitcoinDlcProvider
   }
 
   private GetPayoutsFromPolynomialPayoutFunction(
-    _dlcOffer: DlcOffer,
-    contractDescriptor: ContractDescriptorV1,
-    oracleInfo: OracleInfoV0,
+    dlcOffer: DlcOffer,
+    contractDescriptor: NumericalDescriptor,
+    oracleInfo: SingleOracleInfo,
     totalCollateral: bigint,
   ): GetPayoutsResponse {
-    if (_dlcOffer.type !== MessageType.DlcOfferV0)
-      throw Error('DlcOffer must be V0');
-    const dlcOffer = _dlcOffer as DlcOfferV0;
-    if (contractDescriptor.payoutFunction.type !== MessageType.PayoutFunctionV0)
-      throw Error('PayoutFunction must be V0');
-    const payoutFunction = contractDescriptor.payoutFunction as PayoutFunctionV0;
-    if (payoutFunction.pieces.length === 0)
+    const payoutFunction = contractDescriptor.payoutFunction as PayoutFunction;
+    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 !== MessageType.PolynomialPayoutCurvePiece
       )
         throw Error('Must be PolynomialPayoutCurvePiece');
     }
     const eventDescriptor = oracleInfo.announcement.oracleEvent
-      .eventDescriptor as DigitDecompositionEventDescriptorV0;
-    if (
-      eventDescriptor.type !== MessageType.DigitDecompositionEventDescriptorV0
-    )
+      .eventDescriptor as DigitDecompositionEventDescriptor;
+    if (eventDescriptor.type !== MessageType.DigitDecompositionEventDescriptor)
       throw Error('Only DigitDecomposition Oracle Events supported');
 
     const roundingIntervals = contractDescriptor.roundingIntervals;
@@ -433,17 +567,15 @@ export default class BitcoinDlcProvider
     const { payouts, messagesList } = outputsToPayouts(
       payoutGroups,
       rValuesMessagesList,
-      dlcOffer.offerCollateralSatoshis,
-      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis,
+      dlcOffer.offerCollateral,
+      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral,
       true,
     );
 
     return { payouts, payoutGroups, messagesList };
   }
 
-  private GetPayouts(_dlcOffer: DlcOffer): GetPayoutsResponse[] {
-    const { dlcOffer } = checkTypes({ _dlcOffer });
-
+  private GetPayouts(dlcOffer: DlcOffer): GetPayoutsResponse[] {
     const contractInfo = dlcOffer.contractInfo;
     const totalCollateral = contractInfo.totalCollateral;
     const contractOraclePairs = this.GetContractOraclePairs(contractInfo);
@@ -489,78 +621,130 @@ export default class BitcoinDlcProvider
     );
   }
 
+  private GetPayoutsFromEnumeratedDescriptor(
+    dlcOffer: DlcOffer,
+    contractDescriptor: EnumeratedDescriptor,
+    oracleInfo: OracleInfo,
+    totalCollateral: bigint,
+  ): GetPayoutsResponse {
+    const payoutGroups: PayoutGroup[] = [];
+    const rValuesMessagesList = this.GenerateMessages(
+      oracleInfo as SingleOracleInfo,
+    );
+
+    // 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 } = outputsToPayouts(
+      payoutGroups,
+      rValuesMessagesList,
+      dlcOffer.offerCollateral,
+      totalCollateral - dlcOffer.offerCollateral,
+      true,
+    );
+
+    return { payouts, payoutGroups, messagesList };
+  }
+
   private GetPayoutsFromContractDescriptor(
-    dlcOffer: DlcOfferV0,
+    dlcOffer: DlcOffer,
     contractDescriptor: ContractDescriptor,
-    oracleInfo: OracleInfoV0,
+    oracleInfo: OracleInfo,
     totalCollateral: bigint,
   ) {
-    switch (contractDescriptor.type) {
-      case MessageType.ContractDescriptorV0: {
-        throw Error('ContractDescriptorV0 not yet supported');
+    switch (contractDescriptor.contractDescriptorType) {
+      case ContractDescriptorType.Enumerated: {
+        return this.GetPayoutsFromEnumeratedDescriptor(
+          dlcOffer,
+          contractDescriptor as EnumeratedDescriptor,
+          oracleInfo,
+          totalCollateral,
+        );
       }
-      case MessageType.ContractDescriptorV1:
-        {
-          const contractDescriptorV1 = contractDescriptor as ContractDescriptorV1;
-          const payoutFunction = contractDescriptorV1.payoutFunction as PayoutFunctionV0;
-
-          // TODO: add a better check for this
-          const payoutCurvePiece = payoutFunction.pieces[0].payoutCurvePiece;
-
-          switch (payoutCurvePiece.type) {
-            case MessageType.HyperbolaPayoutCurvePiece:
-              return this.GetPayoutsFromPayoutFunction(
-                dlcOffer,
-                contractDescriptor as ContractDescriptorV1,
-                oracleInfo,
-                totalCollateral,
-              );
-            case MessageType.OldHyperbolaPayoutCurvePiece:
-              return this.GetPayoutsFromPayoutFunction(
-                dlcOffer,
-                contractDescriptor as ContractDescriptorV1,
-                oracleInfo,
-                totalCollateral,
-              );
-            case MessageType.PolynomialPayoutCurvePiece:
-              return this.GetPayoutsFromPolynomialPayoutFunction(
-                dlcOffer,
-                contractDescriptor as ContractDescriptorV1,
-                oracleInfo,
-                totalCollateral,
-              );
-          }
+      case ContractDescriptorType.NumericOutcome: {
+        const numericalDescriptor = contractDescriptor as NumericalDescriptor;
+        const payoutFunction = numericalDescriptor.payoutFunction;
+
+        // TODO: add a better check for this
+        const payoutCurvePiece =
+          payoutFunction.payoutFunctionPieces[0].payoutCurvePiece;
+
+        switch (payoutCurvePiece.payoutCurvePieceType) {
+          case PayoutCurvePieceType.Hyperbola:
+            return this.GetPayoutsFromPayoutFunction(
+              dlcOffer,
+              numericalDescriptor,
+              oracleInfo,
+              totalCollateral,
+            );
+          case PayoutCurvePieceType.Polynomial:
+            return this.GetPayoutsFromPolynomialPayoutFunction(
+              dlcOffer,
+              numericalDescriptor,
+              oracleInfo as SingleOracleInfo,
+              totalCollateral,
+            );
         }
-        break;
-      default: {
-        throw Error('ContractDescriptor must be V0 or V1');
       }
     }
   }
 
   public async createDlcTxs(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
   ): Promise<CreateDlcTxsResponse> {
-    const { dlcOffer, dlcAccept } = 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: Utxo[] = await Promise.all(
-      dlcOffer.fundingInputs.map(async (fundingInput) => {
+    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: 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);
@@ -568,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,
     );
@@ -582,101 +767,164 @@ export default class BitcoinDlcProvider
     let messagesList: Messages[] = [];
 
     if (
-      dlcOffer.contractInfo.type === MessageType.ContractInfoV0 &&
-      (dlcOffer.contractInfo as ContractInfoV0).contractDescriptor.type ===
-        MessageType.ContractDescriptorV0
+      dlcOffer.contractInfo.type === MessageType.SingleContractInfo &&
+      (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor.type ===
+        ContractDescriptorType.Enumerated
     ) {
-      for (const outcome of ((dlcOffer.contractInfo as ContractInfoV0)
-        .contractDescriptor as ContractDescriptorV0).outcomes) {
+      for (const outcome of (
+        (dlcOffer.contractInfo as SingleContractInfo)
+          .contractDescriptor as EnumeratedDescriptor
+      ).outcomes) {
         payouts.push({
           local: outcome.localPayout,
           remote:
-            dlcOffer.offerCollateralSatoshis +
-            dlcAccept.acceptCollateralSatoshis -
+            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: CreateDlcTransactionsRequest = {
-      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,
-    };
+    // 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,
+      };
 
-    const dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+      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,
+      };
+
+      dlcTxs = await this.CreateDlcTransactions(dlcTxRequest);
+    }
 
-    const dlcTransactions = new DlcTransactionsV0();
+    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 };
   }
 
   public async createBatchDlcTxs(
-    _dlcOffers: DlcOffer[],
-    _dlcAccepts: DlcAccept[],
+    dlcOffers: DlcOffer[],
+    dlcAccepts: DlcAccept[],
   ): Promise<CreateBatchDlcTxsResponse> {
-    const dlcOffers = _dlcOffers.map((dlcOffer) => {
-      return checkTypes({ _dlcOffer: dlcOffer }).dlcOffer;
-    });
-    const dlcAccepts = _dlcAccepts.map((dlcAccept) => {
-      return checkTypes({ _dlcAccept: dlcAccept }).dlcAccept;
-    });
-
     const localFundPubkeys = dlcOffers.map((dlcOffer) =>
-      dlcOffer.fundingPubKey.toString('hex'),
+      dlcOffer.fundingPubkey.toString('hex'),
     );
     const remoteFundPubkeys = dlcAccepts.map((dlcAccept) =>
-      dlcAccept.fundingPubKey.toString('hex'),
+      dlcAccept.fundingPubkey.toString('hex'),
     );
     const localFinalScriptPubkeys = dlcOffers.map((dlcOffer) =>
-      dlcOffer.payoutSPK.toString('hex'),
+      dlcOffer.payoutSpk.toString('hex'),
     );
     const remoteFinalScriptPubkeys = dlcAccepts.map((dlcAccept) =>
-      dlcAccept.payoutSPK.toString('hex'),
+      dlcAccept.payoutSpk.toString('hex'),
     );
-    const localChangeScriptPubkey = dlcOffers[0].changeSPK.toString('hex');
-    const remoteChangeScriptPubkey = dlcAccepts[0].changeSPK.toString('hex');
+    const localChangeScriptPubkey = dlcOffers[0].changeSpk.toString('hex');
+    const remoteChangeScriptPubkey = dlcAccepts[0].changeSpk.toString('hex');
 
     const localInputs: Utxo[] = await Promise.all(
       dlcOffers[0].fundingInputs.map(async (fundingInput) => {
@@ -730,7 +978,7 @@ export default class BitcoinDlcProvider
       remoteFinalScriptPubkeys,
       localInputAmount,
       localCollateralAmounts: dlcOffers.map(
-        (dlcOffer) => dlcOffer.offerCollateralSatoshis,
+        (dlcOffer) => dlcOffer.offerCollateral,
       ),
       localPayoutSerialIds: dlcOffers.map(
         (dlcOffer) => dlcOffer.payoutSerialId,
@@ -738,7 +986,7 @@ export default class BitcoinDlcProvider
       localChangeSerialId: dlcOffers[0].changeSerialId,
       remoteInputAmount,
       remoteCollateralAmounts: dlcAccepts.map(
-        (dlcAccept) => dlcAccept.acceptCollateralSatoshis,
+        (dlcAccept) => dlcAccept.acceptCollateral,
       ),
       remotePayoutSerialIds: dlcAccepts.map(
         (dlcAccept) => dlcAccept.payoutSerialId,
@@ -758,11 +1006,11 @@ export default class BitcoinDlcProvider
 
     const dlcTxs = await this.CreateBatchDlcTransactions(batchDlcTxRequest);
 
-    const dlcTransactionsList: DlcTransactionsV0[] = [];
+    const dlcTransactionsList: DlcTransactions[] = [];
 
     let start = 0;
     for (let i = 0; i < dlcTxs.refundTxHexList.length; i++) {
-      const dlcTransactions = new DlcTransactionsV0();
+      const dlcTransactions = new DlcTransactions();
 
       dlcTransactions.fundTx = Tx.decode(
         StreamReader.fromHex(dlcTxs.fundTxHex),
@@ -796,15 +1044,27 @@ export default class BitcoinDlcProvider
     return { dlcTransactionsList, nestedMessagesList };
   }
 
-  private GenerateEnumMessages(oracleEvent: OracleEventV0): Messages[] {
-    throw Error('Only DigitDecomposition Oracle Events supported');
+  private GenerateEnumMessages(oracleEvent: OracleEvent): Messages[] {
+    const eventDescriptor = oracleEvent.eventDescriptor as EnumEventDescriptor;
+
+    // For enum events, each oracle has one nonce and can attest to one of the possible outcomes
+    const messagesList: Messages[] = [];
+
+    // For enum events, hash the outcomes to match the contract descriptor format
+    const messages = eventDescriptor.outcomes.map((outcome) =>
+      sha256(Buffer.from(outcome)).toString('hex'),
+    );
+    messagesList.push({ messages });
+
+    return messagesList;
   }
 
   private GenerateDigitDecompositionMessages(
-    oracleEvent: OracleEventV0,
+    oracleEvent: OracleEvent,
   ): Messages[] {
     const oracleNonces = oracleEvent.oracleNonces;
-    const eventDescriptor = oracleEvent.eventDescriptor as DigitDecompositionEventDescriptorV0;
+    const eventDescriptor =
+      oracleEvent.eventDescriptor as DigitDecompositionEventDescriptor;
 
     const messagesList: Messages[] = [];
     oracleNonces.forEach(() => {
@@ -819,13 +1079,31 @@ export default class BitcoinDlcProvider
     return messagesList;
   }
 
-  private GenerateMessages(oracleInfo: OracleInfoV0): Messages[] {
-    const oracleEvent = oracleInfo.announcement.oracleEvent;
+  private GenerateMessages(oracleInfo: OracleInfo): Messages[] {
+    // Handle both SingleOracleInfo and MultiOracleInfo using type property instead of instanceof
+    let oracleEvent: OracleEvent;
+
+    if (oracleInfo.type === MessageType.SingleOracleInfo) {
+      const singleOracleInfo = oracleInfo as SingleOracleInfo;
+      oracleEvent = singleOracleInfo.announcement.oracleEvent;
+    } else if (oracleInfo.type === MessageType.MultiOracleInfo) {
+      const multiOracleInfo = oracleInfo as MultiOracleInfo;
+      // 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 MessageType.EnumEventDescriptorV0:
+      case MessageType.EnumEventDescriptor:
         return this.GenerateEnumMessages(oracleEvent);
-      case MessageType.DigitDecompositionEventDescriptorV0:
+      case MessageType.DigitDecompositionEventDescriptor:
         return this.GenerateDigitDecompositionMessages(oracleEvent);
       default:
         throw Error('EventDescriptor must be Enum or DigitDecomposition');
@@ -834,23 +1112,35 @@ export default class BitcoinDlcProvider
 
   private GetContractOraclePairs(
     _contractInfo: ContractInfo,
-  ): { contractDescriptor: ContractDescriptor; oracleInfo: OracleInfoV0 }[] {
-    switch (_contractInfo.type) {
-      case MessageType.ContractInfoV0: {
-        const contractInfo = _contractInfo as ContractInfoV0;
-        return [
-          {
-            contractDescriptor: contractInfo.contractDescriptor,
-            oracleInfo: contractInfo.oracleInfo,
-          },
-        ];
-      }
-      case MessageType.ContractInfoV1: {
-        return (_contractInfo as ContractInfoV1).contractOraclePairs;
-      }
-      default:
-        throw Error('ContractInfo must be V0 or V1');
+  ): { contractDescriptor: ContractDescriptor; oracleInfo: OracleInfo }[] {
+    // Use contractInfoType property instead of instanceof for more reliable type checking
+    if (_contractInfo.contractInfoType === ContractInfoType.Single) {
+      const singleInfo = _contractInfo as SingleContractInfo;
+      return [
+        {
+          contractDescriptor: singleInfo.contractDescriptor,
+          oracleInfo: singleInfo.oracleInfo,
+        },
+      ];
+    } else if (_contractInfo.contractInfoType === ContractInfoType.Disjoint) {
+      const disjointInfo = _contractInfo as DisjointContractInfo;
+      return disjointInfo.contractOraclePairs;
+    } else {
+      throw Error('ContractInfo must be Single or Disjoint');
+    }
+  }
+
+  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(
@@ -870,7 +1160,7 @@ export default class BitcoinDlcProvider
     const cetsHex = dlcTxs.cets.map((cet) => cet.serialize().toString('hex'));
 
     const fundingSPK = Script.p2wpkhLock(
-      hash160(isOfferer ? dlcOffer.fundingPubKey : dlcAccept.fundingPubKey),
+      hash160(isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey),
     )
       .serialize()
       .slice(1);
@@ -894,12 +1184,16 @@ export default class BitcoinDlcProvider
     const sigs: ISig[][] = [];
 
     if (
-      dlcOffer.contractInfo.type === MessageType.ContractInfoV0 &&
-      (dlcOffer.contractInfo as ContractInfoV0).contractDescriptor.type ===
+      dlcOffer.contractInfo.contractInfoType === ContractInfoType.Single &&
+      (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor.type ===
         MessageType.ContractDescriptorV0
     ) {
-      for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
-        const oracleAnnouncement = oracleInfo.announcement;
+      for (const { oracleInfo } of contractOraclePairs) {
+        if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+          throw new Error('Only SingleOracleInfo supported in this context');
+        }
+        const oracleAnnouncement = (oracleInfo as SingleOracleInfo)
+          .announcement;
 
         const adaptorSigRequestPromises: Promise<AdaptorPair[]>[] = [];
 
@@ -912,9 +1206,9 @@ export default class BitcoinDlcProvider
           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'),
@@ -923,9 +1217,8 @@ export default class BitcoinDlcProvider
 
         adaptorSigRequestPromises.push(
           (async () => {
-            const response = await this.CreateCetAdaptorSignatures(
-              cetSignRequest,
-            );
+            const response =
+              await this.CreateCetAdaptorSignatures(cetSignRequest);
             return response.adaptorPairs;
           })(),
         );
@@ -947,7 +1240,11 @@ export default class BitcoinDlcProvider
       const indices = this.GetIndicesFromPayouts(this.GetPayouts(_dlcOffer));
 
       for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
-        const oracleAnnouncement = oracleInfo.announcement;
+        if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+          throw new Error('Only SingleOracleInfo supported in this context');
+        }
+        const oracleAnnouncement = (oracleInfo as SingleOracleInfo)
+          .announcement;
 
         const startingIndex = indices[index].startingMessagesIndex,
           endingIndex = indices[index + 1].startingMessagesIndex;
@@ -971,10 +1268,9 @@ export default class BitcoinDlcProvider
             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'),
@@ -983,9 +1279,8 @@ export default class BitcoinDlcProvider
 
           adaptorSigRequestPromises.push(
             (async () => {
-              const response = await this.CreateCetAdaptorSignatures(
-                cetSignRequest,
-              );
+              const response =
+                await this.CreateCetAdaptorSignatures(cetSignRequest);
               return response.adaptorPairs;
             })(),
           );
@@ -1011,9 +1306,9 @@ export default class BitcoinDlcProvider
       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(
@@ -1021,7 +1316,7 @@ export default class BitcoinDlcProvider
       'hex',
     );
 
-    const cetSignatures = new CetAdaptorSignaturesV0();
+    const cetSignatures = new CetAdaptorSignatures();
     cetSignatures.sigs = sigs.flat();
 
     return { cetSignatures, refundSignature };
@@ -1049,17 +1344,21 @@ export default class BitcoinDlcProvider
     );
 
     if (
-      dlcOffer.contractInfo.type === MessageType.ContractInfoV0 &&
-      (dlcOffer.contractInfo as ContractInfoV0).contractDescriptor.type ===
+      dlcOffer.contractInfo.type === MessageType.SingleContractInfo &&
+      (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor.type ===
         MessageType.ContractDescriptorV0
     ) {
-      for (const [_, { oracleInfo }] of contractOraclePairs.entries()) {
-        const oracleAnnouncement = oracleInfo.announcement;
+      for (const { oracleInfo } of contractOraclePairs) {
+        if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+          throw new Error('Only SingleOracleInfo supported in this context');
+        }
+        const oracleAnnouncement = (oracleInfo as SingleOracleInfo)
+          .announcement;
 
         const oracleEventCetsHex = cetsHex;
         const oracleEventSigs = isOfferer
-          ? dlcAccept.cetSignatures.sigs
-          : dlcSign.cetSignatures.sigs;
+          ? dlcAccept.cetAdaptorSignatures.sigs
+          : dlcSign.cetAdaptorSignatures.sigs;
 
         const sigsValidity: Promise<boolean>[] = [];
 
@@ -1073,21 +1372,22 @@ export default class BitcoinDlcProvider
           };
         });
 
-        const verifyCetAdaptorSignaturesRequest: VerifyCetAdaptorSignaturesRequest = {
-          cetsHex: tempCetsHex,
-          messagesList: tempMessagesList,
-          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'),
-          fundTxId: dlcTxs.fundTx.txId.toString(),
-          fundVout: dlcTxs.fundTxVout,
-          fundInputAmount: dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
-          verifyRemote: isOfferer,
-        };
+        const verifyCetAdaptorSignaturesRequest: VerifyCetAdaptorSignaturesRequest =
+          {
+            cetsHex: tempCetsHex,
+            messagesList: tempMessagesList,
+            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'),
+            fundTxId: dlcTxs.fundTx.txId.toString(),
+            fundVout: dlcTxs.fundTxVout,
+            fundInputAmount: this.getFundOutputValueSats(dlcTxs),
+            verifyRemote: isOfferer,
+          };
 
         sigsValidity.push(
           (async () => {
@@ -1105,11 +1405,11 @@ export default class BitcoinDlcProvider
           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,
         };
 
@@ -1127,7 +1427,11 @@ export default class BitcoinDlcProvider
       const indices = this.GetIndicesFromPayouts(this.GetPayouts(_dlcOffer));
 
       for (const [index, { oracleInfo }] of contractOraclePairs.entries()) {
-        const oracleAnnouncement = oracleInfo.announcement;
+        if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+          throw new Error('Only SingleOracleInfo supported in this context');
+        }
+        const oracleAnnouncement = (oracleInfo as SingleOracleInfo)
+          .announcement;
 
         const startingIndex = indices[index].startingMessagesIndex,
           endingIndex = indices[index + 1].startingMessagesIndex;
@@ -1137,9 +1441,10 @@ export default class BitcoinDlcProvider
           endingIndex,
         );
         const oracleEventCetsHex = cetsHex.slice(startingIndex, endingIndex);
-        const oracleEventSigs = (isOfferer
-          ? dlcAccept.cetSignatures.sigs
-          : dlcSign.cetSignatures.sigs
+        const oracleEventSigs = (
+          isOfferer
+            ? dlcAccept.cetAdaptorSignatures.sigs
+            : dlcSign.cetAdaptorSignatures.sigs
         ).slice(startingIndex, endingIndex);
 
         const sigsValidity: Promise<boolean>[] = [];
@@ -1155,22 +1460,22 @@ export default class BitcoinDlcProvider
             };
           });
 
-          const verifyCetAdaptorSignaturesRequest: VerifyCetAdaptorSignaturesRequest = {
-            cetsHex: tempCetsHex,
-            messagesList: tempMessagesList,
-            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'),
-            fundTxId: dlcTxs.fundTx.txId.toString(),
-            fundVout: dlcTxs.fundTxVout,
-            fundInputAmount:
-              dlcTxs.fundTx.outputs[dlcTxs.fundTxVout].value.sats,
-            verifyRemote: isOfferer,
-          };
+          const verifyCetAdaptorSignaturesRequest: VerifyCetAdaptorSignaturesRequest =
+            {
+              cetsHex: tempCetsHex,
+              messagesList: tempMessagesList,
+              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'),
+              fundTxId: dlcTxs.fundTx.txId.toString(),
+              fundVout: dlcTxs.fundTxVout,
+              fundInputAmount: this.getFundOutputValueSats(dlcTxs),
+              verifyRemote: isOfferer,
+            };
 
           sigsValidity.push(
             (async () => {
@@ -1189,11 +1494,11 @@ export default class BitcoinDlcProvider
           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,
         };
 
@@ -1213,7 +1518,7 @@ export default class BitcoinDlcProvider
     _dlcAccept: DlcAccept,
     _dlcTxs: DlcTransactions,
     isOfferer: boolean,
-  ): Promise<FundingSignaturesV0> {
+  ): Promise<FundingSignatures> {
     const { dlcOffer, dlcAccept, dlcTxs } = checkTypes({
       _dlcOffer,
       _dlcAccept,
@@ -1234,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;
+        }
       }),
     );
 
@@ -1267,26 +1591,19 @@ export default class BitcoinDlcProvider
       witnessElements.push([sigWitness, pubKeyWitness]);
     }
 
-    const fundingSignatures = new FundingSignaturesV0();
+    const fundingSignatures = new FundingSignatures();
     fundingSignatures.witnessElements = witnessElements;
 
     return fundingSignatures;
   }
 
   private async VerifyFundingSigs(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
-    _dlcSign: DlcSign,
-    _dlcTxs: DlcTransactions,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcSign: DlcSign,
+    dlcTxs: DlcTransactions,
     isOfferer: boolean,
   ): Promise<void> {
-    const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-      _dlcSign,
-      _dlcTxs,
-    });
-
     const sigsValidity: Promise<boolean>[] = [];
     for (let i = 0; i < dlcSign.fundingSignatures.witnessElements.length; i++) {
       const witnessElement = dlcSign.fundingSignatures.witnessElements[i];
@@ -1294,27 +1611,52 @@ export default class BitcoinDlcProvider
       const pubkey = witnessElement[1].witness.toString('hex');
 
       const fundingInput = isOfferer
-        ? (dlcAccept.fundingInputs[i] as FundingInputV0)
-        : (dlcOffer.fundingInputs[i] as FundingInputV0);
-
-      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,
-      };
+        ? (dlcAccept.fundingInputs[i] as FundingInput)
+        : (dlcOffer.fundingInputs[i] as FundingInput);
 
-      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: 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.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);
@@ -1325,19 +1667,12 @@ export default class BitcoinDlcProvider
   }
 
   private async CreateFundingTx(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
-    _dlcSign: DlcSign,
-    _dlcTxs: DlcTransactions,
-    fundingSignatures: FundingSignaturesV0,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcSign: DlcSign,
+    dlcTxs: DlcTransactions,
+    fundingSignatures: FundingSignatures,
   ): Promise<Tx> {
-    const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-      _dlcSign,
-      _dlcTxs,
-    });
-
     const witnessElements = [
       ...dlcSign.fundingSignatures.witnessElements,
       ...fundingSignatures.witnessElements,
@@ -1349,23 +1684,59 @@ 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) => {
         const signature = witnessElement[0].witness.toString('hex');
         const pubkey = witnessElement[1].witness.toString('hex');
 
-        const fundingInput = fundingInputs[i] as FundingInputV0;
+        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
       },
     );
 
@@ -1375,15 +1746,13 @@ export default class BitcoinDlcProvider
   }
 
   async FindOutcomeIndexFromPolynomialPayoutCurvePiece(
-    _dlcOffer: DlcOffer,
-    contractDescriptor: ContractDescriptorV1,
+    dlcOffer: DlcOffer,
+    contractDescriptor: NumericalDescriptor,
     contractOraclePairIndex: number,
     polynomialPayoutCurvePiece: PolynomialPayoutCurvePiece,
-    oracleAttestation: OracleAttestationV0,
+    oracleAttestation: OracleAttestation,
     outcome: bigint,
   ): Promise<FindOutcomeResponse> {
-    const { dlcOffer } = checkTypes({ _dlcOffer });
-
     const polynomialCurve = PolynomialPayoutCurve.fromPayoutCurvePiece(
       polynomialPayoutCurvePiece,
     );
@@ -1400,9 +1769,9 @@ export default class BitcoinDlcProvider
     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];
 
@@ -1457,10 +1826,10 @@ Payout Group not found',
 
   async FindOutcomeIndexFromHyperbolaPayoutCurvePiece(
     _dlcOffer: DlcOffer,
-    contractDescriptor: ContractDescriptorV1,
+    contractDescriptor: NumericalDescriptor,
     contractOraclePairIndex: number,
     hyperbolaPayoutCurvePiece: HyperbolaPayoutCurvePiece,
-    oracleAttestation: OracleAttestationV0,
+    oracleAttestation: OracleAttestation,
     outcome: bigint,
   ): Promise<FindOutcomeResponse> {
     const { dlcOffer } = checkTypes({ _dlcOffer });
@@ -1478,9 +1847,9 @@ Payout Group not found',
     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];
 
@@ -1541,31 +1910,52 @@ 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: DlcOffer,
-    oracleAttestation: OracleAttestationV0,
+    dlcOffer: DlcOffer,
+    oracleAttestation: OracleAttestation,
   ): Promise<FindOutcomeResponse> {
-    const { dlcOffer } = checkTypes({ _dlcOffer });
-
     const contractOraclePairs = this.GetContractOraclePairs(
       dlcOffer.contractInfo,
     );
-
     const contractOraclePairIndex = contractOraclePairs.findIndex(
-      ({ oracleInfo }) =>
-        oracleInfo.announcement.oracleEvent.eventId ===
-        oracleAttestation.eventId,
+      ({ oracleInfo }) => {
+        if (oracleInfo.type !== MessageType.SingleOracleInfo) return false;
+        const singleOracleInfo = oracleInfo as SingleOracleInfo;
+        return (
+          singleOracleInfo.announcement.oracleEvent.eventId ===
+          oracleAttestation.eventId
+        );
+      },
     );
-
     assert(
       contractOraclePairIndex !== -1,
       'OracleAttestation must be for an existing OracleEvent',
@@ -1573,39 +1963,42 @@ Payout Group not found',
 
     const contractOraclePair = contractOraclePairs[contractOraclePairIndex];
 
-    const {
-      contractDescriptor: _contractDescriptor,
-      oracleInfo,
-    } = contractOraclePair;
-
+    const { contractDescriptor: _contractDescriptor, oracleInfo } =
+      contractOraclePair;
     assert(
-      _contractDescriptor.type === MessageType.ContractDescriptorV1,
-      'ContractDescriptor must be V1',
+      _contractDescriptor.contractDescriptorType ===
+        ContractDescriptorType.NumericOutcome,
+      'ContractDescriptor must be NumericOutcome',
     );
-
-    const contractDescriptor = _contractDescriptor as ContractDescriptorV1;
+    const contractDescriptor = _contractDescriptor as NumericalDescriptor;
     const _payoutFunction = contractDescriptor.payoutFunction;
-
     assert(
-      _payoutFunction.type === MessageType.PayoutFunctionV0,
+      _payoutFunction.type === MessageType.PayoutFunction,
       'PayoutFunction must be V0',
     );
 
-    const eventDescriptor = oracleInfo.announcement.oracleEvent
-      .eventDescriptor as DigitDecompositionEventDescriptorV0;
+    if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+      throw new Error('Only SingleOracleInfo supported in this context');
+    }
+
+    const singleOracleInfo = oracleInfo as SingleOracleInfo;
+    const eventDescriptor = singleOracleInfo.announcement.oracleEvent
+      .eventDescriptor as DigitDecompositionEventDescriptor;
     const payoutFunction = _payoutFunction as PayoutFunctionV0;
 
     const base = eventDescriptor.base;
-
     const outcome: number = [...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 piecesSorted = payoutFunction.payoutFunctionPieces.sort(
+      (a, b) =>
+        Number(a.endPoint.eventOutcome) - Number(b.endPoint.eventOutcome),
     );
 
-    const piece = piecesSorted.find((piece) => outcome < piece.endpoint);
+    const piece = piecesSorted.find(
+      (piece) => outcome < piece.endPoint.eventOutcome,
+    );
 
     switch (piece.payoutCurvePiece.type) {
       case MessageType.PolynomialPayoutCurvePiece:
@@ -1641,30 +2034,34 @@ Payout Group not found',
   }
 
   ValidateEvent(
-    _dlcOffer: DlcOffer,
-    oracleAttestation: OracleAttestationV0,
+    dlcOffer: DlcOffer,
+    oracleAttestation: OracleAttestation,
   ): void {
-    const { dlcOffer } = checkTypes({
-      _dlcOffer,
-    });
-
-    switch (dlcOffer.contractInfo.type) {
-      case MessageType.ContractInfoV0: {
-        const contractInfo = dlcOffer.contractInfo as ContractInfoV0;
-        switch (contractInfo.contractDescriptor.type) {
-          case MessageType.ContractDescriptorV0: {
+    switch (dlcOffer.contractInfo.contractInfoType) {
+      case ContractInfoType.Single: {
+        const contractInfo = dlcOffer.contractInfo as SingleContractInfo;
+        switch (contractInfo.contractDescriptor.contractDescriptorType) {
+          case ContractDescriptorType.Enumerated: {
             const oracleInfo = contractInfo.oracleInfo;
+            if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+              throw Error('Only SingleOracleInfo supported in this context');
+            }
+            const singleOracleInfo = oracleInfo as SingleOracleInfo;
             if (
-              oracleInfo.announcement.oracleEvent.eventId !==
+              singleOracleInfo.announcement.oracleEvent.eventId !==
               oracleAttestation.eventId
             )
               throw Error('Incorrect Oracle Attestation. Event Id must match.');
             break;
           }
-          case MessageType.ContractDescriptorV1: {
+          case ContractDescriptorType.NumericOutcome: {
             const oracleInfo = contractInfo.oracleInfo;
+            if (oracleInfo.type !== MessageType.SingleOracleInfo) {
+              throw Error('Only SingleOracleInfo supported in this context');
+            }
+            const singleOracleInfo = oracleInfo as SingleOracleInfo;
             if (
-              oracleInfo.announcement.oracleEvent.eventId !==
+              singleOracleInfo.announcement.oracleEvent.eventId !==
               oracleAttestation.eventId
             )
               throw Error('Incorrect Oracle Attestation. Event Id must match.');
@@ -1675,12 +2072,17 @@ Payout Group not found',
         }
         break;
       }
-      case MessageType.ContractInfoV1: {
-        const contractInfo = dlcOffer.contractInfo as ContractInfoV1;
+      case ContractInfoType.Disjoint: {
+        const contractInfo = dlcOffer.contractInfo as DisjointContractInfo;
         const attestedOracleEvent = contractInfo.contractOraclePairs.find(
-          ({ oracleInfo }) =>
-            oracleInfo.announcement.oracleEvent.eventId ===
-            oracleAttestation.eventId,
+          ({ oracleInfo }) => {
+            if (oracleInfo.type !== MessageType.SingleOracleInfo) return false;
+            const singleOracleInfo = oracleInfo as SingleOracleInfo;
+            return (
+              singleOracleInfo.announcement.oracleEvent.eventId ===
+              oracleAttestation.eventId
+            );
+          },
         );
 
         if (!attestedOracleEvent)
@@ -1694,20 +2096,13 @@ Payout Group not found',
   }
 
   async FindAndSignCet(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
-    _dlcSign: DlcSign,
-    _dlcTxs: DlcTransactions,
-    oracleAttestation: OracleAttestationV0,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcSign: DlcSign,
+    dlcTxs: DlcTransactions,
+    oracleAttestation: OracleAttestation,
     isOfferer?: boolean,
   ): Promise<Tx> {
-    const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-      _dlcSign,
-      _dlcTxs,
-    });
-
     if (isOfferer === undefined)
       isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
 
@@ -1720,14 +2115,16 @@ Payout Group not found',
     let signCetRequest: SignCetRequest;
 
     if (
-      dlcOffer.contractInfo.type === MessageType.ContractInfoV0 &&
-      (dlcOffer.contractInfo as ContractInfoV0).contractDescriptor.type ===
-        MessageType.ContractDescriptorV0
+      dlcOffer.contractInfo.contractInfoType === ContractInfoType.Single &&
+      (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor
+        .contractDescriptorType === ContractDescriptorType.Enumerated
     ) {
-      const outcomeIndex = ((dlcOffer.contractInfo as ContractInfoV0)
-        .contractDescriptor as ContractDescriptorV0).outcomes.findIndex(
+      const outcomeIndex = (
+        (dlcOffer.contractInfo as SingleContractInfo)
+          .contractDescriptor as EnumeratedDescriptor
+      ).outcomes.findIndex(
         (outcome) =>
-          outcome.outcome.toString('hex') ===
+          outcome.outcome ===
           sha256(Buffer.from(oracleAttestation.outcomes[0])).toString('hex'),
       );
 
@@ -1736,19 +2133,19 @@ 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: 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 {
       const { index: outcomeIndex, groupLength } = await this.FindOutcomeIndex(
@@ -1768,17 +2165,17 @@ 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'),
       };
     }
 
@@ -1788,14 +2185,14 @@ Payout Group not found',
   }
 
   private async GetFundAddress(
-    dlcOffer: DlcOfferV0,
-    dlcAccept: DlcAcceptV0,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
     isOfferer: boolean,
   ): Promise<string> {
     const network = await this.getConnectedNetwork();
 
     const fundingSPK = Script.p2wpkhLock(
-      hash160(isOfferer ? dlcOffer.fundingPubKey : dlcAccept.fundingPubKey),
+      hash160(isOfferer ? dlcOffer.fundingPubkey : dlcAccept.fundingPubkey),
     )
       .serialize()
       .slice(1);
@@ -1809,8 +2206,8 @@ Payout Group not found',
   }
 
   private async GetFundKeyPair(
-    dlcOffer: DlcOfferV0,
-    dlcAccept: DlcAcceptV0,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
     isOfferer: boolean,
   ): Promise<ECPairInterface> {
     const fundingAddress = await this.GetFundAddress(
@@ -1819,19 +2216,17 @@ Payout Group not found',
       isOfferer,
     );
 
-    const { derivationPath } = await this.getMethod('getWalletAddress')(
-      fundingAddress,
-    );
-    const keyPair: ECPairInterface = await this.getMethod('keyPair')(
-      derivationPath,
-    );
+    const { derivationPath } =
+      await this.getMethod('getWalletAddress')(fundingAddress);
+    const keyPair: ECPairInterface =
+      await this.getMethod('keyPair')(derivationPath);
 
     return keyPair;
   }
 
   private async GetFundPrivateKey(
-    dlcOffer: DlcOfferV0,
-    dlcAccept: DlcAcceptV0,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
     isOfferer: boolean,
   ): Promise<string> {
     const fundPrivateKeyPair: ECPairInterface = await this.GetFundKeyPair(
@@ -1844,28 +2239,23 @@ Payout Group not found',
   }
 
   async CreateCloseRawTxs(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
-    _dlcTxs: DlcTransactions,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcTxs: DlcTransactions,
     closeInputAmount: bigint,
     isOfferer: boolean,
     _dlcCloses: DlcClose[] = [],
     fundingInputs?: FundingInput[],
     initiatorPayouts?: bigint[],
   ): Promise<string[]> {
-    const { dlcOffer, dlcAccept, dlcTxs } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-      _dlcTxs,
-    });
     const network = await this.getConnectedNetwork();
 
     let finalizer: DualClosingTxFinalizer;
     if (_dlcCloses.length === 0) {
       finalizer = new DualClosingTxFinalizer(
         fundingInputs,
-        dlcOffer.payoutSPK,
-        dlcAccept.payoutSPK,
+        dlcOffer.payoutSpk,
+        dlcAccept.payoutSpk,
         dlcOffer.feeRatePerVb,
       );
     }
@@ -1909,14 +2299,14 @@ Payout Group not found',
 
       if (Number(offerPayoutValue) > 0) {
         txOuts.push({
-          address: address.fromOutputScript(dlcOffer.payoutSPK, network),
+          address: address.fromOutputScript(dlcOffer.payoutSpk, network),
           amount: Number(offerPayoutValue),
         });
       }
 
       if (Number(acceptPayoutValue) > 0) {
         txOuts.push({
-          address: address.fromOutputScript(dlcAccept.payoutSPK, network),
+          address: address.fromOutputScript(dlcAccept.payoutSpk, network),
           amount: Number(acceptPayoutValue),
         });
       }
@@ -1968,9 +2358,9 @@ Payout Group not found',
     const network = await this.getConnectedNetwork();
 
     const fundingPubKeys =
-      Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
-        ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
-        : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+      Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+        ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+        : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
 
     const p2ms = payments.p2ms({
       m: 2,
@@ -1998,7 +2388,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,
@@ -2079,9 +2469,9 @@ Payout Group not found',
     const network = await this.getConnectedNetwork();
 
     const fundingPubKeys =
-      Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
-        ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
-        : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+      Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+        ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+        : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
 
     const p2ms = payments.p2ms({
       m: 2,
@@ -2094,7 +2484,7 @@ Payout Group not found',
       network,
     });
 
-    const pubkey = isOfferer ? dlcAccept.fundingPubKey : dlcOffer.fundingPubKey;
+    const pubkey = isOfferer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey;
 
     const sigsValidity: Promise<boolean>[] = [];
 
@@ -2113,7 +2503,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)),
         },
       };
 
@@ -2147,10 +2537,10 @@ Payout Group not found',
     });
     const network = await this.getConnectedNetwork();
 
-    const offerFundingSPK = Script.p2wpkhLock(hash160(dlcOffer.fundingPubKey))
+    const offerFundingSPK = Script.p2wpkhLock(hash160(dlcOffer.fundingPubkey))
       .serialize()
       .slice(1);
-    const acceptFundingSPK = Script.p2wpkhLock(hash160(dlcAccept.fundingPubKey))
+    const acceptFundingSPK = Script.p2wpkhLock(hash160(dlcAccept.fundingPubkey))
       .serialize()
       .slice(1);
 
@@ -2183,6 +2573,7 @@ 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(
@@ -2191,35 +2582,77 @@ Payout Group not found',
     feeRatePerVb: bigint,
     cetLocktime: number,
     refundLocktime: number,
-    fixedInputs?: Input[],
+    fixedInputs?: Input[] | FundingInput[],
+    inputSupplementationMode?: InputSupplementationMode,
   ): Promise<DlcOffer> {
     contractInfo.validate();
     const network = await this.getConnectedNetwork();
 
-    const dlcOffer = new DlcOfferV0();
+    const dlcOffer = new DlcOffer();
 
-    const {
-      fundingPubKey,
-      payoutSPK,
-      payoutSerialId,
-      fundingInputs: _fundingInputs,
-      changeSPK,
-      changeSerialId,
-    } = await this.Initialize(
-      offerCollateralSatoshis,
-      feeRatePerVb,
-      fixedInputs,
-    );
+    // Generate a random 32-byte temporary contract ID
+    dlcOffer.temporaryContractId = crypto.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: 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(
-        input.type === MessageType.FundingInputV0,
+        input.type === MessageType.FundingInput,
         'FundingInput must be V0',
       ),
     );
 
-    const fundingInputs: FundingInputV0[] = _fundingInputs.map(
-      (input) => input as FundingInputV0,
+    const fundingInputs: FundingInput[] = _fundingInputs.map(
+      (input) => input as FundingInput,
     );
 
     fundingInputs.sort(
@@ -2236,24 +2669,29 @@ Payout Group not found',
     dlcOffer.contractFlags = Buffer.from('00', 'hex');
     dlcOffer.chainHash = 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();
+    }
+
     assert(
       (() => {
         const finalizer = new DualFundingTxFinalizer(
           dlcOffer.fundingInputs,
-          dlcOffer.payoutSPK,
-          dlcOffer.changeSPK,
+          dlcOffer.payoutSpk,
+          dlcOffer.changeSpk,
           null,
           null,
           null,
@@ -2290,7 +2728,7 @@ Payout Group not found',
       );
     }
 
-    const dlcOffers: DlcOfferV0[] = [];
+    const dlcOffers: DlcOffer[] = [];
 
     for (let i = 0; i < contractInfos.length; i++) {
       contractInfos[i].validate();
@@ -2307,13 +2745,13 @@ Payout Group not found',
 
     _fundingInputs.forEach((input) =>
       assert(
-        input.type === MessageType.FundingInputV0,
+        input.type === MessageType.FundingInput,
         'FundingInput must be V0',
       ),
     );
 
-    const fundingInputs: FundingInputV0[] = _fundingInputs.map(
-      (input) => input as FundingInputV0,
+    const fundingInputs: FundingInput[] = _fundingInputs.map(
+      (input) => input as FundingInput,
     );
 
     fundingInputs.sort(
@@ -2326,34 +2764,40 @@ Payout Group not found',
       const contractInfo = contractInfos[i];
       const offerCollateralSatoshis = offerCollaterals[i];
       const fundOutputSerialId = fundOutputsSerialIds[i];
-      const { fundingPubKey, payoutSPK, payoutSerialId } = initializeResponses[
-        i
-      ];
+      const { fundingPubKey, payoutSPK, payoutSerialId } =
+        initializeResponses[i];
       const refundLocktime = refundLocktimes[i];
 
-      const dlcOffer = new DlcOfferV0();
+      const dlcOffer = new DlcOffer();
+
+      // Generate a random 32-byte temporary contract ID
+      dlcOffer.temporaryContractId = crypto.randomBytes(32);
 
       dlcOffer.contractFlags = Buffer.from('00', 'hex');
       dlcOffer.chainHash = 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();
+      }
+
       assert(
         (() => {
           const finalizer = new DualFundingTxFinalizer(
             dlcOffer.fundingInputs,
-            dlcOffer.payoutSPK,
-            dlcOffer.changeSPK,
+            dlcOffer.payoutSpk,
+            dlcOffer.changeSpk,
             null,
             null,
             null,
@@ -2373,74 +2817,166 @@ Payout Group not found',
       dlcOffers.push(dlcOffer);
     }
 
-    return dlcOffers;
-  }
+    return dlcOffers;
+  }
+
+  /**
+   * 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[] | FundingInput[],
+  ): Promise<AcceptDlcOfferResponse> {
+    const { dlcOffer } = checkTypes({ _dlcOffer });
+    dlcOffer.validate();
+
+    const acceptCollateralSatoshis =
+      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral;
+
+    assert(
+      acceptCollateralSatoshis ===
+        dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral,
+      'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis',
+    );
+
+    let fundingPubKey: Buffer;
+    let payoutSPK: Buffer;
+    let payoutSerialId: bigint;
+    let fundingInputs: FundingInput[];
+    let changeSPK: Buffer;
+    let changeSerialId: bigint;
+
+    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: Address =
+        await this.client.wallet.getUnusedAddress(false);
+      payoutSPK = address.toOutputScript(payoutAddress.address, network);
+
+      // Generate funding pubkey for DLC contract construction
+      const fundingAddress: Address =
+        await this.client.wallet.getUnusedAddress(false);
+      fundingPubKey = Buffer.from(fundingAddress.publicKey, 'hex');
+
+      // 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');
 
-  /**
-   * Accept DLC Offer
-   * @param _dlcOffer Dlc Offer Message
-   * @param fixedInputs Optional inputs to use for Funding Inputs
-   * @returns {Promise<AcceptDlcOfferResponse}
-   */
-  async acceptDlcOffer(
-    _dlcOffer: DlcOffer,
-    fixedInputs?: Input[],
-  ): Promise<AcceptDlcOfferResponse> {
-    const { dlcOffer } = checkTypes({ _dlcOffer });
-    dlcOffer.validate();
+        if (fundingAddress.address === payoutAddress.address)
+          throw Error('Address reuse');
 
-    const acceptCollateralSatoshis =
-      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis;
+        const payoutSerialId = generateSerialId();
+        const changeSerialId = generateSerialId();
 
-    assert(
-      acceptCollateralSatoshis ===
-        dlcOffer.contractInfo.totalCollateral -
-          dlcOffer.offerCollateralSatoshis,
-      'acceptCollaterialSatoshis should equal totalCollateral - offerCollateralSatoshis',
-    );
+        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,
+        );
+      }
 
-    const {
-      fundingPubKey,
-      payoutSPK,
-      payoutSerialId,
-      fundingInputs: _fundingInputs,
-      changeSPK,
-      changeSerialId,
-    } = await this.Initialize(
-      acceptCollateralSatoshis,
-      dlcOffer.feeRatePerVb,
-      fixedInputs,
-    );
+      fundingPubKey = initResult.fundingPubKey;
+      payoutSPK = initResult.payoutSPK;
+      payoutSerialId = initResult.payoutSerialId;
+      changeSPK = initResult.changeSPK;
+      changeSerialId = initResult.changeSerialId;
 
-    assert(
-      Buffer.compare(dlcOffer.fundingPubKey, fundingPubKey) !== 0,
-      'DlcOffer and DlcAccept FundingPubKey cannot be the same',
-    );
+      const _fundingInputs = initResult.fundingInputs;
 
-    _fundingInputs.forEach((input) =>
-      assert(
-        input.type === MessageType.FundingInputV0,
-        'FundingInput must be V0',
-      ),
-    );
+      _fundingInputs.forEach((input) =>
+        assert(
+          input.type === MessageType.FundingInput,
+          'FundingInput must be V0',
+        ),
+      );
 
-    const fundingInputs: FundingInputV0[] = _fundingInputs.map(
-      (input) => input as FundingInputV0,
-    );
+      fundingInputs = _fundingInputs.map((input) => input as FundingInput);
 
-    fundingInputs.sort(
-      (a, b) => Number(a.inputSerialId) - Number(b.inputSerialId),
+      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 DlcAcceptV0();
+    const dlcAccept = new DlcAccept();
 
-    dlcAccept.tempContractId = sha256(dlcOffer.serialize());
-    dlcAccept.acceptCollateralSatoshis = acceptCollateralSatoshis;
-    dlcAccept.fundingPubKey = fundingPubKey;
-    dlcAccept.payoutSPK = payoutSPK;
+    dlcAccept.temporaryContractId = 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;
 
     assert(
@@ -2465,59 +3001,57 @@ Payout Group not found',
       '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,
       dlcAccept,
     );
 
-    const {
-      cetSignatures,
-      refundSignature,
-    } = await this.CreateCetAdaptorAndRefundSigs(
-      dlcOffer,
-      dlcAccept,
-      dlcTransactions,
-      messagesList,
-      false,
-    );
+    const { cetSignatures, refundSignature } =
+      await this.CreateCetAdaptorAndRefundSigs(
+        dlcOffer,
+        dlcAccept,
+        dlcTransactions,
+        messagesList,
+        false,
+      );
 
-    assert(
-      dlcTransactions.type === MessageType.DlcTransactionsV0,
-      'DlcTransactions must be V0',
-    );
-    const _dlcTransactions = dlcTransactions as DlcTransactionsV0;
+    const _dlcTransactions = dlcTransactions;
 
     const contractId = xor(
       _dlcTransactions.fundTx.txId.serialize(),
-      dlcAccept.tempContractId,
+      dlcAccept.temporaryContractId,
     );
     _dlcTransactions.contractId = contractId;
 
-    dlcAccept.cetSignatures = cetSignatures;
+    dlcAccept.cetAdaptorSignatures = cetSignatures;
     dlcAccept.refundSignature = refundSignature;
-    dlcAccept.negotiationFields = new NegotiationFieldsV0();
 
     return { dlcAccept, dlcTransactions: _dlcTransactions };
   }
@@ -2534,8 +3068,7 @@ Payout Group not found',
 
     const acceptCollaterals = dlcOffers.map(
       (dlcOffer) =>
-        dlcOffer.contractInfo.totalCollateral -
-        dlcOffer.offerCollateralSatoshis,
+        dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateral,
     );
 
     const {
@@ -2555,7 +3088,7 @@ Payout Group not found',
       initializeResponses.forEach((initializeResponse) => {
         assert(
           Buffer.compare(
-            dlcOffer.fundingPubKey,
+            dlcOffer.fundingPubkey,
             initializeResponse.fundingPubKey,
           ) !== 0,
           'DlcOffer and DlcAccept FundingPubKey cannot be the same',
@@ -2565,34 +3098,34 @@ Payout Group not found',
 
     _fundingInputs.forEach((input) =>
       assert(
-        input.type === MessageType.FundingInputV0,
+        input.type === MessageType.FundingInput,
         'FundingInput must be V0',
       ),
     );
 
-    const fundingInputs: FundingInputV0[] = _fundingInputs.map(
-      (input) => input as FundingInputV0,
+    const fundingInputs: FundingInput[] = _fundingInputs.map(
+      (input) => input as FundingInput,
     );
 
     fundingInputs.sort(
       (a, b) => Number(a.inputSerialId) - Number(b.inputSerialId),
     );
 
-    const dlcAccepts: DlcAcceptV0[] = [];
+    const dlcAccepts: DlcAccept[] = [];
 
     initializeResponses.forEach((initializeResponse, i) => {
       const dlcOffer = dlcOffers[i];
-      const dlcAccept = new DlcAcceptV0();
+      const dlcAccept = new DlcAccept();
 
       const { fundingPubKey, payoutSPK, payoutSerialId } = initializeResponse;
 
-      dlcAccept.tempContractId = sha256(dlcOffers[i].serialize());
-      dlcAccept.acceptCollateralSatoshis = acceptCollaterals[i];
-      dlcAccept.fundingPubKey = fundingPubKey;
-      dlcAccept.payoutSPK = payoutSPK;
+      dlcAccept.temporaryContractId = 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;
 
       assert(
@@ -2623,11 +3156,11 @@ Payout Group not found',
         (() => {
           const finalizer = new DualFundingTxFinalizer(
             dlcOffer.fundingInputs,
-            dlcOffer.payoutSPK,
-            dlcOffer.changeSPK,
+            dlcOffer.payoutSpk,
+            dlcOffer.changeSpk,
             dlcAccept.fundingInputs,
-            dlcAccept.payoutSPK,
-            dlcAccept.changeSPK,
+            dlcAccept.payoutSpk,
+            dlcAccept.changeSpk,
             dlcOffer.feeRatePerVb,
           );
           const funding = fundingInputs.reduce((total, input) => {
@@ -2642,10 +3175,8 @@ Payout Group not found',
       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];
@@ -2653,32 +3184,25 @@ Payout Group not found',
       const dlcTransactions = dlcTransactionsList[i];
       const messagesList = nestedMessagesList[i];
 
-      const {
-        cetSignatures,
-        refundSignature,
-      } = await this.CreateCetAdaptorAndRefundSigs(
-        dlcOffer,
-        dlcAccept,
-        dlcTransactions,
-        messagesList,
-        false,
-      );
+      const { cetSignatures, refundSignature } =
+        await this.CreateCetAdaptorAndRefundSigs(
+          dlcOffer,
+          dlcAccept,
+          dlcTransactions,
+          messagesList,
+          false,
+        );
 
-      assert(
-        dlcTransactions.type === MessageType.DlcTransactionsV0,
-        'DlcTransactions must be V0',
-      );
-      const _dlcTransactions = dlcTransactions as DlcTransactionsV0;
+      const _dlcTransactions = dlcTransactions;
 
       const contractId = xor(
         _dlcTransactions.fundTx.txId.serialize(),
-        dlcAccept.tempContractId,
+        dlcAccept.temporaryContractId,
       );
       _dlcTransactions.contractId = contractId;
 
-      dlcAccepts[i].cetSignatures = cetSignatures;
+      dlcAccepts[i].cetAdaptorSignatures = cetSignatures;
       dlcAccepts[i].refundSignature = refundSignature;
-      dlcAccepts[i].negotiationFields = new NegotiationFieldsV0();
     }
 
     return { dlcAccepts, dlcTransactionsList };
@@ -2691,22 +3215,18 @@ Payout Group not found',
    * @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();
 
     assert(
-      Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) !== 0,
+      Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) !== 0,
       'DlcOffer and DlcAccept FundingPubKey cannot be the same',
     );
 
-    const dlcSign = new DlcSignV0();
+    const dlcSign = new DlcSign();
 
     const { dlcTransactions, messagesList } = await this.createDlcTxs(
       dlcOffer,
@@ -2722,16 +3242,14 @@ Payout Group not found',
       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,
@@ -2740,17 +3258,17 @@ Payout Group not found',
       true,
     );
 
-    const dlcTxs = dlcTransactions as DlcTransactionsV0;
+    const dlcTxs = dlcTransactions;
 
     const contractId = xor(
       dlcTxs.fundTx.txId.serialize(),
-      dlcAccept.tempContractId,
+      dlcAccept.temporaryContractId,
     );
 
     assert(
       Buffer.compare(
         contractId,
-        xor(dlcTxs.fundTx.txId.serialize(), dlcAccept.tempContractId),
+        xor(dlcTxs.fundTx.txId.serialize(), dlcAccept.temporaryContractId),
       ) === 0,
       'contractId must be the xor of funding txid, fundingOutputIndex and the tempContractId',
     );
@@ -2758,7 +3276,7 @@ Payout Group not found',
     dlcTxs.contractId = contractId;
 
     dlcSign.contractId = contractId;
-    dlcSign.cetSignatures = cetSignatures;
+    dlcSign.cetAdaptorSignatures = cetSignatures;
     dlcSign.refundSignature = refundSignature;
     dlcSign.fundingSignatures = fundingSignatures;
 
@@ -2781,12 +3299,10 @@ Payout Group not found',
       return dlcAccept;
     });
 
-    const {
-      dlcTransactionsList,
-      nestedMessagesList,
-    } = await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
+    const { dlcTransactionsList, nestedMessagesList } =
+      await this.createBatchDlcTxs(dlcOffers, dlcAccepts);
 
-    const dlcSigns: DlcSignV0[] = [];
+    const dlcSigns: DlcSign[] = [];
 
     const fundingSignatures = await this.CreateFundingSigs(
       dlcOffers[0],
@@ -2801,7 +3317,7 @@ Payout Group not found',
       const dlcTransactions = dlcTransactionsList[i];
       const messagesList = nestedMessagesList[i];
 
-      const dlcSign = new DlcSignV0();
+      const dlcSign = new DlcSign();
 
       await this.VerifyCetAdaptorAndRefundSigs(
         dlcOffer,
@@ -2812,28 +3328,26 @@ Payout Group not found',
         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 as DlcTransactionsV0;
+      const dlcTxs = dlcTransactions;
 
       const contractId = xor(
         dlcTxs.fundTx.txId.serialize(),
-        dlcAccept.tempContractId,
+        dlcAccept.temporaryContractId,
       );
 
       dlcTxs.contractId = contractId;
 
       dlcSign.contractId = contractId;
-      dlcSign.cetSignatures = cetSignatures;
+      dlcSign.cetAdaptorSignatures = cetSignatures;
       dlcSign.refundSignature = refundSignature;
       dlcSign.fundingSignatures = fundingSignatures;
 
@@ -2845,41 +3359,35 @@ 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: DlcOffer,
-    _dlcAccept: DlcAccept,
-    _dlcSign: DlcSign,
-    _dlcTxs: DlcTransactions,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcSign: DlcSign,
+    dlcTxs: DlcTransactions,
   ): Promise<Tx> {
-    const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-      _dlcSign,
-      _dlcTxs,
-    });
-
     let messagesList: Messages[] = [];
 
     if (
-      dlcOffer.contractInfo.type === MessageType.ContractInfoV0 &&
-      (dlcOffer.contractInfo as ContractInfoV0).contractDescriptor.type ===
-        MessageType.ContractDescriptorV0
+      dlcOffer.contractInfo.type === MessageType.SingleContractInfo &&
+      (dlcOffer.contractInfo as SingleContractInfo).contractDescriptor.type ===
+        MessageType.SingleContractInfo
     ) {
-      for (const outcome of ((dlcOffer.contractInfo as ContractInfoV0)
-        .contractDescriptor as ContractDescriptorV0).outcomes) {
-        messagesList.push({ messages: [outcome.outcome.toString('hex')] });
+      for (const outcome of (
+        (dlcOffer.contractInfo as SingleContractInfo)
+          .contractDescriptor as EnumeratedDescriptor
+      ).outcomes) {
+        messagesList.push({ messages: [outcome.outcome] });
       }
     } else {
       const payoutResponses = this.GetPayouts(dlcOffer);
-      const { messagesList: oracleEventMessagesList } = this.FlattenPayouts(
-        payoutResponses,
-      );
+      const { messagesList: oracleEventMessagesList } =
+        this.FlattenPayouts(payoutResponses);
       messagesList = oracleEventMessagesList;
     }
 
@@ -2996,20 +3504,13 @@ Payout Group not found',
    * @returns {Promise<Tx>}
    */
   async execute(
-    _dlcOffer: DlcOffer,
-    _dlcAccept: DlcAccept,
-    _dlcSign: DlcSign,
-    _dlcTxs: DlcTransactions,
-    oracleAttestation: OracleAttestationV0,
+    dlcOffer: DlcOffer,
+    dlcAccept: DlcAccept,
+    dlcSign: DlcSign,
+    dlcTxs: DlcTransactions,
+    oracleAttestation: OracleAttestation,
     isOfferer?: boolean,
   ): Promise<Tx> {
-    const { dlcOffer, dlcAccept, dlcSign, dlcTxs } = checkTypes({
-      _dlcOffer,
-      _dlcAccept,
-      _dlcSign,
-      _dlcTxs,
-    });
-
     if (isOfferer === undefined)
       isOfferer = await this.isOfferer(dlcOffer, dlcAccept);
 
@@ -3047,7 +3548,7 @@ Payout Group not found',
     });
 
     const signatures =
-      Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
+      Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
         ? [
             dlcSign.refundSignature.toString('hex'),
             dlcAccept.refundSignature.toString('hex'),
@@ -3062,8 +3563,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 = (
@@ -3111,9 +3612,9 @@ Payout Group not found',
     const psbt = new Psbt({ network });
 
     const fundingPubKeys =
-      Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
-        ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
-        : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+      Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+        ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+        : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
 
     const p2ms = payments.p2ms({
       m: 2,
@@ -3129,28 +3630,46 @@ Payout Group not found',
     // 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();
@@ -3164,7 +3683,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,
@@ -3202,7 +3721,7 @@ Payout Group not found',
     );
 
     // 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) => {
@@ -3212,8 +3731,8 @@ Payout Group not found',
 
     const finalizer = new DualClosingTxFinalizer(
       fundingInputs,
-      dlcOffer.payoutSPK,
-      dlcAccept.payoutSPK,
+      dlcOffer.payoutSpk,
+      dlcAccept.payoutSpk,
       dlcOffer.feeRatePerVb,
     );
 
@@ -3238,7 +3757,7 @@ Payout Group not found',
     psbt.addOutput({
       value: Number(offerFirst ? offerPayoutValue : acceptPayoutValue),
       address: address.fromOutputScript(
-        offerFirst ? dlcOffer.payoutSPK : dlcAccept.payoutSPK,
+        offerFirst ? dlcOffer.payoutSpk : dlcAccept.payoutSpk,
         network,
       ),
     });
@@ -3246,7 +3765,7 @@ Payout Group not found',
     psbt.addOutput({
       value: Number(offerFirst ? acceptPayoutValue : offerPayoutValue),
       address: address.fromOutputScript(
-        offerFirst ? dlcAccept.payoutSPK : dlcOffer.payoutSPK,
+        offerFirst ? dlcAccept.payoutSpk : dlcOffer.payoutSpk,
         network,
       ),
     });
@@ -3267,6 +3786,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);
       }),
@@ -3298,11 +3820,11 @@ Payout Group not found',
       pubKeyWitness.witness = inputSigs[i].pubkey;
       witnessElements.push([sigWitness, pubKeyWitness]);
     }
-    const fundingSignatures = new FundingSignaturesV0();
+    const fundingSignatures = new FundingSignatures();
     fundingSignatures.witnessElements = witnessElements;
 
     // Create DlcClose
-    const dlcClose = new DlcCloseV0();
+    const dlcClose = new DlcClose();
     dlcClose.contractId = dlcTxs.contractId;
     dlcClose.offerPayoutSatoshis = BigInt(
       psbt.txOutputs[offerFirst ? 0 : 1].value,
@@ -3313,7 +3835,7 @@ Payout Group not found',
     dlcClose.fundInputSerialId = fundingInputSerialId; // randomly generated serial id
     dlcClose.closeSignature = closeSignature;
     dlcClose.fundingSignatures = fundingSignatures;
-    dlcClose.fundingInputs = fundingInputs as FundingInputV0[];
+    dlcClose.fundingInputs = fundingInputs as FundingInput[];
     dlcClose.validate();
 
     return dlcClose;
@@ -3355,8 +3877,8 @@ Payout Group not found',
 
     const finalizer = new DualClosingTxFinalizer(
       fundingInputs,
-      dlcOffer.payoutSPK,
-      dlcAccept.payoutSPK,
+      dlcOffer.payoutSpk,
+      dlcAccept.payoutSpk,
       dlcOffer.feeRatePerVb,
     );
 
@@ -3415,9 +3937,9 @@ Payout Group not found',
         ? collateralMinusPayout
         : closeInputAmount + payoutMinusOfferFees;
 
-      const fundingSignatures = new FundingSignaturesV0();
+      const fundingSignatures = new FundingSignatures();
 
-      const dlcClose = new DlcCloseV0();
+      const dlcClose = new DlcClose();
       dlcClose.contractId = dlcTxs.contractId;
       dlcClose.offerPayoutSatoshis = offerPayoutValue;
       dlcClose.acceptPayoutSatoshis = acceptPayoutValue;
@@ -3542,9 +4064,9 @@ Payout Group not found',
     const psbt = new Psbt({ network });
 
     const fundingPubKeys =
-      Buffer.compare(dlcOffer.fundingPubKey, dlcAccept.fundingPubKey) === -1
-        ? [dlcOffer.fundingPubKey, dlcAccept.fundingPubKey]
-        : [dlcAccept.fundingPubKey, dlcOffer.fundingPubKey];
+      Buffer.compare(dlcOffer.fundingPubkey, dlcAccept.fundingPubkey) === -1
+        ? [dlcOffer.fundingPubkey, dlcAccept.fundingPubkey]
+        : [dlcAccept.fundingPubkey, dlcOffer.fundingPubkey];
 
     const p2ms = payments.p2ms({
       m: 2,
@@ -3566,14 +4088,14 @@ 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,
@@ -3610,7 +4132,7 @@ Payout Group not found',
           : dlcClose.acceptPayoutSatoshis,
       ),
       address: address.fromOutputScript(
-        offerFirst ? dlcOffer.payoutSPK : dlcAccept.payoutSPK,
+        offerFirst ? dlcOffer.payoutSpk : dlcAccept.payoutSpk,
         network,
       ),
     });
@@ -3622,13 +4144,13 @@ Payout Group not found',
           : dlcClose.offerPayoutSatoshis,
       ),
       address: address.fromOutputScript(
-        offerFirst ? dlcAccept.payoutSPK : dlcOffer.payoutSPK,
+        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);
 
@@ -3644,7 +4166,7 @@ Payout Group not found',
 
     const partialSig = [
       {
-        pubkey: offerer ? dlcAccept.fundingPubKey : dlcOffer.fundingPubKey,
+        pubkey: offerer ? dlcAccept.fundingPubkey : dlcOffer.fundingPubkey,
         signature: await script.signature.encode(dlcClose.closeSignature, 1), // encode using SIGHASH_ALL
       },
     ];
@@ -3824,16 +4346,45 @@ Payout Group not found',
     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,
   ): Promise<Input> {
-    assert(
-      _input.type === MessageType.FundingInputV0,
-      'FundingInput must be V0',
-    );
+    assert(_input.type === MessageType.FundingInput, 'FundingInput must be V0');
     const network = await this.getConnectedNetwork();
-    const input = _input as FundingInputV0;
+    const input = _input as FundingInput;
     const prevTx = input.prevTx;
     const prevTxOut = prevTx.outputs[input.prevTxVout];
     const scriptPubKey = prevTxOut.scriptPubKey.serialize().slice(1);
@@ -3849,25 +4400,40 @@ Payout Group not found',
       }
     }
 
-    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> {
-    const fundingInput = new FundingInputV0();
+    const fundingInput = new FundingInput();
     fundingInput.prevTxVout = input.vout;
 
     let txRaw = '';
@@ -3898,12 +4464,155 @@ Payout Group not found',
       ? 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,
+        '', // DLC inputs don't have derivation paths
+        dlcInputInfo.maxWitnessLength || 220,
+        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 {
@@ -3973,7 +4682,7 @@ interface ISig {
 }
 
 export interface CreateCetAdaptorAndRefundSigsResponse {
-  cetSignatures: CetAdaptorSignaturesV0;
+  cetSignatures: CetAdaptorSignatures;
   refundSignature: Buffer;
 }
 
@@ -4007,5 +4716,3 @@ export interface InputsForDualAmountResponse {
   inputs: Input[];
   fee: number;
 }
-
-const BurnAddress = 'bcrt1qxcjufgh2jarkp2qkx68azh08w9v5gah8u6es8s';