@atomicfinance/bitcoin-wallet-provider 4.0.0 → 4.0.2

package/.yalc/@node-dlc/core/lib/dlc/finance/LongCall.ts

@@ -0,0 +1,74 @@
+import { PayoutFunctionV0 } from '@node-dlc/messaging';
+import BN from 'bignumber.js';
+
+import { HyperbolaPayoutCurve } from '../HyperbolaPayoutCurve';
+
+const buildCurve = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): {
+  maxOutcome: bigint;
+  totalCollateral: bigint;
+  payoutCurve: HyperbolaPayoutCurve;
+} => {
+  const a = new BN(-1);
+  const b = new BN(0);
+  const c = new BN(0);
+  const d = new BN((strikePrice * contractSize).toString());
+
+  const f_1 = new BN(0);
+  const f_2 = new BN(Number(contractSize));
+
+  const payoutCurve = new HyperbolaPayoutCurve(a, b, c, d, f_1, f_2);
+
+  const maxOutcome = BigInt(
+    new BN(oracleBase).pow(oracleDigits).minus(1).toString(10),
+  );
+
+  return {
+    maxOutcome,
+    totalCollateral: contractSize,
+    payoutCurve,
+  };
+};
+
+const buildPayoutFunction = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  totalCollateral: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): { payoutFunction: PayoutFunctionV0; totalCollateral: bigint } => {
+  const { maxOutcome, payoutCurve } = buildCurve(
+    strikePrice,
+    contractSize,
+    oracleBase,
+    oracleDigits,
+  );
+
+  const payoutFunction = new PayoutFunctionV0();
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: maxOutcome,
+      outcomePayout: totalCollateral,
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: payoutCurve.toPayoutCurvePiece(),
+  });
+
+  payoutFunction.lastEndpoint = {
+    eventOutcome: maxOutcome,
+    outcomePayout: totalCollateral,
+    extraPrecision: 0,
+  };
+
+  return {
+    payoutFunction,
+    totalCollateral,
+  };
+};
+
+export const LongCall = { buildCurve, buildPayoutFunction };

package/.yalc/@node-dlc/core/lib/dlc/finance/LongPut.ts

@@ -0,0 +1,74 @@
+import { PayoutFunctionV0 } from '@node-dlc/messaging';
+import BN from 'bignumber.js';
+
+import { HyperbolaPayoutCurve } from '../HyperbolaPayoutCurve';
+
+const buildCurve = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): {
+  maxOutcome: bigint;
+  totalCollateral: bigint;
+  payoutCurve: HyperbolaPayoutCurve;
+} => {
+  const a = new BN(1);
+  const b = new BN(0);
+  const c = new BN(0);
+  const d = new BN((strikePrice * contractSize).toString());
+
+  const f_1 = new BN(0);
+  const f_2 = new BN(-Number(contractSize));
+
+  const payoutCurve = new HyperbolaPayoutCurve(a, b, c, d, f_1, f_2);
+
+  const maxOutcome = BigInt(
+    new BN(oracleBase).pow(oracleDigits).minus(1).toString(10),
+  );
+
+  return {
+    maxOutcome,
+    totalCollateral: contractSize,
+    payoutCurve,
+  };
+};
+
+const buildPayoutFunction = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  totalCollateral: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): { payoutFunction: PayoutFunctionV0; totalCollateral: bigint } => {
+  const { maxOutcome, payoutCurve } = buildCurve(
+    strikePrice,
+    contractSize,
+    oracleBase,
+    oracleDigits,
+  );
+
+  const payoutFunction = new PayoutFunctionV0();
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: maxOutcome,
+      outcomePayout: BigInt(0),
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: payoutCurve.toPayoutCurvePiece(),
+  });
+
+  payoutFunction.lastEndpoint = {
+    eventOutcome: maxOutcome,
+    outcomePayout: BigInt(0),
+    extraPrecision: 0,
+  };
+
+  return {
+    payoutFunction,
+    totalCollateral,
+  };
+};
+
+export const LongPut = { buildCurve, buildPayoutFunction };

package/.yalc/@node-dlc/core/lib/dlc/finance/OptionInfo.ts

