@atomicfinance/types 4.0.0 → 4.0.2

package/.yalc/@node-dlc/messaging/lib/messages/DlcAccept.ts

@@ -1,5 +1,5 @@
-import { Script, Sequence, Tx } from '@node-dlc/bitcoin';
-import { BufferReader, BufferWriter, StreamReader } from '@node-dlc/bufio';
+import { Script } from '@node-dlc/bitcoin';
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
 import { hash160 } from '@node-dlc/crypto';
 import { BitcoinNetwork } from 'bitcoin-networks';
 import { address } from 'bitcoinjs-lib';
@@ -7,9 +7,9 @@ import secp256k1 from 'secp256k1';
 
 import { MessageType, PROTOCOL_VERSION } from '../MessageType';
 import { deserializeTlv } from '../serialize/deserializeTlv';
-import { getTlv, skipTlv } from '../serialize/getTlv';
+import { getTlv } from '../serialize/getTlv';
 import { bigIntToNumber, toBigInt } from '../util';
-import { BatchFundingGroup, IBatchFundingGroupJSON } from './BatchFundingGroup';
+import { BatchFundingGroup } from './BatchFundingGroup';
 import {
   CetAdaptorSignatures,
   ICetAdaptorSignaturesJSON,
@@ -126,6 +126,7 @@ export class DlcAccept implements IDlcMessage {
    * @param fundingInputsJson Array of JSON objects representing funding inputs
    */
   private static parseFundingInputsFromJSON(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     fundingInputsJson: any[],
   ): FundingInput[] {
     return fundingInputsJson.map((inputJson) => {
@@ -139,6 +140,7 @@ export class DlcAccept implements IDlcMessage {
    * @param cetSigsJson JSON object representing CET adaptor signatures
    */
   private static parseCetAdaptorSignaturesFromJSON(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     cetSigsJson: any,
   ): CetAdaptorSignatures {
     const instance = new CetAdaptorSignatures();
@@ -150,6 +152,7 @@ export class DlcAccept implements IDlcMessage {
       const ecdsaSigs =
         cetSigsJson.ecdsaAdaptorSignatures ||
         cetSigsJson.ecdsa_adaptor_signatures;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       instance.sigs = ecdsaSigs.map((sig: any) => {
         // The test vectors use 'signature' field, but our internal format uses encryptedSig/dleqProof
         // Adaptor signatures have different format than regular ECDSA (65 bytes + 97 bytes)
@@ -170,6 +173,7 @@ export class DlcAccept implements IDlcMessage {
    * @param negotiationJson JSON object representing negotiation fields
    */
   private static parseNegotiationFieldsFromJSON(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     negotiationJson: any,
   ): NegotiationFields {
     return NegotiationFields.fromJSON(negotiationJson);
@@ -277,6 +281,12 @@ export class DlcAccept implements IDlcMessage {
       }
     }
 
+    // Auto-detect single funded DLCs based on minimal acceptCollateral
+    // In single funded DLCs, acceptCollateral is typically 0 or very small
+    if (instance.acceptCollateral === BigInt(0)) {
+      instance.singleFunded = true;
+    }
+
     return instance;
   }
 
@@ -317,6 +327,28 @@ export class DlcAccept implements IDlcMessage {
   // Store unknown TLVs for forward compatibility
   public unknownTlvs?: Array<{ type: number; data: Buffer }>;
 
+  /**
+   * Flag to indicate if this is a single funded DLC
+   * In single funded DLCs, the acceptor provides minimal or no collateral
+   */
+  public singleFunded = false;
+
+  /**
+   * Marks this DLC accept as single funded
+   * For single funded DLCs, acceptCollateral is typically 0 or minimal
+   */
+  public markAsSingleFunded(): void {
+    this.singleFunded = true;
+  }
+
+  /**
+   * Checks if this DLC accept is for a single funded DLC
+   * @returns True if this is a single funded DLC
+   */
+  public isSingleFunded(): boolean {
+    return this.singleFunded;
+  }
+
   /**
    * Get funding, change and payout address from DlcAccept
    * @param network Bitcoin Network
@@ -398,8 +430,20 @@ export class DlcAccept implements IDlcMessage {
       const input = fundingInput as FundingInput;
       return acc + input.prevTx.outputs[input.prevTxVout].value.sats;
     }, BigInt(0));
-    if (this.acceptCollateral >= fundingAmount) {
-      throw new Error('fundingAmount must be greater than acceptCollateral');
+
+    if (this.isSingleFunded()) {
+      // For single funded DLCs, acceptor may provide minimal or no collateral
+      // fundingAmount should be >= acceptCollateral (allowing for 0 collateral case)
+      if (this.acceptCollateral > 0 && fundingAmount < this.acceptCollateral) {
+        throw new Error(
+          'For single funded DLCs, fundingAmount must be at least acceptCollateral',
+        );
+      }
+    } else {
+      // For regular DLCs, funding amount must be greater than accept collateral
+      if (this.acceptCollateral >= fundingAmount) {
+        throw new Error('fundingAmount must be greater than acceptCollateral');
+      }
     }
   }
 

package/.yalc/@node-dlc/messaging/lib/messages/DlcClose.ts

@@ -67,6 +67,7 @@ export class DlcClose implements IDlcMessage {
         instance.fundingSignatures.witnessElements = sigData.fundingSignatures.map(
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           (sig: any) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             sig.witnessElements?.map((elem: any) => {
               const witness = new ScriptWitnessV0();
               witness.length =
@@ -80,6 +81,7 @@ export class DlcClose implements IDlcMessage {
         instance.fundingSignatures.witnessElements = sigData.map(
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           (sig: any) =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             sig.witnessElements?.map((elem: any) => {
               const witness = new ScriptWitnessV0();
               witness.length =
@@ -246,7 +248,7 @@ export class DlcClose implements IDlcMessage {
       fundInputSerialId: bigIntToNumber(this.fundInputSerialId),
       fundingInputs: this.fundingInputs.map((input) => input.toJSON()),
       fundingSignatures: this.fundingSignatures.toJSON(),
-    } as any; // Allow different field names from interface
+    }; // Allow different field names from interface
   }
 
   /**
@@ -298,5 +300,6 @@ export interface IDlcCloseJSON {
   fundingInputs: IFundingInputJSON[];
   fundingSignatures: IFundingSignaturesJSON;
   serialized?: string; // Made optional - hex serialization for compatibility testing
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   tlvs?: any[]; // Made optional - for unknown TLVs
 }

package/.yalc/@node-dlc/messaging/lib/messages/DlcCloseMetadata.ts

@@ -1,9 +1,6 @@
 import { Tx } from '@node-dlc/bitcoin';
-import { BufferReader, BufferWriter } from '@node-dlc/bufio';
 
 import { DlcAccept, DlcOffer, DlcTransactions } from '..';
-import { MessageType } from '../MessageType';
-import { IDlcMessage } from './DlcMessage';
 
 /**
  * DlcClose Metadata object contains information required for verifying DlcClose

package/.yalc/@node-dlc/messaging/lib/messages/DlcInput.ts

@@ -0,0 +1,167 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * DlcInput contains information about a DLC input to be used in a funding transaction.
+ * Contains the local and remote funding public keys and the contract ID of the DLC input.
+ * Matches rust-dlc DlcInput struct.
+ */
+export class DlcInput implements IDlcMessage {
+  public static type = MessageType.DlcInput;
+
+  /**
+   * Creates a DlcInput from JSON data
+   * @param json JSON object representing DLC input
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): DlcInput {
+    const instance = new DlcInput();
+
+    // Parse local funding public key
+    const localFundPubkey = json.localFundPubkey || json.local_fund_pubkey;
+    if (typeof localFundPubkey === 'string') {
+      instance.localFundPubkey = Buffer.from(localFundPubkey, 'hex');
+    } else {
+      throw new Error('localFundPubkey is required');
+    }
+
+    // Parse remote funding public key
+    const remoteFundPubkey = json.remoteFundPubkey || json.remote_fund_pubkey;
+    if (typeof remoteFundPubkey === 'string') {
+      instance.remoteFundPubkey = Buffer.from(remoteFundPubkey, 'hex');
+    } else {
+      throw new Error('remoteFundPubkey is required');
+    }
+
+    // Parse contract ID (32 bytes)
+    const contractId = json.contractId || json.contract_id;
+    if (typeof contractId === 'string') {
+      instance.contractId = Buffer.from(contractId, 'hex');
+    } else {
+      throw new Error('contractId is required');
+    }
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a dlc_input message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): DlcInput {
+    const instance = new DlcInput();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+    instance.length = reader.readBigSize();
+
+    // Read local funding public key (33 bytes)
+    instance.localFundPubkey = reader.readBytes(33);
+
+    // Read remote funding public key (33 bytes)
+    instance.remoteFundPubkey = reader.readBytes(33);
+
+    // Read contract ID (32 bytes)
+    instance.contractId = reader.readBytes(32);
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a dlc_input without TLV wrapper (for use in FundingInput)
+   * @param buf
+   */
+  public static deserializeBody(buf: Buffer): DlcInput {
+    const instance = new DlcInput();
+    const reader = new BufferReader(buf);
+
+    // Read local funding public key (33 bytes)
+    instance.localFundPubkey = reader.readBytes(33);
+
+    // Read remote funding public key (33 bytes)
+    instance.remoteFundPubkey = reader.readBytes(33);
+
+    // Read contract ID (32 bytes)
+    instance.contractId = reader.readBytes(32);
+
+    return instance;
+  }
+
+  /**
+   * The type for dlc_input message. dlc_input = 42773
+   */
+  public type = DlcInput.type;
+
+  public length: bigint;
+
+  public localFundPubkey: Buffer;
+
+  public remoteFundPubkey: Buffer;
+
+  public contractId: Buffer;
+
+  /**
+   * Validates correctness of all fields
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    if (!this.localFundPubkey) {
+      throw new Error('localFundPubkey is required');
+    }
+    if (!this.remoteFundPubkey) {
+      throw new Error('remoteFundPubkey is required');
+    }
+    if (!this.contractId || this.contractId.length !== 32) {
+      throw new Error('contractId must be a 32-byte buffer');
+    }
+  }
+
+  /**
+   * Converts dlc_input to JSON
+   */
+  public toJSON(): IDlcInputJSON {
+    return {
+      localFundPubkey: this.localFundPubkey.toString('hex'),
+      remoteFundPubkey: this.remoteFundPubkey.toString('hex'),
+      contractId: this.contractId.toString('hex'),
+    };
+  }
+
+  /**
+   * Serializes the dlc_input message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeBytes(this.localFundPubkey);
+    dataWriter.writeBytes(this.remoteFundPubkey);
+    dataWriter.writeBytes(this.contractId);
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+
+  /**
+   * Serializes dlc_input body without TLV wrapper (for embedding in FundingInput)
+   */
+  public serializeBody(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBytes(this.localFundPubkey);
+    writer.writeBytes(this.remoteFundPubkey);
+    writer.writeBytes(this.contractId);
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IDlcInputJSON {
+  localFundPubkey: string;
+  remoteFundPubkey: string;
+  contractId: string;
+}

package/.yalc/@node-dlc/messaging/lib/messages/DlcOffer.ts

@@ -207,7 +207,7 @@ export class DlcOffer implements IDlcMessage {
         case MessageType.OrderIrcInfoV0:
           instance.ircInfo = OrderIrcInfoV0.deserialize(buf);
           break;
-        case MessageType.OrderPositionInfoV0:
+        case MessageType.OrderPositionInfo:
           instance.positionInfo = OrderPositionInfo.deserialize(buf);
           break;
         case MessageType.BatchFundingGroup:
@@ -226,6 +226,13 @@ export class DlcOffer implements IDlcMessage {
       }
     }
 
+    // Auto-detect single funded DLCs
+    if (
+      instance.contractInfo.getTotalCollateral() === instance.offerCollateral
+    ) {
+      instance.singleFunded = true;
+    }
+
     return instance;
   }
 
@@ -279,6 +286,37 @@ export class DlcOffer implements IDlcMessage {
   // Store unknown TLVs for forward compatibility
   public unknownTlvs?: Array<{ type: number; data: Buffer }>;
 
+  /**
+   * Flag to indicate if this is a single funded DLC
+   * In single funded DLCs, totalCollateral equals offerCollateral
+   */
+  public singleFunded = false;
+
+  /**
+   * Marks this DLC offer as single funded and validates that collateral amounts are correct
+   * @throws Will throw an error if totalCollateral doesn't equal offerCollateral
+   */
+  public markAsSingleFunded(): void {
+    const totalCollateral = this.contractInfo.getTotalCollateral();
+    if (totalCollateral !== this.offerCollateral) {
+      throw new Error(
+        `Cannot mark as single funded: totalCollateral (${totalCollateral}) must equal offerCollateral (${this.offerCollateral})`,
+      );
+    }
+    this.singleFunded = true;
+  }
+
+  /**
+   * Checks if this DLC offer is single funded (totalCollateral == offerCollateral)
+   * @returns True if this is a single funded DLC
+   */
+  public isSingleFunded(): boolean {
+    return (
+      this.singleFunded ||
+      this.contractInfo.getTotalCollateral() === this.offerCollateral
+    );
+  }
+
   /**
    * Get funding, change and payout address from DlcOffer
    * @param network Bitcoin Network
@@ -400,8 +438,19 @@ export class DlcOffer implements IDlcMessage {
     this.contractInfo.validate();
 
     // totalCollateral should be > offerCollateral (logical validation)
-    if (this.contractInfo.getTotalCollateral() <= this.offerCollateral) {
-      throw new Error('totalCollateral should be greater than offerCollateral');
+    // Exception: for single funded DLCs, totalCollateral == offerCollateral is allowed
+    if (this.isSingleFunded()) {
+      if (this.contractInfo.getTotalCollateral() !== this.offerCollateral) {
+        throw new Error(
+          'For single funded DLCs, totalCollateral must equal offerCollateral',
+        );
+      }
+    } else {
+      if (this.contractInfo.getTotalCollateral() <= this.offerCollateral) {
+        throw new Error(
+          'totalCollateral should be greater than offerCollateral',
+        );
+      }
     }
 
     // validate funding amount
@@ -409,8 +458,19 @@ export class DlcOffer implements IDlcMessage {
       const input = fundingInput as FundingInput;
       return acc + input.prevTx.outputs[input.prevTxVout].value.sats;
     }, BigInt(0));
-    if (this.offerCollateral >= fundingAmount) {
-      throw new Error('fundingAmount must be greater than offerCollateral');
+
+    if (this.isSingleFunded()) {
+      // For single funded DLCs, funding amount must cover the full total collateral plus fees
+      if (fundingAmount < this.contractInfo.getTotalCollateral()) {
+        throw new Error(
+          'For single funded DLCs, fundingAmount must be at least totalCollateral',
+        );
+      }
+    } else {
+      // For regular DLCs, funding amount must be greater than offer collateral
+      if (this.offerCollateral >= fundingAmount) {
+        throw new Error('fundingAmount must be greater than offerCollateral');
+      }
     }
   }
 
@@ -453,7 +513,7 @@ export class DlcOffer implements IDlcMessage {
       feeRatePerVb: bigIntToNumber(this.feeRatePerVb),
       cetLocktime: this.cetLocktime,
       refundLocktime: this.refundLocktime,
-    } as any; // Allow different field names from interface
+    }; // Allow different field names from interface
   }
 
   /**
@@ -537,7 +597,7 @@ export interface IDlcOfferJSON {
     | IOrderIrcInfoJSON
     | IOrderPositionInfoJSON
     | IBatchFundingGroupJSON
-    | any
+    | unknown
   )[]; // Made optional - for unknown TLVs
 }
 

package/.yalc/@node-dlc/messaging/lib/messages/DlcSign.ts

@@ -79,6 +79,7 @@ export class DlcSign implements IDlcMessage {
    * @param cetSigsJson JSON object representing CET adaptor signatures
    */
   private static parseCetAdaptorSignaturesFromJSON(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     cetSigsJson: any,
   ): CetAdaptorSignatures {
     const instance = new CetAdaptorSignatures();
@@ -90,6 +91,7 @@ export class DlcSign implements IDlcMessage {
       const ecdsaSigs =
         cetSigsJson.ecdsaAdaptorSignatures ||
         cetSigsJson.ecdsa_adaptor_signatures;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       instance.sigs = ecdsaSigs.map((sig: any) => {
         // The test vectors use 'signature' field, but our internal format uses encryptedSig/dleqProof
         // For now, we'll parse the signature as encryptedSig and leave dleqProof empty
@@ -110,6 +112,7 @@ export class DlcSign implements IDlcMessage {
    * @param fundingSigsJson JSON object representing funding signatures
    */
   private static parseFundingSignaturesFromJSON(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     fundingSigsJson: any,
   ): FundingSignatures {
     const instance = new FundingSignatures();
@@ -120,8 +123,10 @@ export class DlcSign implements IDlcMessage {
     ) {
       const fundingSigs =
         fundingSigsJson.fundingSignatures || fundingSigsJson.funding_signatures;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       instance.witnessElements = fundingSigs.map((sig: any) =>
         (sig.witnessElements || sig.witness_elements || []).map(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
           (element: any) => {
             // Create a ScriptWitnessV0 instance for each witness element
             const witness = new ScriptWitnessV0();

package/.yalc/@node-dlc/messaging/lib/messages/EventDescriptor.ts

@@ -27,6 +27,7 @@ export abstract class EventDescriptor {
    * Creates an EventDescriptor from JSON data
    * @param json JSON object representing event descriptor
    */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
   public static fromJSON(json: any): EventDescriptor {
     if (!json) {
       throw new Error('eventDescriptor is required');
@@ -70,6 +71,7 @@ export class EnumEventDescriptor
    * Creates an EnumEventDescriptor from JSON data
    * @param json JSON object representing an enum event descriptor
    */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
   public static fromJSON(json: any): EnumEventDescriptor {
     const instance = new EnumEventDescriptor();
     instance.outcomes = json.outcomes || [];
@@ -156,6 +158,7 @@ export class DigitDecompositionEventDescriptor
    * Creates a DigitDecompositionEventDescriptor from JSON data
    * @param json JSON object representing digit decomposition event descriptor
    */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
   public static fromJSON(json: any): DigitDecompositionEventDescriptor {
     const instance = new DigitDecompositionEventDescriptor();
     instance.base = json.base || 10;
@@ -238,7 +241,7 @@ export class DigitDecompositionEventDescriptor
         precision: this.precision,
         nbDigits: this.nbDigits,
       },
-    } as any;
+    };
   }
 
   /**
@@ -273,13 +276,15 @@ export interface IEnumEventDescriptorJSON {
   };
 }
 
+// Rust-dlc enum variant format for DigitDecompositionEventDescriptor
 export interface IDigitDecompositionEventDescriptorJSON {
-  type: number;
-  base: number;
-  isSigned: boolean;
-  unit: string;
-  precision: number;
-  nbDigits: number;
+  digitDecompositionEvent: {
+    base: number;
+    isSigned: boolean;
+    unit: string;
+    precision: number;
+    nbDigits: number;
+  };
 }
 
 // Legacy interface

package/.yalc/@node-dlc/messaging/lib/messages/FundingInput.ts

@@ -3,6 +3,7 @@ import { BufferReader, BufferWriter, StreamReader } from '@node-dlc/bufio';
 
 import { MessageType } from '../MessageType';
 import { bigIntToNumber, toBigInt } from '../util';
+import { DlcInput } from './DlcInput';
 import { IDlcMessage } from './DlcMessage';
 
 /**
@@ -54,6 +55,12 @@ export class FundingInput implements IDlcMessage {
     const redeemScript = json.redeemScript || json.redeem_script || '';
     instance.redeemScript = Buffer.from(redeemScript, 'hex');
 
+    // Parse optional DLC input
+    const dlcInput = json.dlcInput || json.dlc_input;
+    if (dlcInput) {
+      instance.dlcInput = DlcInput.fromJSON(dlcInput);
+    }
+
     return instance;
   }
 
@@ -78,6 +85,14 @@ export class FundingInput implements IDlcMessage {
     const redeemScriptLen = reader.readUInt16BE();
     instance.redeemScript = reader.readBytes(redeemScriptLen);
 
+    // Read optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    if (reader.position < reader.buffer.length) {
+      const dlcInputData = reader.readOptional();
+      if (dlcInputData) {
+        instance.dlcInput = DlcInput.deserializeBody(dlcInputData);
+      }
+    }
+
     return instance;
   }
 
@@ -107,6 +122,14 @@ export class FundingInput implements IDlcMessage {
     const redeemScriptLen = reader.readUInt16BE();
     instance.redeemScript = reader.readBytes(redeemScriptLen);
 
+    // Read optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    if (reader.position < reader.buffer.length) {
+      const dlcInputData = reader.readOptional();
+      if (dlcInputData) {
+        instance.dlcInput = DlcInput.deserializeBody(dlcInputData);
+      }
+    }
+
     return instance;
   }
 
@@ -129,6 +152,8 @@ export class FundingInput implements IDlcMessage {
 
   public redeemScript: Buffer;
 
+  public dlcInput?: DlcInput;
+
   public scriptSigLength(): number {
     if (this.redeemScript.length > 0) {
       return 1 + this.redeemScript.length;
@@ -151,7 +176,7 @@ export class FundingInput implements IDlcMessage {
    * Converts funding_input to JSON (canonical rust-dlc format)
    */
   public toJSON(): IFundingInputJSON {
-    return {
+    const result: IFundingInputJSON = {
       inputSerialId: bigIntToNumber(this.inputSerialId),
       prevTx: this.prevTx.serialize().toString('hex'),
       prevTxVout: this.prevTxVout,
@@ -159,6 +184,12 @@ export class FundingInput implements IDlcMessage {
       maxWitnessLen: this.maxWitnessLen,
       redeemScript: this.redeemScript.toString('hex'),
     };
+
+    if (this.dlcInput) {
+      result.dlcInput = this.dlcInput.toJSON();
+    }
+
+    return result;
   }
 
   /**
@@ -178,6 +209,10 @@ export class FundingInput implements IDlcMessage {
     dataWriter.writeUInt16BE(this.redeemScript.length);
     dataWriter.writeBytes(this.redeemScript);
 
+    // Write optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    const dlcInputData = this.dlcInput ? this.dlcInput.serializeBody() : null;
+    dataWriter.writeOptional(dlcInputData);
+
     writer.writeBigSize(dataWriter.size);
     writer.writeBytes(dataWriter.toBuffer());
 
@@ -202,6 +237,10 @@ export class FundingInput implements IDlcMessage {
     writer.writeUInt16BE(this.redeemScript.length);
     writer.writeBytes(this.redeemScript);
 
+    // Write optional DLC input using rust-dlc Optional format (0x00/0x01 prefix)
+    const dlcInputData = this.dlcInput ? this.dlcInput.serializeBody() : null;
+    writer.writeOptional(dlcInputData);
+
     return writer.toBuffer();
   }
 }
@@ -213,4 +252,9 @@ export interface IFundingInputJSON {
   sequence: number;
   maxWitnessLen: number;
   redeemScript: string;
+  dlcInput?: {
+    localFundPubkey: string;
+    remoteFundPubkey: string;
+    contractId: string;
+  };
 }