@atomicfinance/client 4.2.7 → 4.2.8

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

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

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

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

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