@paraswap/dex-lib 2.23.4 → 2.24.0

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

@@ -0,0 +1,466 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStorage = exports.TIMEPOINT_ZERO = void 0;
+const utils_1 = require("../../../utils");
+exports.TIMEPOINT_ZERO = {
+    // averageTick: 0n,
+    blockTimestamp: 0n,
+    initialized: false,
+    secondsPerLiquidityCumulative: 0n,
+    tickCumulative: 0n,
+    // volatilityCumulative: 0n,
+    // volumePerLiquidityCumulative: 0n,
+};
+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) {
+        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 += 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) {
+        if (Object.keys(self).length < 2)
+            return tick; // MITIGATIONS OFF CONTRACT
+        const oldestTimestamp = (self[Number(oldestIndex)] || exports.TIMEPOINT_ZERO)
+            .blockTimestamp;
+        const oldestTickCumulative = self[Number(oldestIndex)]?.tickCumulative || 0n;
+        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)] || exports.TIMEPOINT_ZERO;
+                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
+        do {
+            let beforeOrAt = self[Number((0, utils_1.uint16)(current))] || exports.TIMEPOINT_ZERO; // 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`?
+                    let atOrAfter = self[Number((0, utils_1.uint16)(current + 1n))] || exports.TIMEPOINT_ZERO; // checking the next point after "middle"
+                    let [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)] || exports.TIMEPOINT_ZERO).blockTimestamp, target, time)) {
+            let last = self[Number(index)] || exports.TIMEPOINT_ZERO;
+            if (last.blockTimestamp == target) {
+                return last;
+            }
+            else {
+                // otherwise, we need to add new timepoint
+                // let avgTick = 0n;
+                // 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)] || exports.TIMEPOINT_ZERO; // considering index underflow
+                        prevLast.blockTimestamp = _prevLast.blockTimestamp;
+                        prevLast.tickCumulative = _prevLast.tickCumulative;
+                        console.log(`QuickSwapV3 denom ${JSON.stringify({ last, prevLast })}`);
+                        prevTick = (0, utils_1.int24)((last.tickCumulative - prevLast.tickCumulative) /
+                            (last.blockTimestamp - prevLast.blockTimestamp));
+                    }
+                }
+                return this.createNewTimepoint(last, target, tick, prevTick, liquidity);
+            }
+        }
+        (0, utils_1._require)(this.lteConsideringOverflow((self[Number(oldestIndex)] || exports.TIMEPOINT_ZERO).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: Record<number, Timepoint>,
+    //   time: bigint,
+    //   secondsAgos: bigint[],
+    //   tick: bigint,
+    //   index: bigint,
+    //   liquidity: bigint,
+    // ): [bigint[], bigint[], bigint[], bigint[]] {
+    //   let tickCumulatives = new Array<bigint>(secondsAgos.length);
+    //   let secondsPerLiquidityCumulatives = new Array<bigint>(secondsAgos.length);
+    //   let volatilityCumulatives = new Array<bigint>(secondsAgos.length);
+    //   let volumePerAvgLiquiditys = new Array<bigint>(secondsAgos.length);
+    //   let oldestIndex = 0n; // solidity default
+    //   // check if we have overflow in the past
+    //   let nextIndex = index + 1n; // considering overflow
+    //   if ((self[Number(nextIndex)] || TIMEPOINT_ZERO).initialized) {
+    //     oldestIndex = nextIndex;
+    //   }
+    //   let current: Timepoint;
+    //   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: Record<number, Timepoint>,
+    //   time: bigint,
+    //   tick: bigint,
+    //   index: bigint,
+    //   liquidity: bigint,
+    // ): [bigint, bigint] {
+    //   let oldestIndex;
+    //   let oldest = self[0];
+    //   let nextIndex = index + 1n; // considering overflow
+    //   if ((self[Number(nextIndex)] || TIMEPOINT_ZERO).initialized) {
+    //     oldest = self[Number(nextIndex)] || TIMEPOINT_ZERO;
+    //     oldestIndex = nextIndex;
+    //   }
+    //   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,
+    //       uint256(
+    //         endOfWindow.volumePerLiquidityCumulative -
+    //           startOfWindow.volumePerLiquidityCumulative,
+    //       ) >> 57n,
+    //     ];
+    //   } else if (time != oldestTimestamp) {
+    //     let _oldestVolatilityCumulative = oldest.volatilityCumulative;
+    //     let _oldestVolumePerLiquidityCumulative =
+    //       oldest.volumePerLiquidityCumulative;
+    //     return [
+    //       (endOfWindow.volatilityCumulative - _oldestVolatilityCumulative) /
+    //         (time - oldestTimestamp),
+    //       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) {
+        let _last = self[Number(index)] || exports.TIMEPOINT_ZERO;
+        // 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 = 0n; // default in evm
+        // check if we have overflow in the past
+        if ((self[Number(indexUpdated)] || exports.TIMEPOINT_ZERO).initialized) {
+            oldestIndex = indexUpdated;
+        }
+        // let avgTick = 0n;
+        // int24(
+        //   this._getAverageTick(
+        //     self,
+        //     blockTimestamp,
+        //     tick,
+        //     index,
+        //     oldestIndex,
+        //     last.blockTimestamp,
+        //     last.tickCumulative,
+        //   ),
+        // );
+        let prevTick = tick;
+        if (index != oldestIndex) {
+            let _prevLast = self[Number(index - 1n)] || exports.TIMEPOINT_ZERO; // 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);
+        // FIXME should delete ?
+        // delete self[Number(index)];
+        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,10 @@
+import { PoolState } from '../types';
+export declare class DataStorageOperator {
+    static getSingleTimepoint(state: PoolState, time: bigint, secondsAgo: bigint, tick: bigint, index: bigint, liquidity: bigint): [
+        bigint,
+        bigint
+    ];
+    static write(state: PoolState, index: bigint, blockTimestamp: bigint, tick: bigint, liquidity: bigint): bigint;
+    static calculateVolumePerLiquidity(liquidity: bigint, amount0: bigint, amount1: bigint): bigint;
+    static window(): bigint;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataStorageOperator = void 0;
+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 = 0n;
+        // check if we have overflow in the past
+        let nextIndex = index + 1n; // considering overflow
+        if ((state.timepoints[Number(nextIndex)] || DataStorage_1.TIMEPOINT_ZERO).initialized) {
+            oldestIndex = nextIndex;
+        }
+        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: PoolState,
+    //   time: bigint,
+    //   secondsAgos: bigint[],
+    //   tick: bigint,
+    //   index: bigint,
+    //   liquidity: bigint,
+    // ): [bigint[], bigint[], bigint[], bigint[]] {
+    //   return DataStorage.getTimepoints(
+    //     state.timepoints,
+    //     time,
+    //     secondsAgos,
+    //     tick,
+    //     index,
+    //     liquidity,
+    //   );
+    // }
+    // /// @inheritdoc IDataStorageOperator
+    // static getAverages(
+    //   state: PoolState,
+    //   time: bigint,
+    //   tick: bigint,
+    //   index: bigint,
+    //   liquidity: bigint,
+    // ): [bigint, bigint] {
+    //   return DataStorage.getAverages(
+    //     state.timepoints,
+    //     time,
+    //     tick,
+    //     index,
+    //     liquidity,
+    //   );
+    // }
+    /// @inheritdoc IDataStorageOperator
+    static write(state, index, blockTimestamp, tick, liquidity) {
+        return DataStorage_1.DataStorage.write(state.timepoints, index, blockTimestamp, tick, liquidity);
+    }
+    /// @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;
+}