@paraswap/dex-lib 3.4.0 → 3.4.1

package/src/dex/platypus/pool-avax.ts

@@ -1,92 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { Address, Token } from '../../types';
-import { lens } from '../../lens';
-import { StakedAvaxSubscriber } from '../../lib/benqi/staked-avax';
-import { PlatypusAssetSubscriber } from './asset';
-import { PlatypusPoolSubscriber } from './pool-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PlatypusAvaxPoolState, PlatypusAvaxPoolConfigInfo } from './types';
-import { PlatypusPoolBase, calcPrice, WAD, wmul, wdiv } from './pool-base';
-
-export class PlatypusAvaxPool extends PlatypusPoolBase<PlatypusAvaxPoolState> {
-  constructor(
-    dexKey: string,
-    network: number,
-    name: string,
-    poolAddress: Address,
-    poolCfg: PlatypusAvaxPoolConfigInfo,
-    dexHelper: IDexHelper,
-  ) {
-    super(
-      dexKey,
-      network,
-      name,
-      dexHelper,
-      [
-        new PlatypusPoolSubscriber<PlatypusAvaxPoolState>(
-          poolAddress,
-          lens<DeepReadonly<PlatypusAvaxPoolState>>().params,
-          dexHelper.getLogger(`${dexKey}-${network} Params ${name}`),
-        ),
-        new StakedAvaxSubscriber<PlatypusAvaxPoolState>(
-          poolCfg.priceOracleAddress,
-          lens<DeepReadonly<PlatypusAvaxPoolState>>().stakedAvax,
-          dexHelper.getLogger(`Staked AVAX for ${dexKey}-${network} ${name}`),
-        ),
-        ...Object.entries(poolCfg.tokens).map(
-          ([tokenAddress, c]) =>
-            new PlatypusAssetSubscriber<PlatypusAvaxPoolState>(
-              c.assetAddress,
-              lens<DeepReadonly<PlatypusAvaxPoolState>>().asset[tokenAddress],
-              dexHelper.getLogger(
-                `${dexKey}-${network} ${c.tokenSymbol} asset ${name}`,
-              ),
-            ),
-        ),
-      ],
-      {
-        params: {
-          paused: false,
-          slippageParamK: 0n,
-          slippageParamN: 0n,
-          c1: 0n,
-          xThreshold: 0n,
-          haircutRate: 0n,
-          retentionRatio: 0n,
-          maxPriceDeviation: 0n,
-        },
-        asset: {},
-        stakedAvax: {
-          totalPooledAvax: 0n,
-          totalShares: 0n,
-        },
-      },
-    );
-  }
-
-  public computePrices(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    state: PlatypusAvaxPoolState,
-  ): bigint[] {
-    let fromShares: boolean;
-    if (this.dexHelper.config.isWETH(destToken.address)) {
-      fromShares = true;
-    } else if (this.dexHelper.config.isWETH(srcToken.address)) {
-      fromShares = false;
-    } else {
-      throw new Error(`Unexpected tokens being swapped in ${this.name}`);
-    }
-    const sAvaxRate = StakedAvaxSubscriber.getPooledAvaxByShares(
-      WAD,
-      state.stakedAvax,
-    );
-    return amounts.map(fromAmount => {
-      const idealToAmount = fromShares
-        ? wmul(fromAmount, sAvaxRate)
-        : wdiv(fromAmount, sAvaxRate);
-      return calcPrice(srcToken, destToken, fromAmount, idealToAmount, state);
-    });
-  }
-}

package/src/dex/platypus/pool-base.ts

