@atomicfinance/bitcoin-dlc-provider 3.6.0 → 4.0.0

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

@@ -0,0 +1,354 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+import secp256k1 from 'secp256k1';
+
+import { MessageType, PROTOCOL_VERSION } from '../MessageType';
+import { deserializeTlv } from '../serialize/deserializeTlv';
+import { getTlv } from '../serialize/getTlv';
+import { BatchFundingGroup } from './BatchFundingGroup';
+import {
+  CetAdaptorSignatures,
+  ICetAdaptorSignaturesJSON,
+} from './CetAdaptorSignatures';
+import { IDlcMessage } from './DlcMessage';
+import { FundingSignatures, IFundingSignaturesJSON } from './FundingSignatures';
+import { ScriptWitnessV0 } from './ScriptWitnessV0';
+
+/**
+ * DlcSign gives all of the initiator's signatures, which allows the
+ * receiver to broadcast the funding transaction with both parties being
+ * fully committed to all closing transactions.
+ * Updated to support dlcspecs PR #163 format.
+ */
+export class DlcSign implements IDlcMessage {
+  public static type = MessageType.DlcSign;
+
+  /**
+   * Creates a DlcSign from JSON data (e.g., from test vectors)
+   * Handles both our internal format and external test vector formats
+   * @param json JSON object representing a DLC sign
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): DlcSign {
+    const instance = new DlcSign();
+
+    // Helper function to parse DER-encoded signature and extract raw r,s values (64 bytes total)
+    const parseDerSignature = (hexSig: string): Buffer => {
+      const sigBuffer = Buffer.from(hexSig, 'hex');
+
+      // If it's already 64 bytes, assume it's raw
+      if (sigBuffer.length === 64) {
+        return sigBuffer;
+      }
+
+      // Use secp256k1.signatureImport to parse DER signature
+      try {
+        const rawSig = secp256k1.signatureImport(sigBuffer);
+        return Buffer.from(rawSig);
+      } catch (ex) {
+        throw new Error(`Invalid DER signature: ${ex.message}`);
+      }
+    };
+
+    // Handle both internal and external field naming conventions
+    instance.protocolVersion =
+      json.protocolVersion || json.protocol_version || PROTOCOL_VERSION;
+    instance.contractId = Buffer.from(
+      json.contractId || json.contract_id,
+      'hex',
+    );
+
+    // Parse CET adaptor signatures
+    instance.cetAdaptorSignatures = DlcSign.parseCetAdaptorSignaturesFromJSON(
+      json.cetAdaptorSignatures || json.cet_adaptor_signatures,
+    );
+
+    // Parse refund signature - handle DER encoding
+    const refundSigHex = json.refundSignature || json.refund_signature;
+    instance.refundSignature = parseDerSignature(refundSigHex);
+
+    // Parse funding signatures
+    instance.fundingSignatures = DlcSign.parseFundingSignaturesFromJSON(
+      json.fundingSignatures || json.funding_signatures,
+    );
+
+    return instance;
+  }
+
+  /**
+   * Parses CetAdaptorSignatures from JSON
+   * @param cetSigsJson JSON object representing CET adaptor signatures
+   */
+  private static parseCetAdaptorSignaturesFromJSON(
+    cetSigsJson: any,
+  ): CetAdaptorSignatures {
+    const instance = new CetAdaptorSignatures();
+
+    if (
+      cetSigsJson.ecdsaAdaptorSignatures ||
+      cetSigsJson.ecdsa_adaptor_signatures
+    ) {
+      const ecdsaSigs =
+        cetSigsJson.ecdsaAdaptorSignatures ||
+        cetSigsJson.ecdsa_adaptor_signatures;
+      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
+        const sigBuffer = Buffer.from(sig.signature, 'hex');
+        return {
+          encryptedSig: sigBuffer.slice(0, 65), // First 65 bytes
+          dleqProof:
+            sigBuffer.length > 65 ? sigBuffer.slice(65, 162) : Buffer.alloc(97), // Next 97 bytes or empty
+        };
+      });
+    }
+
+    return instance;
+  }
+
+  /**
+   * Parses FundingSignatures from JSON
+   * @param fundingSigsJson JSON object representing funding signatures
+   */
+  private static parseFundingSignaturesFromJSON(
+    fundingSigsJson: any,
+  ): FundingSignatures {
+    const instance = new FundingSignatures();
+
+    if (
+      fundingSigsJson.fundingSignatures ||
+      fundingSigsJson.funding_signatures
+    ) {
+      const fundingSigs =
+        fundingSigsJson.fundingSignatures || fundingSigsJson.funding_signatures;
+      instance.witnessElements = fundingSigs.map((sig: any) =>
+        (sig.witnessElements || sig.witness_elements || []).map(
+          (element: any) => {
+            // Create a ScriptWitnessV0 instance for each witness element
+            const witness = new ScriptWitnessV0();
+            witness.witness = Buffer.from(element.witness || element, 'hex');
+            return witness;
+          },
+        ),
+      );
+    }
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a sign_dlc message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): DlcSign {
+    const instance = new DlcSign();
+    const reader = new BufferReader(buf);
+
+    reader.readUInt16BE(); // read type
+
+    // New fields as per dlcspecs PR #163
+    instance.protocolVersion = reader.readUInt32BE();
+    instance.contractId = reader.readBytes(32);
+
+    // Read CET adaptor signatures directly to match serialize format (no TLV wrapping)
+    instance.cetAdaptorSignatures = CetAdaptorSignatures.deserialize(
+      reader.buffer.subarray(reader.position),
+    );
+
+    // Skip past the CET adaptor signatures we just read
+    const cetLength = instance.cetAdaptorSignatures.serialize().length;
+    reader.position += cetLength;
+
+    instance.refundSignature = reader.readBytes(64);
+
+    // Read funding signatures directly to match serialize format (no TLV wrapping)
+    instance.fundingSignatures = FundingSignatures.deserialize(
+      reader.buffer.subarray(reader.position),
+    );
+
+    // Skip past the funding signatures we just read
+    const fundingLength = instance.fundingSignatures.serialize().length;
+    reader.position += fundingLength;
+
+    // Parse TLV stream as per dlcspecs PR #163
+    while (!reader.eof) {
+      const buf = getTlv(reader);
+      const tlvReader = new BufferReader(buf);
+      const { type } = deserializeTlv(tlvReader);
+
+      switch (Number(type)) {
+        case MessageType.BatchFundingGroup:
+          if (!instance.batchFundingGroups) {
+            instance.batchFundingGroups = [];
+          }
+          instance.batchFundingGroups.push(BatchFundingGroup.deserialize(buf));
+          break;
+        default:
+          // Store unknown TLVs for future compatibility
+          if (!instance.unknownTlvs) {
+            instance.unknownTlvs = [];
+          }
+          instance.unknownTlvs.push({ type: Number(type), data: buf });
+          break;
+      }
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for sign_dlc message. sign_dlc = 42782
+   */
+  public type = DlcSign.type;
+
+  // New fields as per dlcspecs PR #163
+  public protocolVersion: number = PROTOCOL_VERSION; // Default to current protocol version
+
+  // Existing fields
+  public contractId: Buffer;
+
+  public cetAdaptorSignatures: CetAdaptorSignatures;
+
+  public refundSignature: Buffer;
+
+  public fundingSignatures: FundingSignatures;
+
+  public batchFundingGroups?: BatchFundingGroup[];
+
+  // Store unknown TLVs for forward compatibility
+  public unknownTlvs?: Array<{ type: number; data: Buffer }>;
+
+  /**
+   * Validates correctness of all fields
+   * Updated validation rules as per dlcspecs PR #163
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    // 1. Type is set automatically in class
+    // 2. protocol_version validation
+    if (this.protocolVersion !== PROTOCOL_VERSION) {
+      throw new Error(
+        `Unsupported protocol version: ${this.protocolVersion}, expected: ${PROTOCOL_VERSION}`,
+      );
+    }
+
+    // 3. contract_id must be 32 bytes
+    if (!this.contractId || this.contractId.length !== 32) {
+      throw new Error('contractId must be 32 bytes');
+    }
+
+    // 4. Other validations would depend on specific business logic
+    // TODO: Add more specific validation rules as needed
+  }
+
+  /**
+   * Converts sign_dlc to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): IDlcSignJSON {
+    // Convert raw signature back to DER format for canonical rust-dlc JSON
+    const derRefundSignature = secp256k1.signatureExport(this.refundSignature);
+
+    return {
+      protocolVersion: this.protocolVersion,
+      contractId: this.contractId.toString('hex'),
+      cetAdaptorSignatures: this.cetAdaptorSignatures.toJSON(),
+      refundSignature: Buffer.from(derRefundSignature).toString('hex'),
+      fundingSignatures: this.fundingSignatures.toJSON(),
+    };
+  }
+
+  /**
+   * Serializes the sign_dlc message into a Buffer
+   * Updated serialization format as per dlcspecs PR #163
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeUInt16BE(this.type);
+
+    // New fields as per dlcspecs PR #163
+    writer.writeUInt32BE(this.protocolVersion);
+    writer.writeBytes(this.contractId);
+    writer.writeBytes(this.cetAdaptorSignatures.serialize());
+    writer.writeBytes(this.refundSignature);
+    writer.writeBytes(this.fundingSignatures.serialize());
+
+    // TLV stream as per dlcspecs PR #163
+    if (this.batchFundingGroups)
+      this.batchFundingGroups.forEach((fundingInfo) =>
+        writer.writeBytes(fundingInfo.serialize()),
+      );
+
+    // Write unknown TLVs for forward compatibility
+    if (this.unknownTlvs) {
+      this.unknownTlvs.forEach((tlv) => {
+        writer.writeBytes(tlv.data);
+      });
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IDlcSignJSON {
+  protocolVersion: number;
+  contractId: string;
+  cetAdaptorSignatures: ICetAdaptorSignaturesJSON;
+  refundSignature: string;
+  fundingSignatures: IFundingSignaturesJSON;
+}
+
+export class DlcSignContainer {
+  private signs: DlcSign[] = [];
+
+  /**
+   * Adds a DlcSign to the container.
+   * @param sign The DlcSign to add.
+   */
+  public addSign(sign: DlcSign): void {
+    this.signs.push(sign);
+  }
+
+  /**
+   * Returns all DlcSigns in the container.
+   * @returns An array of DlcSign instances.
+   */
+  public getSigns(): DlcSign[] {
+    return this.signs;
+  }
+
+  /**
+   * Serializes all DlcSigns in the container to a Buffer.
+   * @returns A Buffer containing the serialized DlcSigns.
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    // Write the number of signs in the container first.
+    writer.writeBigSize(this.signs.length);
+    // Serialize each sign and write it.
+    this.signs.forEach((sign) => {
+      const serializedSign = sign.serialize();
+      // Optionally, write the length of the serialized sign for easier deserialization.
+      writer.writeBigSize(serializedSign.length);
+      writer.writeBytes(serializedSign);
+    });
+    return writer.toBuffer();
+  }
+
+  /**
+   * Deserializes a Buffer into a DlcSignContainer with DlcSigns.
+   * @param buf The Buffer to deserialize.
+   * @returns A DlcSignContainer instance.
+   */
+  public static deserialize(buf: Buffer): DlcSignContainer {
+    const reader = new BufferReader(buf);
+    const container = new DlcSignContainer();
+    const signsCount = reader.readBigSize();
+    for (let i = 0; i < signsCount; i++) {
+      // Optionally, read the length of the serialized sign if it was written during serialization.
+      const signLength = reader.readBigSize();
+      const signBuf = reader.readBytes(Number(signLength));
+      const sign = DlcSign.deserialize(signBuf);
+      container.addSign(sign);
+    }
+    return container;
+  }
+}

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

@@ -0,0 +1,213 @@
+import { Tx } from '@node-dlc/bitcoin';
+import { BufferReader, BufferWriter, StreamReader } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * DlcTransactions message contains information about state of DLC
+ * contract such as fundtx and closetx
+ */
+export class DlcTransactions implements IDlcMessage {
+  public static type = MessageType.DlcTransactions;
+
+  /**
+   * Deserializes a dlc_transactions message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer, parseCets = true): DlcTransactions {
+    const instance = new DlcTransactions();
+    const reader = new BufferReader(buf);
+
+    reader.readUInt16BE(); // read type
+
+    instance.contractId = reader.readBytes(32);
+
+    const fundTxLen = reader.readUInt16BE();
+    instance.fundTx = Tx.decode(
+      StreamReader.fromBuffer(reader.readBytes(fundTxLen)),
+    );
+
+    instance.fundTxVout = reader.readUInt32BE();
+
+    const fundHash = reader.readBytes(32);
+    const fundHeight = reader.readUInt32BE();
+    instance.fundEpoch = {
+      hash: fundHash,
+      height: fundHeight,
+    };
+
+    instance.fundBroadcastHeight = reader.readUInt32BE();
+
+    const refundTxLen = reader.readUInt16BE();
+    instance.refundTx = Tx.decode(
+      StreamReader.fromBuffer(reader.readBytes(refundTxLen)),
+    );
+
+    const numCets = reader.readBigSize(); // num_cets
+    for (let i = 0; i < numCets; i++) {
+      const cetLen = reader.readUInt16BE();
+      if (parseCets || i === 0) {
+        instance.cets.push(
+          Tx.decode(StreamReader.fromBuffer(reader.readBytes(cetLen))),
+        );
+      } else {
+        reader.readBytes(cetLen);
+      }
+    }
+
+    const closeHash = reader.readBytes(32);
+    const closeHeight = reader.readUInt32BE();
+    instance.closeEpoch = {
+      hash: closeHash,
+      height: closeHeight,
+    };
+
+    instance.closeTxHash = reader.readBytes(32);
+
+    instance.closeType = reader.readUInt8();
+
+    instance.closeBroadcastHeight = reader.readUInt32BE();
+
+    return instance;
+  }
+
+  /**
+   * The type for dlc_transactions message. dlc_transactions = 61230
+   */
+  public type = DlcTransactions.type;
+
+  public contractId: Buffer;
+
+  public fundTx: Tx;
+
+  public fundTxVout: number;
+
+  public fundEpoch: BlockEpoch = {
+    hash: Buffer.alloc(32),
+    height: 0,
+  };
+
+  public fundBroadcastHeight = 0;
+
+  public refundTx: Tx;
+
+  public cets: Tx[] = [];
+
+  public closeEpoch: BlockEpoch = {
+    hash: Buffer.alloc(32),
+    height: 0,
+  };
+
+  public closeTxHash: Buffer = Buffer.alloc(32);
+
+  public closeType: CloseType = 0;
+
+  public closeBroadcastHeight = 0;
+
+  /**
+   * Converts dlc_transactions to JSON
+   */
+  public toJSON(): IDlcTransactionsJSON {
+    return {
+      type: this.type,
+      contractId: this.contractId.toString('hex'),
+      fundTx: this.fundTx.serialize().toString('hex'),
+      fundTxVout: this.fundTxVout,
+      fundEpoch: {
+        hash: this.fundEpoch.hash.toString('hex'),
+        height: this.fundEpoch.height,
+      },
+      fundBroadcastHeight: this.fundBroadcastHeight,
+      refundTx: this.refundTx.serialize().toString('hex'),
+      cets: this.cets.map((cet) => cet.serialize().toString('hex')),
+      closeEpoch: {
+        hash: this.closeEpoch.hash.toString('hex'),
+        height: this.closeEpoch.height,
+      },
+      closeTxHash: this.closeTxHash.toString('hex'),
+      closeType: closeTypeToStr(this.closeType),
+      closeBroadcastHeight: this.closeBroadcastHeight,
+    };
+  }
+
+  /**
+   * Serializes the dlc_transactions message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeUInt16BE(this.type);
+    writer.writeBytes(this.contractId);
+    writer.writeUInt16BE(this.fundTx.serialize().length);
+    writer.writeBytes(this.fundTx.serialize());
+    writer.writeUInt32BE(this.fundTxVout);
+    writer.writeBytes(this.fundEpoch.hash);
+    writer.writeUInt32BE(this.fundEpoch.height);
+    writer.writeUInt32BE(this.fundBroadcastHeight);
+    writer.writeUInt16BE(this.refundTx.serialize().length);
+    writer.writeBytes(this.refundTx.serialize());
+
+    writer.writeBigSize(this.cets.length);
+    for (const cet of this.cets) {
+      writer.writeUInt16BE(cet.serialize().length);
+      writer.writeBytes(cet.serialize());
+    }
+
+    writer.writeBytes(this.closeEpoch.hash);
+    writer.writeUInt32BE(this.closeEpoch.height);
+    writer.writeBytes(this.closeTxHash);
+    writer.writeUInt8(this.closeType);
+    writer.writeUInt32BE(this.closeBroadcastHeight);
+
+    return writer.toBuffer();
+  }
+}
+
+const closeTypeToStr = (closeType: CloseType): string => {
+  switch (closeType) {
+    case CloseType.ExecuteClose:
+      return 'ExecuteClose';
+    case CloseType.RefundClose:
+      return 'RefundClose';
+    case CloseType.CooperativeClose:
+      return 'CooperativeClose';
+    default:
+      return 'NotClosed';
+  }
+};
+
+export interface IDlcTransactionsJSON {
+  type: number;
+  contractId: string;
+  fundTx: string;
+  fundTxVout: number;
+  fundEpoch: IBlockEpochJSON;
+  fundBroadcastHeight: number;
+  refundTx: string;
+  cets: string[];
+  closeEpoch: IBlockEpochJSON;
+  closeTxHash: string;
+  closeType: string;
+  closeBroadcastHeight: number;
+}
+
+export interface IBlockEpochJSON {
+  hash: string;
+  height: number;
+}
+
+export interface BlockEpoch {
+  hash: Buffer;
+  height: number;
+}
+
+export enum CloseType {
+  NotClosed = 0,
+  ExecuteClose = 1,
+  RefundClose = 2,
+  CooperativeClose = 3,
+}
+
+// Backward compatibility aliases
+export const DlcTransactionsV0 = DlcTransactions;
+export type IDlcTransactionsV0JSON = IDlcTransactionsJSON;