@atomicfinance/types 3.6.1 → 4.0.1

package/.yalc/@node-dlc/messaging/lib/irc/IrcMessage.ts

@@ -0,0 +1,161 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+import { crc32c } from '@node-dlc/checksum';
+
+import { MessageType } from '../MessageType';
+
+const MAX_DATA_LEN = 190;
+
+export abstract class IrcMessage {
+  public static deserialize(buf: Buffer): IrcMessageV0 {
+    const reader = new BufferReader(buf);
+
+    const type = Number(reader.readUInt16BE());
+
+    switch (type) {
+      case MessageType.IrcMessageV0:
+        return IrcMessageV0.deserialize(buf);
+      default:
+        throw new Error(`Irc message type must be IrcMessageV0`);
+    }
+  }
+
+  public abstract type: number;
+
+  public abstract serialize(): Buffer;
+}
+
+/**
+ * IrcMessage contains information for Irc message packet.
+ */
+export class IrcMessageV0 extends IrcMessage {
+  public static type = MessageType.IrcMessageV0;
+
+  public static fromBuffer(buf: Buffer, pubkey: Buffer): IrcMessageV0[] {
+    const instances: IrcMessageV0[] = [];
+
+    const checksum = crc32c(buf);
+
+    const sequenceLength = Math.ceil(buf.length / MAX_DATA_LEN);
+
+    const reader = new BufferReader(buf);
+    const bufLen = buf.length;
+
+    const currentTime = Math.floor(new Date().getTime() / 1000);
+
+    for (let i = 0; i < sequenceLength; i++) {
+      const sequenceNumber = i;
+      const instance = new IrcMessageV0();
+
+      instance.sequenceLength = BigInt(sequenceLength);
+      instance.sequenceNumber = BigInt(sequenceNumber);
+      instance.checksum = checksum;
+      instance.pubkey = pubkey;
+      instance.timestamp = currentTime;
+      instance.data = reader.readBytes(
+        Math.min(MAX_DATA_LEN, bufLen - reader.position),
+      );
+
+      instances.push(instance);
+    }
+
+    return instances;
+  }
+
+  public static fromString(str: string, pubkey: Buffer): IrcMessageV0[] {
+    const buf = Buffer.from(str);
+
+    return IrcMessageV0.fromBuffer(buf, pubkey);
+  }
+
+  /**
+   * Deserializes an irc message
+   * @param buf
+   */
+  public static deserialize(buf: Buffer): IrcMessageV0 {
+    const instance = new IrcMessageV0();
+    const reader = new BufferReader(buf);
+
+    reader.readBigSize(); // read type
+
+    instance.length = reader.readBigSize();
+
+    instance.sequenceLength = reader.readBigSize();
+    instance.sequenceNumber = reader.readBigSize();
+
+    instance.checksum = reader.readUInt32BE();
+
+    instance.signature = reader.readBytes(64);
+    instance.pubkey = reader.readBytes(33);
+    instance.timestamp = reader.readUInt32BE();
+
+    const dataLen = reader.readUInt16BE();
+    instance.data = reader.readBytes(dataLen);
+
+    return instance;
+  }
+
+  public type = IrcMessageV0.type;
+
+  public length: bigint;
+
+  public sequenceLength: bigint;
+
+  public sequenceNumber: bigint;
+
+  public checksum: number;
+
+  public signature: Buffer;
+
+  public pubkey: Buffer;
+
+  public timestamp: number;
+
+  public data: Buffer;
+
+  public serializeWithoutSig(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.sequenceLength);
+    writer.writeBigSize(this.sequenceNumber);
+    writer.writeUInt64BE(this.checksum);
+    writer.writeBytes(this.pubkey);
+    writer.writeUInt32BE(this.timestamp);
+    writer.writeUInt16BE(this.data.length);
+    writer.writeBytes(this.data);
+
+    return writer.toBuffer();
+  }
+
+  /**
+   * Serializes the irc_message_v0
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeBigSize(this.sequenceLength);
+    dataWriter.writeBigSize(this.sequenceNumber);
+    dataWriter.writeUInt32BE(this.checksum);
+    dataWriter.writeBytes(this.signature);
+    dataWriter.writeBytes(this.pubkey);
+    dataWriter.writeUInt32BE(this.timestamp);
+    dataWriter.writeUInt16BE(this.data.length);
+    dataWriter.writeBytes(this.data);
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}
+
+export class IrcMessageWithoutSig {
+  constructor(
+    readonly sequenceLength: bigint,
+    readonly sequenceNumber: bigint,
+    readonly checksum: number,
+    readonly signature: Buffer,
+    readonly pubkey: Buffer,
+    readonly data: Buffer,
+  ) {}
+}

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;
+}