@atomicfinance/client 4.0.0 → 4.0.1

package/.yalc/@node-dlc/bitcoin/lib/BitcoinErrorCode.ts

@@ -0,0 +1,10 @@
+export enum BitcoinErrorCode {
+  Base58ChecksumFailed,
+  PubKeyInvalid,
+  PubKeyHashInvalid,
+  SigEncodingInvalid,
+  SigHashTypeInvalid,
+  MultiSigSetupInvalid,
+  Hash160Invalid,
+  Hash256Invalid,
+}

package/.yalc/@node-dlc/bitcoin/lib/Block.ts

@@ -0,0 +1,20 @@
+import { Tx } from './Tx';
+
+export type Block = {
+  hash: string;
+  strippedsize: number;
+  size: number;
+  weight: number;
+  height: number;
+  version: number;
+  versionHex: string;
+  merkelroot: string;
+  time: number;
+  mediantime: number;
+  chainwork: string;
+  previousblockhash: string;
+  nextblockhash: string;
+  bits: string;
+  difficulty: string;
+  txs: Tx[];
+};

package/.yalc/@node-dlc/bitcoin/lib/HashByteOrder.ts

@@ -0,0 +1,21 @@
+export enum HashByteOrder {
+  /**
+   * Internal byte order is the natural byte order of elements as they
+   * cedome out of hash function. Calculations are often performed
+   * using the internal byte order.
+   *
+   * This is often referred to as little-endian byte-order due to the
+   * block hash being reversed to compare it to the target.
+   */
+  Internal,
+
+  /**
+   * RPC byte order is the byte order of hash value as displayed in
+   * the bitcoind RPC. Most hash values associated with Bitcoin are
+   * displayed in this order by reversing the internal byte order.
+   *
+   * This is often referred to as big-endian byte-order due to the
+   * block hash being reversed to compare it to the target.
+   */
+  RPC,
+}

package/.yalc/@node-dlc/bitcoin/lib/HashValue.ts

@@ -0,0 +1,90 @@
+import { StreamReader } from '@node-dlc/bufio';
+
+import { HashByteOrder } from './HashByteOrder';
+import { ICloneable } from './ICloneable';
+
+export class HashValue implements ICloneable<HashValue> {
+  /**
+   * Parses a hashed value in internal byte order. This is often
+   * referred to as little-endian due to the block target needing to
+   * be reversed.
+   * @param stream
+   */
+  public static parse(reader: StreamReader): HashValue {
+    return new HashValue(reader.readBytes(32));
+  }
+
+  /**
+   * Parses a hashed value in RPC byte order (which is the reverse) of
+   * the natural or internal byte order. This is often referred to as
+   * big-endian due to the reversed block target being big-endian.
+   * @param stream
+   */
+  public static fromRpcStream(reader: StreamReader): HashValue {
+    const value = reader.readBytes(32).reverse();
+    return new HashValue(value);
+  }
+
+  /**
+   * Parses a hashed value in RPC byte order (which is the reverse) of
+   * the natural or internal byte order. This is often referred to as
+   * big-endian due to the reversed block target being big-endian.
+   * @param value
+   */
+  public static fromRpc(value: string): HashValue {
+    const reader = StreamReader.fromHex(value);
+    return this.fromRpcStream(reader);
+  }
+
+  /**
+   * Internal-byte-order version of the hash value
+   */
+  private _value: Buffer;
+
+  /**
+   * Constructs a new HashValue instance from the internal-byte-order
+   * value provided.
+   * @param value Interval-byte-order of a hash value
+   */
+  constructor(value: Buffer) {
+    this._value = value;
+  }
+
+  /**
+   * Returns the hash value as a hex string. Defaults to using RPC
+   * (reversed/big-endian) byte order.
+   */
+  public toString(byteOrder: HashByteOrder = HashByteOrder.RPC): string {
+    if (byteOrder === HashByteOrder.RPC) {
+      return Buffer.from(this._value).reverse().toString("hex"); // prettier-ignore
+    } else {
+      return Buffer.from(this._value).toString('hex');
+    }
+  }
+
+  /**
+   * Serializes to JSON returning a hex string. Defaults to using
+   * RPC (reversed/big endian) byte order.
+   */
+  public toJSON(byteOrder?: HashByteOrder): string {
+    return this.toString(byteOrder);
+  }
+
+  /**
+   * Serializes the hash value into an internal-byte order Buffer
+   */
+  public serialize(byteOrder: HashByteOrder = HashByteOrder.Internal): Buffer {
+    if (byteOrder === HashByteOrder.Internal) {
+      return Buffer.from(this._value);
+    } else {
+      return Buffer.from(this._value).reverse();
+    }
+  }
+
+  /**
+   * Deep copy clone
+   */
+  public clone(): HashValue {
+    return new HashValue(Buffer.from(this._value));
+  }
+}

