@atomicfinance/types 4.0.0 → 4.0.2

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

@@ -0,0 +1,297 @@
+import { BufferWriter } from '@node-dlc/bufio';
+import { hash256, sign, sigToDER } from '@node-dlc/crypto';
+
+import { LockTime } from './LockTime';
+import { OutPoint } from './OutPoint';
+import { Script } from './Script';
+import { Sequence } from './Sequence';
+import { Tx } from './Tx';
+import { TxIn } from './TxIn';
+import { TxOut } from './TxOut';
+import { Value } from './Value';
+
+export class TxBuilder {
+  private _version: number;
+  private _locktime: LockTime;
+  private _inputs: TxIn[];
+  private _outputs: TxOut[];
+  private _hashPrevOuts: Buffer;
+  private _hashSequence: Buffer;
+  private _hashOutputs: Buffer;
+
+  constructor() {
+    this._inputs = [];
+    this._outputs = [];
+    this._version = 2;
+    this._locktime = new LockTime();
+  }
+
+  /**
+   * Gets or sets the transaction version. Valid transaction versions
+   * are > 1.
+   */
+  public get version(): number {
+    return this._version;
+  }
+
+  public set version(val: number) {
+    this._version = val;
+  }
+
+  /**
+   * Gets or sets the absolute locktime for the transaction
+   */
+  public get locktime(): LockTime {
+    return this._locktime;
+  }
+
+  public set locktime(val: LockTime) {
+    this._locktime = val;
+  }
+
+  /**
+   * Gets the inputs
+   */
+  public get inputs(): TxIn[] {
+    return this._inputs;
+  }
+
+  /**
+   * Gets the outputs
+   */
+  public get outputs(): TxOut[] {
+    return this._outputs;
+  }
+
+  /**
+   * Adds a new transaction input
+   * @param outpoint the previous output represented as an outpoint
+   */
+  public addInput(
+    outpoint: TxIn | string | OutPoint,
+    sequence?: Sequence,
+  ): void {
+    if (outpoint instanceof TxIn) {
+      this._inputs.push(outpoint.clone());
+    } else {
+      outpoint =
+        outpoint instanceof OutPoint ? outpoint : OutPoint.fromString(outpoint);
+      this._inputs.push(new TxIn(outpoint, undefined, sequence));
+    }
+  }
+
+  /**
+   * Adds a transaction output
+   * @param value value sent to the lock script. When represented as a
+   * number, the value is in Bitcoin.
+   * @param scriptPubKey the locking script encumbering the funds send
+   * to this output
+   */
+  public addOutput(value: TxOut | number | Value, scriptPubKey?: Script): void {
+    if (value instanceof TxOut) {
+      this._outputs.push(value.clone());
+    } else {
+      value = value instanceof Value ? value : Value.fromBitcoin(value);
+      this._outputs.push(new TxOut(value, scriptPubKey));
+    }
+  }
+
+  /**
+   * Creates a signature hash including all inputs and all outputs,
+   * which is referred to as SIGHASH_ALL. The scriptSig of all inputs
+   * is removed (as it is never signed), however we commit to the
+   * signatory input using the scriptPubKey from the prevOut or the
+   * redeemScript. The hash is constructed as the serialization of
+   * all information (with the input scriptSig replaced as just
+   * described) and then appending a 4-byte LE sighash type. We then
+   * take the hash256 of that serialized transaction.
+   *
+   * @param input signatory input index
+   * @param commitScript the scriptSig used for the signature input
+   */
+  public hashLegacy(input: number, commitScript: Script): Buffer {
+    const writer = new BufferWriter();
+
+    // write the version
+    writer.writeUInt32LE(this.version);
+
+    // sign all inputs as sorted by the sorting function
+    const inputs = this._inputs;
+    writer.writeVarInt(inputs.length);
+    for (let i = 0; i < inputs.length; i++) {
+      // blank out scriptSig for non-signatory inputs
+      let scriptSig = new Script();
+
+      // use the commit script for signatory input
+      if (i === input) {
+        scriptSig = commitScript;
+      }
+
+      // write the input
+      const vin = new TxIn(inputs[i].outpoint, scriptSig, inputs[i].sequence);
+      writer.writeBytes(vin.serialize());
+    }
+
+    // sign all outputs as sorted by the sorting function
+    const outputs = this._outputs;
+    writer.writeVarInt(outputs.length);
+    for (const vout of outputs) {
+      writer.writeBytes(vout.serialize());
+    }
+
+    // write the sequence
+    writer.writeBytes(this.locktime.serialize());
+
+    // write the sighash type 0x01 as 4-bytes little endian
+    writer.writeUInt32LE(1);
+
+    // return hashed value
+    return hash256(writer.toBuffer());
+  }
+
+  /**
+   * Creates a signature hash using the new segregated witness digets
+   * alorithm defined in BIP143. The current version only supports
+   * SIGHASH_ALL and does not account for OP_CODESEPARATOR.
+   *
+   * This algorithm has side-effects in that it caches hashPrevOut,
+   * hashSequence, and hashOutput values used. This means transaction
+   * should not change after signing, though the code does not yet
+   * enforce this.
+   *
+   * @param index signatory input index
+   * @param commitScript the scriptSig used for the signature input
+   * @param value the value of the input
+   */
+  public hashSegwitv0(
+    index: number,
+    commitScript: Script,
+    value: Value,
+  ): Buffer {
+    const writer = new BufferWriter();
+
+    // Combines the previous outputs for all inputs in the
+    // transaction by serializing and hash256 the concated values:
+    //   prevtx:  32-byte IBO
+    //   prevIdx: 4-byte LE
+    if (this._hashPrevOuts === undefined) {
+      const hashWriter = new BufferWriter(
+        Buffer.alloc(this._inputs.length * 36),
+      );
+      for (const input of this._inputs) {
+        hashWriter.writeBytes(input.outpoint.serialize());
+      }
+      this._hashPrevOuts = hash256(hashWriter.toBuffer());
+    }
+
+    // Combines the nSequence values for all inputs in the
+    // transaction and then hash256 the values
+    if (this._hashSequence === undefined) {
+      const hashWriter = new BufferWriter(
+        Buffer.alloc(this._inputs.length * 4),
+      );
+      for (const input of this._inputs) {
+        hashWriter.writeBytes(input.sequence.serialize());
+      }
+      this._hashSequence = hash256(hashWriter.toBuffer());
+    }
+
+    // Combines the outputs for the transaction according by
+    // concatenating the serialization of the outputs into a single
+    // byte array and then hash256 the values.
+    if (this._hashOutputs === undefined) {
+      const hashWriter = new BufferWriter();
+      for (const vout of this._outputs) {
+        hashWriter.writeBytes(vout.serialize());
+      }
+      this._hashOutputs = hash256(hashWriter.toBuffer());
+    }
+
+    writer.writeUInt32LE(this.version);
+    writer.writeBytes(this._hashPrevOuts);
+    writer.writeBytes(this._hashSequence);
+
+    const vin = this._inputs[index];
+    writer.writeBytes(vin.outpoint.serialize());
+    writer.writeBytes(commitScript.serialize());
+    writer.writeUInt64LE(value.sats);
+    writer.writeBytes(vin.sequence.serialize());
+
+    writer.writeBytes(this._hashOutputs);
+    writer.writeBytes(this.locktime.serialize());
+    writer.writeUInt32LE(1); // SIGHASH_ALL
+
+    return hash256(writer.toBuffer());
+  }
+
+  /**
+   * Signs an input and returns the DER encoded signature. The
+   * script that is committed to will depend on the type of the
+   * signature. This is usually the locking script used in the prior
+   * output, but in the case of p2sh transactions, this is the
+   * redeem script, or the underlying script that is hashed in the
+   * prior output.
+   *
+   * @param input index of input that should be signed
+   * @param commitScript Script that is committed during signature
+   * @param privateKey 32-byte private key
+   */
+  public sign(input: number, commitScript: Script, privateKey: Buffer): Buffer {
+    // create the hash of the transaction for the input
+    const hash = this.hashLegacy(input, commitScript);
+
+    // sign DER encode signature
+    const sig = sign(hash, privateKey);
+    const der = sigToDER(sig);
+
+    // return signature with 1-byte sighash type
+    return Buffer.concat([der, Buffer.from([1])]);
+  }
+
+  /**
+   * Signs an SegWit v0 input and returns the DER encoded signature.
+   * The script that is committed to will depend on the type of the
+   * input. This is usually the locking script or redeem script.
+   *
+   * @param input index of input that should be signed
+   * @param commitScript Script that is committed during signature
+   * @param privateKey 32-byte private key
+   * @param value value of the prior input
+   */
+  public signSegWitv0(
+    input: number,
+    commitScript: Script,
+    privateKey: Buffer,
+    value: Value,
+  ): Buffer {
+    // create the hash of the transaction for the input
+    const hash = this.hashSegwitv0(input, commitScript, value);
+
+    // sign DER encode signature
+    const sig = sign(hash, privateKey);
+    const der = sigToDER(sig);
+
+    // return signature with 1-byte sighash type
+    return Buffer.concat([der, Buffer.from([1])]);
+  }
+
+  /**
+   * Returns an immutable transaction
+   */
+  public toTx(): Tx {
+    return new Tx(
+      this.version,
+      this._inputs.map((vin) => vin.clone()),
+      this._outputs.map((vout) => vout.clone()),
+      this.locktime.clone(),
+    );
+  }
+
+  public serialize(): Buffer {
+    return this.toTx().serialize();
+  }
+
+  public toHex(pretty = false): string {
+    return this.toTx().toHex(pretty);
+  }
+}

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

