@paraswap/dex-lib 2.34.0 → 2.35.1

package/src/composed-event-subscriber.ts

@@ -110,17 +110,22 @@ export abstract class ComposedEventSubscriber<
           .call({}, blockNumber)
       ).returnData;
     }
-    const stateParts = await Promise.all(
-      this.parts.map((p, i) =>
-        p.generateState(
-          returnData.slice(...this.multiCallSlices[i]),
-          blockNumber,
+    try {
+      const stateParts = await Promise.all(
+        this.parts.map((p, i) =>
+          p.generateState(
+            returnData.slice(...this.multiCallSlices[i]),
+            blockNumber,
+          ),
         ),
-      ),
-    );
-    return this.parts.reduce(
-      (acc, p, i) => p.lens.set(stateParts[i])(acc),
-      this.blankState,
-    );
+      );
+      return this.parts.reduce(
+        (acc, p, i) => p.lens.set(stateParts[i])(acc),
+        this.blankState,
+      );
+    } catch (e) {
+      this.logger.error(`Error generating state: ${e}`);
+      throw e;
+    }
   }
 }

package/src/config.ts

@@ -332,8 +332,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     multicallV2Address: '0x6cA478C852DfA8941FC819fDf248606eA04780B6',
     privateHttpProvider: process.env.HTTP_PROVIDER_1101,
     adapterAddresses: {
-      PolygonZkEvmAdapter01: '0x760870be538e7b4E2110e2890473CC17ADB1fdC1',
-      PolygonZkEvmBuyAdapter: '0x61bFA60A992472869F8d7b4705609A6E0BCf383f',
+      PolygonZkEvmAdapter01: '0xd63B7691dD98fa89A2ea5e1604700489c585aa7B',
+      PolygonZkEvmBuyAdapter: '0xe2137168CdA486a2555E16c597905854C84F9127',
     },
 
     rpcPollingMaxAllowedStateDelayInBlocks: 0,

package/src/dex/algebra/algebra.ts

@@ -817,20 +817,7 @@ export class Algebra extends SimpleExchange implements IDex<AlgebraData> {
           return null;
         }
 
-        // TODO buy
-        let lastNonZeroOutput = 0n;
-        let lastNonZeroTickCountsOutputs = 0;
-
         for (let i = 0; i < outputsResult.outputs.length; i++) {
-          // local pricing algo may output 0s at the tail for some out of range amounts, prefer to propagating last amount to appease top algo
-          if (outputsResult.outputs[i] > 0n) {
-            lastNonZeroOutput = outputsResult.outputs[i];
-            lastNonZeroTickCountsOutputs = outputsResult.tickCounts[i];
-          } else {
-            outputsResult.outputs[i] = lastNonZeroOutput;
-            outputsResult.tickCounts[i] = lastNonZeroTickCountsOutputs;
-          }
-
           if (outputsResult.outputs[i] > destTokenBalance) {
             outputsResult.outputs[i] = 0n;
             outputsResult.tickCounts[i] = 0;

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;
+  }
+}