package/.yalc/@node-dlc/bitcoin/lib/ICloneable.ts

@@ -0,0 +1,3 @@
+export interface ICloneable<T> {
+  clone(): T;
+}

package/.yalc/@node-dlc/bitcoin/lib/LexicographicalSorters.ts

@@ -0,0 +1,37 @@
+import { HashByteOrder } from './HashByteOrder';
+import { TxIn } from './TxIn';
+import { TxOut } from './TxOut';
+
+/**
+ * Compares two transaction inputs and lexicographically sorted in
+ * ascending order using the reversed byte order (RPC) of the txids.
+ * If the same txids are in both TxIn, then the output index is sorted
+ * in ascending order.
+ * @param a
+ * @param b
+ */
+export function bip69InputSorter(a: TxIn, b: TxIn): number {
+  const txid = a.outpoint.txid
+    .serialize(HashByteOrder.RPC)
+    .compare(b.outpoint.txid.serialize());
+  if (txid !== 0) return txid;
+
+  if (a.outpoint.outputIndex < b.outpoint.outputIndex) return -1;
+  if (a.outpoint.outputIndex > b.outpoint.outputIndex) return 1;
+  return 0;
+}
+
+/**
+ * Sort transaction amounts in ascending order. Then ScriptPubKey values
+ * will be sorted in ascending byte order next.
+ * @param a
+ * @param b
+ */
+export function bip69OutputSorter(a: TxOut, b: TxOut): number {
+  // sort by amount desc first
+  const amount = Number(a.value.sats - b.value.sats);
+  if (amount !== 0) return amount;
+
+  // then sort by script pub key
+  return a.scriptPubKey.serializeCmds().compare(b.scriptPubKey.serializeCmds());
+}

package/.yalc/@node-dlc/bitcoin/lib/LockTime.ts

@@ -0,0 +1,102 @@
+import { BufferWriter, StreamReader } from '@node-dlc/bufio';
+
+import { ICloneable } from './ICloneable';
+import { TimeLockMode } from './TimeLockMode';
+
+const DEFAULT_LOCKTIME = 0xffff_ffff;
+const TIME_THRESHOLD = 500_000_000;
+
+/**
+ * Specifies the absolute lock time for a transaction referred in the
+ * reference implementation as nLocktime. An absolute locktime is only
+ * active when its value is less than 0xffff_ffff and at least one
+ * transaction input has a non-0xffff_ffff nSequence.
+ */
+export class LockTime implements ICloneable<LockTime> {
+  /**
+   * Parses a locktime from a reader
+   * @param reader
+   */
+  public static parse(reader: StreamReader): LockTime {
+    return new LockTime(reader.readUInt32LE());
+  }
+
+  /**
+   * Creates an nLockTime of zero which enforces finality for the
+   * transaction.
+   */
+  public static zero(): LockTime {
+    return new LockTime(0);
+  }
+
+  /**
+   * Gets or sets the value of the timelock. The value must be less than
+   * the maximum allowed value of 0xffff_ffff. When set to the max
+   * value, the locktime is disabled.
+   */
+  public get value(): number {
+    return this._value;
+  }
+
+  public set value(val: number) {
+    if (val > DEFAULT_LOCKTIME || val < 0) throw new Error('Invalid nLocktime');
+    this._value = val;
+  }
+
+  private _value: number;
+
+  /**
+   * Creates a new locktime instance
+   * @param value defaults to 0xffff_ffff
+   */
+  constructor(value: number = DEFAULT_LOCKTIME) {
+    this.value = value;
+  }
+
+  /**
+   * True when a non-default is configured. This flag has no
+   * knowledge if the locktime is fully enabled with the requirement
+   * that at least one tx input has an nSequence value that non-default.
+   */
+  public get isEnabled(): boolean {
+    return this.value < DEFAULT_LOCKTIME;
+  }
+
+  /**
+   * Gets the type of lock time: Block or Time based
+   */
+  public get type(): TimeLockMode {
+    if (this.value < TIME_THRESHOLD) return TimeLockMode.Block;
+    else return TimeLockMode.Time;
+  }
+
+  /**
+   * Returns the string value
+   */
+  public toString(): string {
+    return this.value.toString();
+  }
+
+  /**
+   * Returns the JSON serialized value
+   */
+  public toJSON(): number {
+    return this.value;
+  }
+
+  /**
+   * Serializes the locktime into a Buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter(Buffer.alloc(4));
+    writer.writeUInt32LE(this.value);
+    return writer.toBuffer();
+  }
+
+  /**
+   * Clone via deep copy
+   */
+  public clone(): LockTime {
+    return new LockTime(this._value);
+  }
+}