@@ -0,0 +1,115 @@
+import { BufferWriter, StreamReader } from '@node-dlc/bufio';
+
+import { ICloneable } from './ICloneable';
+import { OutPoint } from './OutPoint';
+import { Script } from './Script';
+import { Sequence } from './Sequence';
+import { Witness } from './Witness';
+
+export class TxIn implements ICloneable<TxIn> {
+  /**
+   * Parses a TxIn from a a stream reader.
+   * @param stream
+   */
+  public static parse(reader: StreamReader): TxIn {
+    const outpoint = OutPoint.parse(reader);
+    const scriptSig = Script.parse(reader);
+    const sequence = new Sequence(reader.readUInt32LE());
+    return new TxIn(outpoint, scriptSig, sequence);
+  }
+
+  /**
+   * Parses a hex string serialization of a transaction input. This
+   * is a helper function instead of having to do `StreamReader.fromHex`
+   * on a string directly.
+   * @param hex
+   */
+  public static fromHex(hex: string): TxIn {
+    const reader = StreamReader.fromHex(hex);
+    return this.parse(reader);
+  }
+
+  /**
+   * The previous transaction output tuple
+   */
+  public outpoint: OutPoint;
+
+  /**
+   * ScriptSig for the input
+   */
+  public scriptSig: Script;
+
+  /**
+   * nSequence value for the transaction. Defaults to 0xffffffff which
+   * disables the absolute timelock.
+   */
+  public sequence: Sequence;
+
+  /**
+   * Witness data that is required by the input
+   */
+  public witness: Witness[];
+
+  /**
+   * Constructs a new transaction input from the values
+   * @param outpoint
+   * @param scriptSig
+   * @param sequence
+   * @param witness
+   */
+  constructor(
+    outpoint: OutPoint,
+    scriptSig: Script = new Script(),
+    sequence: Sequence = new Sequence(),
+    witness: Witness[] = [],
+  ) {
+    this.outpoint = outpoint;
+    this.scriptSig = scriptSig;
+    this.sequence = sequence;
+    this.witness = witness;
+  }
+
+  /**
+   * Creates a string of the transaction input that includes all of the
+   * properties.
+   */
+  public toString(): string {
+    return `prev=${this.outpoint.toString()}, scriptSig=${this.scriptSig.toString()}, sequence=${this.sequence.toString()}`; // prettier-ignore
+  }
+
+  /**
+   * Creates a JSON object of the transaction input that includes all
+   * of the properties.
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  public toJSON() {
+    return {
+      outpoint: this.outpoint.toJSON(),
+      scriptSig: this.scriptSig.toJSON(),
+      sequence: this.sequence.toJSON(),
+    };
+  }
+
+  /**
+   * Returns the byte serialization of the transaction input
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeBytes(this.outpoint.serialize());
+    writer.writeBytes(this.scriptSig.serialize());
+    writer.writeBytes(this.sequence.serialize());
+    return writer.toBuffer();
+  }
+
+  /**
+   * Clone via deep copy
+   */
+  public clone(): TxIn {
+    return new TxIn(
+      this.outpoint.clone(),
+      this.scriptSig.clone(),
+      this.sequence.clone(),
+      this.witness.map((p) => p.clone()),
+    );
+  }
+}

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