@@ -1,155 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import {
-  PartialEventSubscriber,
-  ComposedEventSubscriber,
-} from '../../composed-event-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PlatypusPoolStateCommon } from './types';
-import { Token } from '../../types';
-import { BI_POWS } from '../../bigint-constants';
-
-export const ETH_UNIT = BI_POWS[18];
-export const WAD = BI_POWS[18];
-export const RAY = BI_POWS[27];
-
-export function wmul(x: bigint, y: bigint): bigint {
-  return (x * y + WAD / 2n) / WAD;
-}
-
-export function wdiv(x: bigint, y: bigint): bigint {
-  return (x * WAD + y / 2n) / y;
-}
-
-export function rmul(x: bigint, y: bigint): bigint {
-  return (x * y + RAY / 2n) / RAY;
-}
-
-export function rpow(x: bigint, n: bigint): bigint {
-  let z = n % 2n !== 0n ? x : RAY;
-
-  for (n /= 2n; n !== 0n; n /= 2n) {
-    x = rmul(x, x);
-
-    if (n % 2n !== 0n) {
-      z = rmul(z, x);
-    }
-  }
-
-  return z;
-}
-
-function slippageFunc(
-  k: bigint,
-  n: bigint,
-  c1: bigint,
-  xThreshold: bigint,
-  x: bigint,
-): bigint {
-  if (x < xThreshold) {
-    return c1 - x;
-  } else {
-    return wdiv(k, (rpow((x * RAY) / WAD, n) * WAD) / RAY);
-  }
-}
-
-function calcSlippage(
-  k: bigint,
-  n: bigint,
-  c1: bigint,
-  xThreshold: bigint,
-  cash: bigint,
-  liability: bigint,
-  cashChange: bigint,
-  addCash: boolean,
-): bigint {
-  const covBefore = wdiv(cash, liability);
-  let covAfter: bigint;
-  if (addCash) {
-    covAfter = wdiv(cash + cashChange, liability);
-  } else {
-    covAfter = wdiv(cash - cashChange, liability);
-  }
-  if (covBefore === covAfter) {
-    return 0n;
-  }
-
-  const slippageBefore = slippageFunc(k, n, c1, xThreshold, covBefore);
-  const slippageAfter = slippageFunc(k, n, c1, xThreshold, covAfter);
-
-  if (covBefore > covAfter) {
-    return wdiv(slippageAfter - slippageBefore, covBefore - covAfter);
-  } else {
-    return wdiv(slippageBefore - slippageAfter, covAfter - covBefore);
-  }
-}
-
-function calcSwappingSlippage(si: bigint, sj: bigint): bigint {
-  return WAD + si - sj;
-}
-
-function calcHaircut(amount: bigint, rate: bigint): bigint {
-  return wmul(amount, rate);
-}
-
-export function calcPrice(
-  srcToken: Token,
-  destToken: Token,
-  fromAmount: bigint,
-  idealToAmount: bigint,
-  state: PlatypusPoolStateCommon,
-): bigint {
-  if (state.asset[destToken.address].cash < idealToAmount) return 0n;
-  const slippageFrom = calcSlippage(
-    state.params.slippageParamK,
-    state.params.slippageParamN,
-    state.params.c1,
-    state.params.xThreshold,
-    state.asset[srcToken.address].cash,
-    state.asset[srcToken.address].liability,
-    fromAmount,
-    true,
-  );
-  const slippageTo = calcSlippage(
-    state.params.slippageParamK,
-    state.params.slippageParamN,
-    state.params.c1,
-    state.params.xThreshold,
-    state.asset[destToken.address].cash,
-    state.asset[destToken.address].liability,
-    idealToAmount,
-    false,
-  );
-  const swappingSlippage = calcSwappingSlippage(slippageFrom, slippageTo);
-  const toAmount = wmul(idealToAmount, swappingSlippage);
-  const haircut = calcHaircut(toAmount, state.params.haircutRate);
-  return toAmount - haircut;
-}
-
-export abstract class PlatypusPoolBase<
-  State extends PlatypusPoolStateCommon,
-> extends ComposedEventSubscriber<State> {
-  constructor(
-    readonly dexKey: string,
-    protected readonly network: number,
-    name: string,
-    dexHelper: IDexHelper,
-    parts: PartialEventSubscriber<State, any>[],
-    blankState: DeepReadonly<State>,
-  ) {
-    super(
-      dexKey,
-      name,
-      dexHelper.getLogger(`${dexKey}-${network} ${name}`),
-      dexHelper,
-      parts,
-      blankState,
-    );
-  }
-
-  public abstract computePrices(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    state: State,
-  ): bigint[];
-}

package/src/dex/platypus/pool-pure.ts

