@paraswap/dex-lib 4.2.3-1 → 4.2.3-11

package/build/dex/swaap-v1/swaap-v1-pool.js

@@ -1,656 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwaapV1Pool = void 0;
-const stateful_event_subscriber_1 = require("../../stateful-event-subscriber");
-const pool_json_1 = __importDefault(require("../../abi/swaap-v1/pool.json"));
-const chainlink_json_1 = __importDefault(require("../../abi/chainlink.json"));
-const erc20_json_1 = __importDefault(require("../../abi/erc20.json"));
-const abi_1 = require("@ethersproject/abi");
-const bytes_1 = require("@ethersproject/bytes");
-class SwaapV1Pool extends stateful_event_subscriber_1.StatefulEventSubscriber {
-    constructor(dexKey, network, pool, dexHelper) {
-        super(dexKey, pool.id, dexHelper, dexHelper.getLogger(`${dexKey}-${network}-${pool.id}`));
-        this.pool = pool;
-        this.dexHelper = dexHelper;
-        this.id = pool.id;
-        this.tokens = pool.tokens.map(t => t.address);
-        this.addressesSubscribed = [pool.id];
-        this.oracleTokenMap = pool.tokens.reduce((acc, t) => {
-            this.addressesSubscribed.push(t.oracleInitialState.aggregator.toLowerCase());
-            return {
-                ...acc,
-                [t.oracleInitialState.aggregator.toLowerCase()]: t.address,
-            };
-        }, {});
-    }
-    // Function which transforms the given state for the given log event.
-    // If the provided log does not affect the state, return null.
-    async processLog(state, log, blockHeader) {
-        try {
-            const tokenAddress = this.oracleTokenMap[log.address.toLowerCase()];
-            if (tokenAddress) {
-                // log comes from a subscribed oracle
-                if (log.topics[0] != SwaapV1Pool.ANSWER_UPDATED_TOPIC)
-                    return null;
-                const decoded = SwaapV1Pool.proxyInterface.decodeEventLog('AnswerUpdated', log.data, log.topics);
-                const latestRoundId = Number(decoded.roundId.toString());
-                const latestRoundData = {
-                    answer: BigInt(decoded.current.toString()),
-                    timestamp: BigInt(decoded.updatedAt.toString()),
-                };
-                let previousRoundId = state.oracles[tokenAddress].latestRoundId;
-                if (previousRoundId == latestRoundId) {
-                    return null;
-                }
-                let updatedHistoricalState = {
-                    ...state.oracles[tokenAddress].historicalOracleState,
-                };
-                const roundLookbackWindow = (state.parameters.priceStatisticsLookbackInRound - 1) *
-                    state.parameters.priceStatisticsLookbackStepInRound;
-                // Case where roundIds are skipped
-                while (latestRoundId > previousRoundId + 1) {
-                    delete updatedHistoricalState[previousRoundId - roundLookbackWindow];
-                    updatedHistoricalState[++previousRoundId] = {
-                        answer: 0n,
-                        timestamp: 0n,
-                    };
-                }
-                delete updatedHistoricalState[previousRoundId - roundLookbackWindow];
-                updatedHistoricalState[latestRoundId] = latestRoundData;
-                return {
-                    ...state,
-                    oracles: {
-                        ...state.oracles,
-                        [tokenAddress]: {
-                            ...state.oracles[tokenAddress],
-                            latestRoundId: latestRoundId,
-                            historicalOracleState: updatedHistoricalState,
-                        },
-                    },
-                };
-            }
-            else if (this.pool.id === log.address.toLowerCase()) {
-                // log comes from the Pool
-                // Check if the event is anonymous or not
-                let isAnonymousEvent = true;
-                const nameOrSignatureOrTopic = log.topics[0];
-                if ((0, bytes_1.isHexString)(nameOrSignatureOrTopic)) {
-                    const topichash = nameOrSignatureOrTopic.toLowerCase();
-                    for (const name of Object.keys(SwaapV1Pool.poolInterface.events)) {
-                        if (topichash === SwaapV1Pool.poolInterface.getEventTopic(name)) {
-                            isAnonymousEvent = false;
-                            break;
-                        }
-                    }
-                }
-                if (isAnonymousEvent) {
-                    // anonymous events
-                    const topic0 = log.topics[0];
-                    switch (topic0) {
-                        // setSwapFee
-                        case SwaapV1Pool.SWAP_FEE_TOPIC: {
-                            const value = BigInt(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            return {
-                                ...state,
-                                parameters: {
-                                    ...state.parameters,
-                                    swapFee: value,
-                                },
-                            };
-                        }
-                        // setPriceStatisticsLookbackInRound
-                        case SwaapV1Pool.LB_IN_ROUND_TOPIC: {
-                            const value = Number(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            const oldRoundLookbackWindow = (state.parameters.priceStatisticsLookbackInRound - 1) *
-                                state.parameters.priceStatisticsLookbackStepInRound;
-                            const newRoundLookbackWindow = (value - 1) *
-                                state.parameters.priceStatisticsLookbackStepInRound;
-                            const tokens = Object.keys(state.oracles);
-                            if (value > state.parameters.priceStatisticsLookbackInRound) {
-                                const multiCallInputs = tokens
-                                    .map((token) => {
-                                    return [
-                                        {
-                                            target: state.oracles[token].oraclesBindState.proxy,
-                                            callData: SwaapV1Pool.proxyInterface.encodeFunctionData('latestRound'),
-                                        },
-                                    ];
-                                })
-                                    .flat();
-                                const multicallOutputs = (await this.dexHelper.multiContract.methods
-                                    .aggregate(multiCallInputs)
-                                    .call({}, blockHeader.number)).returnData;
-                                let i = 0;
-                                const latestRoundIdsBN = tokens.reduce((acc, token) => {
-                                    return {
-                                        ...acc,
-                                        [token]: BigInt(SwaapV1Pool.proxyInterface
-                                            .decodeFunctionResult('latestRound', multicallOutputs[i++])[0]
-                                            .toString()),
-                                    };
-                                }, {});
-                                const missingHistoricalData = await this.getHistoricalRoundsData(tokens, newRoundLookbackWindow, latestRoundIdsBN, state.oracles, blockHeader.number);
-                                const updatedOraclesData = tokens.reduce((acc, token) => {
-                                    return {
-                                        ...acc,
-                                        [token]: {
-                                            oraclesBindState: {
-                                                ...state.oracles[token].oraclesBindState,
-                                            },
-                                            latestRoundId: state.oracles[token].latestRoundId,
-                                            historicalOracleState: missingHistoricalData[token],
-                                        },
-                                    };
-                                }, {});
-                                return {
-                                    ...state,
-                                    parameters: {
-                                        ...state.parameters,
-                                        priceStatisticsLookbackInRound: value,
-                                    },
-                                    oracles: { ...updatedOraclesData },
-                                };
-                            }
-                            else if (value < state.parameters.priceStatisticsLookbackInRound) {
-                                const updatedOraclesData = tokens.reduce((acc, token) => {
-                                    let historicalData = {
-                                        ...state.oracles[token].historicalOracleState,
-                                    };
-                                    let roundId = state.oracles[token].latestRoundId - oldRoundLookbackWindow;
-                                    const endRoundId = state.oracles[token].latestRoundId - newRoundLookbackWindow;
-                                    while (roundId < endRoundId) {
-                                        delete historicalData[roundId++];
-                                    }
-                                    return {
-                                        ...acc,
-                                        [token]: {
-                                            oraclesBindState: {
-                                                ...state.oracles[token].oraclesBindState,
-                                            },
-                                            latestRoundId: state.oracles[token].latestRoundId,
-                                            historicalOracleState: historicalData,
-                                        },
-                                    };
-                                }, {});
-                                return {
-                                    ...state,
-                                    parameters: {
-                                        ...state.parameters,
-                                        priceStatisticsLookbackInRound: value,
-                                    },
-                                    oracles: updatedOraclesData,
-                                };
-                            }
-                            return null;
-                        }
-                        // setPriceStatisticsLookbackStepInRound
-                        case SwaapV1Pool.LB_STEP_IN_ROUND_TOPIC: {
-                            const value = Number(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            const oldRoundLookbackWindow = (state.parameters.priceStatisticsLookbackInRound - 1) *
-                                state.parameters.priceStatisticsLookbackStepInRound;
-                            const newRoundLookbackWindow = (state.parameters.priceStatisticsLookbackInRound - 1) * value;
-                            const tokens = Object.keys(state.oracles);
-                            if (value > state.parameters.priceStatisticsLookbackStepInRound) {
-                                const multiCallInputs = tokens
-                                    .map((token) => {
-                                    return [
-                                        {
-                                            target: state.oracles[token].oraclesBindState.proxy,
-                                            callData: SwaapV1Pool.proxyInterface.encodeFunctionData('latestRound'),
-                                        },
-                                    ];
-                                })
-                                    .flat();
-                                const multicallOutputs = (await this.dexHelper.multiContract.methods
-                                    .aggregate(multiCallInputs)
-                                    .call({}, blockHeader.number)).returnData;
-                                let i = 0;
-                                const latestRoundIdsBN = tokens.reduce((acc, token) => {
-                                    return {
-                                        ...acc,
-                                        [token]: BigInt(SwaapV1Pool.proxyInterface
-                                            .decodeFunctionResult('latestRound', multicallOutputs[i++])[0]
-                                            .toString()),
-                                    };
-                                }, {});
-                                const missingHistoricalData = await this.getHistoricalRoundsData(tokens, newRoundLookbackWindow, latestRoundIdsBN, state.oracles, blockHeader.number);
-                                const updatedOraclesData = tokens.reduce((acc, token) => {
-                                    return {
-                                        ...acc,
-                                        [token]: {
-                                            oraclesBindState: {
-                                                ...state.oracles[token].oraclesBindState,
-                                            },
-                                            latestRoundId: state.oracles[token].latestRoundId,
-                                            historicalOracleState: missingHistoricalData[token],
-                                        },
-                                    };
-                                }, {});
-                                return {
-                                    ...state,
-                                    parameters: {
-                                        ...state.parameters,
-                                        priceStatisticsLookbackStepInRound: value,
-                                    },
-                                    oracles: { ...updatedOraclesData },
-                                };
-                            }
-                            else if (value < state.parameters.priceStatisticsLookbackStepInRound) {
-                                const updatedOraclesData = tokens.reduce((acc, token) => {
-                                    let historicalData = {
-                                        ...state.oracles[token].historicalOracleState,
-                                    };
-                                    let roundId = state.oracles[token].latestRoundId - oldRoundLookbackWindow;
-                                    const endRoundId = state.oracles[token].latestRoundId - newRoundLookbackWindow;
-                                    while (roundId < endRoundId) {
-                                        delete historicalData[roundId++];
-                                    }
-                                    return {
-                                        ...acc,
-                                        [token]: {
-                                            oraclesBindState: {
-                                                ...state.oracles[token].oraclesBindState,
-                                            },
-                                            latestRoundId: state.oracles[token].latestRoundId,
-                                            historicalOracleState: historicalData,
-                                        },
-                                    };
-                                }, {});
-                                return {
-                                    ...state,
-                                    parameters: {
-                                        ...state.parameters,
-                                        priceStatisticsLookbackStepInRound: value,
-                                    },
-                                    oracles: updatedOraclesData,
-                                };
-                            }
-                            return {
-                                ...state,
-                                parameters: {
-                                    ...state.parameters,
-                                    priceStatisticsLookbackStepInRound: value,
-                                },
-                            };
-                        }
-                        // setDynamicCoverageFeesZ
-                        case SwaapV1Pool.Z_TOPIC: {
-                            const value = BigInt(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            return {
-                                ...state,
-                                parameters: {
-                                    ...state.parameters,
-                                    dynamicCoverageFeesZ: value,
-                                },
-                            };
-                        }
-                        // setDynamicCoverageFeesHorizon
-                        case SwaapV1Pool.HORIZON_TOPIC: {
-                            const value = BigInt(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            return {
-                                ...state,
-                                parameters: {
-                                    ...state.parameters,
-                                    dynamicCoverageFeesHorizon: value,
-                                },
-                            };
-                        }
-                        // setPriceStatisticsLookbackInSec
-                        case SwaapV1Pool.LB_IN_SEC_TOPIC: {
-                            const value = BigInt(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            return {
-                                ...state,
-                                parameters: {
-                                    ...state.parameters,
-                                    priceStatisticsLookbackInSec: value,
-                                },
-                            };
-                        }
-                        // setMaxPriceUnpegRatio
-                        case SwaapV1Pool.MAX_UNPEG_TOPIC: {
-                            const value = BigInt(SwaapV1Pool.getValueFromAnonymousEvent(log));
-                            return {
-                                ...state,
-                                parameters: {
-                                    ...state.parameters,
-                                    maxPriceUnpegRatio: value,
-                                },
-                            };
-                        }
-                    }
-                }
-                else {
-                    // named events
-                    const parsed = SwaapV1Pool.poolInterface.parseLog(log);
-                    switch (parsed.name) {
-                        case 'LOG_JOIN': {
-                            const tokenIn = parsed.args.tokenIn.toString().toLowerCase();
-                            const tokenAmountIn = BigInt(parsed.args.tokenAmountIn.toString());
-                            return {
-                                ...state,
-                                liquidities: {
-                                    ...state.liquidities,
-                                    [tokenIn]: {
-                                        ...state.liquidities[tokenIn],
-                                        balance: state.liquidities[tokenIn].balance + tokenAmountIn,
-                                    },
-                                },
-                            };
-                        }
-                        case 'LOG_EXIT': {
-                            const tokenOut = parsed.args.tokenOut.toString().toLowerCase();
-                            const tokenAmountOut = BigInt(parsed.args.tokenAmountOut.toString());
-                            return {
-                                ...state,
-                                liquidities: {
-                                    ...state.liquidities,
-                                    [tokenOut]: {
-                                        ...state.liquidities[tokenOut],
-                                        balance: state.liquidities[tokenOut].balance - tokenAmountOut,
-                                    },
-                                },
-                            };
-                        }
-                        case 'LOG_SWAP': {
-                            const tokenIn = parsed.args.tokenIn.toString().toLowerCase();
-                            const tokenAmountIn = BigInt(parsed.args.tokenAmountIn.toString());
-                            const tokenOut = parsed.args.tokenOut.toString().toLowerCase();
-                            const tokenAmountOut = BigInt(parsed.args.tokenAmountOut.toString());
-                            return {
-                                ...state,
-                                liquidities: {
-                                    ...state.liquidities,
-                                    [tokenIn]: {
-                                        ...state.liquidities[tokenIn],
-                                        balance: state.liquidities[tokenIn].balance + tokenAmountIn,
-                                    },
-                                    [tokenOut]: {
-                                        ...state.liquidities[tokenOut],
-                                        balance: state.liquidities[tokenOut].balance - tokenAmountOut,
-                                    },
-                                },
-                            };
-                        }
-                        default: {
-                            return null;
-                        }
-                    }
-                }
-            }
-            return null;
-        }
-        catch (e) {
-            this.logger.error('Failed to decode result', e);
-            return null;
-        }
-    }
-    async getTokensAndParameters(blockNumber) {
-        const multiCallInputs = [
-            {
-                target: this.pool.id,
-                callData: SwaapV1Pool.poolInterface.encodeFunctionData('getTokens'),
-            },
-            {
-                target: this.pool.id,
-                callData: SwaapV1Pool.poolInterface.encodeFunctionData('getCoverageParameters'),
-            },
-            {
-                target: this.pool.id,
-                callData: SwaapV1Pool.poolInterface.encodeFunctionData('getSwapFee'),
-            },
-        ];
-        const returnData = (await this.dexHelper.multiContract.methods
-            .aggregate(multiCallInputs)
-            .call({}, blockNumber)).returnData;
-        let tokens = SwaapV1Pool.poolInterface.decodeFunctionResult('getTokens', returnData[0])[0];
-        tokens = tokens.map(t => t.toLowerCase());
-        const coverageParameters = SwaapV1Pool.poolInterface.decodeFunctionResult('getCoverageParameters', returnData[1]);
-        const parameters = {
-            swapFee: BigInt(SwaapV1Pool.poolInterface
-                .decodeFunctionResult('getSwapFee', returnData[2])[0]
-                .toString()),
-            priceStatisticsLookbackInRound: Number(coverageParameters[0].toString()),
-            priceStatisticsLookbackStepInRound: Number(coverageParameters[1].toString()),
-            dynamicCoverageFeesZ: BigInt(coverageParameters[2].toString()),
-            dynamicCoverageFeesHorizon: BigInt(coverageParameters[3].toString()),
-            priceStatisticsLookbackInSec: BigInt(coverageParameters[4].toString()),
-            maxPriceUnpegRatio: BigInt(coverageParameters[5].toString()),
-        };
-        return [tokens, parameters];
-    }
-    async getProxiesAndLiquidities(tokens, blockNumber) {
-        let multiCallInputs = tokens
-            .map(token => {
-            return [
-                {
-                    target: this.pool.id,
-                    callData: SwaapV1Pool.poolInterface.encodeFunctionData('getBalance', [token]),
-                },
-                {
-                    target: this.pool.id,
-                    callData: SwaapV1Pool.poolInterface.encodeFunctionData('getDenormalizedWeight', [token]),
-                },
-                {
-                    target: token,
-                    callData: SwaapV1Pool.erc20Interface.encodeFunctionData('decimals'),
-                },
-            ];
-        })
-            .flat();
-        multiCallInputs = tokens.reduce((acc, token) => {
-            return [
-                ...acc,
-                {
-                    target: this.pool.id,
-                    callData: SwaapV1Pool.poolInterface.encodeFunctionData('getTokenPriceOracle', [token]),
-                },
-            ].flat();
-        }, multiCallInputs);
-        let multicallOutputs = (await this.dexHelper.multiContract.methods
-            .aggregate(multiCallInputs)
-            .call({}, blockNumber)).returnData;
-        let idx = 0;
-        // get liquidities
-        const liquidities = tokens.reduce((acc, token) => {
-            const balance = BigInt(SwaapV1Pool.poolInterface
-                .decodeFunctionResult('getBalance', multicallOutputs[idx++])[0]
-                .toString());
-            const initialWeight = BigInt(SwaapV1Pool.poolInterface
-                .decodeFunctionResult('getDenormalizedWeight', multicallOutputs[idx++])[0]
-                .toString());
-            const decimals = parseInt(SwaapV1Pool.erc20Interface
-                .decodeFunctionResult('decimals', multicallOutputs[idx++])[0]
-                .toString());
-            return {
-                ...acc,
-                [token]: {
-                    balance: balance,
-                    initialWeight: initialWeight,
-                    decimals: decimals,
-                },
-            };
-        }, {});
-        const oracles = tokens.reduce((acc, token) => {
-            const oracle = SwaapV1Pool.poolInterface
-                .decodeFunctionResult('getTokenPriceOracle', multicallOutputs[idx++])[0]
-                .toString()
-                .toLowerCase();
-            return {
-                ...acc,
-                [token]: oracle,
-            };
-        }, {});
-        return [oracles, liquidities];
-    }
-    async getOraclesData(tokens, proxies, // key: token, value: proxy
-    parameters, blockNumber) {
-        // aggregators
-        let multiCallInputs = tokens.map((token) => {
-            return {
-                target: proxies[token],
-                callData: SwaapV1Pool.proxyInterface.encodeFunctionData('aggregator'),
-            };
-        });
-        // oracle's addresses
-        let multicallOutputs = (await this.dexHelper.multiContract.methods
-            .aggregate(multiCallInputs)
-            .call({}, blockNumber)).returnData;
-        let i = 0;
-        const oracles = tokens.reduce((acc, token) => {
-            return {
-                ...acc,
-                [token]: SwaapV1Pool.poolInterface
-                    .decodeFunctionResult('getTokenPriceOracle', multicallOutputs[i++])[0]
-                    .toString()
-                    .toLowerCase(),
-            };
-        }, {});
-        multiCallInputs = tokens
-            .map((token) => {
-            return [
-                {
-                    target: this.pool.id,
-                    callData: SwaapV1Pool.poolInterface.encodeFunctionData('getTokenOracleInitialPrice', [token]),
-                },
-                {
-                    target: proxies[token],
-                    callData: SwaapV1Pool.proxyInterface.encodeFunctionData('decimals'),
-                },
-                {
-                    target: proxies[token],
-                    callData: SwaapV1Pool.proxyInterface.encodeFunctionData('description'),
-                },
-                {
-                    target: proxies[token],
-                    callData: SwaapV1Pool.proxyInterface.encodeFunctionData('latestRoundData'),
-                },
-            ];
-        })
-            .flat();
-        multicallOutputs = (await this.dexHelper.multiContract.methods
-            .aggregate(multiCallInputs)
-            .call({}, blockNumber)).returnData;
-        let latestRoundIdsBN = {};
-        i = 0;
-        let oraclesData = tokens.reduce((acc, token) => {
-            const oraclesBindState = {
-                proxy: proxies[token],
-                aggregator: oracles[token],
-                price: BigInt(SwaapV1Pool.poolInterface
-                    .decodeFunctionResult('getTokenOracleInitialPrice', multicallOutputs[i++])[0]
-                    .toString()),
-                decimals: Number(SwaapV1Pool.proxyInterface
-                    .decodeFunctionResult('decimals', multicallOutputs[i++])[0]
-                    .toString()),
-                description: SwaapV1Pool.proxyInterface
-                    .decodeFunctionResult('description', multicallOutputs[i++])[0]
-                    .toString(),
-            };
-            const latestRoundData = SwaapV1Pool.proxyInterface.decodeFunctionResult('latestRoundData', multicallOutputs[i++]);
-            const latestRoundId = BigInt(latestRoundData.roundId.toString());
-            latestRoundIdsBN[token] = latestRoundId;
-            return {
-                ...acc,
-                [token]: {
-                    oraclesBindState: oraclesBindState,
-                    latestRoundId: Number(latestRoundId % 2n ** 64n),
-                    historicalOracleState: {
-                        [Number(latestRoundId % 2n ** 64n)]: {
-                            answer: BigInt(latestRoundData.answer.toString()),
-                            timestamp: BigInt(latestRoundData.updatedAt.toString()),
-                        },
-                    },
-                },
-            };
-        }, {});
-        const roundLookbackWindow = (parameters.priceStatisticsLookbackInRound - 1) *
-            parameters.priceStatisticsLookbackStepInRound;
-        const historicalRoundsData = await this.getHistoricalRoundsData(tokens, roundLookbackWindow, latestRoundIdsBN, oraclesData, blockNumber);
-        tokens.forEach(token => {
-            oraclesData[token].historicalOracleState = historicalRoundsData[token];
-        });
-        return oraclesData;
-    }
-    async getHistoricalRoundsData(tokens, roundLookbackWindow, latestRoundIdsBN, oraclesData, blockNumber) {
-        // historical round data
-        let historicalStates = tokens.reduce((acc, token) => {
-            return {
-                ...acc,
-                [token]: { ...oraclesData[token].historicalOracleState },
-            };
-        }, {});
-        let multiCallInputs = tokens
-            .map((token) => {
-            const startRoundId = latestRoundIdsBN[token];
-            return Array.from({ length: roundLookbackWindow }, (x, idx) => idx)
-                .map(idx => {
-                return {
-                    target: oraclesData[token].oraclesBindState.proxy,
-                    callData: SwaapV1Pool.proxyInterface.encodeFunctionData('getRoundData', [startRoundId - BigInt(idx + 1)]),
-                };
-            })
-                .flat();
-        })
-            .flat();
-        try {
-            let multicallOutputs = (await this.dexHelper.multiContract.methods
-                .aggregate(multiCallInputs)
-                .call({}, blockNumber)).returnData;
-            let i = 0;
-            tokens.map(token => {
-                Array.from({ length: roundLookbackWindow }, (x, idx) => idx).map(idx => {
-                    const decoded = SwaapV1Pool.proxyInterface.decodeFunctionResult('getRoundData', multicallOutputs[i++]);
-                    const roundId = Number(BigInt(decoded.roundId.toString()) % 2n ** 64n);
-                    historicalStates[token][roundId] = {
-                        answer: BigInt(decoded.answer.toString()),
-                        timestamp: BigInt(decoded.updatedAt.toString()),
-                    };
-                });
-            });
-        }
-        catch (e) {
-            this.logger.error('Failed to get historical round data', e);
-        }
-        return historicalStates;
-    }
-    //Function used to generate a state if one is not currently present, which
-    //must be the state at exactly the given block number, unless one is not
-    //provided, in which case one should be generated for latest block.  This
-    //function should not use any previous states to derive a new state, it should
-    //generate one from scratch.
-    async generateState(blockNumber) {
-        if (blockNumber === 'latest' || blockNumber === undefined) {
-            blockNumber = await this.dexHelper.provider.getBlockNumber();
-        }
-        const [tokens, parameters] = await this.getTokensAndParameters(blockNumber);
-        const [proxies, liquidities] = await this.getProxiesAndLiquidities(tokens, blockNumber);
-        const oracles = await this.getOraclesData(tokens, proxies, parameters, blockNumber);
-        return {
-            parameters: parameters,
-            liquidities: liquidities,
-            oracles: oracles,
-        };
-    }
-    static getValueFromAnonymousEvent(log) {
-        const data = log.data.toString();
-        const startIdx = 2 + 64 + 64 + 8;
-        return '0x' + data.slice(startIdx, startIdx + 64).toString();
-    }
-}
-exports.SwaapV1Pool = SwaapV1Pool;
-SwaapV1Pool.poolInterface = new abi_1.Interface(pool_json_1.default);
-SwaapV1Pool.proxyInterface = new abi_1.Interface(chainlink_json_1.default);
-SwaapV1Pool.erc20Interface = new abi_1.Interface(erc20_json_1.default);
-// LOG_CALL Event topics 0
-SwaapV1Pool.SWAP_FEE_TOPIC = '0x34e1990700000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.LB_IN_ROUND_TOPIC = '0x3cc3396000000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.LB_STEP_IN_ROUND_TOPIC = '0x045dbae000000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.Z_TOPIC = '0x3c515d9900000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.HORIZON_TOPIC = '0x314d204f00000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.LB_IN_SEC_TOPIC = '0x538e285c00000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.MAX_UNPEG_TOPIC = '0xacb21b3100000000000000000000000000000000000000000000000000000000';
-SwaapV1Pool.ANSWER_UPDATED_TOPIC = SwaapV1Pool.proxyInterface.getEventTopic('AnswerUpdated');
-//# sourceMappingURL=swaap-v1-pool.js.map