@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.0

package/.yalc/@node-dlc/messaging/lib/MessageType.ts

@@ -0,0 +1,140 @@
+/**
+ * Defined in DLC Messaging Spec
+ * https://github.com/discreetlogcontracts/dlcspecs/blob/master/Messaging.md
+ */
+
+// Protocol version as defined in dlcspecs PR #163
+export const PROTOCOL_VERSION = 1;
+
+// Wire message types (remain unchanged for backward compatibility)
+export enum MessageType {
+  // Core DLC Message Types (remain as wire format with u16 prefix)
+  DlcOffer = 42778,
+  DlcAccept = 42780,
+  DlcSign = 42782,
+
+  // Legacy contract types (keeping for backward compatibility during transition)
+  ContractInfoV0 = 55342,
+  SingleContractInfo = 55342,
+  ContractInfoV1 = 55344,
+  DisjointContractInfo = 55344,
+
+  ContractDescriptorV0 = 42768,
+  ContractDescriptorV1 = 42784,
+
+  OracleInfoV0 = 42770,
+  SingleOracleInfo = 42770,
+  OracleInfoV1 = 42786,
+  MultiOracleInfo = 42786,
+  OracleInfoV2 = 55340,
+
+  OracleParamsV0 = 55338,
+
+  // Oracle message types (remain as TLV for backward compatibility)
+  OracleAnnouncement = 55332,
+  OracleAnnouncementV0 = OracleAnnouncement, // Backward compatibility alias
+  OracleAttestation = 55400,
+  OracleAttestationV0 = OracleAttestation, // Backward compatibility alias
+  OracleEvent = 55330,
+  OracleEventV0 = OracleEvent, // Backward compatibility alias
+
+  OracleEventContainer = 61632,
+
+  EnumEventDescriptor = 55302,
+  EnumEventDescriptorV0 = EnumEventDescriptor, // Backward compatibility alias
+
+  DigitDecompositionEventDescriptor = 55306,
+  DigitDecompositionEventDescriptorV0 = DigitDecompositionEventDescriptor, // Backward compatibility alias
+
+  NegotiationFieldsV0 = 55334,
+  NegotiationFieldsV1 = 55336,
+  NegotiationFieldsV2 = 55346,
+
+  FundingInput = 42772,
+  FundingInputV0 = FundingInput, // Backward compatibility alias
+
+  DlcInput = 42773,
+
+  CetAdaptorSignatures = 42774,
+  CetAdaptorSignaturesV0 = CetAdaptorSignatures, // Backward compatibility alias
+
+  FundingSignatures = 42776,
+  FundingSignaturesV0 = FundingSignatures, // Backward compatibility alias
+
+  PayoutFunction = 42790,
+  PayoutFunctionV0 = PayoutFunction, // Backward compatibility alias
+
+  // PayoutCurvePiece types - kept for backward compatibility
+  PolynomialPayoutCurvePiece = 42792,
+  HyperbolaPayoutCurvePiece = 42794,
+  OldHyperbolaPayoutCurvePiece = 42796, // Legacy support
+
+  RoundingIntervals = 42788,
+  RoundingIntervalsV0 = RoundingIntervals, // Backward compatibility alias
+
+  DlcClose = 52170, // TODO: Temporary type
+  DlcCancel = 52172,
+
+  /**
+   * Dlc Storage Types
+   */
+  DlcTransactions = 61230,
+  DlcTransactionsV0 = DlcTransactions, // Backward compatibility alias
+  DlcIds = 61232,
+  DlcIdsV0 = DlcIds, // Backward compatibility alias
+  DlcInfo = 61234,
+  DlcInfoV0 = DlcInfo, // Backward compatibility alias
+
+  /**
+   * Oracle Identifier
+   */
+  OracleIdentifier = 61472,
+  OracleIdentifierV0 = OracleIdentifier, // Backward compatibility alias
+
+  /**
+   * Order Message Types
+   */
+  OrderOffer = 62770,
+  OrderAccept = 62772,
+  OrderMetadataV0 = 62774,
+  OrderIrcInfoV0 = 62776,
+  OrderPositionInfo = 62778,
+
+  OrderNegotiationFieldsV0 = 65334,
+  OrderNegotiationFieldsV1 = 65336,
+
+  AddressCache = 65132,
+
+  BatchFundingGroup = 65430,
+
+  IrcMessageV0 = 59314,
+
+  NodeAnnouncement = 51394,
+  NodeAnnouncementAddress = 51396,
+}
+
+// New sub-type identifiers for sibling sub-types (as per dlcspecs PR #163)
+export enum ContractInfoType {
+  Single = 0,
+  Disjoint = 1,
+}
+
+export enum ContractDescriptorType {
+  Enumerated = 0,
+  NumericOutcome = 1,
+}
+
+export enum OracleInfoType {
+  Single = 0,
+  Multi = 1,
+}
+
+export enum NegotiationFieldsType {
+  Single = 0,
+  Disjoint = 1,
+}
+
+export enum PayoutCurvePieceType {
+  Polynomial = 0,
+  Hyperbola = 1,
+}

