@atomicfinance/bitcoin-dlc-provider 2.4.0 → 2.5.0

package/lib/BitcoinDlcProvider.ts

@@ -52,6 +52,7 @@ import {
   DualFundingTxFinalizer,
   groupByIgnoringDigits,
   HyperbolaPayoutCurve,
+  PolynomialPayoutCurve,
   roundPayout,
 } from '@node-dlc/core';
 import {
@@ -83,6 +84,7 @@ import {
   OracleEventV0,
   OracleInfoV0,
   PayoutFunctionV0,
+  PolynomialPayoutCurvePiece,
   ScriptWitnessV0,
 } from '@node-dlc/messaging';
 import { Script, Sequence, Tx } from '@node-lightning/bitcoin';
@@ -131,7 +133,15 @@ export default class BitcoinDlcProvider
 
     for (let i = 0; i < inputs.length; i++) {
       const input = inputs[i];
-      const keyPair = await this.getMethod('keyPair')(input.derivationPath);
+      let derivationPath = input.derivationPath;
+
+      if (!derivationPath) {
+        derivationPath = (
+          await this.getMethod('getWalletAddress')(input.address)
+        ).derivationPath;
+      }
+
+      const keyPair = await this.getMethod('keyPair')(derivationPath);
       const privKey = Buffer.from(keyPair.__D).toString('hex');
       privKeys.push(privKey);
     }
@@ -308,6 +318,66 @@ export default class BitcoinDlcProvider
     return { payouts, payoutGroups, messagesList };
   }
 
+  private GetPayoutsFromPolynomialPayoutFunction(
+    _dlcOffer: DlcOffer,
+    contractDescriptor: ContractDescriptorV1,
+    oracleInfo: OracleInfoV0,
+    totalCollateral: bigint,
+  ): GetPayoutsResponse {
+    if (_dlcOffer.type !== MessageType.DlcOfferV0)
+      throw Error('DlcOffer must be V0');
+    const dlcOffer = _dlcOffer as DlcOfferV0;
+    if (contractDescriptor.payoutFunction.type !== MessageType.PayoutFunctionV0)
+      throw Error('PayoutFunction must be V0');
+    const payoutFunction = contractDescriptor.payoutFunction as PayoutFunctionV0;
+    if (payoutFunction.pieces.length === 0)
+      throw Error('PayoutFunction must have at least once PayoutCurvePiece');
+    for (const piece of payoutFunction.pieces) {
+      if (
+        piece.payoutCurvePiece.type !== MessageType.PolynomialPayoutCurvePiece
+      )
+        throw Error('Must be PolynomialPayoutCurvePiece');
+    }
+    const eventDescriptor = oracleInfo.announcement.oracleEvent
+      .eventDescriptor as DigitDecompositionEventDescriptorV0;
+    if (
+      eventDescriptor.type !== MessageType.DigitDecompositionEventDescriptorV0
+    )
+      throw Error('Only DigitDecomposition Oracle Events supported');
+
+    const roundingIntervals = contractDescriptor.roundingIntervals;
+    const cetPayouts = PolynomialPayoutCurve.computePayouts(
+      payoutFunction,
+      totalCollateral,
+      roundingIntervals,
+    );
+
+    const payoutGroups: PayoutGroup[] = [];
+    cetPayouts.forEach((p) => {
+      payoutGroups.push({
+        payout: p.payout,
+        groups: groupByIgnoringDigits(
+          p.indexFrom,
+          p.indexTo,
+          eventDescriptor.base,
+          contractDescriptor.numDigits,
+        ),
+      });
+    });
+
+    const rValuesMessagesList = this.GenerateMessages(oracleInfo);
+
+    const { payouts, messagesList } = outputsToPayouts(
+      payoutGroups,
+      rValuesMessagesList,
+      dlcOffer.offerCollateralSatoshis,
+      dlcOffer.contractInfo.totalCollateral - dlcOffer.offerCollateralSatoshis,
+      true,
+    );
+
+    return { payouts, payoutGroups, messagesList };
+  }
+
   private GetPayouts(_dlcOffer: DlcOffer): GetPayoutsResponse[] {
     const { dlcOffer } = checkTypes({ _dlcOffer });
 
@@ -363,18 +433,45 @@ export default class BitcoinDlcProvider
     totalCollateral: bigint,
   ) {
     switch (contractDescriptor.type) {
-      case MessageType.ContractDescriptorV0:
+      case MessageType.ContractDescriptorV0: {
         throw Error('ContractDescriptorV0 not yet supported');
+      }
       case MessageType.ContractDescriptorV1:
-        // eslint-disable-next-line no-case-declarations
-        return this.GetPayoutsFromPayoutFunction(
-          dlcOffer,
-          contractDescriptor as ContractDescriptorV1,
-          oracleInfo,
-          totalCollateral,
-        );
-      default:
+        {
+          const contractDescriptorV1 = contractDescriptor as ContractDescriptorV1;
+          const payoutFunction = contractDescriptorV1.payoutFunction as PayoutFunctionV0;
+
+          // TODO: add a better check for this
+          const payoutCurvePiece = payoutFunction.pieces[0].payoutCurvePiece;
+
+          switch (payoutCurvePiece.type) {
+            case MessageType.HyperbolaPayoutCurvePiece:
+              return this.GetPayoutsFromPayoutFunction(
+                dlcOffer,
+                contractDescriptor as ContractDescriptorV1,
+                oracleInfo,
+                totalCollateral,
+              );
+            case MessageType.OldHyperbolaPayoutCurvePiece:
+              return this.GetPayoutsFromPayoutFunction(
+                dlcOffer,
+                contractDescriptor as ContractDescriptorV1,
+                oracleInfo,
+                totalCollateral,
+              );
+            case MessageType.PolynomialPayoutCurvePiece:
+              return this.GetPayoutsFromPolynomialPayoutFunction(
+                dlcOffer,
+                contractDescriptor as ContractDescriptorV1,
+                oracleInfo,
+                totalCollateral,
+              );
+          }
+        }
+        break;
+      default: {
         throw Error('ContractDescriptor must be V0 or V1');
+      }
     }
   }
 