@@ -0,0 +1,182 @@
+import {
+  ContractDescriptorType,
+  ContractInfo,
+  DigitDecompositionEventDescriptor,
+  HyperbolaPayoutCurvePiece,
+  MessageType,
+  MultiOracleInfo,
+  NumericalDescriptor,
+  PayoutCurvePieceType,
+  PayoutFunction,
+  SingleContractInfo,
+  SingleOracleInfo,
+} from '@node-dlc/messaging';
+import BN from 'bignumber.js';
+
+import { HyperbolaPayoutCurve } from '../HyperbolaPayoutCurve';
+import { CoveredCall } from './CoveredCall';
+import { ShortPut } from './ShortPut';
+
+export interface OptionInfo {
+  contractSize: bigint;
+  strikePrice: bigint;
+  premium?: bigint;
+  type?: OptionType;
+  expiry: Date;
+}
+
+export type HasOfferCollateral = {
+  offerCollateral: bigint;
+};
+
+export type HasContractInfo = {
+  contractInfo: ContractInfo;
+};
+
+export type HasType = {
+  type: MessageType;
+};
+
+export type OptionType = 'put' | 'call';
+
+export function getOptionInfoFromContractInfo(
+  _contractInfo: ContractInfo,
+): OptionInfo {
+  if (_contractInfo.type !== MessageType.SingleContractInfo)
+    throw Error('Only SingleContractInfo currently supported');
+
+  const contractInfo = _contractInfo as SingleContractInfo;
+  if (
+    contractInfo.contractDescriptor.contractDescriptorType !==
+    ContractDescriptorType.NumericOutcome
+  )
+    throw Error('Numeric Descriptor currently supported');
+
+  const oracleInfo = contractInfo.oracleInfo;
+
+  // Handle both SingleOracleInfo and MultiOracleInfo using proper type discrimination
+  let eventMaturityEpoch: number;
+  let eventDescriptor: DigitDecompositionEventDescriptor;
+
+  switch (oracleInfo.type) {
+    case MessageType.SingleOracleInfo: {
+      const singleOracleInfo = oracleInfo as SingleOracleInfo;
+      eventMaturityEpoch =
+        singleOracleInfo.announcement.oracleEvent.eventMaturityEpoch;
+      eventDescriptor = singleOracleInfo.announcement.oracleEvent
+        .eventDescriptor as DigitDecompositionEventDescriptor;
+
+      if (
+        singleOracleInfo.announcement.oracleEvent.eventDescriptor.type !==
+        MessageType.DigitDecompositionEventDescriptorV0
+      ) {
+        throw Error(
+          'Only DigitDecompositionEventDescriptorV0 currently supported',
+        );
+      }
+      break;
+    }
+    case MessageType.MultiOracleInfo: {
+      const multiOracleInfo = oracleInfo as MultiOracleInfo;
+      eventMaturityEpoch =
+        multiOracleInfo.announcements[0].oracleEvent.eventMaturityEpoch;
+      eventDescriptor = multiOracleInfo.announcements[0].oracleEvent
+        .eventDescriptor as DigitDecompositionEventDescriptor;
+
+      if (
+        multiOracleInfo.announcements[0].oracleEvent.eventDescriptor.type !==
+        MessageType.DigitDecompositionEventDescriptorV0
+      ) {
+        throw Error(
+          'Only DigitDecompositionEventDescriptorV0 currently supported',
+        );
+      }
+      break;
+    }
+    default:
+      throw Error(`Unknown oracle info type: ${oracleInfo.type}`);
+  }
+
+  const { base: oracleBase, nbDigits: oracleDigits } = eventDescriptor;
+
+  const contractDescriptor = contractInfo.contractDescriptor as NumericalDescriptor;
+  if (contractDescriptor.payoutFunction.type !== MessageType.PayoutFunction)
+    throw Error('Only PayoutFunction currently supported');
+
+  const payoutFunction = contractDescriptor.payoutFunction as PayoutFunction;
+  if (payoutFunction.payoutFunctionPieces.length === 0)
+    throw Error('PayoutFunction must have at least once PayoutFunctionPiece');
+  if (payoutFunction.payoutFunctionPieces.length > 1)
+    throw Error('More than one PayoutFunctionPiece not supported');
+
+  const payoutCurvePiece = payoutFunction.payoutFunctionPieces[0]
+    .payoutCurvePiece as HyperbolaPayoutCurvePiece;
+  if (payoutCurvePiece.payoutCurvePieceType !== PayoutCurvePieceType.Hyperbola)
+    throw Error('Must be HyperbolaPayoutCurvePiece');
+  if (!payoutCurvePiece.b.isZero() || !payoutCurvePiece.c.isZero())
+    throw Error('b and c HyperbolaPayoutCurvePiece values must be 0');
+
+  const curve = HyperbolaPayoutCurve.fromPayoutCurvePiece(payoutCurvePiece);
+  const maxOutcome = BigInt(
+    new BN(oracleBase).pow(oracleDigits).minus(1).toString(10),
+  );
+
+  // For the new PayoutFunction structure, we need to get the initial payout from the first piece
+  const initialPayout =
+    payoutFunction.payoutFunctionPieces[0].endPoint.outcomePayout;
+  const isAscending = curve.getPayout(maxOutcome).gt(Number(initialPayout));
+
+  const expiry = new Date(eventMaturityEpoch * 1000);
+  const totalCollateral = contractInfo.totalCollateral;
+
+  // if curve is ascending, assume it is a put.
+  const contractSize = isAscending
+    ? BigInt(payoutCurvePiece.translatePayout.toDecimal().toString()) -
+      totalCollateral
+    : totalCollateral -
+      BigInt(payoutCurvePiece.translatePayout.toDecimal().toString());
+
+  const strikePrice =
+    BigInt(payoutCurvePiece.d.toDecimal().toString()) / contractSize;
+
+  // rebuild payout curve from option info and perform a sanity check
+  const { payoutCurve: sanityCurve } = isAscending
+    ? ShortPut.buildCurve(
+        strikePrice,
+        contractSize,
+        totalCollateral,
+        oracleBase,
+        oracleDigits,
+      )
+    : CoveredCall.buildCurve(
+        strikePrice,
+        contractSize,
+        oracleBase,
+        oracleDigits,
+      );
+  const type = isAscending ? 'put' : 'call';
+
+  if (!curve.equals(sanityCurve))
+    throw new Error(
+      'Payout curve built from extracted OptionInfo does not match original payout curve',
+    );
+
+  return { contractSize, strikePrice, expiry, type };
+}
+
+export function getOptionInfoFromOffer(
+  offer: HasOfferCollateral & HasContractInfo & HasType,
+): OptionInfo {
+  if (
+    offer.type !== MessageType.DlcOffer &&
+    offer.type !== MessageType.OrderOffer
+  )
+    throw Error('Only DlcOffer and OrderOffer currently supported');
+
+  const premium = offer.contractInfo.totalCollateral - offer.offerCollateral;
+
+  return {
+    ...getOptionInfoFromContractInfo(offer.contractInfo),
+    premium,
+  };
+}

