@atomicfinance/bitcoin-wallet-provider 3.6.1 → 4.0.1

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 --ignore-path ../../.eslintignore  -c ../../.eslintrc.js .",
+    "lint:fix": "../../node_modules/.bin/eslint --fix --ignore-path ../../.eslintignore  -c ../../.eslintrc.js .",
+    "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/CHANGELOG.md

@@ -1,5 +1,117 @@
 # @atomicfinance/bitcoin-wallet-provider
 
+## 4.0.1
+
+### Patch Changes
+
+- 03c6974: Add DLC input splicing support
+
+  This release introduces DLC (Discreet Log Contract) input splicing functionality, enabling more flexible contract funding and management.
+
+  ## Key Features
+  - **Core Types**: Added new types and interfaces for DLC input splicing operations
+  - **Provider Integration**: Implemented splicing support in BitcoinDlcProvider with proper input handling
+  - **Comprehensive Testing**: Added integration tests to validate splicing functionality
+  - **Dependency Updates**: Upgraded @node-dlc to v1.1.0 for enhanced splicing capabilities
+
+  ## What's New
+  - DLC contracts can now be funded using spliced inputs
+  - Enhanced input selection and handling for splicing operations
+  - Improved test coverage for edge cases in DLC splicing scenarios
+
+  This feature enables more efficient Bitcoin transaction management when working with DLC contracts by allowing existing UTXOs to be split and used as contract inputs.
+
+- d94fbbf: Fix TypeScript ESLint compatibility and improve type safety
+  - Upgrade @typescript-eslint dependencies to v6.21.0 for TypeScript 4.9.5 support
+
+- b83e3a8: Add single-funded DLC support and update to node-dlc v1.0.1
+  - Add comprehensive single-funded DLC support to BitcoinDlcProvider
+  - Update @node-dlc dependencies to v1.0.1 with single-funded support
+  - Update cfd-dlc-js to v0.0.52
+  - Implement single-funded DLC detection and validation logic
+  - Handle acceptDlcOffer with 0 collateral scenarios (no funding)
+  - Fix fundTxVout calculation for parties with collateral only
+  - Add getFundOutputValueSats helper with proper error handling
+  - Add markAsSingleFunded() calls for proper DLC type identification
+  - Skip funding validation when accept collateral is 0
+  - Generate addresses/keys without requiring funding inputs
+
+  Enables single-funded DLCs where one party provides all collateral
+  while the other party participates without funding inputs.
+
+- Updated dependencies [03c6974]
+- Updated dependencies [d94fbbf]
+- Updated dependencies [b83e3a8]
+  - @atomicfinance/types@4.0.1
+  - @atomicfinance/bitcoin-utils@4.0.1
+  - @atomicfinance/provider@4.0.1
+
+## 4.0.0
+
+### Major Changes
+
+- 8989c75: Upgrade to @node-dlc v1.0.0
+
+  ## Breaking Changes
+
+  This release upgrades to @node-dlc v1.0.0 with significant breaking changes:
+
+  ### Dependencies
+  - Upgraded @node-dlc packages from 0.24.0 to ^1.0.0
+  - Minimum Node.js version now 18.18.2
+  - Added decimal.js dependency for F64 type support
+
+  ### API Changes
+  - **Message Types**: Removed versioned suffixes (DlcOfferV0 → DlcOffer)
+  - **Property Names**:
+    - `fundingPubKey` → `fundingPubkey`
+    - `payoutSPK` → `payoutSpk`
+    - `changeSPK` → `changeSpk`
+    - `cetSignatures` → `cetAdaptorSignatures`
+    - `tempContractId` → `temporaryContractId`
+
+  ### Type System
+  - **Contract Descriptors**: V0/V1 types replaced with Enumerated/Numerical descriptors
+  - **Oracle Types**: OracleInfoV0 → SingleOracleInfo/MultiOracleInfo
+  - **Message Validation**: Switched from type-based to property-based checking
+  - **Enum Outcomes**: Migrated from Buffer to string format
+
+  ### New Features
+  - Enhanced oracle event descriptor handling
+  - Improved decimal precision with F64 types
+  - Fallback outcome index search algorithm
+  - Auto-generation of temporary contract IDs
+
+  ## Migration Guide
+
+  ### Code Updates Required
+
+  ```javascript
+  // Before
+  const dlcOffer = new DlcOfferV0();
+  dlcOffer.fundingPubKey = pubkey;
+  dlcOffer.payoutSPK = spk;
+
+  // After
+  const dlcOffer = new DlcOffer();
+  dlcOffer.fundingPubkey = pubkey;
+  dlcOffer.payoutSpk = spk;
+  ```
+
+  ### Environment
+  - Update Node.js to 18.18.2+
+  - Run `yarn install` to update dependencies
+  - Review custom DLC implementations for compatibility
+
+  This is a **major breaking change** requiring code updates in consuming applications.
+
+### Patch Changes
+
+- Updated dependencies [8989c75]
+  - @atomicfinance/types@4.0.0
+  - @atomicfinance/bitcoin-utils@4.0.0
+  - @atomicfinance/provider@4.0.0
+
 ## 3.6.1
 
 ### Patch Changes

package/dist/BitcoinWalletProvider.d.ts

@@ -40,7 +40,9 @@ declare const _default: <T extends Constructor<Provider>>(superclass: T) => (abs
         {
             inputTxHex: string;
             index: number;
-            vout: any;
+            vout: {
+                vSat: number;
+            };
             outputScript: Buffer;
         }
     ], addresses: string, tx: any, lockTime?: number, segwit?: boolean): Promise<Buffer[]>;
@@ -104,7 +106,7 @@ declare const _default: <T extends Constructor<Provider>>(superclass: T) => (abs
      */
     findAddress(addresses: string[], change?: boolean | null): Promise<Address>;
     getUsedAddresses(numAddressPerCall?: number): Promise<any[]>;
-    withCachedUtxos(func: () => any): Promise<any>;
+    withCachedUtxos(func: () => unknown): Promise<any>;
     getTotalFee(opts: SendOptions, max: boolean): Promise<number>;
     getTotalFees(transactions: SendOptions[], max: boolean): Promise<any>;
     getInputsForAmount(_targets: bT.OutputTarget[], feePerByte?: number, fixedInputs?: bT.Input[], numAddressPerCall?: number, sweep?: boolean): Promise<{

package/dist/BitcoinWalletProvider.js

@@ -46,6 +46,7 @@ var AddressSearchType;
 })(AddressSearchType = exports.AddressSearchType || (exports.AddressSearchType = {}));
 exports.default = (superclass) => {
     class BitcoinWalletProvider extends superclass {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         constructor(...args) {
             const options = args[0];
             const { network, baseDerivationPath, addressType = types_1.bitcoin.AddressType.BECH32, addressIndex = 0, changeAddressIndex = 0, } = options;