@@ -1,71 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { Address, Token } from '../../types';
-import { lens } from '../../lens';
-import { PlatypusAssetSubscriber } from './asset';
-import { PlatypusPoolSubscriber } from './pool-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PlatypusPurePoolState, PlatypusPurePoolConfigInfo } from './types';
-import { getBigIntPow } from '../../utils';
-import { PlatypusPoolBase, calcPrice } from './pool-base';
-
-export class PlatypusPurePool extends PlatypusPoolBase<PlatypusPurePoolState> {
-  constructor(
-    dexKey: string,
-    network: number,
-    name: string,
-    poolAddress: Address,
-    poolCfg: PlatypusPurePoolConfigInfo,
-    dexHelper: IDexHelper,
-  ) {
-    super(
-      dexKey,
-      network,
-      name,
-      dexHelper,
-      [
-        new PlatypusPoolSubscriber<PlatypusPurePoolState>(
-          poolAddress,
-          lens<DeepReadonly<PlatypusPurePoolState>>().params,
-          dexHelper.getLogger(`${dexKey}-${network} Params ${name}`),
-        ),
-        ...Object.entries(poolCfg.tokens).map(
-          ([tokenAddress, c]) =>
-            new PlatypusAssetSubscriber<PlatypusPurePoolState>(
-              c.assetAddress,
-              lens<DeepReadonly<PlatypusPurePoolState>>().asset[tokenAddress],
-              dexHelper.getLogger(
-                `${dexKey}-${network} ${c.tokenSymbol} asset ${name}`,
-              ),
-            ),
-        ),
-      ],
-      {
-        params: {
-          paused: false,
-          slippageParamK: 0n,
-          slippageParamN: 0n,
-          c1: 0n,
-          xThreshold: 0n,
-          haircutRate: 0n,
-          retentionRatio: 0n,
-          maxPriceDeviation: 0n,
-        },
-        asset: {},
-      },
-    );
-  }
-
-  public computePrices(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    state: PlatypusPurePoolState,
-  ): bigint[] {
-    return amounts.map(fromAmount => {
-      const idealToAmount =
-        (fromAmount * getBigIntPow(destToken.decimals)) /
-        getBigIntPow(srcToken.decimals);
-      return calcPrice(srcToken, destToken, fromAmount, idealToAmount, state);
-    });
-  }
-}

package/src/dex/platypus/pool-subscriber.ts