@@ -0,0 +1,87 @@
+import { BufferWriter, StreamReader } from '@node-dlc/bufio';
+
+import { ICloneable } from './ICloneable';
+import { Script } from './Script';
+import { Value } from './Value';
+
+export class TxOut implements ICloneable<TxOut> {
+  /**
+   * Parses a TxOut from a stream and returns a new instance of TxOut
+   * @param reader
+   */
+  public static parse(reader: StreamReader): TxOut {
+    const value = Value.fromSats(reader.readBigUInt64LE());
+    const scriptPubKey = Script.parse(reader);
+    return new TxOut(value, scriptPubKey);
+  }
+
+  /**
+   * Parses a hex string serialization of a transaction output. This
+   * is a helper function instead of having to do `StreamReader.fromHex`
+   * on a string directly.
+   * @param hex
+   */
+  public static fromHex(hex: string): TxOut {
+    const reader = StreamReader.fromHex(hex);
+    return TxOut.parse(reader);
+  }
+
+  /**
+   * Value (often in satoshi or bitcoin) that will be locked into the
+   * output using the provided scriptPubKey. The combined outputs must
+   * be lte the combined input value for in transaction.
+   */
+  public value: Value;
+
+  /**
+   * The locking script used to encumbered the value in the output.
+   * To claim these funds as an input in another transaction requires
+   * providing a ScriptSig that successfully evaluates when combined
+   * with the ScriptPubKey.
+   */
+  public scriptPubKey: Script;
+
+  /**
+   * Constructs a new TxOut from the supplied arguments
+   * @param value
+   * @param scriptPubKey
+   */
+  constructor(value: Value, scriptPubKey: Script) {
+    this.value = value;
+    this.scriptPubKey = scriptPubKey;
+  }
+
+  /**
+   * Returns the TxOut as a string
+   */
+  public toString(): string {
+    return `value="${this.value.sats}", scriptPubKey="${this.scriptPubKey}"`;
+  }
+
+  /**
+   * Returns the TxOut as a JSON object
+   */
+  public toJSON(): { value: string; scriptPubKey: string } {
+    return {
+      value: this.value.sats.toString(),
+      scriptPubKey: this.scriptPubKey.toJSON(),
+    };
+  }
+
+  /**
+   * Returns the serialization of the transaction output into a buffer
+   */
+  public serialize(): Buffer {
+    const writer = new BufferWriter();
+    writer.writeUInt64LE(this.value.sats);
+    writer.writeBytes(this.scriptPubKey.serialize());
+    return writer.toBuffer();
+  }
+
+  /**
+   * Clone via deep copy
+   */
+  public clone(): TxOut {
+    return new TxOut(this.value.clone(), this.scriptPubKey.clone());
+  }
+}

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

