@d8x/perpetuals-sdk 2.7.3 → 2.7.5

package/src/d8XMath.ts

@@ -637,15 +637,26 @@ export function pmExitFee(varphi: number, varphiBar: number, mu_m: number, m_0:
   const pLiq = varphi + mu_m - m_0;
   const kappa = calcKappa(varphiBar, pLiq, sigt);
   let fee = prdMktLvgFee(kappa, varphi, m_0);
+  // console.log({ pLiq, kappa, varphi });
   return fee;
 }
 
-export function pmOpenFee(varphi: number, varphiBar: number, mu_m: number, m_0: number, sigt: number, jump: number) {
-  const pLiq = varphi + mu_m - m_0;
+export function pmOpenFee(
+  varphi: number,
+  varphiBar: number,
+  lvg: number,
+  mu_m: number,
+  m_0: number,
+  sigt: number,
+  jump: number
+) {
+  let fee = Math.min(varphiBar, m_0) / lvg;
+  const pLiq = varphi + mu_m - fee;
   const kappa = calcKappa(varphiBar, pLiq, sigt);
   const es = calcJumpRisk(kappa, varphiBar, jump);
-  const feecap = (1 - varphiBar) * varphiBar - (1 - varphiBar) * m_0;
-  let fee = prdMktLvgFee(kappa, varphi, m_0);
+  const feecap = (1 - varphiBar) * varphiBar - (1 - varphiBar) * fee;
+  // let fee = prdMktLvgFee(kappa, varphi, m_0);
+  // console.log({ m_0, pLiq, lvg, kappa, es, feecap, fee, varphi, varphiBar });
   fee = fee + es;
   if (fee > feecap) {
     fee = feecap;
@@ -666,6 +677,41 @@ function firstNonZeroNum(numDec: bigint) {
   return pos;
 }
 
+function decodeUint16Float(num: bigint) {
+  // uint16 sgnNum = num >> 15;
+  const sgnNum = BigInt.asUintN(16, num >> 15n);
+  // uint16 sgnE = (num >> 14) & 1;
+  const sgnE = BigInt.asUintN(16, (num >> 14n) & 1n);
+  // uint16 val = (num >> 4) & ((2 ** 10) - 1);
+  const val = BigInt.asUintN(16, (num >> 4n) & (2n ** 10n - 1n));
+  // uint16 exponent = num & ((2 ** 4) - 1);
+  const exponent = BigInt.asUintN(16, num & (2n ** 4n - 1n));
+
+  // //convert val abcde to normalized form a.bcde
+  // int128 v = int128(uint128(val)) * ONE_64x64;
+  let v = ABK64x64ToFloat(BigInt.asIntN(128, BigInt.asUintN(128, val)) * ONE_64x64);
+  // uint256 exponent1 = first_nonzeronum(val);
+  let exponent1 = firstNonZeroNum(val);
+  if (exponent1 > 0n) {
+    exponent1 -= 1n;
+  }
+  // v = v.div(ABDKMath64x64.pow(10 * ONE_64x64, exponent1));
+  v = v / ABK64x64ToFloat(10n * ONE_64x64) ** Number(exponent1);
+  if (sgnE == 1n) {
+    // v = v.div(ABDKMath64x64.pow(10 * ONE_64x64, uint256(exponent)));
+    v = v / ABK64x64ToFloat(10n * ONE_64x64) ** Number(exponent);
+  } else {
+    // v = v.mul(ABDKMath64x64.pow(10 * ONE_64x64, uint256(exponent)));
+    v = v * ABK64x64ToFloat(10n * ONE_64x64) ** Number(exponent);
+  }
+  if (sgnNum == 1n) {
+    // v = v.neg();
+    v = -v;
+  }
+  // console.log({ num, v, fV: floatToABK64x64(v) });
+  return v;
+}
+
 function decodeUint24Float(num: number | bigint) {
   const n = BigInt(num);
 
@@ -688,23 +734,72 @@ function decodeUint24Float(num: number | bigint) {
 
 export function extractLvgFeeParams(conf: bigint) {
   // static replication of _checkOracleStatus and _extractLvgFeeParams
-  const param = BigInt.asIntN(64, conf >> 16n); //  int64(conf >> 16);
-  const enc = BigInt.asUintN(64, BigInt.asUintN(128, param)); // uint64(uint128(_param));
-  const j = BigInt.asUintN(64, enc >> 44n); // uint64 j = enc >> 44; //top 4 bits
-  const st = BigInt.asUintN(64, enc & ((BigInt.asUintN(64, 1n) << 44n) - 1n)); // uint64 st = enc & ((uint64(1) << 44) - 1); // low 44 bits are sigt (padded 24-bit)
-  const jump = ABK64x64ToFloat(BigInt.asUintN(128, BigInt.asIntN(64, j)) * BigInt.asIntN(128, 922337203685477580n)); // jump = int128(int64(j)) * int128(922337203685477580); // times 0.05 in ABDK
-
+  //  int64(conf >> 16);
+  const param = BigInt.asIntN(64, conf >> 16n);
+  // uint64(uint128(_param));
+  const enc = BigInt.asUintN(64, BigInt.asUintN(128, param));
+  // uint64 j = enc >> 44; //top 4 bits
+  const j = BigInt.asUintN(64, enc >> 44n);
+  // uint64 st = enc & ((uint64(1) << 44) - 1); // low 44 bits are sigt (padded 24-bit)
+  const st = BigInt.asUintN(64, enc & ((BigInt.asUintN(64, 1n) << 44n) - 1n));
+  // jump = int128(int64(j)) * int128(922337203685477580); // times 0.05 in ABDK
+  const jump = ABK64x64ToFloat(BigInt.asIntN(128, BigInt.asIntN(64, j))) * 0.5;
   const sigt = decodeUint24Float(BigInt.asUintN(24, st & ((1n << 24n) - 1n))); // uint24(st & ((1 << 24) - 1));
-
+  // console.log({ jump, sigt });
   return { jump, sigt };
 }
 
+export function decodePriceImpact(amount: bigint, params: bigint) {
+  // uint32 params;
+  // if (_amount > 0) {
+  //     params = uint32(_params & ((2 ** 32) - 1));
+  // } else {
+  //     params = uint32(_params >> 32);
+  // }
+  // console.log({ params2sided: params });
+  params = BigInt.asUintN(
+    32,
+    amount > 0n ? BigInt.asUintN(32, params) & BigInt.asUintN(32, 2n ** 32n - 1n) : BigInt.asUintN(32, params) >> 32n
+  );
+  // console.log({ amountSign: amount > 0n, params });
+  // int128 a = decodeUint16Float(uint16(params >> 16));
+  // int128 m = decodeUint16Float(uint16(params & ((2 ** 16) - 1)));
+  // int128 l = a.add(_amount.abs().mul(m));
+  const a = decodeUint16Float(BigInt.asUintN(16, params >> 16n));
+  const m = decodeUint16Float(BigInt.asUintN(16, params & (2n ** 16n - 1n)));
+  const l = a + Math.abs(ABK64x64ToFloat(amount)) * m;
+
+  // if (l < 0x200000000000000000) {
+  //     // here if impact is not close to overflow
+  //     return _amount < 0 ? -l.exp() : l.exp();
+  // }
+  let dp: number;
+  if (l < ABK64x64ToFloat(BigInt("0x200000000000000000"))) {
+    dp = amount < 0n ? -Math.exp(l) : Math.exp(l);
+  } else {
+    dp = (amount < 0n ? -1 : 1) * ABK64x64ToFloat(BigInt("0x40000000000000000000000000000000"));
+  }
+  // // return a very big number
+  // return
+  //     _amount < 0
+  //         ? -int128(0x40000000000000000000000000000000)
+  //         : int128(0x40000000000000000000000000000000);
+
+  return { a, m, l, dp };
+}
+
 //sigt = sigma*sqrt(t)
 function calcKappa(varphi: number, varphiLiq: number, sigt: number): number {
   const p = 1 - varphi;
   const pStar = 1 - varphiLiq;
   const x0 = Math.log(p / (1 - p));
   const a = Math.log(pStar / (1 - pStar));
+  // a - x0 = log( p*(1-p*) / (1-p)p* )
+  const cdfArg = Math.log((p * (1 - pStar)) / (pStar * (1 - p))) / sigt;
+  // console.log({ p, pStar, x0, a, sigt, cdfarg: (a - x0) / sigt });
+  if (isNaN(cdfArg)) {
+    return pStar * (1 - p) < p * (1 - pStar) ? 0 : 2;
+  }
   const kappa = 2 * (1 - cdfNormalStd((a - x0) / sigt));
   return kappa;
 }
@@ -721,14 +816,26 @@ function prdMktLvgFee(kappa: number, varphi: number, m0: number): number {
   return f;
 }
 
-function cdfNormalStd(x: number) {
-  const t = 1 / (1 + 0.2315419 * Math.abs(x));
-  const d = 0.3989423 * Math.exp((-x * x) / 2);
-  let prob = d * t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274))));
-  if (x > 0) {
-    prob = 1 - prob;
+export function erfc(x: number): number {
+  if (x < -10) {
+    return 0;
+  }
+  if (x > 10) {
+    return 1;
   }
-  return prob;
+  const z = Math.abs(x);
+  const t = 1 / (1 + z / 2);
+  // prettier-ignore
+  const r = t * Math.exp(-z * z - 1.26551223 + t * (1.00002368 +
+          t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 +
+          t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 +
+          t * (-0.82215223 + t * 0.17087277)))))))));
+
+  return x >= 0 ? r : 2 - r;
+}
+
+function cdfNormalStd(x: number) {
+  return 0.5 * erfc(-x / Math.sqrt(2));
 }
 /**
  * Margin balance for prediction markets

package/src/marketData.ts

@@ -505,7 +505,7 @@ export default class MarketData extends PerpetualDataHandler {
           perpId,
           floatToABK64x64(tradeAmountBC),
           [fS2, fS3],
-          indexPriceInfo.conf & ((1n << 16n) - 1n),
+          10n*(indexPriceInfo.conf & ((1n << 16n) - 1n)),
           indexPriceInfo.predMktCLOBParams,
         ]),
       },
@@ -847,8 +847,8 @@ export default class MarketData extends PerpetualDataHandler {
     tradeAmtBC: number,
     traderPosBC: number,
     traderLockedInQC: number,
+    traderLeverage: number,
     mu_m: number,
-    mr: number,
     m_0: number,
     conf: bigint
   ): number {
@@ -865,12 +865,13 @@ export default class MarketData extends PerpetualDataHandler {
         : 2 - traderLockedInQC / traderPosBC;
     let fee: number;
     const { jump, sigt } = extractLvgFeeParams(conf);
+
     if (isClose && !isFlip) {
       // exit fee
       fee = pmExitFee(varphi, varphiBar, mu_m, m_0, sigt, jump);
     } else {
       // open fee
-      fee = pmOpenFee(varphi, varphiBar, mu_m, mr, sigt, jump);
+      fee = pmOpenFee(varphi, varphiBar, traderLeverage, mu_m, m_0, sigt, jump);
     }
     if (fee < 0.001) {
       fee = 0.001;

package/src/version.ts

@@ -1 +1 @@
-export const D8X_SDK_VERSION = "2.7.3";
+export const D8X_SDK_VERSION = "2.7.5";