package/.yalc/@node-dlc/bitcoin/lib/OpCodes.ts

@@ -0,0 +1,119 @@
+export enum OpCode {
+  // Reserved
+  OP_RESERVED = 0x50,
+
+  // Constants
+  OP_0 = 0x00,
+  OP_FALSE = 0x00,
+  OP_PUSHDATA1 = 0x4c,
+  OP_PUSHDATA2 = 0x4d,
+  OP_PUSHDATA4 = 0x4e,
+  OP_1NEGATE = 0x4f,
+  OP_1 = 0x51,
+  OP_TRUE = 0x51,
+  OP_2 = 0x52,
+  OP_3 = 0x53,
+  OP_4 = 0x54,
+  OP_5 = 0x55,
+  OP_6 = 0x56,
+  OP_7 = 0x57,
+  OP_8 = 0x58,
+  OP_9 = 0x50,
+  OP_10 = 0x5a,
+  OP_11 = 0x5b,
+  OP_12 = 0x5c,
+  OP_13 = 0x5d,
+  OP_14 = 0x5e,
+  OP_15 = 0x5f,
+  OP_16 = 0x60,
+
+  // Flow Control
+  OP_NOOP = 0x61,
+  OP_IF = 0x63,
+  OP_NOTIF = 0x64,
+  OP_ELSE = 0x67,
+  OP_ENDIF = 0x68,
+  OP_VERIFY = 0x69,
+  OP_RETURN = 0x6a,
+
+  // Stack
+  OP_TOALTSTACK = 0x6b,
+  OP_FROMALTSTACK = 0x6c,
+  OP_2DROP = 0x6d,
+  OP_2DUP = 0x6e,
+  OP_3DUP = 0x6f,
+  OP_2OVER = 0x70,
+  OP_2ROT = 0x71,
+  OP_2SWAP = 0x72,
+  OP_IFDUP = 0x73,
+  OP_DEPTH = 0x74,
+  OP_DROP = 0x75,
+  OP_DUP = 0x76,
+  OP_NIP = 0x77,
+  OP_OVER = 0x78,
+  OP_PICK = 0x79,
+  OP_ROLL = 0x7a,
+  OP_ROT = 0x7b,
+  OP_SWAP = 0x7c,
+  OP_TUCK = 0x7d,
+
+  // Splice
+  OP_CAT = 0x7e, // disabled
+  OP_SUBSTR = 0x7f, // disabled
+  OP_LEFT = 0x80, // disabled
+  OP_RIGHT = 0x81, // disabled
+  OP_SIZE = 0x82,
+
+  // Bitwise
+  OP_INVERT = 0x83, // disabled
+  OP_AND = 0x84, // disabled
+  OP_OR = 0x85, // disabled
+  OP_XOR = 0x86, // disabled
+  OP_EQUAL = 0x87,
+  OP_EQUALVERIFY = 0x88,
+
+  // Arithmetic
+  OP_1ADD = 0x8b,
+  OP_1SUB = 0x8c,
+  OP_2MUL = 0x8d, // disabled
+  OP_2DIV = 0x8e, // disabled
+  OP_NEGATE = 0x8f,
+  OP_ABS = 0x90,
+  OP_NOT = 0x91,
+  OP_0NOTEQUAL = 0x92,
+  OP_ADD = 0x93,
+  OP_SUB = 0x94,
+  OP_MUL = 0x95, // disabled
+  OP_DIV = 0x96, // disabled
+  OP_MOD = 0x97, // disabled
+  OP_LSHIFT = 0x98, // disabled
+  OP_RSHIFT = 0x99, // disabled
+  OP_BOOLAND = 0x9a,
+  OP_BOOLOR = 0x9b,
+  OP_NUMEQUAL = 0x9c,
+  OP_NUMEQUALVERIFY = 0x9d,
+  OP_NUMNOTEQUAL = 0x9e,
+  OP_LESSTHAN = 0x9f,
+  OP_GREATERTHAN = 0xa0,
+  OP_LESSTHANOREQUAL = 0xa1,
+  OP_GREATERTHANOREQUAL = 0xa2,
+  OP_MIN = 0xa3,
+  OP_MAX = 0xa4,
+  OP_WITHIN = 0xa5,
+
+  // Crypto
+  OP_RIPEMD160 = 0xa6,
+  OP_SHA1 = 0xa7,
+  OP_SHA256 = 0xa8,
+  OP_HASH160 = 0xa9,
+  OP_HASH256 = 0xaa,
+  OP_CODESEPARATOR = 0xab,
+  OP_CHECKSIG = 0xac,
+  OP_CHECKSIGVERIFY = 0xad,
+  OP_CHECKMULTISIG = 0xae,
+  OP_CHECKMULTISIGVERIFY = 0xaf,
+
+  // Locktime
+  OP_CHECKLOCKTIMEVERIFY = 0xb1,
+  OP_CHECKSEQUENCEVERIFY = 0xb2,
+}