@@ -0,0 +1,201 @@
+import { ICloneable } from './ICloneable';
+
+/**
+ * Represents bitcoin value that can be converted to or from multiple
+ * formats.
+ */
+export class Value implements ICloneable<Value> {
+  /**
+   * Creates a value object from value in bitcoin, eg: 1.12345678
+   * @param num
+   */
+  public static fromBitcoin(num: number): Value {
+    return Value.fromSats(Math.round(num * 1e8));
+  }
+
+  /**
+   * Creates a value instance from value in satoshis where 1 satoshis
+   * equates to 0.00000001 bitcoin.
+   * @param num
+   */
+  public static fromSats(num: bigint | number): Value {
+    return new Value(BigInt(num) * BigInt(1e12));
+  }
+
+  /**
+   * Creates a value instance from value in millisatoshis, 1/1000 of a
+   * satoshi.
+   * eg: 123 millisatoshis equates to 0.123 satoshis
+   * eg: 123 millisatoshis equates to 0.00000000123 bitcoin
+   * @param num
+   */
+  public static fromMilliSats(num: bigint | number): Value {
+    return new Value(BigInt(num) * BigInt(1e9));
+  }
+
+  /**
+   * Creates a value instance from value in microsatoshis, 1/1e6 of a
+   * satoshi.
+   * eg: 123 microsatoshis equates to 0.000123 satoshis
+   * eg: 123 microsatoshis equates to 0.00000000000123 bitcoin
+   * @param num
+   */
+  public static fromMicroSats(num: bigint | number): Value {
+    return new Value(BigInt(num) * BigInt(1e6));
+  }
+
+  /**
+   * Creates a value instance from value in picosatoshis, 1/1e12 of a
+   * satoshi.
+   * eg: 123 picosatoshis equates to 0.000000000123 satoshis
+   * eg: 123 picosatoshis equates to 0.00000000000000000123 bitcoin
+   * @param num
+   */
+  public static fromPicoSats(num: bigint | number): Value {
+    return new Value(BigInt(num));
+  }
+
+  /**
+   * Generates a value instance of zero
+   */
+  public static zero(): Value {
+    return new Value(BigInt(0));
+  }
+
+  protected _picoSats: bigint;
+
+  /**
+   * Gets the value in picosatoshis (1/1e12 satoshis)
+   */
+  public get psats(): bigint {
+    return this._picoSats;
+  }
+
+  /**
+   * Gets the value in millionth of satoshis (1/1e6 satoshis)
+   */
+  public get microsats(): bigint {
+    return this._picoSats / BigInt(1e6);
+  }
+
+  /**
+   * Gets the value in millisatoshis (1/1000 satoshis)
+   */
+  public get msats(): bigint {
+    return this._picoSats / BigInt(1e9);
+  }
+
+  /**
+   * Gets the value in satoshis (1/1e8 bitcoin)
+   */
+  public get sats(): bigint {
+    return this._picoSats / BigInt(1e12);
+  }
+
+  /**
+   * Gets the value in bitcoin
+   */
+  public get bitcoin(): number {
+    return Math.max(0, Number(this.sats) / 1e8);
+  }
+
+  protected constructor(picoSats: bigint) {
+    this._picoSats = picoSats;
+  }
+
+  /**
+   * Clone via deep copy
+   */
+  public clone(): Value {
+    return new Value(this._picoSats);
+  }
+
+  /**
+   * Adds another value to this instance and returns this instance
+   * @param other
+   */
+  public add(other: Value): this {
+    this._picoSats += other.psats;
+    return this;
+  }
+
+  /**
+   * Adds another value to the current value and returns a new Value instance
+   * @param other
+   */
+  public addn(other: Value): Value {
+    return new Value(this._picoSats + other.psats);
+  }
+
+  /**
+   * Subtracts another value from this instance and returns this instance
+   * @param other
+   */
+  public sub(other: Value): this {
+    if (this._picoSats < other.psats) {
+      throw new Error('Value underflow');
+    }
+    this._picoSats -= other.psats;
+    return this;
+  }
+
+  /**
+   * Subtracts another value from the current value and returns a new Value instance
+   * @param other
+   */
+  public subn(other: Value): Value {
+    if (this._picoSats < other.psats) {
+      throw new Error('Value underflow');
+    }
+    return new Value(this._picoSats - other.psats);
+  }
+
+  /**
+   * Returns true if this value is less than the other value
+   * @param other
+   */
+  public lt(other: Value): boolean {
+    return this._picoSats < other.psats;
+  }
+
+  /**
+   * Returns true if this value is equal to the other value
+   * @param other
+   */
+  public eq(other: Value): boolean {
+    return this._picoSats === other.psats;
+  }
+
+  /**
+   * Returns true if this value is greater than the other value
+   * @param other
+   */
+  public gt(other: Value): boolean {
+    return this._picoSats > other.psats;
+  }
+
+  /**
+   * Returns true if this value is greater than or equal to the other value
+   * @param other
+   */
+  public gte(other: Value): boolean {
+    return this._picoSats >= other.psats;
+  }
+
+  /**
+   * Returns true if this value is less than or equal to the other value
+   * @param other
+   */
+  public lte(other: Value): boolean {
+    return this._picoSats <= other.psats;
+  }
+
+  /**
+   * Returns a string representation of the value in bitcoin format
+   * with 8 decimal places
+   */
+  public toString(): string {
+    const btc = this.bitcoin;
+    return btc.toFixed(8);
+  }
+}