@@ -1,239 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { PartialEventSubscriber } from '../../composed-event-subscriber';
-import {
-  Address,
-  BlockHeader,
-  Log,
-  Logger,
-  MultiCallInput,
-  MultiCallOutput,
-} from '../../types';
-import { Lens } from '../../lens';
-import { Interface } from '@ethersproject/abi';
-import PoolABI from '../../abi/platypus/pool.json';
-import { PlatypusPoolParams } from './types';
-
-export class PlatypusPoolSubscriber<State> extends PartialEventSubscriber<
-  State,
-  PlatypusPoolParams
-> {
-  static readonly poolInterface = new Interface(PoolABI);
-
-  constructor(
-    private pool: Address,
-    lens: Lens<DeepReadonly<State>, DeepReadonly<PlatypusPoolParams>>,
-    logger: Logger,
-  ) {
-    super([pool], lens, logger);
-  }
-
-  public processLog(
-    state: DeepReadonly<PlatypusPoolParams>,
-    log: Readonly<Log>,
-    blockHeader: Readonly<BlockHeader>,
-  ): DeepReadonly<PlatypusPoolParams> | null {
-    try {
-      const parsed = PlatypusPoolSubscriber.poolInterface.parseLog(log);
-      switch (parsed.name) {
-        case 'Paused': {
-          return {
-            ...state,
-            paused: true,
-          };
-        }
-        case 'Unpaused': {
-          return {
-            ...state,
-            paused: false,
-          };
-        }
-        case 'PriceDeviationUpdated': {
-          const previousPriceDeviation = BigInt(
-            parsed.args.previousPriceDeviation.toString(),
-          );
-          const newPriceDeviation = BigInt(
-            parsed.args.newPriceDeviation.toString(),
-          );
-          if (state.maxPriceDeviation !== previousPriceDeviation) {
-            this.logger.error(
-              'state.maxPriceDeviation !== previousPriceDeviation',
-            );
-          }
-          return {
-            ...state,
-            maxPriceDeviation: newPriceDeviation,
-          };
-        }
-        case 'SlippageParamsUpdated': {
-          const previousK = BigInt(parsed.args.previousK.toString());
-          const newK = BigInt(parsed.args.newK.toString());
-          const previousN = BigInt(parsed.args.previousN.toString());
-          const newN = BigInt(parsed.args.newN.toString());
-          const previousC1 = BigInt(parsed.args.previousC1.toString());
-          const newC1 = BigInt(parsed.args.newC1.toString());
-          const previousXThreshold = BigInt(
-            parsed.args.previousXThreshold.toString(),
-          );
-          const newXThreshold = BigInt(parsed.args.newXThreshold.toString());
-          if (state.slippageParamK !== previousK) {
-            this.logger.error('state.slippageParamK !== previousK');
-          }
-          if (state.slippageParamN !== previousN) {
-            this.logger.error('state.slippageParamN !== previousN');
-          }
-          if (state.c1 !== previousC1) {
-            this.logger.error('state.c1 !== previousC1');
-          }
-          if (state.xThreshold !== previousXThreshold) {
-            this.logger.error('state.xThreshold !== previousXThreshold');
-          }
-          return {
-            ...state,
-            slippageParamK: newK,
-            slippageParamN: newN,
-            c1: newC1,
-            xThreshold: newXThreshold,
-          };
-        }
-        case 'HaircutRateUpdated': {
-          const previousHaircut = BigInt(
-            parsed.args.previousHaircut.toString(),
-          );
-          const newHaircut = BigInt(parsed.args.newHaircut.toString());
-          if (state.haircutRate !== previousHaircut) {
-            this.logger.error('state.haircutRate !== previousHaircut');
-          }
-          return {
-            ...state,
-            haircutRate: newHaircut,
-          };
-        }
-        case 'RetentionRatioUpdated': {
-          const previousRetentionRatio = BigInt(
-            parsed.args.previousRetentionRatio.toString(),
-          );
-          const newRetentionRatio = BigInt(
-            parsed.args.newRetentionRatio.toString(),
-          );
-          if (state.retentionRatio !== previousRetentionRatio) {
-            this.logger.error(
-              'state.retentionRatio !== previousRetentionRatio',
-            );
-          }
-          return {
-            ...state,
-            retentionRatio: newRetentionRatio,
-          };
-        }
-        default:
-          return null;
-      }
-    } catch (e) {
-      this.logger.error('Failed to parse log', e);
-      return null;
-    }
-  }
-
-  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
-    return [
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData('paused'),
-      },
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData(
-            'getSlippageParamK',
-          ),
-      },
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData(
-            'getSlippageParamN',
-          ),
-      },
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData('getC1'),
-      },
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData(
-            'getXThreshold',
-          ),
-      },
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData(
-            'getHaircutRate',
-          ),
-      },
-      {
-        target: this.pool,
-        callData:
-          PlatypusPoolSubscriber.poolInterface.encodeFunctionData(
-            'getRetentionRatio',
-          ),
-      },
-      {
-        target: this.pool,
-        callData: PlatypusPoolSubscriber.poolInterface.encodeFunctionData(
-          'getMaxPriceDeviation',
-        ),
-      },
-    ];
-  }
-
-  public generateState(
-    multicallOutputs: MultiCallOutput[],
-    blockNumber?: number | 'latest',
-  ): DeepReadonly<PlatypusPoolParams> {
-    return {
-      paused: PlatypusPoolSubscriber.poolInterface.decodeFunctionResult(
-        'paused',
-        multicallOutputs[0],
-      )[0],
-      slippageParamK: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getSlippageParamK', multicallOutputs[1])[0]
-          .toString(),
-      ),
-      slippageParamN: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getSlippageParamN', multicallOutputs[2])[0]
-          .toString(),
-      ),
-      c1: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getC1', multicallOutputs[3])[0]
-          .toString(),
-      ),
-      xThreshold: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getXThreshold', multicallOutputs[4])[0]
-          .toString(),
-      ),
-      haircutRate: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getHaircutRate', multicallOutputs[5])[0]
-          .toString(),
-      ),
-      retentionRatio: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getRetentionRatio', multicallOutputs[6])[0]
-          .toString(),
-      ),
-      maxPriceDeviation: BigInt(
-        PlatypusPoolSubscriber.poolInterface
-          .decodeFunctionResult('getMaxPriceDeviation', multicallOutputs[7])[0]
-          .toString(),
-      ),
-    };
-  }
-}

