@paraswap/dex-lib 2.23.1-zkevm-quickswap.4 → 2.23.2

package/build/dex/algebra/lib/DataStorage.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStorage = void 0;
+const ts_essentials_1 = require("ts-essentials");
+const utils_1 = require("../../../utils");
+require("./FullMath.sol");
+const WINDOW = 24n * 60n;
+const UINT16_MODULO = 65536n;
+class DataStorage {
+    /// @notice Calculates volatility between two sequential timepoints with resampling to 1 sec frequency
+    /// @param dt Timedelta between timepoints, must be within uint32 range
+    /// @param tick0 The tick at the left timepoint, must be within int24 range
+    /// @param tick1 The tick at the right timepoint, must be within int24 range
+    /// @param avgTick0 The average tick at the left timepoint, must be within int24 range
+    /// @param avgTick1 The average tick at the right timepoint, must be within int24 range
+    /// @return volatility The volatility between two sequential timepoints
+    /// If the requirements for the parameters are met, it always fits 88 bits
+    static _volatilityOnRange(dt, tick0, tick1, avgTick0, avgTick1) {
+        // On the time interval from the previous timepoint to the current
+        // we can represent tick and average tick change as two straight lines:
+        // tick = k*t + b, where k and b are some constants
+        // avgTick = p*t + q, where p and q are some constants
+        // we want to get sum of (tick(t) - avgTick(t))^2 for every t in the interval (0; dt]
+        // so: (tick(t) - avgTick(t))^2 = ((k*t + b) - (p*t + q))^2 = (k-p)^2 * t^2 + 2(k-p)(b-q)t + (b-q)^2
+        // since everything except t is a constant, we need to use progressions for t and t^2:
+        // sum(t) for t from 1 to dt = dt*(dt + 1)/2 = sumOfSequence
+        // sum(t^2) for t from 1 to dt = dt*(dt+1)*(2dt + 1)/6 = sumOfSquares
+        // so result will be: (k-p)^2 * sumOfSquares + 2(k-p)(b-q)*sumOfSequence + dt*(b-q)^2
+        const K = tick1 - tick0 - (avgTick1 - avgTick0); // (k - p)*dt
+        const B = (tick0 - avgTick0) * dt; // (b - q)*dt
+        const sumOfSquares = dt * (dt + 1n) * (2n * dt + 1n); // sumOfSquares * 6
+        const sumOfSequence = dt * (dt + 1n); // sumOfSequence * 2
+        const volatility = (0, utils_1.uint256)((K ** 2n * sumOfSquares +
+            6n * B * K * sumOfSequence +
+            6n * dt * B ** 2n) /
+            (6n * dt ** 2n));
+        return volatility;
+    }
+    /// @notice Transforms a previous timepoint into a new timepoint, given the passage of time and the current tick and liquidity values
+    /// @dev blockTimestamp _must_ be chronologically equal to or greater than last.blockTimestamp, safe for 0 or 1 overflows
+    /// @param last The specified timepoint to be used in creation of new timepoint
+    /// @param blockTimestamp The timestamp of the new timepoint
+    /// @param tick The active tick at the time of the new timepoint
+    /// @param prevTick The active tick at the time of the last timepoint
+    /// @param liquidity The total in-range liquidity at the time of the new timepoint
+    /// @param averageTick The average tick at the time of the new timepoint
+    /// @param volumePerLiquidity The gmean(volumes)/liquidity at the time of the new timepoint
+    /// @return Timepoint The newly populated timepoint
+    static createNewTimepoint(last, blockTimestamp, tick, prevTick, liquidity, averageTick, volumePerLiquidity) {
+        const delta = blockTimestamp - last.blockTimestamp;
+        last.initialized = true;
+        last.blockTimestamp = blockTimestamp;
+        last.tickCumulative += (0, utils_1.int56)(tick) * delta;
+        last.secondsPerLiquidityCumulative +=
+            ((0, utils_1.uint160)(delta) << 128n) / (liquidity > 0n ? liquidity : 1n); // just timedelta if liquidity == 0
+        last.volatilityCumulative += (0, utils_1.uint88)(this._volatilityOnRange(delta, prevTick, tick, last.averageTick, averageTick)); // always fits 88 bits
+        last.averageTick = averageTick;
+        last.volumePerLiquidityCumulative += volumePerLiquidity;
+        return last;
+    }
+    /// @notice comparator for 32-bit timestamps
+    /// @dev safe for 0 or 1 overflows, a and b _must_ be chronologically before or equal to currentTime
+    /// @param a A comparison timestamp from which to determine the relative position of `currentTime`
+    /// @param b From which to determine the relative position of `currentTime`
+    /// @param currentTime A timestamp truncated to 32 bits
+    /// @return res Whether `a` is chronologically <= `b`
+    static lteConsideringOverflow(a, b, currentTime) {
+        let res = a > currentTime;
+        if (res == b > currentTime)
+            res = a <= b; // if both are on the same side
+        return res;
+    }
+    /// @dev guaranteed that the result is within the bounds of int24
+    /// returns int256 for fuzzy tests
+    static _getAverageTick(self, time, tick, index, oldestIndex, lastTimestamp, lastTickCumulative) {
+        const oldestTimestamp = self[Number(oldestIndex)].blockTimestamp;
+        const oldestTickCumulative = self[Number(oldestIndex)].tickCumulative;
+        let avgTick;
+        if (this.lteConsideringOverflow(oldestTimestamp, time - WINDOW, time)) {
+            if (this.lteConsideringOverflow(lastTimestamp, time - WINDOW, time)) {
+                index -= 1n; // considering underflow
+                const startTimepoint = self[Number(index)];
+                avgTick = startTimepoint.initialized
+                    ? (lastTickCumulative - startTimepoint.tickCumulative) /
+                        (lastTimestamp - startTimepoint.blockTimestamp)
+                    : tick;
+            }
+            else {
+                const startOfWindow = this.getSingleTimepoint(self, time, WINDOW, tick, index, oldestIndex, 0n);
+                //    current-WINDOW  last   current
+                // _________*____________*_______*_
+                //           ||||||||||||
+                avgTick =
+                    (lastTickCumulative - startOfWindow.tickCumulative) /
+                        (lastTimestamp - time + WINDOW);
+            }
+        }
+        else {
+            avgTick =
+                lastTimestamp == oldestTimestamp
+                    ? tick
+                    : (lastTickCumulative - oldestTickCumulative) /
+                        (lastTimestamp - oldestTimestamp);
+        }
+        return avgTick;
+    }
+    /// @notice Fetches the timepoints beforeOrAt and atOrAfter a target, i.e. where [beforeOrAt, atOrAfter] is satisfied.
+    /// The result may be the same timepoint, or adjacent timepoints.
+    /// @dev The answer must be contained in the array, used when the target is located within the stored timepoint
+    /// boundaries: older than the most recent timepoint and younger, or the same age as, the oldest timepoint
+    /// @param self The stored dataStorage array
+    /// @param time The current block.timestamp
+    /// @param target The timestamp at which the reserved timepoint should be for
+    /// @param lastIndex The index of the timepoint that was most recently written to the timepoints array
+    /// @param oldestIndex The index of the oldest timepoint in the timepoints array
+    /// @return beforeOrAt The timepoint recorded before, or at, the target
+    /// @return atOrAfter The timepoint recorded at, or after, the target
+    static binarySearch(self, time, target, lastIndex, oldestIndex) {
+        let left = oldestIndex; // oldest timepoint
+        let right = lastIndex >= oldestIndex ? lastIndex : lastIndex + UINT16_MODULO; // newest timepoint considering one index overflow
+        let current = (left + right) >> 1n; // "middle" point between the boundaries
+        let beforeOrAt;
+        let atOrAfter;
+        let initializedAfter;
+        let timestampAfter;
+        do {
+            beforeOrAt = self[Number((0, utils_1.uint16)(current))]; // checking the "middle" point between the boundaries
+            let [initializedBefore, timestampBefore] = [
+                beforeOrAt.initialized,
+                beforeOrAt.blockTimestamp,
+            ];
+            if (initializedBefore) {
+                if (this.lteConsideringOverflow(timestampBefore, target, time)) {
+                    // is current point before or at `target`?
+                    atOrAfter = self[Number((0, utils_1.uint16)(current + 1n))]; // checking the next point after "middle"
+                    [initializedAfter, timestampAfter] = [
+                        atOrAfter.initialized,
+                        atOrAfter.blockTimestamp,
+                    ];
+                    if (initializedAfter) {
+                        if (this.lteConsideringOverflow(target, timestampAfter, time)) {
+                            // is the "next" point after or at `target`?
+                            return [beforeOrAt, atOrAfter]; // the only fully correct way to finish
+                        }
+                        left = current + 1n; // "next" point is before the `target`, so looking in the right half
+                    }
+                    else {
+                        // beforeOrAt is initialized and <= target, and next timepoint is uninitialized
+                        // should be impossible if initial boundaries and `target` are correct
+                        return [beforeOrAt, beforeOrAt];
+                    }
+                }
+                else {
+                    right = current - 1n; // current point is after the `target`, so looking in the left half
+                }
+            }
+            else {
+                // we've landed on an uninitialized timepoint, keep searching higher
+                // should be impossible if initial boundaries and `target` are correct
+                left = current + 1n;
+            }
+            current = (left + right) >> 1n; // calculating the new "middle" point index after updating the bounds
+        } while (true); // protect with max nb of iterations?
+        // unreachable code here
+        // atOrAfter = beforeOrAt; // code is unreachable, to suppress compiler warning
+        // assert(false);
+        // return [beforeOrAt, atOrAfter]
+    }
+    /// @dev Reverts if an timepoint at or before the desired timepoint timestamp does not exist.
+    /// 0 may be passed as `secondsAgo' to return the current cumulative values.
+    /// If called with a timestamp falling between two timepoints, returns the counterfactual accumulator values
+    /// at exactly the timestamp between the two timepoints.
+    /// @param self The stored dataStorage array
+    /// @param time The current block timestamp
+    /// @param secondsAgo The amount of time to look back, in seconds, at which point to return an timepoint
+    /// @param tick The current tick
+    /// @param index The index of the timepoint that was most recently written to the timepoints array
+    /// @param oldestIndex The index of the oldest timepoint
+    /// @param liquidity The current in-range pool liquidity
+    /// @return targetTimepoint desired timepoint or it's approximation
+    static getSingleTimepoint(self, time, secondsAgo, tick, index, oldestIndex, liquidity) {
+        let target = time - secondsAgo;
+        // if target is newer than last timepoint
+        if (secondsAgo == 0n ||
+            this.lteConsideringOverflow(self[Number(index)].blockTimestamp, target, time)) {
+            let last = self[Number(index)];
+            if (last.blockTimestamp == target) {
+                return last;
+            }
+            else {
+                // otherwise, we need to add new timepoint
+                let avgTick = (0, utils_1.int24)(this._getAverageTick(self, time, tick, index, oldestIndex, last.blockTimestamp, last.tickCumulative));
+                let prevTick = tick;
+                {
+                    if (index != oldestIndex) {
+                        // FIXME?
+                        let prevLast = {
+                            averageTick: 0n,
+                            blockTimestamp: 0n,
+                            initialized: false,
+                            secondsPerLiquidityCumulative: 0n,
+                            tickCumulative: 0n,
+                            volatilityCumulative: 0n,
+                            volumePerLiquidityCumulative: 0n,
+                        };
+                        let _prevLast = self[Number(index - 1n)]; // considering index underflow
+                        prevLast.blockTimestamp = _prevLast.blockTimestamp;
+                        prevLast.tickCumulative = _prevLast.tickCumulative;
+                        prevTick = (0, utils_1.int24)((last.tickCumulative - prevLast.tickCumulative) /
+                            (last.blockTimestamp - prevLast.blockTimestamp));
+                    }
+                }
+                return this.createNewTimepoint(last, target, tick, prevTick, liquidity, avgTick, 0n);
+            }
+        }
+        (0, utils_1._require)(this.lteConsideringOverflow(self[Number(oldestIndex)].blockTimestamp, target, time), 'OLD');
+        let [beforeOrAt, atOrAfter] = this.binarySearch(self, time, target, index, oldestIndex);
+        if (target == atOrAfter.blockTimestamp) {
+            return atOrAfter; // we're at the right boundary
+        }
+        if (target != beforeOrAt.blockTimestamp) {
+            // we're in the middle
+            let timepointTimeDelta = atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
+            let targetDelta = target - beforeOrAt.blockTimestamp;
+            // For gas savings the resulting point is written to beforeAt
+            beforeOrAt.tickCumulative +=
+                ((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) /
+                    timepointTimeDelta) *
+                    targetDelta;
+            beforeOrAt.secondsPerLiquidityCumulative += (0, utils_1.uint160)(((0, utils_1.uint256)(atOrAfter.secondsPerLiquidityCumulative -
+                beforeOrAt.secondsPerLiquidityCumulative) *
+                targetDelta) /
+                timepointTimeDelta);
+            beforeOrAt.volatilityCumulative +=
+                ((atOrAfter.volatilityCumulative - beforeOrAt.volatilityCumulative) /
+                    timepointTimeDelta) *
+                    targetDelta;
+            beforeOrAt.volumePerLiquidityCumulative +=
+                ((atOrAfter.volumePerLiquidityCumulative -
+                    beforeOrAt.volumePerLiquidityCumulative) /
+                    timepointTimeDelta) *
+                    targetDelta;
+        }
+        // we're at the left boundary or at the middle
+        return beforeOrAt;
+    }
+    /// @notice Returns the accumulator values as of each time seconds ago from the given time in the array of `secondsAgos`
+    /// @dev Reverts if `secondsAgos` > oldest timepoint
+    /// @param self The stored dataStorage array
+    /// @param time The current block.timestamp
+    /// @param secondsAgos Each amount of time to look back, in seconds, at which point to return an timepoint
+    /// @param tick The current tick
+    /// @param index The index of the timepoint that was most recently written to the timepoints array
+    /// @param liquidity The current in-range pool liquidity
+    /// @return tickCumulatives The tick * time elapsed since the pool was first initialized, as of each `secondsAgo`
+    /// @return secondsPerLiquidityCumulatives The cumulative seconds / max(1, liquidity) since the pool was first initialized, as of each `secondsAgo`
+    /// @return volatilityCumulatives The cumulative volatility values since the pool was first initialized, as of each `secondsAgo`
+    /// @return volumePerAvgLiquiditys The cumulative volume per liquidity values since the pool was first initialized, as of each `secondsAgo`
+    static getTimepoints(self, time, secondsAgos, tick, index, liquidity) {
+        let tickCumulatives = new Array(secondsAgos.length);
+        let secondsPerLiquidityCumulatives = new Array(secondsAgos.length);
+        let volatilityCumulatives = new Array(secondsAgos.length);
+        let volumePerAvgLiquiditys = new Array(secondsAgos.length);
+        let oldestIndex;
+        // check if we have overflow in the past
+        let nextIndex = index + 1n; // considering overflow
+        if (self[Number(nextIndex)].initialized) {
+            oldestIndex = nextIndex;
+        }
+        (0, ts_essentials_1.assert)(oldestIndex); // FIXME ?
+        let current;
+        for (let i = 0; i < secondsAgos.length; i++) {
+            current = this.getSingleTimepoint(self, time, secondsAgos[i], tick, index, oldestIndex, liquidity);
+            [
+                tickCumulatives[i],
+                secondsPerLiquidityCumulatives[i],
+                volatilityCumulatives[i],
+                volumePerAvgLiquiditys[i],
+            ] = [
+                current.tickCumulative,
+                current.secondsPerLiquidityCumulative,
+                current.volatilityCumulative,
+                current.volumePerLiquidityCumulative,
+            ];
+        }
+        return [
+            tickCumulatives,
+            secondsPerLiquidityCumulatives,
+            volatilityCumulatives,
+            volumePerAvgLiquiditys,
+        ];
+    }
+    /// @notice Returns average volatility in the range from time-WINDOW to time
+    /// @param self The stored dataStorage array
+    /// @param time The current block.timestamp
+    /// @param tick The current tick
+    /// @param index The index of the timepoint that was most recently written to the timepoints array
+    /// @param liquidity The current in-range pool liquidity
+    /// @return volatilityAverage The average volatility in the recent range
+    /// @return volumePerLiqAverage The average volume per liquidity in the recent range
+    static getAverages(self, time, tick, index, liquidity) {
+        let oldestIndex;
+        let oldest = self[0];
+        let nextIndex = index + 1n; // considering overflow
+        if (self[Number(nextIndex)].initialized) {
+            oldest = self[Number(nextIndex)];
+            oldestIndex = nextIndex;
+        }
+        (0, ts_essentials_1.assert)(oldestIndex); // FIXME ?
+        let endOfWindow = this.getSingleTimepoint(self, time, 0n, tick, index, oldestIndex, liquidity);
+        let oldestTimestamp = oldest.blockTimestamp;
+        if (this.lteConsideringOverflow(oldestTimestamp, time - WINDOW, time)) {
+            let startOfWindow = this.getSingleTimepoint(self, time, WINDOW, tick, index, oldestIndex, liquidity);
+            return [
+                (endOfWindow.volatilityCumulative -
+                    startOfWindow.volatilityCumulative) /
+                    WINDOW,
+                (0, utils_1.uint256)(endOfWindow.volumePerLiquidityCumulative -
+                    startOfWindow.volumePerLiquidityCumulative) >> 57n,
+            ];
+        }
+        else if (time != oldestTimestamp) {
+            let _oldestVolatilityCumulative = oldest.volatilityCumulative;
+            let _oldestVolumePerLiquidityCumulative = oldest.volumePerLiquidityCumulative;
+            return [
+                (endOfWindow.volatilityCumulative - _oldestVolatilityCumulative) /
+                    (time - oldestTimestamp),
+                (0, utils_1.uint256)(endOfWindow.volumePerLiquidityCumulative -
+                    _oldestVolumePerLiquidityCumulative) >> 57n,
+            ];
+        }
+        return [0n, 0n]; // should not enter here ?
+    }
+    /// @notice Initialize the dataStorage array by writing the first slot. Called once for the lifecycle of the timepoints array
+    /// @param self The stored dataStorage array
+    /// @param time The time of the dataStorage initialization, via block.timestamp truncated to uint32
+    /// @param tick Initial tick
+    //   static initialize(
+    //     Timepoint[UINT16_MODULO] storage self,
+    //     uint32 time,
+    //     int24 tick
+    //   ) internal {
+    //     require(!self[0].initialized);
+    //     self[0].initialized = true;
+    //     self[0].blockTimestamp = time;
+    //     self[0].averageTick = tick;
+    //   }
+    /// @notice Writes an dataStorage timepoint to the array
+    /// @dev Writable at most once per block. Index represents the most recently written element. index must be tracked externally.
+    /// @param self The stored dataStorage array
+    /// @param index The index of the timepoint that was most recently written to the timepoints array
+    /// @param blockTimestamp The timestamp of the new timepoint
+    /// @param tick The active tick at the time of the new timepoint
+    /// @param liquidity The total in-range liquidity at the time of the new timepoint
+    /// @param volumePerLiquidity The gmean(volumes)/liquidity at the time of the new timepoint
+    /// @return indexUpdated The new index of the most recently written element in the dataStorage array
+    static write(self, index, blockTimestamp, tick, liquidity, volumePerLiquidity) {
+        let _last = self[Number(index)];
+        // early return if we've already written an timepoint this block
+        if (_last.blockTimestamp == blockTimestamp) {
+            return index;
+        }
+        let last = _last;
+        // get next index considering overflow
+        let indexUpdated = index + 1n;
+        let oldestIndex;
+        // check if we have overflow in the past
+        if (self[Number(indexUpdated)].initialized) {
+            oldestIndex = indexUpdated;
+        }
+        (0, ts_essentials_1.assert)(oldestIndex); // FIXME ?
+        let avgTick = (0, utils_1.int24)(this._getAverageTick(self, blockTimestamp, tick, index, oldestIndex, last.blockTimestamp, last.tickCumulative));
+        let prevTick = tick;
+        if (index != oldestIndex) {
+            let _prevLast = self[Number(index - 1n)]; // considering index underflow
+            let _prevLastBlockTimestamp = _prevLast.blockTimestamp;
+            let _prevLastTickCumulative = _prevLast.tickCumulative;
+            prevTick = (0, utils_1.int24)((last.tickCumulative - _prevLastTickCumulative) /
+                (last.blockTimestamp - _prevLastBlockTimestamp));
+        }
+        self[Number(indexUpdated)] = this.createNewTimepoint(last, blockTimestamp, tick, prevTick, liquidity, avgTick, volumePerLiquidity);
+        return indexUpdated;
+    }
+}
+exports.DataStorage = DataStorage;
+DataStorage.WINDOW = WINDOW;
+DataStorage.UINT16_MODULO = UINT16_MODULO;
+//# sourceMappingURL=DataStorage.js.map

