@atomicfinance/bitcoin-dlc-provider 4.2.8 → 4.3.0

package/.yalc/@node-dlc/core/lib/lightning/TxFactory.ts

@@ -0,0 +1,338 @@
+import {
+  HashValue,
+  LockTime,
+  OutPoint,
+  Script,
+  Sequence,
+  TxBuilder,
+  TxOut,
+  Value,
+} from '@node-dlc/bitcoin';
+
+import { CommitmentNumber } from './CommitmentNumber';
+import { Htlc } from './Htlc';
+import { HtlcDirection } from './HtlcDirection';
+import { ScriptFactory } from './ScriptFactory';
+
+export class TxFactory {
+  /**
+   * Creates a TxOut to attach to a funding transaction. This includes
+   * the P2WSH-P2MS script that uses 2-2MS. The open and accept funding
+   * pubkeys are sorted lexicographcially to create the script.
+   * @param builder
+   */
+  public static createFundingOutput(
+    value: Value,
+    openPubKey: Buffer,
+    acceptPubKey: Buffer,
+  ): TxOut {
+    const script = Script.p2wshLock(
+      ScriptFactory.fundingScript(openPubKey, acceptPubKey),
+    );
+    return new TxOut(value, script);
+  }
+
+  /**
+   * Constructs an unsigned commitment transaction according to BOLT3.
+   * This method is a low level commitment transaction builder, meaning
+   * it accepts primatives and constructs a commitment transaction
+   * accordingly. The proper inputs are determiend
+   *
+   * @param isFunderLocal True when the funding node is local. This
+   * is used to determine which output pays fees (to_local/to_remote).
+   * @param commitmentNumber The commitment number of the transaction
+   * which is used to generate the obscurred commitment number.
+   * @param openPaymentBasePoint The basepoint sent in open_channel
+   * which is used to generate the obscurred commitment number.
+   * @param acceptPaymentBasePoint The basepoitn sent in accept_channel
+   * which is used to generate the obscurred commitment number.
+   * @param fundingOutPoint The outpoint of the funding transaction
+   * which was established in funding_created.
+   * @param dustLimitSatoshi The dust limit in sats after which outputs
+   * will be prune
+   * @param feePerKw The fee rate per kiloweight which will be deducted
+   * from the funding node's output
+   * @param localDelay The delay applied to the to_local output
+   * @param localValue Value paid to the to_local RSMC output
+   * @param remoteValue Value paid to the to_emote P2WPKH output
+   * @param revocationPubKey The revocation public key used to in the
+   * to_local and HTLC outputs
+   * @param delayedPubKey The delayed public key used to spend the
+   * to_local output
+   * @param remotePubKey The public key used to spend the to_remote
+   * output
+   * @param reverseHtlcs True when the HTLC direction needs to be
+   * inverted because the holder of this commitment transaction is
+   * our counterparty.
+   * @param localHtlcPubKey The public key used to spend HTLC outputs
+   * by the commitment holder.
+   * @param remoteHtlcPubKey The public key used to spend HTLC outputs
+   * by the commitment counterparty.
+   * @param htlcs A full list of HTLCs that will be selectively
+   * included in the commitment transaction based on the feePerKw.
+   */
+  public static createCommitment(
+    isFunderLocal: boolean,
+    commitmentNumber: number,
+    openPaymentBasePoint: Buffer,
+    acceptPaymentBasePoint: Buffer,
+    fundingOutPoint: OutPoint,
+    dustLimitSatoshi: Value,
+    feePerKw: bigint,
+    localDelay: number,
+    localValue: Value,
+    remoteValue: Value,
+    revocationPubKey: Buffer,
+    delayedPubKey: Buffer,
+    remotePubKey: Buffer,
+    reverseHtlcs: boolean,
+    localHtlcPubKey?: Buffer,
+    remoteHtlcPubKey?: Buffer,
+    htlcs: Htlc[] = [],
+  ): [TxBuilder, Htlc[]] {
+    const obscuredCommitmentNumber = CommitmentNumber.obscure(
+      commitmentNumber,
+      openPaymentBasePoint,
+      acceptPaymentBasePoint,
+    );
+
+    // 1. add the input as the funding outpoint and set the nSequence
+    const tx = new TxBuilder();
+    tx.version = 2;
+    tx.addInput(
+      fundingOutPoint,
+      CommitmentNumber.getSequence(obscuredCommitmentNumber),
+    );
+
+    // 2. set the locktime to the obscurred commitment number
+    tx.locktime = CommitmentNumber.getLockTime(obscuredCommitmentNumber);
+
+    // 3. find unpruned outputs
+    const unprunedHtlcs: Htlc[] = [];
+    for (const htlc of htlcs) {
+      const valueInSats = htlc.value.sats;
+      let feeWeight: bigint;
+
+      // HtlcDirection refers to the local nodes perception of the HTLC.
+      // When isLocal, offered uses the HTLC-Timeout weight of 663. When
+      // remote, the commitment is for the remote counterparty and an
+      // offered HTLC is received and will be spent by the remote
+      // counterparty using the HTLC-Success transaction with a weight of 703
+      if (reverseHtlcs) {
+        feeWeight =
+          htlc.direction === HtlcDirection.Offered ? BigInt(703) : BigInt(663);
+      } else {
+        feeWeight =
+          htlc.direction === HtlcDirection.Offered ? BigInt(663) : BigInt(703);
+      }
+
+      // Calculate the HTLC less fees
+      const feeInSats = (feeWeight * feePerKw) / BigInt(1000);
+      const satsLessFee = valueInSats - feeInSats;
+
+      // Only keep HTLCs greater than the dustLimitSatoshi for the tx
+      if (satsLessFee >= dustLimitSatoshi.sats) {
+        unprunedHtlcs.push(htlc);
+      }
+    }
+
+    // 4. calculate base fee
+    const weight = 724 + unprunedHtlcs.length * 172;
+    const baseFee = (BigInt(weight) * feePerKw) / BigInt(1000);
+
+    // 5. substract base fee from funding node
+    if (isFunderLocal) {
+      const newValue = localValue.sats - baseFee;
+      if (newValue > BigInt(0)) {
+        localValue = Value.fromSats(newValue);
+      } else {
+        localValue = Value.zero();
+      }
+    } else {
+      const newValue = remoteValue.sats - baseFee;
+      if (newValue > BigInt(0)) {
+        remoteValue = Value.fromSats(newValue);
+      } else {
+        remoteValue = Value.zero();
+      }
+    }
+
+    // 6/7. add unpruned offered/received HTLCs
+    const txouts: Array<[TxOut, Htlc?]> = [];
+    for (const htlc of unprunedHtlcs) {
+      const witnessScript: Script =
+        (!reverseHtlcs && htlc.direction === HtlcDirection.Offered) ||
+        (reverseHtlcs && htlc.direction === HtlcDirection.Accepted)
+          ? ScriptFactory.offeredHtlcScript(
+              htlc.paymentHash,
+              revocationPubKey,
+              localHtlcPubKey,
+              remoteHtlcPubKey,
+            )
+          : ScriptFactory.receivedHtlcScript(
+              htlc.paymentHash,
+              htlc.cltvExpiry,
+              revocationPubKey,
+              localHtlcPubKey,
+              remoteHtlcPubKey,
+            );
+      const txout = new TxOut(htlc.value, Script.p2wshLock(witnessScript));
+      txouts.push([txout, htlc]);
+    }
+
+    // 8. add local if unpruned
+    if (localValue.sats >= dustLimitSatoshi.sats) {
+      txouts.push([
+        new TxOut(
+          localValue,
+          Script.p2wshLock(
+            ScriptFactory.toLocalScript(
+              revocationPubKey,
+              delayedPubKey,
+              localDelay,
+            ),
+          ),
+        ),
+      ]);
+    }
+
+    // 9. add remote if unpruned
+    if (remoteValue.sats >= dustLimitSatoshi.sats) {
+      txouts.push([new TxOut(remoteValue, Script.p2wpkhLock(remotePubKey))]);
+    }
+
+    // 10. sort outputs using bip69 and using cltv for htlc tiebreaks
+    txouts.sort((a, b) => {
+      // compare on value
+      const value = Number(a[0].value.sats - b[0].value.sats);
+      if (value !== 0) return value;
+
+      // compare on script
+      const scriptCompare = a[0].scriptPubKey
+        .serializeCmds()
+        .compare(b[0].scriptPubKey.serializeCmds());
+      if (scriptCompare !== 0) return scriptCompare;
+
+      // tie-break on htlcs
+      return b[1].cltvExpiry - a[1].cltvExpiry;
+    });
+
+    // add hte outputs in sorted order
+    const sortedHtlcs: Htlc[] = [];
+    for (const [txout, htlc] of txouts) {
+      tx.addOutput(txout);
+      sortedHtlcs.push(htlc);
+    }
+
+    // return the tuple with the sorted htlcs
+    return [tx, sortedHtlcs];
+  }
+
+  /**
+   * Constructs an HTLC-Timeout transaction as defined in BOLT3. This
+   * transaction spends an offered HTLC from the commitment transaction
+   * and outputs the HTLC value less the fee. The output is spendable
+   * via an RSMC that is sequence locked for the received by the
+   * transaction owner. Finally this transaction has an absolute
+   * locktime of the HTLC's cltv expiry.
+   * @param commitmentTx
+   * @param outputIndex
+   * @param localDelay
+   * @param revocationPubKey
+   * @param delayedPubKey
+   * @param feePerKw
+   * @param htlc
+   */
+  public static createHtlcTimeout(
+    commitmentTx: HashValue,
+    outputIndex: number,
+    localDelay: number,
+    revocationPubKey: Buffer,
+    delayedPubKey: Buffer,
+    feePerKw: bigint,
+    htlc: Htlc,
+  ): TxBuilder {
+    const tx = new TxBuilder();
+
+    // Input points to the commmitment transaction and the BIP69
+    // sorted index of the HTLC. nSequence is set to zero.
+    tx.addInput(new OutPoint(commitmentTx, outputIndex), Sequence.zero());
+
+    // calc value less fees for this transaction
+    const weight = BigInt(663);
+    const fees = (weight * feePerKw) / BigInt(1000);
+    const sats = fees > htlc.value.sats ? 0 : htlc.value.sats - fees;
+
+    // Spends a P2WSH RSMC
+    tx.addOutput(
+      Value.fromSats(sats),
+      Script.p2wshLock(
+        ScriptFactory.toLocalScript(
+          revocationPubKey,
+          delayedPubKey,
+          localDelay,
+        ),
+      ),
+    );
+
+    // nLocktime is set to the cltvExpiry of the HTLC. This prevents
+    // the HTLC-Timeout from being broadcast until after the expiry
+    // has been reached.
+    tx.locktime = new LockTime(htlc.cltvExpiry);
+
+    return tx;
+  }
+
+  /**
+   * Constructs an HTLC-Success transaction as defined in BOLT3. This
+   * transaction spends a received HTLC form the commitment transaction
+   * and outputs the HTLC value less the fee. The output is spendable
+   * via an RSMC that is sequence locked for the received by the
+   * transaction owner.
+   * @param commitmentTx
+   * @param outputIndex
+   * @param localDelay
+   * @param revocationPubKey
+   * @param delayedPubKey
+   * @param feePerKw
+   * @param htlc
+   */
+  public static createHtlcSuccess(
+    commitmentTx: HashValue,
+    outputIndex: number,
+    localDelay: number,
+    revocationPubKey: Buffer,
+    delayedPubKey: Buffer,
+    feePerKw: bigint,
+    htlc: Htlc,
+  ): TxBuilder {
+    const tx = new TxBuilder();
+
+    // Input points to the commmitment transaction and the BIP69
+    // sorted index of the HTLC. nSequence is set to zero.
+    tx.addInput(new OutPoint(commitmentTx, outputIndex), Sequence.zero());
+
+    // calc value less fees for this transaction
+    const weight = BigInt(703);
+    const fees = (weight * feePerKw) / BigInt(1000);
+    const sats = fees > htlc.value.sats ? 0 : htlc.value.sats - fees;
+
+    // Spends a P2WSH RSMC
+    tx.addOutput(
+      Value.fromSats(sats),
+      Script.p2wshLock(
+        ScriptFactory.toLocalScript(
+          revocationPubKey,
+          delayedPubKey,
+          localDelay,
+        ),
+      ),
+    );
+
+    // nLockTime is zero since the tx owner can immediately spend
+    // this transaction if they have the preimage
+    tx.locktime = LockTime.zero();
+
+    return tx;
+  }
+}