@@ -550,9 +647,9 @@ export default class BitcoinDlcProvider
       network,
     );
 
-    const { derivationPath } = await this.getMethod('findAddress')([
-      fundingAddress,
-    ]);
+    const {
+      derivationPath,
+    } = await this.client.financewallet.quickFindAddress([fundingAddress]);
 
     const fundPrivateKeyPair = await this.getMethod('keyPair')(derivationPath);
     const fundPrivateKey = Buffer.from(fundPrivateKeyPair.__D).toString('hex');
@@ -914,6 +1011,84 @@ export default class BitcoinDlcProvider
     return fundTx;
   }
 
+  async FindOutcomeIndexFromPolynomialPayoutCurvePiece(
+    _dlcOffer: DlcOffer,
+    contractDescriptor: ContractDescriptorV1,
+    contractOraclePairIndex: number,
+    polynomialPayoutCurvePiece: PolynomialPayoutCurvePiece,
+    oracleAttestation: OracleAttestationV0,
+    outcome: bigint,
+  ): Promise<FindOutcomeResponse> {
+    const { dlcOffer } = checkTypes({ _dlcOffer });
+
+    const polynomialCurve = PolynomialPayoutCurve.fromPayoutCurvePiece(
+      polynomialPayoutCurvePiece,
+    );
+
+    const clampBN = (val: BigNumber) =>
+      BigNumber.max(
+        0,
+        BigNumber.min(val, dlcOffer.contractInfo.totalCollateral.toString()),
+      );
+
+    const payout = clampBN(polynomialCurve.getPayout(outcome));
+
+    const payoutResponses = this.GetPayouts(dlcOffer);
+    const payoutIndexOffset = this.GetIndicesFromPayouts(payoutResponses)[
+      contractOraclePairIndex
+    ].startingMessagesIndex;
+
+    const { payoutGroups } = payoutResponses[contractOraclePairIndex];
+
+    const intervalsSorted = [
+      ...contractDescriptor.roundingIntervals.intervals,
+    ].sort((a, b) => Number(b.beginInterval) - Number(a.beginInterval));
+
+    const interval = intervalsSorted.find(
+      (interval) => Number(outcome) >= Number(interval.beginInterval),
+    );
+
+    const roundedPayout = BigInt(
+      clampBN(
+        new BigNumber(roundPayout(payout, interval.roundingMod).toString()),
+      ).toString(),
+    );
+
+    const outcomesFormatted = oracleAttestation.outcomes.map((outcome) =>
+      parseInt(outcome),
+    );
+
+    let index = 0;
+    let groupIndex = -1;
+    let groupLength = 0;
+
+    for (const payoutGroup of payoutGroups) {
+      if (payoutGroup.payout === roundedPayout) {
+        groupIndex = payoutGroup.groups.findIndex((group) => {
+          return group.every((msg, i) => msg === outcomesFormatted[i]);
+        });
+        if (groupIndex === -1)
+          throw Error(
+            'Failed to Find OutcomeIndex From PolynomialPayoutCurvePiece. \
+Payout Group found but incorrect group index',
+          );
+        index += groupIndex;
+        groupLength = payoutGroup.groups[groupIndex].length;
+        break;
+      } else {
+        index += payoutGroup.groups.length;
+      }
+    }
+
+    if (groupIndex === -1)
+      throw Error(
+        'Failed to Find OutcomeIndex From PolynomialPayoutCurvePiece. \
+Payout Group not found',
+      );
+
+    return { index: payoutIndexOffset + index, groupLength };
+  }
+
   async FindOutcomeIndexFromHyperbolaPayoutCurvePiece(
     _dlcOffer: DlcOffer,
     contractDescriptor: ContractDescriptorV1,
@@ -1044,14 +1219,21 @@ Payout Group not found',
       .reduce((acc, val, i) => acc + Number(val) * base ** i, 0);
 
     const piecesSorted = payoutFunction.pieces.sort(
-      (a, b) => Number(b.endpoint) - Number(a.endpoint),
+      (a, b) => Number(a.endpoint) - Number(b.endpoint),
     );
 
     const piece = piecesSorted.find((piece) => outcome < piece.endpoint);
 
     switch (piece.payoutCurvePiece.type) {
       case MessageType.PolynomialPayoutCurvePiece:
-        throw Error('Polynomial Curve Piece not yet supported');
+        return this.FindOutcomeIndexFromPolynomialPayoutCurvePiece(
+          dlcOffer,
+          contractDescriptor,
+          contractOraclePairIndex,
+          piece.payoutCurvePiece as PolynomialPayoutCurvePiece,
+          oracleAttestation,
+          BigInt(outcome),
+        );
       case MessageType.HyperbolaPayoutCurvePiece:
         return this.FindOutcomeIndexFromHyperbolaPayoutCurvePiece(
           dlcOffer,
@@ -1555,11 +1737,13 @@ Payout Group not found',
       network,
     );
 
-    let walletAddress: Address = await this.getMethod('findAddress')([
-      offerFundingAddress,
-    ]);
+    let walletAddress: Address = await this.client.financewallet.quickFindAddress(
+      [offerFundingAddress],
+    );
     if (walletAddress) return true;
-    walletAddress = await this.getMethod('findAddress')([acceptFundingAddress]);
+    walletAddress = await this.client.financewallet.quickFindAddress([
+      acceptFundingAddress,
+    ]);
     if (walletAddress) return false;
 
     throw Error('Wallet Address not found for DlcOffer or DlcAccept');

package/package.json

@@ -1,33 +1,33 @@
 {
   "name": "@atomicfinance/bitcoin-dlc-provider",
   "umdName": "BitcoinDlcProvider",
-  "version": "2.4.0",
+  "version": "2.5.0",
   "description": "CAL Finance Bitcoin Dlc Provider",
   "author": "Atomic Finance <info@atomic.finance>",
   "homepage": "",
   "license": "ISC",
   "main": "dist/index.js",
   "scripts": {
-    "build": "../../node_modules/.bin/tsc --project tsconfig.json",
+    "build": "../../node_modules/.bin/swc lib --out-dir=dist --config-file=../../.swcrc",
     "prepublishOnly": "yarn run build",
     "test": "yarn run build",
     "lint": "../../node_modules/.bin/eslint --ignore-path ../../.eslintignore  -c ../../.eslintrc.js .",
     "lint:fix": "../../node_modules/.bin/eslint --fix --ignore-path ../../.eslintignore  -c ../../.eslintrc.js ."
   },
   "dependencies": {
-    "@atomicfinance/bitcoin-networks": "^2.4.0",
-    "@atomicfinance/provider": "^2.4.0",
-    "@atomicfinance/types": "^2.4.0",
+    "@atomicfinance/bitcoin-networks": "^2.5.0",
+    "@atomicfinance/provider": "^2.5.0",
+    "@atomicfinance/types": "^2.5.0",
     "@liquality/bitcoin-utils": "1.1.5",
     "@liquality/provider": "1.1.5",
     "@liquality/types": "1.1.5",
     "@liquality/utils": "1.1.5",
-    "@node-dlc/core": "0.12.0",
-    "@node-dlc/messaging": "0.12.0",
+    "@node-dlc/core": "0.18.3",
+    "@node-dlc/messaging": "0.18.3",
     "@node-lightning/bitcoin": "0.26.1",
     "@node-lightning/bufio": "0.26.1",
     "@node-lightning/crypto": "0.26.1",
-    "bignumber.js": "9.0.1",
+    "bignumber.js": "^9.0.1",
     "bip-schnorr": "0.6.2",
     "bitcoinjs-lib": "5.2.0",
     "lodash": "^4.17.20",
@@ -36,10 +36,10 @@
   },
   "devDependencies": {
     "@types/lodash": "^4.14.160",
-    "@types/node": "^16.10.2"
+    "@types/node": "16.10.3"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f746b0495c707d2162d92413aba3fa2dffbe169f"
+  "gitHead": "021537d74a46eb5bd578a7c4b122555e6b0a310f"
 }