package/.yalc/@node-dlc/core/lib/dlc/finance/ShortPut.ts

@@ -0,0 +1,75 @@
+import { PayoutFunctionV0 } from '@node-dlc/messaging';
+import BN from 'bignumber.js';
+
+import { HyperbolaPayoutCurve } from '../HyperbolaPayoutCurve';
+
+const buildCurve = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  totalCollateral: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): {
+  maxOutcome: bigint;
+  totalCollateral: bigint;
+  payoutCurve: HyperbolaPayoutCurve;
+} => {
+  const a = new BN(-1);
+  const b = new BN(0);
+  const c = new BN(0);
+  const d = new BN((strikePrice * contractSize).toString());
+
+  const f_1 = new BN(0);
+  const f_2 = new BN(Number(contractSize)).plus(Number(totalCollateral));
+
+  const payoutCurve = new HyperbolaPayoutCurve(a, b, c, d, f_1, f_2);
+
+  const maxOutcome = BigInt(
+    new BN(oracleBase).pow(oracleDigits).minus(1).toString(10),
+  );
+
+  return {
+    maxOutcome,
+    totalCollateral,
+    payoutCurve,
+  };
+};
+
+const buildPayoutFunction = (
+  strikePrice: bigint,
+  contractSize: bigint,
+  totalCollateral: bigint,
+  oracleBase: number,
+  oracleDigits: number,
+): { payoutFunction: PayoutFunctionV0 } => {
+  const { maxOutcome, payoutCurve } = buildCurve(
+    strikePrice,
+    contractSize,
+    totalCollateral,
+    oracleBase,
+    oracleDigits,
+  );
+
+  const payoutFunction = new PayoutFunctionV0();
+
+  payoutFunction.payoutFunctionPieces.push({
+    endPoint: {
+      eventOutcome: maxOutcome,
+      outcomePayout: totalCollateral,
+      extraPrecision: 0,
+    },
+    payoutCurvePiece: payoutCurve.toPayoutCurvePiece(),
+  });
+
+  payoutFunction.lastEndpoint = {
+    eventOutcome: maxOutcome,
+    outcomePayout: totalCollateral,
+    extraPrecision: 0,
+  };
+
+  return {
+    payoutFunction,
+  };
+};
+
+export const ShortPut = { buildCurve, buildPayoutFunction };