package/src/dex/platypus/pool.ts

@@ -1,99 +0,0 @@
-import { DeepReadonly } from 'ts-essentials';
-import { Address, Token } from '../../types';
-import { lens } from '../../lens';
-import { ChainLinkSubscriber } from '../../lib/chainlink';
-import { PlatypusAssetSubscriber } from './asset';
-import { PlatypusPoolSubscriber } from './pool-subscriber';
-import { IDexHelper } from '../../dex-helper/idex-helper';
-import { PlatypusPoolState, PlatypusPoolConfigInfo } from './types';
-import { getBigIntPow } from '../../utils';
-import { PlatypusPoolBase, calcPrice, ETH_UNIT } from './pool-base';
-
-export class PlatypusPool extends PlatypusPoolBase<PlatypusPoolState> {
-  constructor(
-    dexKey: string,
-    network: number,
-    name: string,
-    poolAddress: Address,
-    poolCfg: PlatypusPoolConfigInfo,
-    dexHelper: IDexHelper,
-  ) {
-    super(
-      dexKey,
-      network,
-      name,
-      dexHelper,
-      [
-        new PlatypusPoolSubscriber<PlatypusPoolState>(
-          poolAddress,
-          lens<DeepReadonly<PlatypusPoolState>>().params,
-          dexHelper.getLogger(`${dexKey}-${network} Params ${name}`),
-        ),
-        ...Object.entries(poolCfg.tokens)
-          .map(([tokenAddress, c]) => [
-            new PlatypusAssetSubscriber<PlatypusPoolState>(
-              c.assetAddress,
-              lens<DeepReadonly<PlatypusPoolState>>().asset[tokenAddress],
-              dexHelper.getLogger(
-                `${dexKey}-${network} ${c.tokenSymbol} asset ${name}`,
-              ),
-            ),
-            new ChainLinkSubscriber<PlatypusPoolState>(
-              c.chainlink.proxyAddress,
-              c.chainlink.aggregatorAddress,
-              lens<DeepReadonly<PlatypusPoolState>>().chainlink[tokenAddress],
-              dexHelper.getLogger(
-                `${c.tokenSymbol} ChainLink for ${dexKey}-${network} ${name}`,
-              ),
-            ),
-          ])
-          .flat(),
-      ],
-      {
-        params: {
-          paused: false,
-          slippageParamK: 0n,
-          slippageParamN: 0n,
-          c1: 0n,
-          xThreshold: 0n,
-          haircutRate: 0n,
-          retentionRatio: 0n,
-          maxPriceDeviation: 0n,
-        },
-        asset: {},
-        chainlink: {},
-      },
-    );
-  }
-
-  public computePrices(
-    srcToken: Token,
-    destToken: Token,
-    amounts: bigint[],
-    state: PlatypusPoolState,
-  ): bigint[] {
-    const tokenAPrice = state.chainlink[srcToken.address].answer;
-    const tokenBPrice = state.chainlink[destToken.address].answer;
-    if (tokenBPrice > tokenAPrice) {
-      if (
-        ((tokenBPrice - tokenAPrice) * ETH_UNIT) / tokenBPrice >
-        state.params.maxPriceDeviation
-      ) {
-        return Array(amounts.length).fill(0n);
-      }
-    } else {
-      if (
-        ((tokenAPrice - tokenBPrice) * ETH_UNIT) / tokenAPrice >
-        state.params.maxPriceDeviation
-      ) {
-        return Array(amounts.length).fill(0n);
-      }
-    }
-    return amounts.map(fromAmount => {
-      const idealToAmount =
-        (fromAmount * getBigIntPow(destToken.decimals)) /
-        getBigIntPow(srcToken.decimals);
-      return calcPrice(srcToken, destToken, fromAmount, idealToAmount, state);
-    });
-  }
-}