package/.yalc/@node-dlc/core/lib/utils/BigIntUtils.ts

@@ -0,0 +1,64 @@
+import BigNumber from 'bignumber.js';
+
+export class BigIntMath {
+  static max(...values: bigint[]): bigint {
+    if (values.length === 0) {
+      return null;
+    }
+
+    if (values.length === 1) {
+      return values[0];
+    }
+
+    let max = values[0];
+    for (let i = 1; i < values.length; i++) {
+      if (values[i] > max) {
+        max = values[i];
+      }
+    }
+    return max;
+  }
+
+  static min(...values: bigint[]): bigint {
+    if (values.length === 0) {
+      return null;
+    }
+
+    if (values.length === 1) {
+      return values[0];
+    }
+
+    let min = values[0];
+    for (let i = 1; i < values.length; i++) {
+      if (values[i] < min) {
+        min = values[i];
+      }
+    }
+    return min;
+  }
+
+  static sign(value: bigint): bigint {
+    if (value > BigInt(0)) {
+      return BigInt(1);
+    }
+    if (value < BigInt(0)) {
+      return BigInt(-1);
+    }
+    return BigInt(0);
+  }
+
+  static abs(value: bigint): bigint {
+    if (this.sign(value) === BigInt(-1)) {
+      return -value;
+    }
+    return value;
+  }
+
+  static clamp(min: bigint, val: bigint, max: bigint): bigint {
+    return this.max(min, this.min(val, max));
+  }
+}
+
+export function toBigInt(num: BigNumber): bigint {
+  return BigInt(num.integerValue().toString());
+}