package/.yalc/@node-dlc/core/lib/index.ts

@@ -0,0 +1,66 @@
+export * from '@node-dlc/bitcoin';
+
+// Explicitly re-export commonly used types from bitcoin for better TypeScript support
+export * from './AsyncProcessingQueue';
+export * from './Base32';
+export * from './BigIntUtils';
+export * from './BitField';
+export * from './ChannelId';
+export * from './LinkedList';
+export * from './LinkedListNode';
+export * from './Queue';
+export * from './ShortChannelId';
+export * from './ShortChannelIdUtils';
+export {
+  HashByteOrder,
+  HashValue,
+  OutPoint,
+  Script,
+  Tx,
+  TxBuilder,
+  TxIn,
+  TxOut,
+  Value,
+} from '@node-dlc/bitcoin';
+
+// Explicitly export the utility functions that wire needs
+export {
+  shortChannelIdFromBuffer,
+  shortChannelIdFromNumber,
+  shortChannelIdFromString,
+  shortChannelIdToBuffer,
+  shortChannelIdToNumber,
+  shortChannelIdToString,
+} from './ShortChannelIdUtils';
+
+// Lightning subdirectory exports (excluding ChannelId to avoid conflict)
+export { ChannelId as LightningChannelId } from './lightning/ChannelId';
+export * from './lightning/ChannelKeys';
+export * from './lightning/CommitmentNumber';
+export * from './lightning/CommitmentSecret';
+export * from './lightning/CommitmentSecretStore';
+export * from './lightning/Htlc';
+export * from './lightning/HtlcDirection';
+export * from './lightning/ScriptFactory';
+export * from './lightning/TxFactory';
+
+// Original node-dlc core exports
+export * from './dlc/CETCalculator';
+export * from './dlc/CoinSelect';
+export * from './dlc/HyperbolaPayoutCurve';
+export * from './dlc/PayoutCurve';
+export * from './dlc/PolynomialPayoutCurve';
+export * from './dlc/TxBuilder';
+export * from './dlc/TxFinalizer';
+
+// Finance subdirectory exports
+export * from './dlc/finance/Builder';
+export * from './dlc/finance/CoveredCall';
+export * from './dlc/finance/CsoInfo';
+export * from './dlc/finance/LinearPayout';
+export * from './dlc/finance/LongCall';
+export * from './dlc/finance/LongPut';
+export * from './dlc/finance/OptionInfo';
+export * from './dlc/finance/ShortPut';
+export * from './utils/BigIntUtils';
+export * from './utils/Precision';

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

@@ -0,0 +1,54 @@
+import { HashByteOrder, OutPoint } from '@node-dlc/bitcoin';
+
+/**
+ * ChannelId type that that encapsulates an outpoint as a 32-byte value
+ * and is used to identify a channel. This type is defined in BOLT 2
+ * under the peer protocol. It is defined as combinging the funding_txid
+ * and the funding_output_index, using big-endian XOR (meaning the
+ * output_index modifies the last two bytes).
+ */
+export class ChannelId {
+  public static fromOutPoint(outpoint: OutPoint): ChannelId {
+    const txid = outpoint.txid.serialize(HashByteOrder.RPC);
+
+    if (outpoint.outputIndex > 0xffff) {
+      throw new Error('Invalid output index length');
+    }
+
+    txid[30] ^= outpoint.outputIndex >> 8;
+    txid[31] ^= outpoint.outputIndex & 0xff;
+
+    return new ChannelId(txid);
+  }
+
+  constructor(readonly value: Buffer) {}
+
+  /**
+   * Converts the ChannelId into a buffer
+   */
+  public toBuffer(): Buffer {
+    return Buffer.from(this.value);
+  }
+
+  /**
+   * Converts the ChannelId into a hex-encoded string
+   */
+  public toString(): string {
+    return this.toHex();
+  }
+
+  /**
+   * Converts the ChannelId to a hex-encoded string
+   */
+  public toHex(): string {
+    return this.value.toString('hex');
+  }
+
+  /**
+   * Returns true if the ChannelIds are byte-wise equal
+   * @param other
+   */
+  public equals(other: ChannelId): boolean {
+    return this.value.equals(other.value);
+  }
+}

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

