@atomicfinance/bitcoin-dlc-provider 4.0.3 → 4.1.1

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

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

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

@@ -1,20 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,90 +0,0 @@
-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

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

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

@@ -1,37 +0,0 @@
-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

@@ -1,102 +0,0 @@
-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

@@ -1,119 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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);
-  }
-}