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

package/src/dex/algebra/utils.ts

@@ -1,11 +1,12 @@
-import { BytesLike, ethers } from 'ethers';
+import { BigNumber, BytesLike, ethers } from 'ethers';
 import { assert } from 'ts-essentials';
 import { extractSuccessAndValue } from '../../lib/decoders';
 import { MultiResult } from '../../lib/multi-wrapper';
 import {
-  DecodedGlobalStateV1_9,
+  DecodedGlobalStateV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_1,
   DecodedStateMultiCallResultWithRelativeBitmapsV1_9,
+  TickInfoWithBigNumber,
 } from './types';
 
 export function decodeStateMultiCallResultWithRelativeBitmapsV1_1(
@@ -134,3 +135,83 @@ export function decodeStateMultiCallResultWithRelativeBitmapsV1_9(
   // But I typed only the ones that are used later
   return decoded as DecodedStateMultiCallResultWithRelativeBitmapsV1_9;
 }
+
+export function decodeGlobalStateV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecodedGlobalStateV1_1 {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: DecodedGlobalStateV1_1 = {
+    price: BigNumber.from(0),
+    tick: 0,
+    fee: 0,
+    communityFeeToken0: 0,
+    communityFeeToken1: 0,
+  };
+
+  [
+    results.price,
+    results.tick,
+    results.fee,
+    ,
+    results.communityFeeToken0,
+    results.communityFeeToken1,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [`uint160`, `int24`, `uint16`, `uint16`, `uint8`, `uint8`, `bool`],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}
+
+export function decodeTicksV1_1(
+  result: MultiResult<BytesLike> | BytesLike,
+): TickInfoWithBigNumber {
+  const [isSuccess, toDecode] = extractSuccessAndValue(result);
+
+  assert(
+    isSuccess && toDecode !== '0x',
+    `decodeGlobalStateV1_1 failed to get decodable result: ${result}`,
+  );
+
+  const results: TickInfoWithBigNumber = {
+    liquidityNet: BigNumber.from(0),
+    liquidityGross: BigNumber.from(0),
+    secondsOutside: 0,
+    secondsPerLiquidityOutsideX128: BigNumber.from(0),
+    tickCumulativeOutside: BigNumber.from(0),
+    initialized: false,
+  };
+
+  [
+    results.liquidityGross,
+    results.liquidityNet,
+    ,
+    ,
+    results.tickCumulativeOutside,
+    results.secondsPerLiquidityOutsideX128,
+    results.secondsOutside,
+    results.initialized,
+  ] = ethers.utils.defaultAbiCoder.decode(
+    [
+      `uint128`,
+      `int128`,
+      `uint256`,
+      `uint256`,
+      `int256`,
+      `uint160`,
+      `uint32`,
+      `bool`,
+    ],
+    toDecode,
+  );
+  // This conversion is not precise, because when we decode, we have more values
+  // But used later
+  return results;
+}

package/src/dex/balancer-v2/optimizer.ts

@@ -3,20 +3,22 @@ import { BalancerSwapV2 } from './types';
 import { SwapSide } from '../../constants';
 import { BalancerConfig } from './config';
 
-export const AllBalancerV2Forks = Object.keys(BalancerConfig);
+const MAX_UINT256 =
+  '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+
+const AllBalancerV2Forks = Object.keys(BalancerConfig);
 
 export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
   const fixSwap = (
     rawSwap: OptimalSwapExchange<any>[],
-    accumulatedBalancers: { [key: string]: OptimalSwapExchange<any> },
     side: SwapSide,
   ): OptimalSwapExchange<any>[] => {
-    let optimizedSwap = new Array<OptimalSwapExchange<any>>();
     const newBalancers: { [key: string]: OptimalSwapExchange<any> } = {};
+    let optimizedSwap = new Array<OptimalSwapExchange<any>>();
     rawSwap.forEach((s: OptimalSwapExchange<any>) => {
       const exchangeKey = s.exchange.toLowerCase();
       if (AllBalancerV2Forks.some(d => d.toLowerCase() === exchangeKey)) {
-        if (!(exchangeKey in accumulatedBalancers)) {
+        if (!(exchangeKey in newBalancers)) {
           newBalancers[exchangeKey] = {
             exchange: s.exchange,
             srcAmount: '0',
@@ -28,33 +30,27 @@ export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
               gasUSD: '0',
             },
           };
-          accumulatedBalancers[exchangeKey] = newBalancers[exchangeKey];
         }
-        accumulatedBalancers[exchangeKey].srcAmount = (
-          BigInt(accumulatedBalancers[exchangeKey].srcAmount) +
-          BigInt(s.srcAmount)
+        newBalancers[exchangeKey].srcAmount = (
+          BigInt(newBalancers[exchangeKey].srcAmount) + BigInt(s.srcAmount)
         ).toString();
 
-        accumulatedBalancers[exchangeKey].destAmount = (
-          BigInt(accumulatedBalancers[exchangeKey].destAmount) +
-          BigInt(s.destAmount)
+        newBalancers[exchangeKey].destAmount = (
+          BigInt(newBalancers[exchangeKey].destAmount) + BigInt(s.destAmount)
         ).toString();
 
-        accumulatedBalancers[exchangeKey].percent += s.percent;
-        accumulatedBalancers[exchangeKey].data.exchangeProxy =
-          s.data.exchangeProxy;
-        accumulatedBalancers[exchangeKey].data.gasUSD = (
-          parseFloat(accumulatedBalancers[exchangeKey].data.gasUSD) +
+        newBalancers[exchangeKey].percent += s.percent;
+        newBalancers[exchangeKey].data.exchangeProxy = s.data.exchangeProxy;
+        newBalancers[exchangeKey].data.gasUSD = (
+          parseFloat(newBalancers[exchangeKey].data.gasUSD) +
           parseFloat(s.data.gasUSD)
         ).toFixed(6);
 
-        accumulatedBalancers[exchangeKey].data.swaps.push({
+        newBalancers[exchangeKey].data.swaps.push({
           poolId: s.data.poolId,
           amount: side === SwapSide.SELL ? s.srcAmount : s.destAmount,
         });
-        accumulatedBalancers[exchangeKey].poolAddresses!.push(
-          s.poolAddresses![0],
-        );
+        newBalancers[exchangeKey].poolAddresses!.push(s.poolAddresses![0]);
       } else {
         optimizedSwap.push(s);
       }
@@ -63,23 +59,12 @@ export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
     return optimizedSwap;
   };
 
-  or.bestRoute = or.bestRoute.map(r => {
-    const accumulatedBalancers: {
-      [key: string]: OptimalSwapExchange<any>;
-    } = {};
-    return {
-      ...r,
-      swaps: r.swaps
-        .map(s => ({
-          ...s,
-          swapExchanges: fixSwap(
-            s.swapExchanges,
-            accumulatedBalancers,
-            or.side,
-          ),
-        }))
-        .filter(s => s.swapExchanges.length > 0),
-    };
-  });
+  or.bestRoute = or.bestRoute.map(r => ({
+    ...r,
+    swaps: r.swaps.map(s => ({
+      ...s,
+      swapExchanges: fixSwap(s.swapExchanges, or.side),
+    })),
+  }));
   return or;
 }

package/src/dex/index.ts

@@ -73,6 +73,7 @@ import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
 import { Algebra } from './algebra/algebra';
+import { QuickPerps } from './quick-perps/quick-perps';
 import { NomiswapV2 } from './uniswap-v2/nomiswap-v2';
 
 const LegacyDexes = [
@@ -144,6 +145,7 @@ const Dexes = [
   MaverickV1,
   Camelot,
   SwaapV2,
+  QuickPerps,
   NomiswapV2,
 ];
 

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

@@ -0,0 +1,31 @@
+import { DexParams } from './types';
+import { DexConfigMap } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const QuickPerpsConfig: DexConfigMap<DexParams> = {
+  QuickPerps: {
+    [Network.ZKEVM]: {
+      vault: '0x99B31498B0a1Dae01fc3433e3Cb60F095340935C',
+      reader: '0xf1CFB75854DE535475B88Bb6FBad317eea98c0F9',
+      priceFeed: '0x5b1F500134bdD7f4359F5B2adC65f839737290f4',
+      fastPriceFeed: '0x73903fEc691a80Ec47bc830bf3F0baD127A06e30',
+      fastPriceEvents: '0x08bC8ef0b71238055f9Ee6BBc90869D8d0DBdCCa',
+      usdq: '0x48aC594dd00c4aAcF40f83337fc6dA31F9F439A7',
+    },
+  },
+};
+
+export const Adapters: {
+  [chainId: number]: {
+    [side: string]: { name: string; index: number }[] | null;
+  };
+} = {
+  [Network.ZKEVM]: {
+    [SwapSide.SELL]: [
+      {
+        name: 'PolygonZkEvmAdapter01',
+        index: 2,
+      },
+    ],
+  },
+};

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

@@ -0,0 +1,279 @@
+import _ from 'lodash';
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
+import { PartialEventSubscriber } from '../../composed-event-subscriber';
+import {
+  Address,
+  MultiCallInput,
+  MultiCallOutput,
+  Logger,
+  Log,
+  BlockHeader,
+} from '../../types';
+import { FastPriceFeedConfig, FastPriceFeedState } from './types';
+import FastPriceFeedAbi from '../../abi/quick-perps/fast-price-feed.json';
+import FastPriceEventsAbi from '../../abi/quick-perps/fast-price-events.json';
+import { Lens } from '../../lens';
+
+export class FastPriceFeed<State> extends PartialEventSubscriber<
+  State,
+  FastPriceFeedState
+> {
+  static readonly interface = new Interface(FastPriceFeedAbi);
+  static readonly fastPriceEventsInterface = new Interface(FastPriceEventsAbi);
+
+  BASIS_POINTS_DIVISOR = 10000n;
+  protected priceDuration: number;
+  protected maxDeviationBasisPoints: bigint;
+  protected favorFastPrice: Record<string, boolean>;
+  private spreadBasisPointsIfInactive: bigint;
+  private spreadBasisPointsIfChainError: bigint;
+  private maxPriceUpdateDelay: number;
+
+  constructor(
+    private fastPriceFeedAddress: Address,
+    fastPriceEventsAddress: Address,
+    private tokenAddresses: Address[],
+    config: FastPriceFeedConfig,
+    lens: Lens<DeepReadonly<State>, DeepReadonly<FastPriceFeedState>>,
+    logger: Logger,
+  ) {
+    super([fastPriceEventsAddress], lens, logger);
+    this.priceDuration = config.priceDuration;
+    this.maxDeviationBasisPoints = config.maxDeviationBasisPoints;
+    this.favorFastPrice = config.favorFastPrice;
+    this.spreadBasisPointsIfInactive = config.spreadBasisPointsIfInactive;
+    this.spreadBasisPointsIfChainError = config.spreadBasisPointsIfChainError;
+    this.maxPriceUpdateDelay = config.maxPriceUpdateDelay;
+  }
+
+  public processLog(
+    state: DeepReadonly<FastPriceFeedState>,
+    log: Readonly<Log>,
+    blockHeader: Readonly<BlockHeader>,
+  ): DeepReadonly<FastPriceFeedState> | null {
+    try {
+      const parsed = FastPriceFeed.fastPriceEventsInterface.parseLog(log);
+      switch (parsed.name) {
+        case 'PriceUpdate': {
+          const _state: FastPriceFeedState = _.cloneDeep(state);
+          _state.lastUpdatedAt =
+            typeof blockHeader.timestamp === 'string'
+              ? parseInt(blockHeader.timestamp)
+              : blockHeader.timestamp;
+          const tokenAddress = parsed.args.token.toLowerCase();
+          if (tokenAddress in state.prices)
+            _state.prices[tokenAddress] = BigInt(parsed.args.price.toString());
+          return _state;
+        }
+        default:
+          return null;
+      }
+    } catch (e) {
+      this.logger.error('Failed to parse log', e);
+      return null;
+    }
+  }
+
+  getPrice(
+    _state: DeepReadonly<State>,
+    _token: Address,
+    _refPrice: bigint,
+    _maximize: boolean,
+  ) {
+    const state = this.lens.get()(_state);
+
+    const timestamp = Math.floor(Date.now() / 1000);
+
+    if (timestamp > state.lastUpdatedAt + this.maxPriceUpdateDelay) {
+      if (_maximize) {
+        return (
+          (_refPrice *
+            (this.BASIS_POINTS_DIVISOR + this.spreadBasisPointsIfChainError)) /
+          this.BASIS_POINTS_DIVISOR
+        );
+      }
+
+      return (
+        (_refPrice *
+          (this.BASIS_POINTS_DIVISOR - this.spreadBasisPointsIfChainError)) /
+        this.BASIS_POINTS_DIVISOR
+      );
+    }
+
+    if (timestamp > state.lastUpdatedAt + this.priceDuration) {
+      if (_maximize) {
+        return (
+          (_refPrice *
+            (this.BASIS_POINTS_DIVISOR + this.spreadBasisPointsIfInactive)) /
+          this.BASIS_POINTS_DIVISOR
+        );
+      }
+
+      return (
+        (_refPrice *
+          (this.BASIS_POINTS_DIVISOR - this.spreadBasisPointsIfInactive)) /
+        this.BASIS_POINTS_DIVISOR
+      );
+    }
+
+    const fastPrice = state.prices[_token];
+    if (fastPrice === 0n) return _refPrice;
+
+    let diffBasisPoints =
+      _refPrice > fastPrice ? _refPrice - fastPrice : fastPrice - _refPrice;
+    diffBasisPoints = (diffBasisPoints * this.BASIS_POINTS_DIVISOR) / _refPrice;
+
+    // create a spread between the _refPrice and the fastPrice if the maxDeviationBasisPoints is exceeded
+    // or if watchers have flagged an issue with the fast price
+    const hasSpread =
+      !this.favorFastPrice[_token] ||
+      diffBasisPoints > this.maxDeviationBasisPoints;
+
+    if (hasSpread) {
+      // return the higher of the two prices
+      if (_maximize) {
+        return _refPrice > fastPrice ? _refPrice : fastPrice;
+      }
+
+      // return the lower of the two prices
+      return _refPrice < fastPrice ? _refPrice : fastPrice;
+    }
+
+    return fastPrice;
+  }
+
+  static getConfigMulticallInputs(
+    fastPriceFeedAddress: Address,
+    tokenAddresses: Address[],
+  ): MultiCallInput[] {
+    return [
+      {
+        target: fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData('priceDuration'),
+      },
+      {
+        target: fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData(
+          'maxDeviationBasisPoints',
+        ),
+      },
+      {
+        target: fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData(
+          'spreadBasisPointsIfInactive',
+        ),
+      },
+      {
+        target: fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData(
+          'spreadBasisPointsIfChainError',
+        ),
+      },
+      {
+        target: fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData(
+          'maxPriceUpdateDelay',
+        ),
+      },
+      ...tokenAddresses.map(t => ({
+        target: fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData('favorFastPrice', [
+          t,
+        ]),
+      })),
+    ];
+  }
+
+  static getConfig(
+    multicallOutputs: MultiCallOutput[],
+    tokenAddresses: Address[],
+  ): FastPriceFeedConfig {
+    return {
+      priceDuration: parseInt(
+        FastPriceFeed.interface
+          .decodeFunctionResult('priceDuration', multicallOutputs[0])[0]
+          .toString(),
+      ),
+      maxDeviationBasisPoints: BigInt(
+        FastPriceFeed.interface
+          .decodeFunctionResult(
+            'maxDeviationBasisPoints',
+            multicallOutputs[1],
+          )[0]
+          .toString(),
+      ),
+      spreadBasisPointsIfInactive: BigInt(
+        FastPriceFeed.interface
+          .decodeFunctionResult(
+            'spreadBasisPointsIfInactive',
+            multicallOutputs[2],
+          )[0]
+          .toString(),
+      ),
+      spreadBasisPointsIfChainError: BigInt(
+        FastPriceFeed.interface
+          .decodeFunctionResult(
+            'spreadBasisPointsIfChainError',
+            multicallOutputs[3],
+          )[0]
+          .toString(),
+      ),
+      maxPriceUpdateDelay: parseInt(
+        FastPriceFeed.interface
+          .decodeFunctionResult('maxPriceUpdateDelay', multicallOutputs[4])[0]
+          .toString(),
+      ),
+      favorFastPrice: multicallOutputs
+        .slice(5)
+        .reduce<Record<string, boolean>>((acc, curr, i) => {
+          acc[tokenAddresses[i]] = FastPriceFeed.interface.decodeFunctionResult(
+            'favorFastPrice',
+            curr,
+          )[0];
+          return acc;
+        }, {}),
+    };
+  }
+
+  public getGenerateStateMultiCallInputs(): MultiCallInput[] {
+    const pricesEntries = this.tokenAddresses.map((t: Address) => ({
+      target: this.fastPriceFeedAddress,
+      callData: FastPriceFeed.interface.encodeFunctionData('prices', [t]),
+    }));
+    return [
+      ...pricesEntries,
+      {
+        target: this.fastPriceFeedAddress,
+        callData: FastPriceFeed.interface.encodeFunctionData('lastUpdatedAt'),
+      },
+    ];
+  }
+
+  public generateState(
+    multicallOutputs: MultiCallOutput[],
+    blockNumber?: number | 'latest',
+  ): DeepReadonly<FastPriceFeedState> {
+    let fastPriceFeedState: FastPriceFeedState = {
+      prices: {},
+      lastUpdatedAt: 0,
+    };
+    this.tokenAddresses.forEach(
+      (t: Address, i: number) =>
+        (fastPriceFeedState.prices[t] = BigInt(
+          FastPriceFeed.interface
+            .decodeFunctionResult('prices', multicallOutputs[i])[0]
+            .toString(),
+        )),
+    );
+    fastPriceFeedState.lastUpdatedAt = parseInt(
+      FastPriceFeed.interface
+        .decodeFunctionResult(
+          'lastUpdatedAt',
+          multicallOutputs[this.tokenAddresses.length],
+        )[0]
+        .toString(),
+    );
+    return fastPriceFeedState;
+  }
+}