package/.yalc/@node-dlc/messaging/lib/chain/ChainManager.ts

@@ -0,0 +1,327 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { Tx } from '@node-dlc/bitcoin';
+import { Block, Transaction } from 'bitcoinjs-lib';
+import { EventEmitter } from 'events';
+
+import { DlcTransactions } from '../messages/DlcTransactions';
+import { sleep } from '../util';
+import { IDlcStore } from './DlcStore';
+import {
+  HasHash,
+  HasHeight,
+  IChainFilterChainClient,
+} from './IChainFilterChainClient';
+
+export enum SyncState {
+  Unsynced,
+  Syncing,
+  Synced,
+}
+
+export interface ILogger {
+  area: string;
+  instance: string;
+  trace(...args: any[]): void;
+  debug(...args: any[]): void;
+  info(...args: any[]): void;
+  warn(...args: any[]): void;
+  error(...args: any[]): void;
+  sub(area: string, instance?: string): ILogger;
+}
+
+/**
+ * ChainManager validates and stores dlc txs
+ * from chain updates
+ */
+export class ChainManager extends EventEmitter {
+  public blockHeight: number;
+  public started = false;
+  public syncState: SyncState;
+  public isSynchronizing: boolean;
+  public chainClient: IChainFilterChainClient;
+  public logger: ILogger;
+  public dlcStore: IDlcStore;
+  public dlcTxsList: DlcTransactions[];
+
+  constructor(
+    logger: ILogger,
+    chainClient: IChainFilterChainClient,
+    dlcStore: IDlcStore,
+  ) {
+    super();
+    this.logger = logger.sub('dlcmgr');
+    this.dlcStore = dlcStore;
+    this.chainClient = chainClient;
+  }
+
+  /**
+   * Starts the chain manager. This method will load information
+   * from the chain store, determine when the last information
+   * was obtained, validate the existing messages
+   */
+  public async start(blockHeight = 0): Promise<void> {
+    this.logger.info('starting dlc state manager');
+
+    // wait for chain sync to complete
+    if (this.chainClient) {
+      this.logger.info('waiting for chain sync');
+      await this.chainClient.waitForSync();
+      this.logger.info('chain sync complete');
+    }
+
+    await this._restoreState(blockHeight);
+    this.syncState = SyncState.Synced;
+
+    // flag that the manager has now started
+    this.started = true;
+  }
+
+  public async updateFundBroadcast(dlcTxs: DlcTransactions): Promise<void> {
+    const info = await this.chainClient.getBlockchainInfo();
+    const block = await this.chainClient.getBlock(info.bestblockhash);
+
+    dlcTxs.fundBroadcastHeight = block.height;
+
+    await this.dlcStore.saveDlcTransactions(dlcTxs);
+  }
+
+  public async updateCloseBroadcast(dlcTxs: DlcTransactions): Promise<void> {
+    const info = await this.chainClient.getBlockchainInfo();
+    const block = await this.chainClient.getBlock(info.bestblockhash);
+
+    dlcTxs.closeBroadcastHeight = block.height;
+
+    await this.dlcStore.saveDlcTransactions(dlcTxs);
+  }
+
+  public async updateFundEpoch(
+    dlcTxs: DlcTransactions,
+    block: HasHeight & HasHash,
+  ): Promise<void> {
+    this.logger.info(
+      `updating fund epoch on dlc ${dlcTxs.contractId.toString('hex')}`,
+    );
+    dlcTxs.fundEpoch.hash = Buffer.from(block.hash, 'hex');
+    dlcTxs.fundEpoch.height = block.height;
+
+    if (dlcTxs.fundBroadcastHeight === 0) {
+      dlcTxs.fundBroadcastHeight = block.height - 1;
+    }
+
+    await this.dlcStore.saveDlcTransactions(dlcTxs);
+
+    this.logger.info(
+      `fund epoch updated on dlc ${dlcTxs.contractId.toString('hex')}`,
+    );
+  }
+
+  public async updateCloseEpoch(
+    dlcTxs: DlcTransactions,
+    tx: Tx,
+    block: HasHeight & HasHash,
+  ): Promise<void> {
+    this.logger.info(
+      `updating close epoch on dlc ${dlcTxs.contractId.toString('hex')}`,
+    );
+    dlcTxs.closeEpoch.hash = Buffer.from(block.hash, 'hex');
+    dlcTxs.closeEpoch.height = Number(block.height);
+    dlcTxs.closeTxHash = Buffer.from(tx.txId.toString(), 'hex');
+    dlcTxs.closeType = 3; // Default to cooperative close if txid not refund or cet txid
+
+    const _dlcTxs = await this.dlcStore.findDlcTransactions(dlcTxs.contractId);
+
+    // figure out if it's execute, refund or mutual close
+    if (tx.txId.toString() === dlcTxs.refundTx.txId.toString()) {
+      dlcTxs.closeType = 2;
+    } else {
+      const cetIndex = _dlcTxs.cets.findIndex(
+        (cet) => tx.txId.toString() === cet.txId.toString(),
+      );
+      if (cetIndex >= 0) dlcTxs.closeType = 1;
+    }
+
+    if (dlcTxs.closeBroadcastHeight === 0) {
+      dlcTxs.closeBroadcastHeight = block.height - 1;
+    }
+
+    await this.dlcStore.saveDlcTransactions(dlcTxs);
+
+    this.logger.info(
+      `close epoch updated on dlc ${dlcTxs.contractId.toString('hex')}`,
+    );
+  }
+
+  private async _restoreState(blockHeight = 0): Promise<void> {
+    this.logger.info('retrieving dlc state from store');
+    this.blockHeight = blockHeight;
+    this.syncState = SyncState.Syncing;
+    this.dlcTxsList = await this.dlcStore.findDlcTransactionsList();
+    this.logger.info('found %d dlcs', this.dlcTxsList.length);
+
+    if (blockHeight === 0) {
+      // find best block height
+      for (const dlcTxs of this.dlcTxsList) {
+        this.blockHeight = Math.max(
+          Math.max(this.blockHeight, dlcTxs.fundEpoch.height),
+          dlcTxs.closeEpoch.height,
+        );
+      }
+    }
+
+    this.logger.info("highest block %d found from %d dlcs", this.blockHeight, this.dlcTxsList.length); // prettier-ignore
+
+    // validate all utxos
+    await this._validateUtxos(this.dlcTxsList);
+  }
+
+  private async _validateUtxos(_dlcTxsList: DlcTransactions[]) {
+    if (!this.chainClient) {
+      this.logger.info('skipping utxo validation, no chain_client configured');
+      return;
+    }
+
+    const dlcTxsList = _dlcTxsList.filter(
+      (dlcTxs) => dlcTxs.closeEpoch.height === 0,
+    );
+
+    const dlcTxsCount = dlcTxsList.reduce(
+      (acc, msg) => acc + (msg instanceof DlcTransactions ? 1 : 0),
+      0,
+    );
+    this.logger.info('validating %d funding utxos', dlcTxsCount);
+
+    if (!dlcTxsCount) return;
+
+    const dlcTxsToVerify: DlcTransactions[] = [];
+
+    const oct = Math.trunc(dlcTxsCount / 16);
+    for (let i = 0; i < dlcTxsList.length; i++) {
+      const dlcTxs = dlcTxsList[i];
+      if ((i + 1) % oct === 0) {
+        this.logger.info(
+          'validating funding utxos %s% complete',
+          (((i + 1) / dlcTxsCount) * 100).toFixed(2),
+        );
+      }
+      if (dlcTxs instanceof DlcTransactions) {
+        const utxo = await this.chainClient.getUtxo(
+          dlcTxs.fundTx.txId.toString(),
+          dlcTxs.fundTxVout,
+        );
+
+        try {
+          const tx = await this.chainClient.getTransaction(
+            dlcTxs.fundTx.txId.toString(),
+          );
+          if (!utxo) dlcTxsToVerify.push(dlcTxs);
+
+          if (utxo && Number(utxo.confirmations) === 0)
+            this.updateFundBroadcast(dlcTxs);
+
+          if (
+            utxo &&
+            Number(utxo.confirmations) > 0 &&
+            dlcTxs.fundEpoch.height === 0
+          ) {
+            const block = await this.chainClient.getBlock(tx.blockhash);
+            await this.updateFundEpoch(dlcTxs, block);
+          }
+        } catch (e) {
+          /**
+           * tx doesn't exist
+           * fund tx wasn't broadcast in the first place
+           */
+        }
+      }
+    }
+    this.logger.info('validating funding utxos 100% complete');
+
+    if (dlcTxsToVerify.length === 0) {
+      this.logger.info('no closing utxos to validate');
+      return;
+    }
+
+    await this._validateClosingUtxos(dlcTxsToVerify);
+  }
+
+  private async _validateClosingUtxos(dlcTxsList: DlcTransactions[]) {
+    let info = await this.chainClient.getBlockchainInfo();
+
+    if (this.blockHeight === 0) {
+      this.logger.info('cannot sync from block height 0');
+      return;
+    }
+
+    let numBlocksToSync = Math.max(info.blocks - this.blockHeight, 0);
+    this.logger.info('validating %d blocks for closing utxos', numBlocksToSync);
+    const oct = Math.trunc(numBlocksToSync / 16);
+    let i = 0;
+    while (info.blocks > this.blockHeight) {
+      await sleep(10);
+
+      if ((i + 1) % oct === 0) {
+        this.logger.info(
+          'validating block %s, closing utxos %s% complete',
+          this.blockHeight,
+          (((i + 1) / numBlocksToSync) * 100).toFixed(2),
+        );
+      }
+
+      // Log every 10 blocks
+      if (this.blockHeight % 10 === 0) {
+        this.logger.info(
+          'Validating block %s for closing utxos',
+          this.blockHeight,
+        );
+      }
+
+      this.blockHeight += 1;
+
+      const blockHash = await this.chainClient.getBlockHash(this.blockHeight);
+      const blockBuf = await this.chainClient.getRawBlock(blockHash);
+
+      const block = Block.fromBuffer(blockBuf);
+      for (const transaction of block.transactions) {
+        try {
+          const bjsTx = Transaction.fromBuffer(transaction.toBuffer());
+          if (!bjsTx.isCoinbase()) {
+            // ignore coinbase txs for outpoint check
+            const tx = Tx.fromBuffer(transaction.toBuffer());
+            await this._checkOutpoints(dlcTxsList, tx, block.getId());
+          }
+        } catch (e) {
+          this.logger.error(
+            'Invalid tx for validating closing utxo: %s',
+            transaction.toHex(),
+          );
+          this.logger.trace('Error: ', e);
+        }
+      }
+
+      if (info.blocks === this.blockHeight) {
+        info = await this.chainClient.getBlockchainInfo();
+        if (info.blocks === this.blockHeight) break;
+        numBlocksToSync += info.blocks - this.blockHeight;
+      }
+
+      i++;
+    }
+
+    this.logger.info('validating closing utxos 100% complete');
+  }
+
+  private async _checkOutpoints(
+    dlcTxsList: DlcTransactions[],
+    tx: Tx,
+    blockHash: string,
+  ) {
+    for (const dlcTxs of dlcTxsList) {
+      for (const input of tx.inputs) {
+        if (dlcTxs.fundTx.txId.toString() === input.outpoint.txid.toString()) {
+          const block = await this.chainClient.getBlock(blockHash);
+          await this.updateCloseEpoch(dlcTxs, tx, block);
+        }
+      }
+    }
+  }
+}

