@paraswap/dex-lib 2.42.16 → 2.42.17-wombat.0

package/src/dex/wombat/wombat-pool.ts

@@ -0,0 +1,231 @@
+import { Interface } from '@ethersproject/abi';
+import { Address } from '@paraswap/core';
+import _ from 'lodash';
+
+import { MultiCallParams, MultiResult } from '../../lib/multi-wrapper';
+import { IDexHelper } from '../../dex-helper';
+import { StatefulRpcPoller } from '../../lib/stateful-rpc-poller/stateful-rpc-poller';
+import { StatePollingManager } from '../../lib/stateful-rpc-poller/state-polling-manager';
+import { ObjWithUpdateInfo } from '../../lib/stateful-rpc-poller/types';
+import { pollingManagerCbExtractor } from '../../lib/stateful-rpc-poller/utils';
+import {
+  addressArrayDecode,
+  booleanDecode,
+  uint256ToBigInt,
+  uint8ToNumber,
+} from '../../lib/decoders';
+import PoolABI from '../../abi/wombat/pool.json';
+import AssetABI from '../../abi/wombat/asset.json';
+import { uint120ToBigInt } from './utils';
+import { AssetState, MulticallResultOutputs, PoolState } from './types';
+
+export class WombatPool extends StatefulRpcPoller<
+  PoolState,
+  MulticallResultOutputs
+> {
+  static readonly poolInterface = new Interface(PoolABI);
+  static readonly assetInterface = new Interface(AssetABI);
+
+  constructor(
+    dexKey: string,
+    poolIdentifier: string,
+    dexHelper: IDexHelper,
+    protected poolAddress: Address,
+    protected asset2TokenMap: Map<Address, Address>,
+  ) {
+    const callbacks = pollingManagerCbExtractor(
+      StatePollingManager.getInstance(dexHelper),
+    );
+
+    super(dexKey, poolIdentifier, dexHelper, 0, 0, false, callbacks);
+  }
+
+  protected _getFetchStateMultiCalls(): MultiCallParams<MulticallResultOutputs>[] {
+    const params: MultiCallParams<MulticallResultOutputs>[] = [];
+
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('paused'),
+      decodeFunction: booleanDecode,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('ampFactor'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('haircutRate'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('startCovRatio'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('endCovRatio'),
+      decodeFunction: uint256ToBigInt,
+    });
+    params.push({
+      target: this.poolAddress,
+      callData: WombatPool.poolInterface.encodeFunctionData('getTokens'),
+      decodeFunction: addressArrayDecode,
+    });
+
+    this.asset2TokenMap.forEach((token, asset) => {
+      params.push({
+        target: this.poolAddress,
+        callData: WombatPool.poolInterface.encodeFunctionData('isPaused', [
+          token,
+        ]),
+        decodeFunction: booleanDecode,
+      });
+      params.push({
+        target: asset,
+        callData: WombatPool.assetInterface.encodeFunctionData('cash'),
+        decodeFunction: uint120ToBigInt,
+      });
+      params.push({
+        target: asset,
+        callData: WombatPool.assetInterface.encodeFunctionData('liability'),
+        decodeFunction: uint120ToBigInt,
+      });
+      params.push({
+        target: asset,
+        callData: WombatPool.assetInterface.encodeFunctionData(
+          'underlyingTokenDecimals',
+        ),
+        decodeFunction: uint8ToNumber,
+      });
+      params.push({
+        target: asset,
+        callData:
+          WombatPool.assetInterface.encodeFunctionData('getRelativePrice'),
+        decodeFunction: uint256ToBigInt,
+      });
+    });
+
+    return params;
+  }
+
+  protected _parseStateFromMultiResults(
+    multiOutputs: MulticallResultOutputs[],
+  ): PoolState {
+    const [
+      paused,
+      ampFactor,
+      haircutRate,
+      startCovRatio,
+      endCovRatio,
+      tokens,
+      ...remained
+    ] = multiOutputs as [
+      boolean,
+      bigint,
+      bigint,
+      bigint,
+      bigint,
+      Address[],
+      ...MulticallResultOutputs[],
+    ];
+
+    const assetTokenArray = Array.from(this.asset2TokenMap.entries());
+    const token2AssetStates = new Map<Address, AssetState>();
+    _.chunk(remained, 5).forEach((chunk, i) => {
+      const [paused, cash, liability, underlyingTokenDecimals, relativePrice] =
+        chunk as [boolean, bigint, bigint, number, bigint | undefined];
+
+      const [asset, token] = assetTokenArray[i];
+      token2AssetStates.set(token, {
+        address: asset,
+        paused,
+        cash,
+        liability,
+        underlyingTokenDecimals,
+        relativePrice,
+      });
+    });
+
+    const poolState: PoolState = {
+      params: {
+        paused,
+        ampFactor,
+        haircutRate,
+        startCovRatio,
+        endCovRatio,
+      },
+      underlyingAddresses: tokens,
+      asset: {},
+    };
+
+    const isMainPool =
+      Array.from(token2AssetStates.values()).filter(
+        assetState => assetState.relativePrice === undefined,
+      ).length > 0;
+    for (const token of poolState.underlyingAddresses) {
+      if (!token2AssetStates.has(token)) {
+        // this happens when asset has been added to pool but is not added to BMW yet
+        continue;
+      }
+      poolState.asset[token] = token2AssetStates.get(token)!;
+      if (isMainPool) {
+        poolState.asset[token].relativePrice = undefined;
+      }
+    }
+
+    return poolState;
+  }
+
+  public async fetchLatestStateFromRpc(): Promise<ObjWithUpdateInfo<PoolState> | null> {
+    const multiCalls = this.getFetchStateWithBlockInfoMultiCalls();
+    try {
+      const lastUpdatedAtMs = Date.now();
+      const aggregatedResults = (await this.dexHelper.multiWrapper.tryAggregate<
+        number | MulticallResultOutputs
+      >(
+        false,
+        multiCalls as MultiCallParams<MulticallResultOutputs | number>[],
+      )) as [MultiResult<number>, ...MultiResult<MulticallResultOutputs>[]];
+
+      return this.parseStateFromMultiResultsWithBlockInfo(
+        aggregatedResults,
+        lastUpdatedAtMs,
+      );
+    } catch (e) {
+      this._logMessageWithSuppression('ERROR_FETCHING_STATE_FROM_RPC', e);
+    }
+
+    return null;
+  }
+
+  public parseStateFromMultiResultsWithBlockInfo(
+    multiOutputs: [
+      MultiResult<number>,
+      ...MultiResult<MulticallResultOutputs>[],
+    ],
+    lastUpdatedAtMs: number,
+  ): ObjWithUpdateInfo<PoolState> {
+    const [blockNumber, ...outputsForAbstract] = multiOutputs.map((m, i) => {
+      return m.returnData;
+    }) as [number, ...MulticallResultOutputs[]];
+
+    return {
+      value: this._parseStateFromMultiResults(outputsForAbstract),
+      blockNumber,
+      lastUpdatedAtMs,
+    };
+  }
+
+  public addAssets(asset2TokenMap: Map<Address, Address>) {
+    for (const [asset, token] of asset2TokenMap) {
+      if (this.asset2TokenMap.has(asset)) {
+        continue;
+      }
+
+      this.asset2TokenMap.set(asset, token);
+      this._cachedMultiCallData = undefined;
+    }
+  }
+}

package/src/dex/wombat/wombat-quoter.ts

@@ -0,0 +1,269 @@
+import { AssetState, PoolParams } from './types';
+import { fromWad, sqrt, toWad, WAD, wdiv, wmul } from './utils';
+
+export class WombatQuoter {
+  private readonly ampFactor: bigint;
+  private readonly haircutRate: bigint;
+  private readonly startCovRatio: bigint;
+  private readonly endCovRatio: bigint;
+
+  constructor(poolParams: PoolParams) {
+    this.ampFactor = poolParams.ampFactor;
+    this.haircutRate = poolParams.haircutRate;
+    this.startCovRatio = poolParams.startCovRatio;
+    this.endCovRatio = poolParams.endCovRatio;
+  }
+
+  public getQuote(
+    fromAsset: AssetState,
+    toAsset: AssetState,
+    fromAmount: bigint,
+  ): bigint {
+    if (fromAmount === 0n || fromAsset.paused) {
+      return 0n;
+    }
+
+    fromAmount = toWad(fromAmount, BigInt(fromAsset.underlyingTokenDecimals));
+
+    try {
+      const { actualToAmount, haircut } = this._highCovRatioPoolQuoteFrom(
+        fromAsset,
+        toAsset,
+        fromAmount,
+      );
+      const toCash = toAsset.cash - actualToAmount - haircut;
+
+      if (wdiv(toCash, toAsset.liability) < WAD / 100n) {
+        return 0n;
+      }
+
+      return fromWad(actualToAmount, BigInt(toAsset.underlyingTokenDecimals));
+    } catch (e) {
+      return 0n;
+    }
+  }
+
+  private _highCovRatioPoolQuoteFrom(
+    fromAsset: AssetState,
+    toAsset: AssetState,
+    fromAmount: bigint,
+  ): { actualToAmount: bigint; haircut: bigint } {
+    let { actualToAmount, haircut } = this._quoteFrom(
+      fromAsset,
+      toAsset,
+      fromAmount,
+    );
+
+    if (fromAmount > 0n) {
+      const fromCash = fromAsset.cash;
+      const fromLiability = fromAsset.liability;
+
+      const finalFromAssetCovRatio = wdiv(fromCash + fromAmount, fromLiability);
+      if (finalFromAssetCovRatio > this.startCovRatio) {
+        // charge high cov ratio fee
+        const highCovRatioFee = wmul(
+          this._highCovRatioFee(
+            wdiv(fromCash, fromLiability),
+            finalFromAssetCovRatio,
+          ),
+          actualToAmount,
+        );
+
+        actualToAmount -= highCovRatioFee;
+        haircut += highCovRatioFee;
+      }
+    } else {
+      // reverse quote
+      const toCash = toAsset.cash;
+      const toLiability = toAsset.liability;
+
+      const finalToAssetCovRatio = wdiv(toCash + actualToAmount, toLiability);
+      if (finalToAssetCovRatio <= this.startCovRatio) {
+        // happy path: no high cov ratio fee is charged
+        return { actualToAmount, haircut };
+      } else if (wdiv(toCash, toLiability) >= this.endCovRatio) {
+        // the to-asset exceeds it's cov ratio limit, further swap to increase cov ratio is impossible
+        throw new Error('WOMBAT_COV_RATIO_LIMIT_EXCEEDED');
+      }
+
+      // reverse quote: cov ratio of the to-asset exceed endCovRatio. direct reverse quote is not supported
+      // we binary search for a upper bound
+      actualToAmount = this._findUpperBound(toAsset, fromAsset, -fromAmount);
+      const result = this._highCovRatioPoolQuoteFrom(
+        toAsset,
+        fromAsset,
+        actualToAmount,
+      );
+      haircut = result.haircut;
+    }
+
+    return { actualToAmount, haircut };
+  }
+
+  private _highCovRatioFee(
+    initCovRatio: bigint,
+    finalCovRatio: bigint,
+  ): bigint {
+    const startCovRatio = this.startCovRatio!;
+    const endCovRatio = this.endCovRatio!;
+    if (finalCovRatio > endCovRatio) {
+      // invalid swap
+      throw new Error('WOMBAT_COV_RATIO_LIMIT_EXCEEDED');
+    } else if (
+      finalCovRatio <= startCovRatio ||
+      finalCovRatio <= initCovRatio
+    ) {
+      return 0n;
+    }
+
+    // 1. Calculate the area of fee(r) = (r - startCovRatio) / (endCovRatio - startCovRatio)
+    // when r increase from initCovRatio to finalCovRatio
+    // 2. Then multiply it by (endCovRatio - startCovRatio) / (finalCovRatio - initCovRatio)
+    // to get the average fee over the range
+    const a =
+      initCovRatio <= startCovRatio
+        ? 0n
+        : (initCovRatio - startCovRatio) * (initCovRatio - startCovRatio);
+    const b = (finalCovRatio - startCovRatio) * (finalCovRatio - startCovRatio);
+    return wdiv(
+      (b - a) / (finalCovRatio - initCovRatio) / BigInt(2),
+      endCovRatio - startCovRatio,
+    );
+  }
+
+  private _quoteFrom(
+    fromAsset: AssetState,
+    toAsset: AssetState,
+    fromAmount: bigint,
+  ): { actualToAmount: bigint; haircut: bigint } {
+    if (fromAmount < 0n) {
+      fromAmount = wdiv(fromAmount, WAD - this.haircutRate);
+    }
+
+    let fromCash = fromAsset.cash;
+    const toCash = toAsset.cash;
+    let fromLiability = fromAsset.liability;
+    const toLiability = toAsset.liability;
+
+    const scaleFactor = this._quoteFactor(fromAsset, toAsset);
+    if (scaleFactor !== WAD) {
+      fromCash = (fromCash * scaleFactor) / WAD;
+      fromLiability = (fromLiability * scaleFactor) / WAD;
+      fromAmount = (fromAmount * scaleFactor) / WAD;
+    }
+
+    const idealToAmount = WombatQuoter.swapQuoteFunc(
+      fromCash,
+      toCash,
+      fromLiability,
+      toLiability,
+      fromAmount,
+      this.ampFactor,
+    );
+    if (
+      (fromAmount > 0n && toCash < idealToAmount) ||
+      (fromAmount < 0n && fromCash < -fromAmount)
+    ) {
+      throw new Error('WOMBAT_CASH_NOT_ENOUGH');
+    }
+
+    let actualToAmount, haircut;
+    if (fromAmount > 0) {
+      haircut = wmul(idealToAmount, this.haircutRate);
+      actualToAmount = idealToAmount - haircut;
+    } else {
+      actualToAmount = idealToAmount;
+      haircut = wmul(-fromAmount, this.haircutRate);
+    }
+
+    return { actualToAmount, haircut };
+  }
+
+  private _findUpperBound(
+    fromAsset: AssetState,
+    toAsset: AssetState,
+    toAmount: bigint,
+  ): bigint {
+    const decimals = BigInt(fromAsset.underlyingTokenDecimals);
+    const toWadFactor = toWad(1n, decimals);
+    // the search value uses the same number of digits as the token
+    let high = fromWad(
+      wmul(fromAsset.liability, this.endCovRatio!) - fromAsset.cash,
+      decimals,
+    );
+    let low = 1n;
+
+    // verify `high` is a valid upper bound
+    const { actualToAmount: quote } = this._highCovRatioPoolQuoteFrom(
+      fromAsset,
+      toAsset,
+      high * toWadFactor,
+    );
+    if (quote < toAmount) {
+      throw new Error('WOMBAT_COV_RATIO_LIMIT_EXCEEDED');
+    }
+
+    // Note: we might limit the maximum number of rounds if the request is always rejected by the RPC server
+    while (low < high) {
+      const mid = (low + high) / BigInt(2);
+      const { actualToAmount: quote } = this._highCovRatioPoolQuoteFrom(
+        fromAsset,
+        toAsset,
+        mid * toWadFactor,
+      );
+      if (quote >= toAmount) {
+        high = mid;
+      } else {
+        low = mid + 1n;
+      }
+    }
+    return high * toWadFactor;
+  }
+
+  private _quoteFactor(fromAsset: AssetState, toAsset: AssetState): bigint {
+    if (!fromAsset.relativePrice || !toAsset.relativePrice) {
+      return WAD;
+    }
+    return (WAD * fromAsset.relativePrice) / toAsset.relativePrice;
+  }
+
+  static solveQuad(b: bigint, c: bigint): bigint {
+    return (sqrt(b * b + c * 4n * WAD, b) - b) / 2n;
+  }
+
+  static swapQuoteFunc(
+    aX: bigint,
+    aY: bigint,
+    lX: bigint,
+    lY: bigint,
+    dX: bigint,
+    a: bigint,
+  ): bigint {
+    if (lX == 0n || lY == 0n) {
+      // in case div of 0, CORE_UNDERFLOW
+      return 0n;
+    }
+
+    // int256 D = Ax + Ay - A.wmul((Lx * Lx) / Ax + (Ly * Ly) / Ay); // flattened _invariantFunc
+    const d = aX + aY - wmul(a, (lX * lX) / aX + (lY * lY) / aY);
+    // int256 rx_ = (Ax + Dx).wdiv(Lx);
+    const rX = wdiv(aX + dX, lX);
+    // int256 b = (Lx * (rx_ - A.wdiv(rx_))) / Ly - D.wdiv(Ly); // flattened _coefficientFunc
+    const b = (lX * (rX - wdiv(a, rX))) / lY - wdiv(d, lY);
+    // int256 ry_ = _solveQuad(b, A);
+    const rY = WombatQuoter.solveQuad(b, a);
+    // int256 Dy = Ly.wmul(ry_) - Ay;
+    const dY = wmul(lY, rY) - aY;
+
+    // if (Dy < 0) {
+    //     quote = uint256(-Dy);
+    // } else {
+    //     quote = uint256(Dy);
+    // }
+    if (dY < 0n) {
+      return -dY;
+    } else {
+      return dY;
+    }
+  }
+}