@atomicfinance/types 3.6.0 → 4.0.0

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

@@ -0,0 +1,74 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+import { BitcoinNetwork } from 'bitcoin-networks';
+import { address } from 'bitcoinjs-lib';
+
+import { MessageType } from '../MessageType';
+
+export class AddressCache {
+  public static type = MessageType.AddressCache;
+
+  public static fromAddressCache(
+    addressesBlacklist: IAddressCache[],
+    network: BitcoinNetwork,
+  ): AddressCache {
+    const instance = new AddressCache();
+
+    for (const blacklistAddress of Object.keys(addressesBlacklist)) {
+      instance.cacheSPKs.push(
+        address.toOutputScript(blacklistAddress, network),
+      );
+    }
+
+    return instance;
+  }
+
+  public static deserialize(buf: Buffer): AddressCache {
+    const instance = new AddressCache();
+    const reader = new BufferReader(buf);
+
+    reader.readUInt16BE(); // read type
+    reader.readBigSize(); // num_cache_spks
+
+    while (!reader.eof) {
+      const cacheSPKLen = reader.readBigSize();
+      const cacheSPK = reader.readBytes(Number(cacheSPKLen));
+
+      instance.cacheSPKs.push(cacheSPK);
+    }
+
+    return instance;
+  }
+
+  public type = AddressCache.type;
+
+  public cacheSPKs: Buffer[] = [];
+
+  public toAddressCache(network: BitcoinNetwork): IAddressCache[] {
+    const addressCache: IAddressCache[] = [];
+
+    for (const cacheSPK of this.cacheSPKs) {
+      addressCache[address.fromOutputScript(cacheSPK, network)] = true;
+    }
+
+    return addressCache;
+  }
+
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeUInt16BE(this.type);
+
+    writer.writeBigSize(this.cacheSPKs.length);
+
+    for (const cacheSPK of this.cacheSPKs) {
+      writer.writeBigSize(cacheSPK.length);
+      writer.writeBytes(cacheSPK);
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IAddressCache {
+  [x: string]: boolean;
+}

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

@@ -0,0 +1,141 @@
+import { Value } from '@node-dlc/bitcoin';
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * The BatchFundingGroup TLV contains information about the intent to
+ * enter multiple DLCs simulatenously within one batch dlc funding
+ * transaction in the contract negotiation stage of the peer protocol
+ *
+ * This is the first step toward creating a batch dlc funding transaction
+ *
+ * A DlcOffer or DlcAccept can contain one or multiple BatchFundingInfo
+ * TLVs to specify one or more groupings. This allows specification of
+ * collateral put towards different types of contracts, such as options
+ * contracts, futures contracts, or other investment types.
+ *
+ * Attributes:
+ * - tempContractIds: Temporary identifiers for contracts proposed in DlcOffers.
+ * - contractIds: Identifiers for contracts that have been accepted and are
+ *   part of the funding transaction. These are derived from DlcOffers and DlcAccepts.
+ * - allocatedCollateral: The amount of collateral allocated to the contracts
+ *   within this group. This is specified early in the negotiation process.
+ * - eventIds: Oracle event identifiers for the contracts in this group. These
+ *   are also specified early in the negotiation process.
+ *
+ * Note: During the early stages of the negotiation protocol, only allocatedCollateral
+ * and eventIds are specified. tempContractIds and contractIds are added to the
+ * DlcAccept upon creation.
+ */
+export class BatchFundingGroup implements IDlcMessage {
+  public static type = MessageType.BatchFundingGroup;
+
+  /**
+   * Deserializes a batch_contract_info message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): BatchFundingGroup {
+    const instance = new BatchFundingGroup();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+    instance.length = reader.readBigSize();
+
+    const tempContractIdsCount = reader.readBigSize();
+    for (let i = 0; i < Number(tempContractIdsCount); i++) {
+      const length = reader.readBigSize();
+      instance.tempContractIds.push(reader.readBytes(Number(length)));
+    }
+
+    const contractIdsCount = reader.readBigSize();
+    for (let i = 0; i < Number(contractIdsCount); i++) {
+      const length = reader.readBigSize();
+      instance.contractIds.push(reader.readBytes(Number(length)));
+    }
+
+    instance.allocatedCollateral = Value.fromSats(reader.readUInt64BE());
+
+    const eventIdsCount = reader.readBigSize();
+    for (let i = 0; i < Number(eventIdsCount); i++) {
+      const eventIdLength = reader.readBigSize();
+      const eventIdBuf = reader.readBytes(Number(eventIdLength));
+      instance.eventIds.push(eventIdBuf.toString());
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for batch_contract_info message.
+   */
+  public type = BatchFundingGroup.type;
+
+  public length: bigint;
+
+  public tempContractIds: Buffer[] = [];
+
+  public contractIds: Buffer[] = [];
+
+  public allocatedCollateral: Value;
+
+  public eventIds: string[] = [];
+
+  /**
+   * Converts batch_funding_info to JSON
+   */
+  public toJSON(): IBatchFundingGroupJSON {
+    return {
+      type: this.type,
+      tempContractIds: this.tempContractIds.map((id) => id.toString('hex')),
+      contractIds: this.contractIds.map((id) => id.toString('hex')),
+      totalCollateral: Number(this.allocatedCollateral.sats),
+      eventIds: this.eventIds,
+    };
+  }
+
+  /**
+   * Serializes the batch_funding_info message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+
+    dataWriter.writeBigSize(this.tempContractIds.length);
+    this.tempContractIds.forEach((id) => {
+      dataWriter.writeBigSize(id.length);
+      dataWriter.writeBytes(id);
+    });
+
+    dataWriter.writeBigSize(this.contractIds.length);
+    this.contractIds.forEach((id) => {
+      dataWriter.writeBigSize(id.length);
+      dataWriter.writeBytes(id);
+    });
+
+    dataWriter.writeUInt64BE(this.allocatedCollateral.sats);
+
+    dataWriter.writeBigSize(this.eventIds.length);
+    this.eventIds.forEach((id) => {
+      const idBuffer = Buffer.from(id);
+      dataWriter.writeBigSize(id.length);
+      dataWriter.writeBytes(idBuffer);
+    });
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}
+
+export interface IBatchFundingGroupJSON {
+  type: number;
+  tempContractIds: string[];
+  contractIds: string[];
+  totalCollateral: number;
+  eventIds: string[];
+}

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

@@ -0,0 +1,89 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+
+/**
+ * CetAdaptorSignatures contains CET signatures and any necessary
+ * information linking the signatures to their corresponding outcome
+ */
+export class CetAdaptorSignatures implements IDlcMessage {
+  public static type = MessageType.CetAdaptorSignatures;
+
+  /**
+   * Deserializes a cet_adaptor_signature message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): CetAdaptorSignatures {
+    const instance = new CetAdaptorSignatures();
+    const reader = new BufferReader(buf);
+
+    const nbSignatures = Number(reader.readBigSize()); // nb_signatures
+
+    // Read exactly nbSignatures * (65 + 97) bytes to match serialize format
+    for (let i = 0; i < nbSignatures; i++) {
+      const encryptedSig = reader.readBytes(65);
+      const dleqProof = reader.readBytes(97);
+      instance.sigs.push({ encryptedSig, dleqProof });
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for cet_adaptor_signature message. cet_adaptor_signature = 42774
+   */
+  public type = CetAdaptorSignatures.type;
+
+  public length: bigint;
+
+  public sigs: ISig[] = [];
+
+  /**
+   * Converts cet_adaptor_signature to JSON (canonical rust-dlc format)
+   */
+  public toJSON(): ICetAdaptorSignaturesJSON {
+    return {
+      ecdsaAdaptorSignatures: this.sigs.map((sig) => {
+        // Combine encryptedSig and dleqProof into single signature field as expected by rust-dlc
+        const signature = Buffer.concat([sig.encryptedSig, sig.dleqProof]);
+        return {
+          signature: signature.toString('hex'),
+        };
+      }),
+    };
+  }
+
+  /**
+   * Serializes the cet_adaptor_signature message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    // writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeBigSize(this.sigs.length);
+
+    for (const sig of this.sigs) {
+      dataWriter.writeBytes(sig.encryptedSig);
+      dataWriter.writeBytes(sig.dleqProof);
+    }
+
+    // writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+    return writer.toBuffer();
+  }
+}
+
+interface ISig {
+  encryptedSig: Buffer;
+  dleqProof: Buffer;
+}
+
+export interface ICetAdaptorSignaturesJSON {
+  ecdsaAdaptorSignatures: ISigJSON[];
+}
+
+export interface ISigJSON {
+  signature: string;
+}

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

@@ -0,0 +1,318 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { ContractDescriptorType, MessageType } from '../MessageType';
+import { IDlcMessage } from './DlcMessage';
+import { PayoutFunction, PayoutFunctionV0JSON } from './PayoutFunction';
+import { IRoundingIntervalsJSON, RoundingIntervals } from './RoundingIntervals';
+
+export abstract class ContractDescriptor {
+  public static deserialize(
+    buf: Buffer,
+  ): EnumeratedDescriptor | NumericalDescriptor {
+    const reader = new BufferReader(buf);
+    const typeId = Number(reader.readBigSize());
+
+    switch (typeId) {
+      case ContractDescriptorType.Enumerated:
+        return EnumeratedDescriptor.deserialize(buf);
+      case ContractDescriptorType.NumericOutcome:
+        return NumericalDescriptor.deserialize(buf);
+      default:
+        throw new Error(
+          `Contract descriptor type must be Enumerated (0) or NumericOutcome (1), got ${typeId}`,
+        );
+    }
+  }
+
+  /**
+   * Creates a ContractDescriptor from JSON data (e.g., from test vectors)
+   * @param json JSON object representing a contract descriptor
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): ContractDescriptor {
+    if (!json) {
+      throw new Error('contractDescriptor is required');
+    }
+
+    // Handle enumerated contract descriptor
+    if (
+      json.enumeratedContractDescriptor ||
+      json.enumerated_contract_descriptor
+    ) {
+      return EnumeratedDescriptor.fromJSON(
+        json.enumeratedContractDescriptor ||
+          json.enumerated_contract_descriptor,
+      );
+    }
+    // Handle numeric outcome contract descriptor
+    else if (
+      json.numericOutcomeContractDescriptor ||
+      json.numeric_outcome_contract_descriptor
+    ) {
+      return NumericalDescriptor.fromJSON(
+        json.numericOutcomeContractDescriptor ||
+          json.numeric_outcome_contract_descriptor,
+      );
+    } else {
+      throw new Error(
+        'contractDescriptor must have either enumeratedContractDescriptor or numericOutcomeContractDescriptor',
+      );
+    }
+  }
+
+  public abstract contractDescriptorType: ContractDescriptorType;
+  public abstract type: number; // For backward compatibility
+  public abstract toJSON(): EnumeratedDescriptorJSON | NumericalDescriptorJSON;
+  public abstract serialize(): Buffer;
+}
+
+/**
+ * EnumeratedContractDescriptor contains information about a contract's outcomes
+ * and their corresponding payouts (for enumerated outcomes).
+ * This corresponds to the previous ContractDescriptorV0.
+ */
+export class EnumeratedDescriptor
+  extends ContractDescriptor
+  implements IDlcMessage {
+  public static contractDescriptorType = ContractDescriptorType.Enumerated;
+
+  /**
+   * Creates an EnumeratedContractDescriptor from JSON data
+   * @param json JSON object representing an enumerated contract descriptor
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): EnumeratedDescriptor {
+    const instance = new EnumeratedDescriptor();
+
+    const payouts = json.payouts || [];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    instance.outcomes = payouts.map((payout: any) => ({
+      outcome: payout.outcome,
+      localPayout: BigInt(payout.offerPayout || 0), // Use canonical offerPayout field
+    }));
+
+    return instance;
+  }
+
+  /**
+   * Deserializes an enumerated_contract_descriptor message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): EnumeratedDescriptor {
+    const instance = new EnumeratedDescriptor();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type (0)
+    const numOutcomes = Number(reader.readBigSize());
+
+    for (let i = 0; i < numOutcomes; i++) {
+      const outcomeLen = Number(reader.readBigSize());
+      const outcome = reader.readBytes(outcomeLen).toString();
+      const localPayout = reader.readUInt64BE();
+
+      instance.outcomes.push({
+        outcome,
+        localPayout,
+      });
+    }
+
+    return instance;
+  }
+
+  /**
+   * The type for enumerated_contract_descriptor message - using MessageType for IDlcMessage compatibility
+   */
+  public type = MessageType.ContractDescriptorV0; // For IDlcMessage compatibility
+
+  /**
+   * The contract descriptor type for new format
+   */
+  public contractDescriptorType = ContractDescriptorType.Enumerated;
+
+  public outcomes: IOutcome[] = [];
+
+  /**
+   * Converts enumerated_contract_descriptor to JSON
+   */
+  public toJSON(): EnumeratedDescriptorJSON {
+    // Return enum variant format for Rust compatibility
+    return {
+      enumeratedContractDescriptor: {
+        payouts: this.outcomes.map((outcome) => ({
+          outcome: outcome.outcome,
+          offerPayout: Number(outcome.localPayout), // Use offerPayout to match Rust
+        })),
+      },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any;
+  }
+
+  /**
+   * Serializes the enumerated_contract_descriptor message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeBigSize(this.contractDescriptorType);
+    writer.writeBigSize(this.outcomes.length);
+
+    for (const outcome of this.outcomes) {
+      writer.writeBigSize(outcome.outcome.length);
+      writer.writeBytes(Buffer.from(outcome.outcome));
+      writer.writeUInt64BE(outcome.localPayout);
+    }
+
+    return writer.toBuffer();
+  }
+}
+
+/**
+ * NumericOutcomeContractDescriptor contains information about a contract's outcomes
+ * and their corresponding payouts (for numeric outcomes).
+ * This corresponds to the previous ContractDescriptorV1.
+ */
+export class NumericalDescriptor
+  extends ContractDescriptor
+  implements IDlcMessage {
+  public static contractDescriptorType = ContractDescriptorType.NumericOutcome;
+
+  /**
+   * Creates a NumericOutcomeContractDescriptor from JSON data
+   * @param json JSON object representing a numeric outcome contract descriptor
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+  public static fromJSON(json: any): NumericalDescriptor {
+    const instance = new NumericalDescriptor();
+
+    instance.numDigits = json.numDigits || json.num_digits || 0;
+
+    // Parse payout function using proper fromJSON method
+    instance.payoutFunction = PayoutFunction.fromJSON(
+      json.payoutFunction || json.payout_function,
+    );
+
+    // Parse rounding intervals using proper fromJSON method
+    instance.roundingIntervals = RoundingIntervals.fromJSON(
+      json.roundingIntervals || json.rounding_intervals,
+    );
+
+    return instance;
+  }
+
+  /**
+   * Deserializes a numeric_outcome_contract_descriptor message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): NumericalDescriptor {
+    const instance = new NumericalDescriptor();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type (1)
+    instance.numDigits = reader.readUInt16BE();
+
+    // Parse payout function - need to calculate its size to avoid consuming all bytes
+    const payoutFunctionStartPos = reader.position;
+    const tempPayoutFunction = PayoutFunction.deserialize(
+      reader.buffer.subarray(reader.position),
+    );
+    instance.payoutFunction = tempPayoutFunction;
+
+    // Skip past the payout function bytes
+    const payoutFunctionSize = tempPayoutFunction.serialize().length;
+    reader.position = payoutFunctionStartPos + payoutFunctionSize;
+
+    // Parse remaining bytes as rounding intervals
+    instance.roundingIntervals = RoundingIntervals.deserialize(
+      reader.buffer.subarray(reader.position),
+    );
+
+    return instance;
+  }
+
+  /**
+   * The type for numeric_outcome_contract_descriptor message - using MessageType for IDlcMessage compatibility
+   */
+  public type = MessageType.ContractDescriptorV1; // For IDlcMessage compatibility
+
+  /**
+   * The contract descriptor type for new format
+   */
+  public contractDescriptorType = ContractDescriptorType.NumericOutcome;
+
+  public numDigits: number;
+
+  public payoutFunction: PayoutFunction;
+
+  public roundingIntervals: RoundingIntervals;
+
+  /**
+   * Validates correctness of all fields in the message
+   * https://github.com/discreetlogcontracts/dlcspecs/blob/master/Messaging.md#the-contract_descriptor-type
+   * @throws Will throw an error if validation fails
+   */
+  public validate(): void {
+    this.roundingIntervals.validate();
+  }
+
+  /**
+   * Converts numeric_outcome_contract_descriptor to JSON
+   */
+  public toJSON(): NumericalDescriptorJSON {
+    // Return enum variant format for Rust compatibility
+    return {
+      numericOutcomeContractDescriptor: {
+        numDigits: this.numDigits,
+        payoutFunction: this.payoutFunction.toJSON(),
+        roundingIntervals: this.roundingIntervals.toJSON(),
+      },
+    } as any;
+  }
+
+  /**
+   * Serializes the numeric_outcome_contract_descriptor message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+
+    writer.writeBigSize(this.contractDescriptorType);
+    writer.writeUInt16BE(this.numDigits);
+    writer.writeBytes(this.payoutFunction.serialize());
+    writer.writeBytes(this.roundingIntervals.serialize());
+
+    return writer.toBuffer();
+  }
+}
+
+// Legacy support - keeping old class names as aliases
+export const ContractDescriptorV0 = EnumeratedDescriptor;
+export const ContractDescriptorV1 = NumericalDescriptor;
+export type ContractDescriptorV0 = EnumeratedDescriptor;
+export type ContractDescriptorV1 = NumericalDescriptor;
+
+interface IOutcome {
+  outcome: string;
+  localPayout: bigint;
+}
+
+interface IOutcomeJSON {
+  outcome: string;
+  localPayout: number;
+}
+
+export interface EnumeratedDescriptorJSON {
+  type?: number; // Made optional for rust-dlc compatibility
+  contractDescriptorType?: ContractDescriptorType; // Made optional for rust-dlc compatibility
+  outcomes: IOutcomeJSON[];
+}
+
+export interface NumericalDescriptorJSON {
+  type?: number; // Made optional for rust-dlc compatibility
+  contractDescriptorType?: ContractDescriptorType; // Made optional for rust-dlc compatibility
+  numDigits: number;
+  payoutFunction: PayoutFunctionV0JSON;
+  roundingIntervals: IRoundingIntervalsJSON;
+}
+
+// Legacy interfaces for backward compatibility
+export type ContractDescriptorV0JSON = EnumeratedDescriptorJSON;
+export type ContractDescriptorV1JSON = NumericalDescriptorJSON;