@atomicfinance/bitcoin-dlc-provider 3.6.0 → 4.0.0

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

@@ -0,0 +1,326 @@
+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,44 @@
+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/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/OracleEventContainer';
+export * from './messages/OracleEvent';
+export * from './messages/OracleIdentifier';
+export * from './messages/OracleInfo';
+export * from './messages/OrderAccept';
+export * from './messages/OrderNegotiationFields';
+export * from './messages/OrderOffer';
+export * from './messages/OrderPositionInfo';
+export * from './messages/OrderIrcInfo';
+export * from './messages/OrderMetadata';
+export * from './messages/PayoutCurvePiece';
+export * from './messages/PayoutFunction';
+export * from './messages/RoundingIntervals';
+export * from './messages/ScriptWitnessV0';
+export * from './MessageType';
+export * from './validation/validate';
+export { F64 } from './serialize/F64';

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,
+  ) {}
+}