@@ -0,0 +1,109 @@
+import * as crypto from '@node-dlc/crypto';
+
+export class ChannelKeys {
+  /**
+   * Derives a public key that can be used for local or remote
+   * pubkey, htlc_pubkey, or delayed_pubkey
+   *
+   * Derived via:
+   *  pubkey = basepoint + SHA256(per_commitment_point || basepoint) * G
+   *
+   * @param perCommitmentPoint 33-byte buffer
+   * @param basePoint 33-byte base point
+   * @returns 33-byte buffer
+   */
+  public static derivePubKey(
+    perCommitmentPoint: Buffer,
+    basePoint: Buffer,
+  ): Buffer {
+    const tweak = crypto.sha256(Buffer.concat([perCommitmentPoint, basePoint]));
+    return crypto.publicKeyTweakAdd(basePoint, tweak, true);
+  }
+
+  /**
+   * Derives the private keys based on local basepoint secrets and can
+   * be used to derive per-commitment
+   * - payment_scret
+   * - delayedpayment_secret
+   * - htlc_secret
+   *
+   * Derived via:
+   *  privkey = basepoint_secret + SHA256(per_commitment_point || basepoint)
+   *
+   * @param perCommitmentPoint 32-byte buffer
+   * @param basePointSecret 32-byte buffer
+   * @return 32-byte buffer
+   */
+  public static derivePrivKey(
+    perCommitmentPoint: Buffer,
+    basePointSecret: Buffer,
+  ): Buffer {
+    const basePoint = crypto.getPublicKey(basePointSecret, true);
+    const tweak = crypto.sha256(Buffer.concat([perCommitmentPoint, basePoint]));
+    return crypto.privateKeyTweakAdd(basePointSecret, tweak);
+  }
+
+  /**
+   * Derives the revocationpubkey blinded key for either local or
+   * remote revocation pubkey generation.
+   *
+   * Derived via:
+   *  revocationpubkey = revocation_basepoint * SHA256(revocation_basepoint || per_commitment_point) +
+   *                     per_commitment_point * SHA256(per_commitment_point || revocation_basepoint)
+   *
+   * @param perCommitmentPoint 33-byte buffer
+   * @param basePoint 33-byte buffer
+   * @returns 33-byte buffer
+   */
+  public static deriveRevocationPubKey(
+    perCommitmentPoint: Buffer,
+    basePoint: Buffer,
+  ): Buffer {
+    const tweakA = crypto.sha256(
+      Buffer.concat([basePoint, perCommitmentPoint]),
+    );
+    const a = crypto.publicKeyTweakMul(basePoint, tweakA, true);
+
+    const tweakB = crypto.sha256(
+      Buffer.concat([perCommitmentPoint, basePoint]),
+    );
+    const b = crypto.publicKeyTweakMul(perCommitmentPoint, tweakB, true);
+
+    return crypto.publicKeyCombine([a, b], true);
+  }
+
+  /**
+   * Derives the revocationprivkey which is used by the local node
+   * and with a per_commitment_secret that was revealed by the
+   * counterparty.
+   *
+   * Derived via:
+   * revocationprivkey = revocation_basepoint_secret * SHA256(revocation_basepoint || per_commitment_point) +
+   *                     per_commitment_secret * SHA256(per_commitment_point || revocation_basepoint)
+   * @param perCommitmentPointSecret 32-byte buffer
+   * @param basePointSecret 32-byte buffer
+   */
+  public static deriveRevocationPrivKey(
+    perCommitmentPointSecret: Buffer,
+    basePointSecret: Buffer,
+  ): Buffer {
+    const basePoint = crypto.getPublicKey(basePointSecret, true);
+    const perCommitmentPoint = crypto.getPublicKey(
+      perCommitmentPointSecret,
+      true,
+    );
+
+    const tweakA = crypto.sha256(
+      Buffer.concat([basePoint, perCommitmentPoint]),
+    );
+    const a = crypto.privateKeyTweakMul(basePointSecret, tweakA);
+
+    const tweakB = crypto.sha256(
+      Buffer.concat([perCommitmentPoint, basePoint]),
+    );
+    const b = crypto.privateKeyTweakMul(perCommitmentPointSecret, tweakB);
+
+    const result = crypto.privateKeyTweakAdd(a, b);
+    return result;
+  }
+}