package/.yalc/@node-dlc/messaging/lib/chain/ChainMemoryStore.ts

@@ -0,0 +1,34 @@
+/* eslint-disable @typescript-eslint/require-await */
+import { DlcTransactions } from '../messages/DlcTransactions';
+import { IDlcStore } from './DlcStore';
+
+/**
+ * In-memory implementation of the IDlcStore.
+ */
+export class ChainMemoryStore implements IDlcStore {
+  private _dlcTxs = new Map<Buffer, DlcTransactions>();
+
+  public get dlcTransactionsListCount(): number {
+    return this._dlcTxs.size;
+  }
+
+  public async findDlcTransactionsList(): Promise<DlcTransactions[]> {
+    return Array.from(this._dlcTxs.values());
+  }
+
+  public async findDlcTransactions(
+    contractId: Buffer,
+  ): Promise<DlcTransactions> {
+    return this._dlcTxs.get(contractId);
+  }
+
+  public async saveDlcTransactions(
+    dlcTransactions: DlcTransactions,
+  ): Promise<void> {
+    this._dlcTxs.set(dlcTransactions.contractId, dlcTransactions);
+  }
+
+  public async deleteDlcTransactions(contractId: Buffer): Promise<void> {
+    this._dlcTxs.delete(contractId);
+  }
+}

