@paraswap/dex-lib 2.33.4-balancer-v2-multihop.2 → 2.35.0

package/src/dex/quick-perps/vault-price-feed.ts

@@ -0,0 +1,322 @@
+import { Interface } from '@ethersproject/abi';
+import { Address, MultiCallInput, MultiCallOutput } from '../../types';
+import { VaultPriceFeedConfig } from './types';
+import { FastPriceFeed } from './fast-price-feed';
+import VaultPriceFeedAbi from '../../abi/quick-perps/vault-price-feed.json';
+import { DeepReadonly } from 'ts-essentials';
+import { Api3FeedSubscriber } from '../../lib/api3-feed';
+
+export class VaultPriceFeed<State> {
+  BASIS_POINTS_DIVISOR = 10000n;
+  PRICE_PRECISION = 10n ** 30n;
+  ONE_USD = this.PRICE_PRECISION;
+
+  static interface = new Interface(VaultPriceFeedAbi);
+
+  protected isSecondaryPriceEnabled: boolean;
+  protected strictStableTokens: { [address: string]: boolean };
+  protected spreadBasisPoints: { [address: string]: bigint };
+  protected adjustmentBasisPoints: { [address: string]: bigint };
+  protected isAdjustmentAdditive: { [address: string]: boolean };
+  protected priceDecimals: { [address: string]: number };
+  protected maxStrictPriceDeviation: bigint;
+
+  constructor(
+    config: VaultPriceFeedConfig,
+    protected primaryPrices: { [token: string]: Api3FeedSubscriber<State> },
+    protected secondaryPrice: FastPriceFeed<State>,
+  ) {
+    this.isSecondaryPriceEnabled = config.isSecondaryPriceEnabled;
+    this.strictStableTokens = config.strictStableTokens;
+    this.spreadBasisPoints = config.spreadBasisPoints;
+    this.adjustmentBasisPoints = config.adjustmentBasisPoints;
+    this.isAdjustmentAdditive = config.isAdjustmentAdditive;
+    this.priceDecimals = config.priceDecimals;
+    this.maxStrictPriceDeviation = config.maxStrictPriceDeviation;
+  }
+
+  getPrice(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _maximize: boolean,
+    _includeAmmPrice: boolean,
+    _useSwapPricing: boolean,
+  ): bigint {
+    let price = this.getPriceV1(state, _token, _maximize, _includeAmmPrice);
+
+    const adjustmentBps = this.adjustmentBasisPoints[_token];
+    if (adjustmentBps > 0n) {
+      const isAdditive = this.isAdjustmentAdditive[_token];
+      if (isAdditive) {
+        price =
+          (price * (this.BASIS_POINTS_DIVISOR + adjustmentBps)) /
+          this.BASIS_POINTS_DIVISOR;
+      } else {
+        price =
+          (price * (this.BASIS_POINTS_DIVISOR - adjustmentBps)) /
+          this.BASIS_POINTS_DIVISOR;
+      }
+    }
+
+    return price;
+  }
+
+  getPriceV1(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _maximize: boolean,
+    _includeAmmPrice: boolean,
+  ): bigint {
+    let price = this.getPrimaryPrice(state, _token, _maximize);
+
+    if (this.isSecondaryPriceEnabled) {
+      price = this.getSecondaryPrice(state, _token, price, _maximize);
+    }
+
+    if (this.strictStableTokens[_token]) {
+      const delta =
+        price > this.ONE_USD ? price - this.ONE_USD : this.ONE_USD - price;
+      if (delta <= this.maxStrictPriceDeviation) {
+        return this.ONE_USD;
+      }
+
+      // if _maximize and price is e.g. 1.02, return 1.02
+      if (_maximize && price > this.ONE_USD) {
+        return price;
+      }
+
+      // if !_maximize and price is e.g. 0.98, return 0.98
+      if (!_maximize && price < this.ONE_USD) {
+        return price;
+      }
+
+      return this.ONE_USD;
+    }
+
+    const _spreadBasisPoints = this.spreadBasisPoints[_token];
+
+    if (_maximize) {
+      return (
+        (price * (this.BASIS_POINTS_DIVISOR + _spreadBasisPoints)) /
+        this.BASIS_POINTS_DIVISOR
+      );
+    }
+
+    return (
+      (price * (this.BASIS_POINTS_DIVISOR - _spreadBasisPoints)) /
+      this.BASIS_POINTS_DIVISOR
+    );
+  }
+
+  getAmmPrice(state: DeepReadonly<State>, token: Address): bigint {
+    throw new Error(
+      'getAmmPrice implementation is not complete, developers should disable the dex or complete the implementation',
+    );
+  }
+
+  getPrimaryPrice(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _maximize: boolean,
+  ): bigint {
+    // const priceFeedAddress = this.priceFeeds[_token];
+    // require(priceFeedAddress != address(0), "VaultPriceFeed: invalid price feed");
+
+    // if (chainlinkFlags != address(0)) {
+    //   bool isRaised = IChainlinkFlags(chainlinkFlags).getFlag(FLAG_ARBITRUM_SEQ_OFFLINE);
+    //   if (isRaised) {
+    //           // If flag is raised we shouldn't perform any critical operations
+    //       revert("Chainlink feeds are not being updated");
+    //   }
+    // }
+
+    // IPriceFeed priceFeed = IPriceFeed(priceFeedAddress);
+    let price = 0n;
+    // const roundId = priceFeed.latestRound;
+
+    // for (let i = 0; i < this.priceSampleSpace; i++) {
+    //   if (roundId <= i) {
+    //     break;
+    //   }
+
+    //   if (i == 0) {
+    //       const _p = priceFeed.latestAnswer();
+    //       require(_p > 0, "VaultPriceFeed: invalid price");
+    //       p = uint256(_p);
+    //   } else {
+    //       (, int256 _p, , ,) = priceFeed.getRoundData(roundId - i);
+    //       require(_p > 0, "VaultPriceFeed: invalid price");
+    //       p = uint256(_p);
+    //   }
+
+    //   if (price == 0n) {
+    //     price = p;
+    //     continue;
+    //   }
+
+    //   if (_maximize && p > price) {
+    //     price = p;
+    //     continue;
+    //   }
+
+    //   if (!_maximize && p < price) {
+    //     price = p;
+    //   }
+    // }
+    price = this.primaryPrices[_token].getLatestData(state);
+
+    // require(price > 0n, "VaultPriceFeed: could not fetch price");
+    if (price <= 0n) throw new Error('VaultPriceFeed: could not fetch price');
+    // normalize price precision
+    const _priceDecimals = this.priceDecimals[_token];
+    return (price * this.PRICE_PRECISION) / BigInt(10 ** _priceDecimals);
+  }
+
+  getSecondaryPrice(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _referencePrice: bigint,
+    _maximize: boolean,
+  ): bigint {
+    return this.secondaryPrice.getPrice(
+      state,
+      _token,
+      _referencePrice,
+      _maximize,
+    );
+  }
+
+  static getConfigMulticallInputs(
+    vaultPriceFeedAddress: Address,
+    tokenAddresses: Address[],
+  ): MultiCallInput[] {
+    return [
+      {
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'isSecondaryPriceEnabled',
+        ),
+      },
+      ...tokenAddresses.map(t => ({
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'strictStableTokens',
+          [t],
+        ),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'spreadBasisPoints',
+          [t],
+        ),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'isAdjustmentAdditive',
+          [t],
+        ),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'adjustmentBasisPoints',
+          [t],
+        ),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData('priceDecimals', [
+          t,
+        ]),
+      })),
+      {
+        target: vaultPriceFeedAddress,
+        callData: VaultPriceFeed.interface.encodeFunctionData(
+          'maxStrictPriceDeviation',
+        ),
+      },
+    ];
+  }
+
+  static getConfig(
+    multicallOutputs: MultiCallOutput[],
+    tokenAddress: Address[],
+  ): VaultPriceFeedConfig {
+    let i = 0;
+    return {
+      isSecondaryPriceEnabled: VaultPriceFeed.interface.decodeFunctionResult(
+        'isSecondaryPriceEnabled',
+        multicallOutputs[i++],
+      )[0],
+      strictStableTokens: tokenAddress.reduce(
+        (acc: { [address: string]: boolean }, t: Address) => {
+          acc[t] = VaultPriceFeed.interface.decodeFunctionResult(
+            'strictStableTokens',
+            multicallOutputs[i++],
+          )[0];
+          return acc;
+        },
+        {},
+      ),
+      spreadBasisPoints: tokenAddress.reduce(
+        (acc: { [address: string]: bigint }, t: Address) => {
+          acc[t] = BigInt(
+            VaultPriceFeed.interface
+              .decodeFunctionResult(
+                'spreadBasisPoints',
+                multicallOutputs[i++],
+              )[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      isAdjustmentAdditive: tokenAddress.reduce(
+        (acc: { [address: string]: boolean }, t: Address) => {
+          acc[t] = VaultPriceFeed.interface.decodeFunctionResult(
+            'isAdjustmentAdditive',
+            multicallOutputs[i++],
+          )[0];
+          return acc;
+        },
+        {},
+      ),
+      adjustmentBasisPoints: tokenAddress.reduce(
+        (acc: { [address: string]: bigint }, t: Address) => {
+          acc[t] = BigInt(
+            VaultPriceFeed.interface
+              .decodeFunctionResult(
+                'adjustmentBasisPoints',
+                multicallOutputs[i++],
+              )[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      priceDecimals: tokenAddress.reduce(
+        (acc: { [address: string]: number }, t: Address) => {
+          acc[t] = parseInt(
+            VaultPriceFeed.interface
+              .decodeFunctionResult('priceDecimals', multicallOutputs[i++])[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      maxStrictPriceDeviation: BigInt(
+        VaultPriceFeed.interface
+          .decodeFunctionResult(
+            'maxStrictPriceDeviation',
+            multicallOutputs[i++],
+          )[0]
+          .toString(),
+      ),
+    };
+  }
+}

package/src/dex/quick-perps/vault-utils.ts

@@ -0,0 +1,53 @@
+import { Vault } from './vault';
+import { Address } from '../../types';
+import { DeepReadonly } from 'ts-essentials';
+
+export class VaultUtils<State> {
+  constructor(protected vault: Vault<State>) {}
+
+  getFeeBasisPoints(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _usdqDelta: bigint,
+    _feeBasisPoints: bigint,
+    _taxBasisPoints: bigint,
+    _increment: boolean,
+  ) {
+    if (!this.vault.hasDynamicFees) {
+      return _feeBasisPoints;
+    }
+
+    const initialAmount = this.vault.getUSDQAmount(state, _token);
+    let nextAmount = initialAmount + _usdqDelta;
+    if (!_increment) {
+      nextAmount = _usdqDelta > initialAmount ? 0n : initialAmount - _usdqDelta;
+    }
+
+    const targetAmount = this.vault.getTargetUsdqAmount(state, _token);
+    if (targetAmount == 0n) {
+      return _feeBasisPoints;
+    }
+
+    const initialDiff =
+      initialAmount > targetAmount
+        ? initialAmount - targetAmount
+        : targetAmount - initialAmount;
+    const nextDiff =
+      nextAmount > targetAmount
+        ? nextAmount - targetAmount
+        : targetAmount - nextAmount;
+
+    // action improves relative asset balance
+    if (nextDiff < initialDiff) {
+      const rebateBps = (_taxBasisPoints * initialDiff) / targetAmount;
+      return rebateBps > _feeBasisPoints ? 0n : _feeBasisPoints - rebateBps;
+    }
+
+    let averageDiff = (initialDiff + nextDiff) / 2n;
+    if (averageDiff > targetAmount) {
+      averageDiff = targetAmount;
+    }
+    const taxBps = (_taxBasisPoints * averageDiff) / targetAmount;
+    return _feeBasisPoints + taxBps;
+  }
+}

package/src/dex/quick-perps/vault.ts

@@ -0,0 +1,290 @@
+import _ from 'lodash';
+import { Interface } from '@ethersproject/abi';
+import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
+import { PartialEventSubscriber } from '../../composed-event-subscriber';
+import { Lens } from '../../lens';
+import VaultABI from '../../abi/quick-perps/vault.json';
+import { VaultUtils } from './vault-utils';
+import {
+  VaultConfig,
+  VaultState,
+  FastPriceFeedConfig,
+  PoolState,
+} from './types';
+import { VaultPriceFeed } from './vault-price-feed';
+import { USDQ } from './usdq';
+import {
+  MultiCallInput,
+  MultiCallOutput,
+  Address,
+  Logger,
+  Log,
+} from '../../types';
+import { BlockHeader } from 'web3-eth';
+
+export class Vault<State> extends PartialEventSubscriber<State, VaultState> {
+  static readonly interface: Interface = new Interface(VaultABI);
+
+  protected vaultUtils: VaultUtils<State>;
+
+  public tokenDecimals: { [address: string]: number };
+  public stableTokens: { [address: string]: boolean };
+  protected tokenWeights: { [address: string]: bigint };
+  public stableSwapFeeBasisPoints: bigint;
+  public swapFeeBasisPoints: bigint;
+  public stableTaxBasisPoints: bigint;
+  public taxBasisPoints: bigint;
+  public hasDynamicFees: bigint;
+  protected includeAmmPrice: boolean;
+  protected useSwapPricing: boolean;
+  protected totalTokenWeights: bigint;
+
+  constructor(
+    public readonly vaultAddress: Address,
+    protected tokenAddresses: Address[],
+    config: VaultConfig,
+    protected vaultPriceFeed: VaultPriceFeed<State>,
+    protected usdq: USDQ<State>,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<VaultState>>,
+    logger: Logger,
+  ) {
+    super([vaultAddress], lens, logger);
+    this.vaultUtils = new VaultUtils(this);
+    this.tokenDecimals = config.tokenDecimals;
+    this.stableTokens = config.stableTokens;
+    this.tokenWeights = config.tokenWeights;
+    this.stableSwapFeeBasisPoints = config.stableSwapFeeBasisPoints;
+    this.swapFeeBasisPoints = config.swapFeeBasisPoints;
+    this.stableTaxBasisPoints = config.stableTaxBasisPoints;
+    this.taxBasisPoints = config.taxBasisPoints;
+    this.hasDynamicFees = config.hasDynamicFees;
+    this.includeAmmPrice = config.includeAmmPrice;
+    this.useSwapPricing = config.useSwapPricing;
+    this.totalTokenWeights = config.totalTokenWeights;
+  }
+
+  getMinPrice(state: DeepReadonly<State>, _token: Address): bigint {
+    return this.vaultPriceFeed.getPrice(
+      state,
+      _token,
+      false,
+      this.includeAmmPrice,
+      this.useSwapPricing,
+    );
+  }
+
+  getMaxPrice(state: DeepReadonly<State>, _token: Address): bigint {
+    return this.vaultPriceFeed.getPrice(
+      state,
+      _token,
+      true,
+      this.includeAmmPrice,
+      this.useSwapPricing,
+    );
+  }
+
+  getFeeBasisPoints(
+    state: DeepReadonly<State>,
+    _token: Address,
+    _usdqDelta: bigint,
+    _feeBasisPoints: bigint,
+    _taxBasisPoints: bigint,
+    _increment: boolean,
+  ): bigint {
+    return this.vaultUtils.getFeeBasisPoints(
+      state,
+      _token,
+      _usdqDelta,
+      _feeBasisPoints,
+      _taxBasisPoints,
+      _increment,
+    );
+  }
+
+  getTargetUsdqAmount(state: DeepReadonly<State>, _token: Address): bigint {
+    const supply = this.usdq.getTotalSupply(state);
+    if (supply == 0n) {
+      return 0n;
+    }
+    const weight = this.tokenWeights[_token];
+    return (weight * supply) / this.totalTokenWeights;
+  }
+
+  static getConfigMulticallInputs(
+    vaultAddress: Address,
+    tokenAddresses: Address[],
+  ): MultiCallInput[] {
+    return [
+      ...tokenAddresses.map(t => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData('tokenDecimals', [t]),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData('stableTokens', [t]),
+      })),
+      ...tokenAddresses.map(t => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData('tokenWeights', [t]),
+      })),
+      ...[
+        'stableSwapFeeBasisPoints',
+        'swapFeeBasisPoints',
+        'stableTaxBasisPoints',
+        'taxBasisPoints',
+        'hasDynamicFees',
+        'includeAmmPrice',
+        'useSwapPricing',
+        'totalTokenWeights',
+      ].map(fn => ({
+        target: vaultAddress,
+        callData: Vault.interface.encodeFunctionData(fn),
+      })),
+    ];
+  }
+
+  static getConfig(
+    multicallOutputs: MultiCallOutput[],
+    tokenAddresses: Address[],
+  ): VaultConfig {
+    let i = 0;
+    return {
+      tokenDecimals: tokenAddresses.reduce(
+        (acc: { [address: string]: number }, t: Address) => {
+          acc[t] = parseInt(
+            Vault.interface
+              .decodeFunctionResult('tokenDecimals', multicallOutputs[i++])[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      stableTokens: tokenAddresses.reduce(
+        (acc: { [address: string]: boolean }, t: Address) => {
+          acc[t] = Vault.interface.decodeFunctionResult(
+            'stableTokens',
+            multicallOutputs[i++],
+          )[0];
+          return acc;
+        },
+        {},
+      ),
+      tokenWeights: tokenAddresses.reduce(
+        (acc: { [address: string]: bigint }, t: Address) => {
+          acc[t] = BigInt(
+            Vault.interface
+              .decodeFunctionResult('tokenWeights', multicallOutputs[i++])[0]
+              .toString(),
+          );
+          return acc;
+        },
+        {},
+      ),
+      stableSwapFeeBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult(
+            'stableSwapFeeBasisPoints',
+            multicallOutputs[i++],
+          )[0]
+          .toString(),
+      ),
+      swapFeeBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult('swapFeeBasisPoints', multicallOutputs[i++])[0]
+          .toString(),
+      ),
+      stableTaxBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult(
+            'stableTaxBasisPoints',
+            multicallOutputs[i++],
+          )[0]
+          .toString(),
+      ),
+      taxBasisPoints: BigInt(
+        Vault.interface
+          .decodeFunctionResult('taxBasisPoints', multicallOutputs[i++])[0]
+          .toString(),
+      ),
+      hasDynamicFees: Vault.interface.decodeFunctionResult(
+        'hasDynamicFees',
+        multicallOutputs[i++],
+      )[0],
+      includeAmmPrice: Vault.interface.decodeFunctionResult(
+        'includeAmmPrice',
+        multicallOutputs[i++],
+      )[0],
+      useSwapPricing: Vault.interface.decodeFunctionResult(
+        'useSwapPricing',
+        multicallOutputs[i++],
+      )[0],
+      totalTokenWeights: BigInt(
+        Vault.interface
+          .decodeFunctionResult('totalTokenWeights', multicallOutputs[i++])[0]
+          .toString(),
+      ),
+    };
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    return this.tokenAddresses.map((t: Address) => ({
+      target: this.vaultAddress,
+      callData: Vault.interface.encodeFunctionData('usdqAmounts', [t]),
+    }));
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<VaultState> {
+    let vaultState: VaultState = {
+      usdqAmounts: {},
+    };
+    this.tokenAddresses.forEach(
+      (t: Address, i: number) =>
+        (vaultState.usdqAmounts[t] = BigInt(
+          Vault.interface
+            .decodeFunctionResult('usdqAmounts', multicallOutputs[i])[0]
+            .toString(),
+        )),
+    );
+    return vaultState;
+  }
+
+  public getUSDQAmount(state: DeepReadonly<State>, token: Address): bigint {
+    return this.lens.get()(state).usdqAmounts[token];
+  }
+
+  public processLog(
+    state: DeepReadonly<VaultState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): AsyncOrSync<VaultState | null> {
+    try {
+      const parsed = Vault.interface.parseLog(log);
+      const _state: VaultState = _.cloneDeep(state);
+      switch (parsed.name) {
+        case 'IncreaseUsdqAmount': {
+          const tokenAddress = parsed.args.token.toLowerCase();
+          const amount = BigInt(parsed.args.amount.toString());
+          if (tokenAddress in state.usdqAmounts)
+            _state.usdqAmounts[tokenAddress] += amount;
+          return _state;
+        }
+        case 'DecreaseUsdqAmount': {
+          const tokenAddress = parsed.args.token.toLowerCase();
+          const amount = BigInt(parsed.args.amount.toString());
+          if (tokenAddress in state.usdqAmounts)
+            _state.usdqAmounts[tokenAddress] -= amount;
+          return _state;
+        }
+        default:
+          return null;
+      }
+    } catch (e) {
+      this.logger.error('Failed to parse log', e);
+      return null;
+    }
+  }
+}

package/src/dex/solidly/forks-override/velodromeV2.ts

@@ -24,7 +24,6 @@ const VelodromeV2FactoryABI = [
 const velodromeV2FactoryIface = new Interface(VelodromeV2FactoryABI);
 
 export class VelodromeV2 extends Solidly {
-
   public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
     getDexKeysWithNetwork(_.pick(SolidlyConfig, ['VelodromeV2']));
 
@@ -44,7 +43,10 @@ export class VelodromeV2 extends Solidly {
   protected getFeesMultiCallData(pair: SolidlyPair) {
     const callEntry = {
       target: this.factoryAddress,
-      callData: velodromeV2FactoryIface.encodeFunctionData('getFee', [pair.exchange, pair.stable]),
+      callData: velodromeV2FactoryIface.encodeFunctionData('getFee', [
+        pair.exchange,
+        pair.stable,
+      ]),
     };
     const callDecoder = (values: any[]) =>
       parseInt(

package/src/dex/uniswap-v2/nomiswap-v2.ts

@@ -15,7 +15,8 @@ export const NomiswapV2Config: DexConfigMap<DexParams> = {
         '0x83eb759f5ea0525124f03d4ac741bb4af0bb1c703d5f694bd42a8bd72e495a01',
       poolGasCost: 120 * 1000,
       feeCode: 0, // this is ignored as Nomiswap uses dynamic fees,
-      subgraphURL: 'https://api.thegraph.com/subgraphs/name/nominex/nomiswap-exchange-subgraph',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/nominex/nomiswap-exchange-subgraph',
     },
   },
 };