package/build/dex/algebra/lib/DataStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataStorage.js","sourceRoot":"","sources":["../../../../src/dex/algebra/lib/DataStorage.ts"],"names":[],"mappings":"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"}

package/build/dex/algebra/lib/DataStorageOperator.d.ts

@@ -0,0 +1,9 @@
+import { PoolState } from '../types';
+export declare class DataStorageOperator {
+    static getSingleTimepoint(state: PoolState, time: bigint, secondsAgo: bigint, tick: bigint, index: bigint, liquidity: bigint): [bigint, bigint, bigint, bigint];
+    static getTimepoints(state: PoolState, time: bigint, secondsAgos: bigint[], tick: bigint, index: bigint, liquidity: bigint): [bigint[], bigint[], bigint[], bigint[]];
+    static getAverages(state: PoolState, time: bigint, tick: bigint, index: bigint, liquidity: bigint): [bigint, bigint];
+    static write(state: PoolState, index: bigint, blockTimestamp: bigint, tick: bigint, liquidity: bigint, volumePerLiquidity: bigint): bigint;
+    static calculateVolumePerLiquidity(liquidity: bigint, amount0: bigint, amount1: bigint): bigint;
+    static window(): bigint;
+}

package/build/dex/algebra/lib/DataStorageOperator.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStorageOperator = void 0;
+const ts_essentials_1 = require("ts-essentials");
+const DataStorage_1 = require("./DataStorage");
+const bigint_constants_1 = require("../../../bigint-constants");
+const utils_1 = require("../../../utils");
+const Sqrt_1 = require("./Sqrt");
+// TO COMPARE WITH https://github.com/cryptoalgebra/Algebra/blob/3cd9a65bb5bb39d26fb4346e8f7d6d2a28672cc6/src/core/contracts/DataStorageOperator.sol#L16-L17
+const MAX_VOLUME_PER_LIQUIDITY = 100000 << 64; // maximum meaningful ratio of volume to liquidity
+class DataStorageOperator {
+    /// @inheritdoc IDataStorageOperator
+    static getSingleTimepoint(state, time, secondsAgo, tick, index, liquidity) {
+        let oldestIndex;
+        // check if we have overflow in the past
+        let nextIndex = index + 1n; // considering overflow
+        if (state.timepoints[Number(nextIndex)].initialized) {
+            oldestIndex = nextIndex;
+        }
+        (0, ts_essentials_1.assert)(oldestIndex); //
+        let result = DataStorage_1.DataStorage.getSingleTimepoint(state.timepoints, time, secondsAgo, tick, index, oldestIndex, liquidity);
+        let [tickCumulative, secondsPerLiquidityCumulative, volatilityCumulative, volumePerAvgLiquidity,] = [
+            result.tickCumulative,
+            result.secondsPerLiquidityCumulative,
+            result.volatilityCumulative,
+            result.volumePerLiquidityCumulative,
+        ];
+        return [
+            tickCumulative,
+            secondsPerLiquidityCumulative,
+            volatilityCumulative,
+            volumePerAvgLiquidity,
+        ];
+    }
+    /// @inheritdoc IDataStorageOperator
+    static getTimepoints(state, time, secondsAgos, tick, index, liquidity) {
+        return DataStorage_1.DataStorage.getTimepoints(state.timepoints, time, secondsAgos, tick, index, liquidity);
+    }
+    /// @inheritdoc IDataStorageOperator
+    static getAverages(state, time, tick, index, liquidity) {
+        return DataStorage_1.DataStorage.getAverages(state.timepoints, time, tick, index, liquidity);
+    }
+    /// @inheritdoc IDataStorageOperator
+    static write(state, index, blockTimestamp, tick, liquidity, volumePerLiquidity) {
+        return DataStorage_1.DataStorage.write(state.timepoints, index, blockTimestamp, tick, liquidity, volumePerLiquidity);
+    }
+    /// @inheritdoc IDataStorageOperator
+    static calculateVolumePerLiquidity(liquidity, amount0, amount1) {
+        let volume = Sqrt_1.Sqrt.sqrtAbs(amount0) * Sqrt_1.Sqrt.sqrtAbs(amount1);
+        let volumeShifted;
+        if (volume >= 2n ** 192n)
+            volumeShifted = bigint_constants_1.BI_MAX_UINT256 / (liquidity > 0n ? liquidity : 1n);
+        else
+            volumeShifted = (volume << 64n) / (liquidity > 0n ? liquidity : 1n);
+        if (volumeShifted >= MAX_VOLUME_PER_LIQUIDITY)
+            return BigInt(MAX_VOLUME_PER_LIQUIDITY);
+        else
+            return (0, utils_1.uint128)(volumeShifted);
+    }
+    /// @inheritdoc IDataStorageOperator
+    static window() {
+        return DataStorage_1.DataStorage.WINDOW;
+    }
+}
+exports.DataStorageOperator = DataStorageOperator;
+//# sourceMappingURL=DataStorageOperator.js.map