package/.yalc/@node-dlc/core/lib/utils/Precision.ts

@@ -0,0 +1,23 @@
+import BigNumber from 'bignumber.js';
+
+// Precision refers to the number of digits after the decimal point.
+// Refer to https://github.com/discreetlogcontracts/dlcspecs/blob/master/PayoutCurve.md#version-0-payout_function
+
+/**
+ * Extract the precision of a number
+ * @param num
+ * @returns The precision of the number
+ */
+export const getPrecision = (num: BigNumber): number =>
+  num.decimalPlaces(16).abs().modulo(1).shiftedBy(16).toNumber();
+
+/**
+ * Creates a precise number from a precision
+ * @param precision
+ * @returns The number with the given precision
+ */
+export const fromPrecision = (precision: number): BigNumber => {
+  if (precision.toString().length > 16)
+    throw new Error('Precision is too large');
+  return new BigNumber(precision).shiftedBy(-16);
+};

package/.yalc/@node-dlc/core/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@node-dlc/core",
+  "version": "1.0.1",
+  "description": "DLC Core",
+  "scripts": {
+    "start": "npm run build && node dist/index.js",
+    "test": "../../node_modules/.bin/nyc --reporter=lcov --reporter=text --extension=.ts ../../node_modules/.bin/mocha --require ts-node/register --recursive \"__tests__/**/*.spec.*\"",
+    "lint": "../../node_modules/.bin/eslint  .",
+    "lint:fix": "../../node_modules/.bin/eslint --fix  .",
+    "build": "../../node_modules/.bin/tsc --project tsconfig.json"
+  },
+  "keywords": [
+    "dlc",
+    "core"
+  ],
+  "author": "Atomic Finance <info@atomic.finance>",
+  "homepage": "https://github.com/atomicfinance/node-dlc/tree/master/packages/daemon",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/atomicfinance/node-dlc.git"
+  },
+  "dependencies": {
+    "@node-dlc/bitcoin": "^1.0.1",
+    "@node-dlc/bufio": "^1.0.1",
+    "@node-dlc/common": "^1.0.1",
+    "@node-dlc/crypto": "^1.0.1",
+    "@node-dlc/messaging": "^1.0.1",
+    "bignumber.js": "^9.0.1",
+    "bitcoin-networks": "^1.0.0",
+    "decimal.js": "10.4.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "yalcSig": "d6b67fd54b29f78ffbe9737666f9467e"
+}

package/.yalc/@node-dlc/core/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["./lib"],
+  "exclude": ["./dist", "node_modules"]
+}

package/.yalc/@node-dlc/core/yalc.sig

@@ -0,0 +1 @@
+d6b67fd54b29f78ffbe9737666f9467e

package/.yalc/@node-dlc/crypto/.eslintrc

@@ -0,0 +1,6 @@
+{
+  "extends": ["../../.eslintrc"],
+  "parserOptions": {
+    "project": "./tsconfig.json"
+  }
+}