@paraswap/dex-lib 3.8.28-fm.3 → 3.8.28

package/src/dex/infusion/infusion.ts

@@ -151,11 +151,7 @@ export class Infusion extends UniswapV2 {
     return pair;
   }
 
-  async batchCatchUpPairs(
-    pairs: [Token, Token][],
-    blockNumber: number,
-    fmode?: boolean,
-  ) {
+  async batchCatchUpPairs(pairs: [Token, Token][], blockNumber: number) {
     if (!blockNumber) return;
     const pairsToFetch: InfusionPair[] = [];
     for (const _pair of pairs) {
@@ -167,7 +163,7 @@ export class Infusion extends UniswapV2 {
         if (!(pair && pair.exchange)) continue;
         if (!pair.pool) {
           pairsToFetch.push(pair);
-        } else if (!fmode && !pair.pool.getState(blockNumber)) {
+        } else if (!pair.pool.getState(blockNumber)) {
           pairsToFetch.push(pair);
         }
       }
@@ -281,8 +277,6 @@ export class Infusion extends UniswapV2 {
       srcDexFee: 0,
       destDexFee: 0,
     },
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<ExchangePrices<InfusionData> | null> {
     try {
       if (side === SwapSide.BUY) return null; // Buy side not implemented yet
@@ -300,7 +294,7 @@ export class Infusion extends UniswapV2 {
         .sort((a, b) => (a > b ? 1 : -1))
         .join('_');
 
-      await this.batchCatchUpPairs([[from, to]], blockNumber, fmode);
+      await this.batchCatchUpPairs([[from, to]], blockNumber);
 
       const resultPromises = [false, true].map(async stable => {
         // We don't support fee on transfer for stable pools yet

package/src/dex/lite-psm/lite-psm.ts

@@ -13,7 +13,6 @@ import {
   DexExchangeParam,
   ExchangeTxInfo,
   PreprocessTransactionOptions,
-  TransferFeeParams,
 } from '../../types';
 import { SwapSide, Network, NULL_ADDRESS } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -145,11 +144,9 @@ export class LitePsm
   async getPoolState(
     pool: LitePsmEventPool,
     blockNumber: number,
-    fmode?: boolean,
-  ): Promise<PoolState | null> {
+  ): Promise<PoolState> {
     const eventState = pool.getState(blockNumber);
     if (eventState) return eventState;
-    if (fmode) return null;
     const onChainState = await pool.generateState(blockNumber);
     pool.setState(onChainState, blockNumber);
     return onChainState;
@@ -204,9 +201,6 @@ export class LitePsm
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees?: TransferFeeParams,
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<LitePsmData>> {
     const eventPool = this.getEventPool(srcToken, destToken);
     if (!eventPool) return null;
@@ -214,9 +208,7 @@ export class LitePsm
     const poolIdentifier = eventPool.getIdentifier();
     if (limitPools && !limitPools.includes(poolIdentifier)) return null;
 
-    const poolState = await this.getPoolState(eventPool, blockNumber, fmode);
-
-    if (!poolState) return null;
+    const poolState = await this.getPoolState(eventPool, blockNumber);
 
     const unitVolume = getBigIntPow(
       (side === SwapSide.SELL ? srcToken : destToken).decimals,

package/src/dex/maverick-v1/maverick-v1.ts

@@ -10,7 +10,6 @@ import {
   PoolLiquidity,
   Logger,
   DexExchangeParam,
-  TransferFeeParams,
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import { getDexKeysWithNetwork, getBigIntPow, isTruthy } from '../../utils';
@@ -210,9 +209,6 @@ export class MaverickV1
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees?: TransferFeeParams,
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<MaverickV1Data>> {
     try {
       const from = this.dexHelper.config.wrapETH(srcToken);
@@ -240,8 +236,6 @@ export class MaverickV1
           allowedPools.map(async (pool: MaverickV1EventPool) => {
             try {
               let state = pool.getState(blockNumber);
-              if (fmode && !state) return null;
-
               if (state === null) {
                 state = await pool.generateState(blockNumber);
                 pool.setState(state, blockNumber);

package/src/dex/maverick-v2/maverick-v2-pool.ts

@@ -346,15 +346,12 @@ export class MaverickV2EventPool extends StatefulEventSubscriber<PoolState> {
 
   async getOrGenerateState(
     blockNumber: number,
-    fmode?: boolean,
   ): Promise<DeepReadonly<PoolState> | null> {
     const state = this.getState(blockNumber);
     if (state) {
       return state;
     }
 
-    if (fmode) return null;
-
     this.logger.error(
       `No state found for ${this.name} ${this.addressesSubscribed[0]}, generating new one`,
     );

package/src/dex/maverick-v2/maverick-v2.ts

@@ -9,7 +9,6 @@ import {
   Logger,
   NumberAsString,
   DexExchangeParam,
-  TransferFeeParams,
 } from '../../types';
 import { SwapSide, Network, NULL_ADDRESS } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -144,9 +143,6 @@ export class MaverickV2 extends SimpleExchange implements IDex<MaverickV2Data> {
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees?: TransferFeeParams,
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<MaverickV2Data>> {
     try {
       const from = this.dexHelper.config.wrapETH(srcToken);
@@ -170,7 +166,7 @@ export class MaverickV2 extends SimpleExchange implements IDex<MaverickV2Data> {
 
       const tasks = allowedPools.map(async (pool: MaverickV2EventPool) => {
         try {
-          const state = await pool.getOrGenerateState(blockNumber, fmode);
+          const state = await pool.getOrGenerateState(blockNumber);
           if (!state) {
             this.logger.debug(`Received null state for pool ${pool.address}`);
             return null;

package/src/dex/nerve/nerve.ts

@@ -11,12 +11,11 @@ import {
   Logger,
   NumberAsString,
   DexExchangeParam,
-  TransferFeeParams,
 } from '../../types';
 import nervePoolABIDefault from '../../abi/nerve/nerve-pool.json';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { getDexKeysWithNetwork, getBigIntPow, isTruthy } from '../../utils';
+import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import {
@@ -112,7 +111,6 @@ export class Nerve
   async getStates(
     pools?: NerveEventPool[],
     blockNumber?: number,
-    fmode?: boolean,
   ): Promise<DeepReadonly<{ state: PoolState; pool: NerveEventPool }[]>> {
     const _pools = pools === undefined ? this.allPools : pools;
 
@@ -123,23 +121,20 @@ export class Nerve
 
     // TODO: Need to batch this RPC calls in one multicall
     return Promise.all(
-      _pools
-        .map(async eventPool => {
-          let state = eventPool.getState(_blockNumber);
-          if (!state || !state.isValid) {
-            this.logger.info(
-              `State for ${this.dexKey} pool ${eventPool.name} on ${this.network} is stale or invalid on block ${_blockNumber}. Generating new one`,
-            );
-            if (fmode) return null;
-            const newState = await eventPool.generateState(_blockNumber);
-            eventPool.setState(newState, _blockNumber);
-            return { state: newState, pool: eventPool };
-          } else {
-            return { state, pool: eventPool };
-          }
-        })
-        .filter(isTruthy),
-    ) as Promise<{ state: PoolState; pool: NerveEventPool }[]>;
+      _pools.map(async eventPool => {
+        let state = eventPool.getState(_blockNumber);
+        if (!state || !state.isValid) {
+          this.logger.info(
+            `State for ${this.dexKey} pool ${eventPool.name} on ${this.network} is stale or invalid on block ${_blockNumber}. Generating new one`,
+          );
+          const newState = await eventPool.generateState(_blockNumber);
+          eventPool.setState(newState, _blockNumber);
+          return { state: newState, pool: eventPool };
+        } else {
+          return { state, pool: eventPool };
+        }
+      }),
+    );
   }
 
   async getPoolIdentifiers(
@@ -170,9 +165,6 @@ export class Nerve
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees?: TransferFeeParams,
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<NerveData>> {
     try {
       if (side === SwapSide.BUY) return null;
@@ -207,11 +199,7 @@ export class Nerve
           )
         : filterPoolsByIdentifiers(limitPools, this.allPools);
 
-      const statePoolPair = await this.getStates(
-        selectedPools,
-        blockNumber,
-        fmode,
-      );
+      const statePoolPair = await this.getStates(selectedPools, blockNumber);
 
       // here side === SwapSide.SELL
       const unitVolume = getBigIntPow(_srcToken.decimals);

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

@@ -126,11 +126,9 @@ export class OSwapEventPool extends StatefulEventSubscriber<OSwapPoolState> {
   async getStateOrGenerate(
     blockNumber: number,
     readonly: boolean = true,
-    fmode?: boolean,
-  ): Promise<OSwapPoolState | null> {
+  ): Promise<OSwapPoolState> {
     let state = this.getState(blockNumber);
     if (!state) {
-      if (fmode) return null;
       state = await this.generateState(blockNumber);
       if (!readonly) this.setState(state, blockNumber);
     }

package/src/dex/oswap/oswap.ts

@@ -1,5 +1,5 @@
 import { Interface } from '@ethersproject/abi';
-import { assert, AsyncOrSync } from 'ts-essentials';
+import { AsyncOrSync } from 'ts-essentials';
 import {
   Token,
   Address,
@@ -203,8 +203,6 @@ export class OSwap extends SimpleExchange implements IDex<OSwapData> {
       srcDexFee: 0,
       destDexFee: 0,
     },
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<OSwapData>> {
     try {
       // Get the pool to use.
@@ -222,9 +220,7 @@ export class OSwap extends SimpleExchange implements IDex<OSwapData> {
         return null;
       }
 
-      const state = await eventPool.getStateOrGenerate(blockNumber, fmode);
-
-      if (!state) return null;
+      const state = await eventPool.getStateOrGenerate(blockNumber);
 
       // Calculate the prices
       const unitAmount = getBigIntPow(18);
@@ -383,8 +379,6 @@ export class OSwap extends SimpleExchange implements IDex<OSwapData> {
           await this.dexHelper.web3Provider.eth.getBlockNumber();
         const state = await eventPool.getStateOrGenerate(blockNumber);
 
-        assert(state, 'OSwap pool state not found');
-
         const usd0 = await this.dexHelper.getTokenUSDPrice(
           { address: pool.token0, decimals: 18 },
           BigInt(state.balance0),

package/src/dex/pancakeswap-v3/pancakeswap-v3.ts

@@ -12,7 +12,6 @@ import {
   NumberAsString,
   PoolPrices,
   DexExchangeParam,
-  TransferFeeParams,
 } from '../../types';
 import { SwapSide, Network, CACHE_PREFIX } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -547,9 +546,6 @@ export class PancakeswapV3
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees?: TransferFeeParams,
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<UniswapV3Data>> {
     try {
       const _srcToken = this.dexHelper.config.wrapETH(srcToken);
@@ -636,15 +632,13 @@ export class PancakeswapV3
         },
       );
 
-      const rpcResultsPromise = fmode
-        ? null
-        : this.getPricingFromRpc(
-            _srcToken,
-            _destToken,
-            amounts,
-            side,
-            this.network === Network.ZKEVM ? [] : poolsToUse.poolWithoutState,
-          );
+      const rpcResultsPromise = this.getPricingFromRpc(
+        _srcToken,
+        _destToken,
+        amounts,
+        side,
+        this.network === Network.ZKEVM ? [] : poolsToUse.poolWithoutState,
+      );
 
       const states = poolsToUse.poolWithState.map(
         p => p.getState(blockNumber)!,

package/src/dex/solidly/solidly.ts

@@ -171,11 +171,7 @@ export class Solidly extends UniswapV2 {
     return pair;
   }
 
-  async batchCatchUpPairs(
-    pairs: [Token, Token][],
-    blockNumber: number,
-    fmode?: boolean,
-  ) {
+  async batchCatchUpPairs(pairs: [Token, Token][], blockNumber: number) {
     if (!blockNumber) return;
     const pairsToFetch: SolidlyPair[] = [];
     for (const _pair of pairs) {
@@ -184,7 +180,7 @@ export class Solidly extends UniswapV2 {
         if (!(pair && pair.exchange)) continue;
         if (!pair.pool) {
           pairsToFetch.push(pair);
-        } else if (!fmode && !pair.pool.getState(blockNumber)) {
+        } else if (!pair.pool.getState(blockNumber)) {
           pairsToFetch.push(pair);
         }
       }
@@ -310,8 +306,6 @@ export class Solidly extends UniswapV2 {
       srcDexFee: 0,
       destDexFee: 0,
     },
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<ExchangePrices<UniswapV2Data> | null> {
     try {
       if (side === SwapSide.BUY) return null; // Buy side not implemented yet
@@ -329,7 +323,7 @@ export class Solidly extends UniswapV2 {
         .sort((a, b) => (a > b ? 1 : -1))
         .join('_');
 
-      await this.batchCatchUpPairs([[from, to]], blockNumber, fmode);
+      await this.batchCatchUpPairs([[from, to]], blockNumber);
 
       const resultPromises = [false, true].map(async stable => {
         // We don't support fee on transfer for stable pools yet

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

@@ -445,11 +445,7 @@ export class UniswapV2
     }
   }
 
-  async batchCatchUpPairs(
-    pairs: [Token, Token][],
-    blockNumber: number,
-    fmode?: boolean,
-  ) {
+  async batchCatchUpPairs(pairs: [Token, Token][], blockNumber: number) {
     if (!blockNumber) return;
     const pairsToFetch: UniswapV2Pair[] = [];
     for (const _pair of pairs) {
@@ -457,7 +453,7 @@ export class UniswapV2
       if (!(pair && pair.exchange)) continue;
       if (!pair.pool) {
         pairsToFetch.push(pair);
-      } else if (!fmode && !pair.pool.getState(blockNumber)) {
+      } else if (!pair.pool.getState(blockNumber)) {
         pairsToFetch.push(pair);
       }
     }
@@ -564,8 +560,6 @@ export class UniswapV2
       srcDexFee: 0,
       destDexFee: 0,
     },
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<ExchangePrices<UniswapV2Data> | null> {
     try {
       const from = this.dexHelper.config.wrapETH(_from);
@@ -587,7 +581,7 @@ export class UniswapV2
       if (limitPools && limitPools.every(p => p !== poolIdentifier))
         return null;
 
-      await this.batchCatchUpPairs([[from, to]], blockNumber, fmode);
+      await this.batchCatchUpPairs([[from, to]], blockNumber);
       const isSell = side === SwapSide.SELL;
       const pairParam = await this.getPairOrderedParams(
         from,

package/src/dex/uniswap-v3/uniswap-v3.ts

@@ -14,7 +14,6 @@ import {
   PreprocessTransactionOptions,
   SimpleExchangeParam,
   Token,
-  TransferFeeParams,
   TxInfo,
 } from '../../types';
 import { CACHE_PREFIX, Network, SwapSide } from '../../constants';
@@ -662,9 +661,6 @@ export class UniswapV3
     side: SwapSide,
     blockNumber: number,
     limitPools?: string[],
-    transferFees?: TransferFeeParams,
-    isFirstSwap?: boolean,
-    fmode?: boolean,
   ): Promise<null | ExchangePrices<UniswapV3Data>> {
     try {
       const _srcToken = this.dexHelper.config.wrapETH(srcToken);
@@ -741,16 +737,14 @@ export class UniswapV3
         p => p.getState(blockNumber)!,
       );
 
-      const rpcResultsPromise = fmode
-        ? null
-        : this.getPricingFromRpc(
-            _srcToken,
-            _destToken,
-            amounts,
-            side,
-            this.network === Network.ZKEVM ? [] : poolsToUse.poolWithoutState,
-            this.network === Network.ZKEVM ? [] : states,
-          );
+      const rpcResultsPromise = this.getPricingFromRpc(
+        _srcToken,
+        _destToken,
+        amounts,
+        side,
+        this.network === Network.ZKEVM ? [] : poolsToUse.poolWithoutState,
+        this.network === Network.ZKEVM ? [] : states,
+      );
 
       const unitAmount = getBigIntPow(
         side == SwapSide.SELL ? _srcToken.decimals : _destToken.decimals,

package/src/executor/types.ts

@@ -25,6 +25,8 @@ export enum SpecialDex {
   SWAP_ON_AUGUSTUS_RFQ = 9, // swapOnAugustusRFQ
   EXECUTE_VERTICAL_BRANCHING = 10, // execute vertical branching
   BUY_ON_SOLIDLY_V3 = 11,
+  SWAP_ON_DEXALOT = 12,
+  SWAP_ON_HASHFLOW = 13,
 }
 
 export enum Executors {

package/src/pricing-helper.ts

@@ -111,24 +111,14 @@ export class PricingHelper {
     blockNumber: number,
     dexKeys: string[],
     filterConstantPricePool: boolean = false,
-    overrideTimeout?: number,
   ): Promise<{ [dexKey: string]: string[] | null }> {
     const poolIdentifiers = await Promise.all(
       dexKeys.map(async key => {
         try {
           return await new Promise<string[] | null>((resolve, reject) => {
-            const now = Date.now();
-            const timeout = overrideTimeout ?? FETCH_POOL_IDENTIFIER_TIMEOUT;
             const timer = setTimeout(
-              () =>
-                reject(
-                  new Error(
-                    `Timeout of ${timeout}ms breached after ${
-                      Date.now() - now
-                    }ms for ${key}`,
-                  ),
-                ),
-              timeout,
+              () => reject(new Error(`Timeout`)),
+              FETCH_POOL_IDENTIFIER_TIMEOUT,
             );
             const dexInstance = this.dexAdapterService.getDexByKey(key);
 
@@ -202,8 +192,6 @@ export class PricingHelper {
       destDexFee: 0,
     },
     rollupL1ToL2GasRatio?: number,
-    overrideTimeout?: number,
-    fmode?: boolean,
   ): Promise<PoolPrices<any>[]> {
     const dexPoolPrices = await Promise.all(
       dexKeys.map(async key => {
@@ -214,18 +202,9 @@ export class PricingHelper {
 
           return await new Promise<PoolPrices<any>[] | null>(
             (resolve, reject) => {
-              const now = Date.now();
-              const timeout = overrideTimeout ?? FETCH_POOL_PRICES_TIMEOUT;
               const timer = setTimeout(
-                () =>
-                  reject(
-                    new Error(
-                      `Timeout of ${timeout}ms breached after ${
-                        Date.now() - now
-                      }ms for ${key}`,
-                    ),
-                  ),
-                timeout,
+                () => reject(new Error(`Timeout`)),
+                FETCH_POOL_PRICES_TIMEOUT,
               );
 
               const dexInstance = this.dexAdapterService.getDexByKey(key);
@@ -247,8 +226,6 @@ export class PricingHelper {
                   blockNumber,
                   limitPools ? limitPools : undefined,
                   transferFees,
-                  false,
-                  fmode,
                 )
                 .then(poolPrices => {
                   try {

package/build/dex-utils.d.ts

@@ -1,3 +0,0 @@
-export declare class DexPoolNotFoundError extends Error {
-    constructor(dexKey: string, poolIdentifier: string);
-}

package/build/dex-utils.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DexPoolNotFoundError = void 0;
-class DexPoolNotFoundError extends Error {
-    constructor(dexKey, poolIdentifier) {
-        super(`Pool ${poolIdentifier} not found for DEX ${dexKey}`);
-    }
-}
-exports.DexPoolNotFoundError = DexPoolNotFoundError;
-//# sourceMappingURL=dex-utils.js.map

package/build/dex-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dex-utils.js","sourceRoot":"","sources":["../src/dex-utils.ts"],"names":[],"mappings":";;;AAAA,MAAa,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,MAAc,EAAE,cAAsB;QAChD,KAAK,CAAC,QAAQ,cAAc,sBAAsB,MAAM,EAAE,CAAC,CAAC;IAC9D,CAAC;CACF;AAJD,oDAIC"}

package/build/stateful-dual-synchronizer.d.ts

@@ -1,46 +0,0 @@
-import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
-import { Log, Logger } from './types';
-import { BlockHeader } from 'web3-eth';
-import { EventSubscriber } from './dex-helper/iblock-manager';
-import { IDexHelper } from './dex-helper';
-export declare type InitializeStateOptions<State> = {
-    state?: DeepReadonly<State>;
-    initCallback?: (state: DeepReadonly<State>) => void;
-    forceRegenerate?: boolean;
-};
-declare type ObjectOrString<State> = DeepReadonly<State> | string;
-declare type ObjectOrStringOrNull<State> = ObjectOrString<State> | null;
-export declare abstract class StatefulDualSynchronizer<State> implements EventSubscriber {
-    dexKey: string;
-    poolIdentifier: string;
-    protected dexHelper: IDexHelper;
-    protected logger: Logger;
-    protected state: ObjectOrStringOrNull<State>;
-    protected stateBlockNumber: number;
-    protected stateHistory: {
-        [blockNumber: number]: ObjectOrString<State>;
-    };
-    protected invalid: boolean;
-    isTracking: () => boolean;
-    addressesSubscribed: string[];
-    parentName: string;
-    name: string;
-    isInitialized: boolean;
-    constructor(dexKey: string, poolIdentifier: string, dexHelper: IDexHelper, logger: Logger);
-    getStateBlockNumber(): Readonly<number>;
-    initialize(blockNumber: number, options?: InitializeStateOptions<State>): Promise<void>;
-    protected abstract processLog(state: DeepReadonly<State>, log: Readonly<Log>, blockHeader: Readonly<BlockHeader>): AsyncOrSync<DeepReadonly<State> | null>;
-    protected processBlockLogs(state: DeepReadonly<State>, logs: Readonly<Log>[], blockHeader: Readonly<BlockHeader>): Promise<DeepReadonly<State> | null>;
-    abstract generateState(blockNumber?: number | 'latest'): AsyncOrSync<DeepReadonly<State>>;
-    restart(blockNumber: number): void;
-    update(logs: Readonly<Log>[], blockHeaders: Readonly<{
-        [blockNumber: number]: Readonly<BlockHeader>;
-    }>): Promise<void>;
-    rollback(blockNumber: number): void;
-    invalidate(): void;
-    getState(minBlockNumber: number): DeepReadonly<State> | null;
-    getStaleState(): DeepReadonly<State> | null;
-    _setState(state: ObjectOrStringOrNull<State>, blockNumber: number): void;
-    setState(state: ObjectOrString<State>, blockNumber: number): void;
-}
-export {};