package/.yalc/@node-dlc/messaging/lib/chain/DlcStore.ts

@@ -0,0 +1,11 @@
+import { DlcTransactions } from '../messages/DlcTransactions';
+
+/**
+ * Interface for storing, finding, and deleting dlc messages.
+ */
+export interface IDlcStore {
+  findDlcTransactionsList(): Promise<DlcTransactions[]>;
+  findDlcTransactions(contractId: Buffer): Promise<DlcTransactions>;
+  saveDlcTransactions(dlcTransactions: DlcTransactions): Promise<void>;
+  deleteDlcTransactions(contractId: Buffer): Promise<void>;
+}

package/.yalc/@node-dlc/messaging/lib/chain/IChainFilterChainClient.ts

@@ -0,0 +1,57 @@
+/**
+ * The interface required by the Chainfilter to perform on-chain validation checks
+ * of messages. A simplified interface is required by the Chainfilter. The actual
+ * chain client implementation may offer a broader set of feautures. Additionally,
+ * an adapter could be constructred to make an chain client conform to that required
+ * by the Chainfilter.
+ */
+export interface IChainFilterChainClient {
+  getBlockchainInfo(): Promise<HasBlocks & HasBestBlockHash>;
+  getBlockHash(height: number): Promise<string>;
+  getBlock(hash: string): Promise<HasTxStrings & HasHeight & HasHash>;
+  getRawBlock(hash: string): Promise<Buffer>;
+  getTransaction(txId: string): Promise<HasTransaction>;
+  getUtxo(txId: string, voutIdx: number): Promise<HasConfirmations>;
+  waitForSync(): Promise<boolean>;
+}
+
+export type HasBlocks = {
+  blocks: number;
+};
+
+export type HasBestBlockHash = {
+  bestblockhash: string;
+};
+
+export type HasTxStrings = {
+  tx: string[];
+};
+
+export type HasHeight = {
+  height: number;
+};
+
+export type HasHash = {
+  hash: string;
+};
+
+export type HasTransaction = {
+  txid: string;
+  blockhash: string;
+};
+
+export type HasScriptPubKey = {
+  scriptPubKey: HasHex;
+};
+
+export type HasValue = {
+  value: number;
+};
+
+export type HasConfirmations = {
+  confirmations: string;
+};
+
+export type HasHex = {
+  hex: string;
+};