package/.yalc/@node-dlc/bitcoin/lib/OutPoint.ts

@@ -0,0 +1,101 @@
+import { BufferWriter, StreamReader } from '@node-dlc/bufio';
+
+import { HashByteOrder } from './HashByteOrder';
+import { HashValue } from './HashValue';
+import { ICloneable } from './ICloneable';
+
+/**
+ * A tuple defining a transaction output which contains the transaction
+ * identifier and the output index.
+ */
+export class OutPoint implements ICloneable<OutPoint> {
+  /**
+   * Creates an OutPoint from a byte stream.
+   * @param reader
+   */
+  public static parse(reader: StreamReader): OutPoint {
+    const txid = HashValue.parse(reader);
+    const outputIndex = reader.readUInt32LE();
+    return new OutPoint(txid, outputIndex);
+  }
+
+  /**
+   * Creates an OutPoint instance from an Outpoint serialized
+   * to the standard string of "txid:vout" where the txid is in RPC
+   * (reversed) byte order
+   */
+  public static fromString(text: string): OutPoint {
+    const parts = /^([0-9a-f]{64,64}):(\d+)$/i.exec(text);
+    if (!parts) {
+      throw new Error('invalid argument');
+    }
+    const txid = HashValue.fromRpc(parts[1]);
+    const voutIdx = parseInt(parts[2]);
+    if (voutIdx < 0) {
+      throw new Error('invalid argument');
+    }
+    return new OutPoint(txid, voutIdx);
+  }
+
+  /**
+   * Transaction identifier
+   */
+  public txid: HashValue;
+
+  /**
+   * Index of output in transaction
+   */
+  public outputIndex: number;
+
+  /**
+   * Constructs a new OutPoint
+   * @param txid TxId as a HashValue or an RPC (big-endian) string
+   * @param outputIndex
+   */
+  constructor(txid: HashValue | string, outputIndex: number) {
+    if (txid instanceof HashValue) {
+      this.txid = txid;
+    } else {
+      this.txid = HashValue.fromRpc(txid);
+    }
+    this.outputIndex = outputIndex;
+  }
+
+  /**
+   * Converts the outpoint to a human readable string in the format
+   * [txid]:[voutidx]
+   */
+  public toString(): string {
+    return `${this.txid.toString(HashByteOrder.RPC)}:${this.outputIndex}`;
+  }
+
+  /**
+   * Converts the outpoint to a JSON object with the txid and index
+   * tuple
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  public toJSON() {
+    return {
+      txid: this.txid.toString(HashByteOrder.RPC),
+      index: this.outputIndex,
+    };
+  }
+
+  /**
+   * Serializes the OutPoint to a buffer where the txid is serialized
+   * in internal byte order, and the output index is uint32LE
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter(Buffer.alloc(36));
+    writer.writeBytes(this.txid.serialize());
+    writer.writeUInt32LE(this.outputIndex);
+    return writer.toBuffer();
+  }
+
+  /**
+   * Clones by performing deep copy
+   */
+  public clone(): OutPoint {
+    return new OutPoint(this.txid.clone(), this.outputIndex);
+  }
+}