@paraswap/dex-lib 3.8.28-fm.2 → 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/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/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 {};

package/build/stateful-dual-synchronizer.js

@@ -1,300 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatefulDualSynchronizer = void 0;
-const ts_essentials_1 = require("ts-essentials");
-const constants_1 = require("./constants");
-const utils_1 = require("./utils");
-// TODO:  make sure that we can get either state object or string
-class StatefulDualSynchronizer {
-    constructor(dexKey, poolIdentifier, dexHelper, logger) {
-        this.dexKey = dexKey;
-        this.poolIdentifier = poolIdentifier;
-        this.dexHelper = dexHelper;
-        this.logger = logger;
-        //The current state and its block number
-        //Derived classes should not set these directly, and instead use setState()
-        this.state = null;
-        this.stateBlockNumber = 0;
-        //Derived classes should use setState() to record a new entry
-        this.stateHistory = {};
-        //Invalid flag - indicates that the currently stored state might not be valid
-        this.invalid = false;
-        this.isTracking = () => false;
-        this.addressesSubscribed = [];
-        this.isInitialized = false;
-        this.dexKey = dexKey.toLowerCase();
-        this.poolIdentifier = poolIdentifier.toLowerCase();
-        // parentName and Name are imposed by the interface. Prefer dexKey and poolIdentifier
-        this.parentName = this.dexKey;
-        this.name = this.poolIdentifier;
-        if (!this.dexHelper.config.isSlave) {
-            this.dexHelper.dexStatePublisher.registerPool(this.dexKey, this.poolIdentifier, this);
-        }
-    }
-    getStateBlockNumber() {
-        return this.stateBlockNumber;
-    }
-    //Function which set the initial state and bounded it to blockNumber
-    //There is multiple possible case:
-    // 1. You provide a state in options object the function will initialize with the provided state
-    //  with blockNumber and subscribe to logs.
-    // 2. if you are a master instance of dex-lib and no state is provided in options object
-    //  then the function generate a new state with blockNumber as height and set the state with
-    //  the result.
-    // 3. if you are a slave instance of dex-lib
-    //  either:
-    //    - If a state is found in the cache and the state is not null we set our state with the
-    //      cache state and cache blockNumber. Subscribe to logs with the cache blockNumber
-    //  or:
-    //    - If no valid state found in cache, we generate a new state with blockNumber
-    //      and se state with blockNumber. Subscribe to logs with blockNumber. The function
-    //      will also publish a message to cache to tell one master version of dex-lib that this slave
-    //      instance subscribed to a pool from dex this.parentName and name this.name.
-    async initialize(blockNumber, options) {
-        let masterBn = undefined;
-        if (options && options.state) {
-            this.setState(options.state, blockNumber);
-        }
-        else {
-            if (this.dexHelper.config.isSlave) {
-                let updatedState = await this.dexHelper.dexStateSubscriber.requestDEXPoolState(this.dexKey, this.poolIdentifier, blockNumber);
-                this.setState(updatedState, blockNumber);
-            }
-            else {
-                // if you are not a slave instance always generate new state
-                this.logger.info(`${this.dexKey}: ${this.poolIdentifier}: cache generating state`);
-                const state = await this.generateState(blockNumber);
-                this.setState(state, blockNumber);
-            }
-        }
-        // apply a callback on the state
-        if (options && options.initCallback) {
-            if (this.state) {
-                (0, ts_essentials_1.assert)(typeof this.state !== 'string', 'LOGIC ERROR: state is serialised');
-                options.initCallback(this.state);
-            }
-        }
-        if (this.dexHelper.config.isSlave) {
-            this.dexHelper.dexStateSubscriber.subscribeToDEXPoolUpdates(this.dexKey, this.poolIdentifier, (state, blockNumber) => {
-                this.setState(state, blockNumber);
-            });
-        }
-        else {
-            this.dexHelper.blockManager.subscribeToLogs(this, this.addressesSubscribed, masterBn || blockNumber);
-        }
-        this.isInitialized = true;
-    }
-    //This function processes all logs for a single block (the block number is
-    //contained in each of the logs).  It is not allowed to call this function
-    //with an empty logs array.  The default implementation here will just call
-    //processLog for each of the logs; it may be overridden, if block specific
-    //handling or handling multiple logs at once is needed.  Null should be
-    //returned if none of the provided logs affect the state.
-    async processBlockLogs(state, logs, blockHeader) {
-        let nextState = null;
-        for (const log of logs) {
-            const retState = await this.processLog(nextState || state, log, blockHeader);
-            if (retState)
-                nextState = retState;
-        }
-        return nextState;
-    }
-    restart(blockNumber) {
-        for (const _bn of Object.keys(this.stateHistory)) {
-            const bn = +_bn;
-            if (bn >= blockNumber)
-                break;
-            delete this.stateHistory[bn];
-        }
-        if (this.state && this.stateBlockNumber < blockNumber) {
-            this.logger.info(`StatefulDualSynchronizer restart, bn: ${blockNumber}, state_bn: ${this.stateBlockNumber}: ${this.dexKey}: ${this.poolIdentifier}`);
-            this._setState(null, blockNumber);
-        }
-    }
-    //Implementation must call setState() for every block in which the state
-    //changes and must ignore any logs that aren't newer than the oldest state
-    //stored.  If state is not set or null, then the implementation should derive
-    //the state by another method for the block number of the first log, ignore
-    //all logs with that block number and then proceed as normal for the remaining
-    //logs.  Remember to clear the invalid flag, even if there are no logs!
-    //A default implementation is provided here, but could be overridden.
-    async update(logs, blockHeaders) {
-        if (this.dexHelper.config.isSlave) {
-            throw new Error('LOGIC ERROR: we should expect to listen to events on slave instances');
-        }
-        let index = 0;
-        let lastBlockNumber;
-        while (index < logs.length) {
-            const blockNumber = logs[index].blockNumber;
-            if (index && blockNumber <= lastBlockNumber) {
-                this.logger.error('update() received blocks out of order!');
-            }
-            const blockHeader = blockHeaders[blockNumber];
-            if (!blockHeader) {
-                this.logger.error('update() missing block header!');
-            }
-            let lastLogIndex = logs[index].logIndex;
-            let indexBlockEnd = index + 1;
-            while (indexBlockEnd < logs.length &&
-                logs[indexBlockEnd].blockNumber === blockNumber) {
-                if (logs[indexBlockEnd].logIndex <= lastLogIndex) {
-                    this.logger.error('update() received logs out of order!');
-                }
-                lastLogIndex = logs[indexBlockEnd].logIndex;
-                ++indexBlockEnd;
-            }
-            if (!this.state) {
-                const freshState = await this.generateState(blockNumber);
-                this.setState(freshState, blockNumber);
-            }
-            //Find the last state before the blockNumber of the logs
-            let stateBeforeLog;
-            for (const _bn of Object.keys(this.stateHistory)) {
-                const bn = +_bn;
-                if (bn >= blockNumber)
-                    break;
-                stateBeforeLog = this.stateHistory[bn];
-            }
-            //Ignoring logs if there's no older state to play them onto
-            if (stateBeforeLog) {
-                (0, ts_essentials_1.assert)(typeof stateBeforeLog !== 'string', 'LOGIC ERROR: state is serialised');
-                const nextState = await this.processBlockLogs(stateBeforeLog, logs.slice(index, indexBlockEnd), blockHeader);
-                if (nextState)
-                    this.setState(nextState, blockNumber);
-            }
-            lastBlockNumber = blockNumber;
-            index = indexBlockEnd;
-        }
-        this.invalid = false;
-        if (!this.dexHelper.config.isSlave && this.state === null) {
-            const network = this.dexHelper.config.data.network;
-            const createNewState = async () => {
-                if (this.state !== null) {
-                    return true;
-                }
-                const latestBlockNumber = this.dexHelper.blockManager.getLatestBlockNumber();
-                this.logger.warn(`${network}: ${this.dexKey}: ${this.poolIdentifier}: master generate (latest: ${latestBlockNumber}) new state because state is null`);
-                try {
-                    const state = await this.generateState(latestBlockNumber);
-                    this.setState(state, latestBlockNumber);
-                    return true;
-                }
-                catch (e) {
-                    this.logger.error(`${network}: ${this.dexKey} ${this.poolIdentifier}: (${latestBlockNumber}) failed fetch state:`, e);
-                }
-                return false;
-            };
-            this.dexHelper.promiseScheduler.addPromise(createNewState);
-        }
-    }
-    //Removes all states that are beyond the given block number and sets the
-    //current state to the latest one that is left, if any, unless the invalid
-    //flag is not set, in which case the most recent state can be kept.
-    rollback(blockNumber) {
-        if (this.invalid) {
-            let lastBn = undefined;
-            //loop in the ascending order of the blockNumber. V8 property when object keys are number.
-            for (const bn of Object.keys(this.stateHistory)) {
-                const bnAsNumber = +bn;
-                if (bnAsNumber > blockNumber) {
-                    delete this.stateHistory[+bn];
-                }
-                else {
-                    lastBn = bnAsNumber;
-                }
-            }
-            if (lastBn) {
-                this._setState(this.stateHistory[lastBn], lastBn);
-            }
-            else {
-                this.logger.info(`StatefulDualSynchronizer rollback, bn: ${blockNumber}: ${this.dexKey}: ${this.poolIdentifier}`);
-                this._setState(null, blockNumber);
-                // TODO: explore generating new state on invalidation
-            }
-        }
-        else {
-            //Keep the current state in this.state and in the history
-            for (const _bn of Object.keys(this.stateHistory)) {
-                const bn = +_bn;
-                if (+bn > blockNumber && +bn !== this.stateBlockNumber) {
-                    delete this.stateHistory[bn];
-                }
-            }
-        }
-    }
-    invalidate() {
-        this.logger.info(`StatefulDualSynchronizer invalidate: ${this.dexKey}: ${this.poolIdentifier}`);
-        this.invalid = true;
-        // TODO: explore generating new state on invalidation
-    }
-    //May return a state that is more recent than the block number specified, or
-    //will return null if a recent enough state cannot be found, in which case the
-    //caller should derive a state using another method (at an exact block
-    //number), possibly using generateState(), and set it on this object using
-    //setState.  In case isTracking() returns true, it is assumed that the stored
-    //state is current and so the minBlockNumber will be disregarded.
-    getState(minBlockNumber) {
-        if (!this.state || this.invalid)
-            return null;
-        if (this.dexHelper.config.isSlave) {
-            if (this.dexHelper.dexStateSubscriber.isSynced(minBlockNumber) ||
-                this.stateBlockNumber >= minBlockNumber) {
-                if (typeof this.state === 'string') {
-                    this.state = utils_1.Utils.Parse(this.state);
-                }
-                (0, ts_essentials_1.assert)(typeof this.state !== 'string', 'LOGIC ERROR: state is serialised');
-                return this.state;
-            }
-        }
-        else {
-            if (this.isTracking() || this.stateBlockNumber >= minBlockNumber) {
-                if (typeof this.state === 'string') {
-                    this.state = utils_1.Utils.Parse(this.state);
-                }
-                (0, ts_essentials_1.assert)(typeof this.state !== 'string', 'LOGIC ERROR: state is serialised');
-                return this.state;
-            }
-        }
-        return null; // DEX need to implement an fallback strategy here
-    }
-    // Returns the last set state. The state might be invalid or not updated.
-    getStaleState() {
-        if (typeof this.state === 'string') {
-            this.state = utils_1.Utils.Parse(this.state);
-        }
-        (0, ts_essentials_1.assert)(typeof this.state !== 'string', 'LOGIC ERROR: state is serialised');
-        return this.state;
-    }
-    _setState(state, blockNumber) {
-        this.state = state;
-        this.stateBlockNumber = blockNumber;
-    }
-    //Saves the state into the stateHistory, and cleans up any old state that is
-    //no longer needed.  If the blockNumber is greater than or equal to the
-    //current state, then the current state will be updated and the invalid flag
-    //can be reset.
-    setState(state, blockNumber) {
-        if (!blockNumber) {
-            this.logger.error('setState() with blockNumber', blockNumber);
-            return;
-        }
-        this.stateHistory[blockNumber] = state;
-        if (!this.state || blockNumber >= this.stateBlockNumber) {
-            this._setState(state, blockNumber);
-            this.invalid = false;
-        }
-        const minBlockNumberToKeep = this.stateBlockNumber - constants_1.MAX_BLOCKS_HISTORY;
-        let lastBlockNumber;
-        for (const bn of Object.keys(this.stateHistory)) {
-            if (+bn <= minBlockNumberToKeep) {
-                if (lastBlockNumber)
-                    delete this.stateHistory[lastBlockNumber];
-            }
-            if (+bn >= minBlockNumberToKeep)
-                break;
-            lastBlockNumber = +bn;
-        }
-    }
-}
-exports.StatefulDualSynchronizer = StatefulDualSynchronizer;
-//# sourceMappingURL=stateful-dual-synchronizer.js.map