package/build/dex/algebra/lib/DataStorageOperator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataStorageOperator.js","sourceRoot":"","sources":["../../../../src/dex/algebra/lib/DataStorageOperator.ts"],"names":[],"mappings":"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"}

package/build/dex/algebra/lib/Sqrt.d.ts

@@ -0,0 +1,3 @@
+export declare class Sqrt {
+    static sqrtAbs(_x: bigint): bigint;
+}

package/build/dex/algebra/lib/Sqrt.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sqrt = void 0;
+const utils_1 = require("../../../utils");
+// TO COMPARE WITH https://github.com/cryptoalgebra/Algebra/blob/509f5bbb80b81daef1d5c15ea8695b5d039630cc/src/core/contracts/libraries/Sqrt.sol#L2-L3
+class Sqrt {
+    /// @notice Gets the square root of the absolute value of the parameter
+    static sqrtAbs(_x) {
+        let result;
+        // get abs value
+        let mask = _x >> (256n - 1n);
+        let x = (0, utils_1.uint256)((_x ^ mask) - mask);
+        if (x == 0n)
+            result = 0n;
+        else {
+            let xx = x;
+            let r = 1n;
+            if (xx >= 0x100000000000000000000000000000000n) {
+                xx >>= 128n;
+                r <<= 64n;
+            }
+            if (xx >= 0x10000000000000000n) {
+                xx >>= 64n;
+                r <<= 32n;
+            }
+            Sqrt;
+            if (xx >= 0x100000000n) {
+                xx >>= 32n;
+                r <<= 16n;
+            }
+            if (xx >= 0x10000n) {
+                xx >>= 16n;
+                r <<= 8n;
+            }
+            if (xx >= 0x100n) {
+                xx >>= 8n;
+                r <<= 4n;
+            }
+            if (xx >= 0x10n) {
+                xx >>= 4n;
+                r <<= 2n;
+            }
+            if (xx >= 0x8n) {
+                r <<= 1n;
+            }
+            r = (r + x / r) >> 1n;
+            r = (r + x / r) >> 1n;
+            r = (r + x / r) >> 1n;
+            r = (r + x / r) >> 1n;
+            r = (r + x / r) >> 1n;
+            r = (r + x / r) >> 1n;
+            r = (r + x / r) >> 1n; // @dev Seven iterations should be enough.
+            let r1 = x / r;
+            result = r < r1 ? r : r1;
+        }
+        return result;
+    }
+}
+exports.Sqrt = Sqrt;
+//# sourceMappingURL=Sqrt.js.map