package/.yalc/@node-dlc/messaging/lib/domain/Address.ts

@@ -0,0 +1,64 @@
+import { BufferReader, BufferWriter } from '@node-dlc/bufio';
+
+import { MessageType } from '../MessageType';
+
+export class Address {
+  public static type = MessageType.NodeAnnouncementAddress;
+
+  public static deserialize(buf: Buffer): Address {
+    const reader = new BufferReader(buf);
+    reader.readBigSize(); // read off type
+    reader.readBigSize(); // read size
+
+    const hostLen = reader.readBigSize();
+    const hostBuf = reader.readBytes(Number(hostLen));
+    const host = hostBuf.toString();
+    const port = reader.readUInt16BE();
+
+    const instance = new Address(host, port);
+
+    return instance;
+  }
+
+  public type = Address.type;
+
+  /**
+   * String notation representation of the host
+   */
+  public host: string;
+
+  /**
+   * Port number
+   */
+  public port: number;
+
+  /**
+   * Base class representing a network address
+   */
+  constructor(host: string, port: number) {
+    this.host = host;
+    this.port = port;
+  }
+
+  public toString(): string {
+    return `${this.host}:${this.port}`;
+  }
+
+  /**
+   * Serializes the dlc_transactions_v0 message into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBigSize(this.type);
+
+    const dataWriter = new BufferWriter();
+    dataWriter.writeBigSize(this.host.length);
+    dataWriter.writeBytes(Buffer.from(this.host));
+    dataWriter.writeUInt16BE(this.port);
+
+    writer.writeBigSize(dataWriter.size);
+    writer.writeBytes(dataWriter.toBuffer());
+
+    return writer.toBuffer();
+  }
+}

package/.yalc/@node-dlc/messaging/lib/index.ts

@@ -0,0 +1,45 @@
+export * from './chain/ChainManager';
+export * from './chain/DlcStore';
+export * from './chain/IChainFilterChainClient';
+export * from './domain/Address';
+export * from './irc/IrcMessage';
+export * from './messages/AddressCache';
+export * from './messages/BatchFundingGroup';
+export * from './messages/CetAdaptorSignatures';
+export * from './messages/ContractDescriptor';
+export * from './messages/ContractInfo';
+export * from './messages/DlcAccept';
+export * from './messages/DlcCancel';
+export * from './messages/DlcClose';
+export * from './messages/DlcCloseMetadata';
+export * from './messages/DlcIds';
+export * from './messages/DlcInfo';
+export * from './messages/DlcInput';
+export * from './messages/DlcMessage';
+export * from './messages/DlcOffer';
+export * from './messages/DlcSign';
+export * from './messages/DlcTransactions';
+export * from './messages/EventDescriptor';
+export * from './messages/FundingInput';
+export * from './messages/FundingSignatures';
+export * from './messages/NegotiationFields';
+export * from './messages/NodeAnnouncementMessage';
+export * from './messages/OracleAnnouncement';
+export * from './messages/OracleAttestation';
+export * from './messages/OracleEvent';
+export * from './messages/OracleEventContainer';
+export * from './messages/OracleIdentifier';
+export * from './messages/OracleInfo';
+export * from './messages/OrderAccept';
+export * from './messages/OrderIrcInfo';
+export * from './messages/OrderMetadata';
+export * from './messages/OrderNegotiationFields';
+export * from './messages/OrderOffer';
+export * from './messages/OrderPositionInfo';
+export * from './messages/PayoutCurvePiece';
+export * from './messages/PayoutFunction';
+export * from './messages/RoundingIntervals';
+export * from './messages/ScriptWitnessV0';
+export * from './MessageType';
+export { F64 } from './serialize/F64';
+export * from './validation/validate';