package/build/dex/algebra/lib/Sqrt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sqrt.js","sourceRoot":"","sources":["../../../../src/dex/algebra/lib/Sqrt.ts"],"names":[],"mappings":";;;AAAA,0CAAyC;AAEzC,qJAAqJ;AACrJ,MAAa,IAAI;IACf,uEAAuE;IACvE,MAAM,CAAC,OAAO,CAAC,EAAU;QACvB,IAAI,MAAM,CAAC;QAEX,gBAAgB;QAChB,IAAI,IAAI,GAAG,EAAE,IAAI,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC;QAC7B,IAAI,CAAC,GAAG,IAAA,eAAO,EAAC,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,IAAI,EAAE;YAAE,MAAM,GAAG,EAAE,CAAC;aACpB;YACH,IAAI,EAAE,GAAG,CAAC,CAAC;YACX,IAAI,CAAC,GAAG,EAAE,CAAC;YACX,IAAI,EAAE,IAAI,oCAAoC,EAAE;gBAC9C,EAAE,KAAK,IAAI,CAAC;gBACZ,CAAC,KAAK,GAAG,CAAC;aACX;YACD,IAAI,EAAE,IAAI,oBAAoB,EAAE;gBAC9B,EAAE,KAAK,GAAG,CAAC;gBACX,CAAC,KAAK,GAAG,CAAC;aACX;YACD,IAAI,CAAC;YACL,IAAI,EAAE,IAAI,YAAY,EAAE;gBACtB,EAAE,KAAK,GAAG,CAAC;gBACX,CAAC,KAAK,GAAG,CAAC;aACX;YACD,IAAI,EAAE,IAAI,QAAQ,EAAE;gBAClB,EAAE,KAAK,GAAG,CAAC;gBACX,CAAC,KAAK,EAAE,CAAC;aACV;YACD,IAAI,EAAE,IAAI,MAAM,EAAE;gBAChB,EAAE,KAAK,EAAE,CAAC;gBACV,CAAC,KAAK,EAAE,CAAC;aACV;YACD,IAAI,EAAE,IAAI,KAAK,EAAE;gBACf,EAAE,KAAK,EAAE,CAAC;gBACV,CAAC,KAAK,EAAE,CAAC;aACV;YACD,IAAI,EAAE,IAAI,IAAI,EAAE;gBACd,CAAC,KAAK,EAAE,CAAC;aACV;YACD,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YACtB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YACtB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YACtB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YACtB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YACtB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC;YACtB,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,0CAA0C;YACjE,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;YACf,MAAM,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SAC1B;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AArDD,oBAqDC"}

package/build/dex/algebra/lib/TickManager.d.ts

@@ -0,0 +1,10 @@
+export declare type Tick = {
+    liquidityTotal: bigint;
+    liquidityDelta: bigint;
+    outerFeeGrowth0Token: bigint;
+    outerFeeGrowth1Token: bigint;
+    outerTickCumulative: bigint;
+    outerSecondsPerLiquidity: bigint;
+    outerSecondsSpent: bigint;
+    initialized: boolean;
+};

package/build/dex/algebra/lib/TickManager.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=TickManager.js.map

package/build/dex/algebra/lib/TickManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TickManager.js","sourceRoot":"","sources":["../../../../src/dex/algebra/lib/TickManager.ts"],"names":[],"mappings":""}

package/build/dex/algebra/types.d.ts

@@ -0,0 +1,55 @@
+import { Address, NumberAsString } from '../../types';
+import { TickInfo } from '../uniswap-v3/types';
+declare type Timepoint = {
+    initialized: boolean;
+    blockTimestamp: bigint;
+    tickCumulative: bigint;
+    secondsPerLiquidityCumulative: bigint;
+    volatilityCumulative: bigint;
+    averageTick: bigint;
+    volumePerLiquidityCumulative: bigint;
+};
+declare type GlobalState = {
+    price: bigint;
+    tick: bigint;
+    fee: bigint;
+    timepointIndex: bigint;
+    communityFeeToken0: bigint;
+    communityFeeToken1: bigint;
+    unlocked: boolean;
+};
+export declare type PoolState = {
+    pool: string;
+    blockTimestamp: bigint;
+    tickSpacing: bigint;
+    globalState: GlobalState;
+    liquidity: bigint;
+    maxLiquidityPerTick: bigint;
+    tickBitmap: Record<NumberAsString, bigint>;
+    ticks: Record<NumberAsString, TickInfo>;
+    timepoints: Record<number, Timepoint>;
+    volumePerLiquidityInBlock: bigint;
+    isValid: boolean;
+    startTickBitmap: bigint;
+    balance0: bigint;
+    balance1: bigint;
+};
+export declare type AlgebraData = {
+    path: {
+        tokenIn: Address;
+        tokenOut: Address;
+    }[];
+    isApproved?: boolean;
+};
+export declare type DexParams = {
+    router: Address;
+    quoter: Address;
+    factory: Address;
+    algebraStateMulticall: Address;
+    uniswapMulticall: Address;
+    chunksCount: number;
+    deployer: Address;
+    subgraphURL: string;
+    initHash: string;
+};
+export {};

package/build/dex/algebra/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map