@paraswap/dex-lib 4.7.27-1 → 4.7.27-ekubo-v3.1

package/build/dex/ekubo-v3/pools/oracle.d.ts

@@ -0,0 +1,8 @@
+import { DeepReadonly } from 'ts-essentials';
+import { FullRangePool, FullRangePoolState } from './full-range';
+import { PoolKeyed, Quote } from './pool';
+import { StableswapPoolTypeConfig } from './utils';
+export declare class OraclePool extends FullRangePool {
+    protected _quote(amount: bigint, isToken1: boolean, state: DeepReadonly<FullRangePoolState.Object>, sqrtRatioLimit?: bigint): Quote;
+    quoteOracle(this: PoolKeyed<StableswapPoolTypeConfig>, amount: bigint, isToken1: boolean, state: DeepReadonly<FullRangePoolState.Object>, sqrtRatioLimit?: bigint): Quote;
+}

package/build/dex/ekubo-v3/pools/oracle.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OraclePool = void 0;
+const full_range_1 = require("./full-range");
+// TODO
+const BASE_GAS_COST_OF_ONE_ORACLE_SWAP = 32_000;
+class OraclePool extends full_range_1.FullRangePool {
+    _quote(amount, isToken1, state, sqrtRatioLimit) {
+        return this.quoteOracle(amount, isToken1, state, sqrtRatioLimit);
+    }
+    quoteOracle(amount, isToken1, state, sqrtRatioLimit) {
+        const fullRangeQuote = full_range_1.FullRangePool.prototype.quoteFullRange.call(this, amount, isToken1, state, sqrtRatioLimit);
+        fullRangeQuote.gasConsumed = BASE_GAS_COST_OF_ONE_ORACLE_SWAP;
+        return fullRangeQuote;
+    }
+}
+exports.OraclePool = OraclePool;
+//# sourceMappingURL=oracle.js.map

package/build/dex/ekubo-v3/pools/oracle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle.js","sourceRoot":"","sources":["../../../../src/dex/ekubo-v3/pools/oracle.ts"],"names":[],"mappings":";;;AACA,6CAAiE;AAIjE,OAAO;AACP,MAAM,gCAAgC,GAAG,MAAM,CAAC;AAEhD,MAAa,UAAW,SAAQ,0BAAa;IACxB,MAAM,CACvB,MAAc,EACd,QAAiB,EACjB,KAA8C,EAC9C,cAAuB;QAEvB,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC;IACnE,CAAC;IAEM,WAAW,CAEhB,MAAc,EACd,QAAiB,EACjB,KAA8C,EAC9C,cAAuB;QAEvB,MAAM,cAAc,GAAG,0BAAa,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAChE,IAAI,EACJ,MAAM,EACN,QAAQ,EACR,KAAK,EACL,cAAc,CACf,CAAC;QAEF,cAAc,CAAC,WAAW,GAAG,gCAAgC,CAAC;QAE9D,OAAO,cAAc,CAAC;IACxB,CAAC;CACF;AA7BD,gCA6BC"}

package/build/dex/ekubo-v3/pools/pool.d.ts

@@ -0,0 +1,56 @@
+import { Interface, Result } from '@ethersproject/abi';
+import { Logger } from 'log4js';
+import { DeepReadonly } from 'ts-essentials';
+import { IDexHelper } from '../../../dex-helper/idex-helper';
+import { StatefulEventSubscriber } from '../../../stateful-event-subscriber';
+import { BlockHeader, Log } from '../../../types';
+import { PoolKey, PoolTypeConfig } from './utils';
+import { EventSubscriber } from '../../../dex-helper';
+export type Quote<StateAfter = undefined> = {
+    consumedAmount: bigint;
+    calculatedAmount: bigint;
+    gasConsumed: number;
+    skipAhead: number;
+} & (StateAfter extends undefined ? {} : {
+    stateAfter: StateAfter;
+});
+export interface PoolKeyed<C extends PoolTypeConfig> {
+    key: PoolKey<C>;
+}
+export interface IEkuboPool<C extends PoolTypeConfig> extends PoolKeyed<C>, EventSubscriber {
+    initializationBlockNumber(): number;
+    quote(amount: bigint, token: bigint, blockNumber: number): Quote;
+    updateState(blockNumber: number): Promise<void>;
+    computeTvl(): [bigint, bigint];
+}
+export type NamedEventHandler<State> = (args: Result, oldState: DeepReadonly<State>, blockHeader: Readonly<BlockHeader>) => DeepReadonly<State> | null;
+export type AnonymousEventHandler<State> = (data: string, oldState: DeepReadonly<State>, blockHeader: Readonly<BlockHeader>) => DeepReadonly<State> | null;
+export declare class NamedEventHandlers<State> {
+    private readonly iface;
+    private readonly handlers;
+    constructor(iface: Interface, handlers: Record<string, NamedEventHandler<State>>);
+    parseLog(log: Readonly<Log>, oldState: DeepReadonly<State>, blockHeader: Readonly<BlockHeader>): DeepReadonly<State> | null;
+}
+export declare abstract class EkuboPool<C extends PoolTypeConfig, S> extends StatefulEventSubscriber<S> implements IEkuboPool<C> {
+    private readonly initBlockNumber;
+    readonly key: PoolKey<C>;
+    private readonly namedEventHandlers;
+    private readonly anonymousEventHandlers;
+    protected constructor(parentName: string, dexHelper: IDexHelper, logger: Logger, initBlockNumber: number, key: PoolKey<C>, namedEventHandlers: Record<string, NamedEventHandlers<S>>, anonymousEventHandlers: Record<string, AnonymousEventHandler<S>>);
+    initializationBlockNumber(): number;
+    updateState(blockNumber: number): Promise<void>;
+    quote(amount: bigint, token: bigint, blockNumber: number): Quote;
+    computeTvl(): [bigint, bigint];
+    /**
+     * The function is called every time any of the subscribed
+     * addresses release log. The function accepts the current
+     * state, updates the state according to the log, and returns
+     * the updated state.
+     * @param state - Current state of event subscriber
+     * @param log - Log released by one of the subscribed addresses
+     * @returns Updates state of the event subscriber after the log
+     */
+    protected processLog(state: DeepReadonly<S>, log: Readonly<Log>, blockHeader: Readonly<BlockHeader>): DeepReadonly<S> | null;
+    protected abstract _quote(amount: bigint, isToken1: boolean, state: DeepReadonly<S>, sqrtRatioLimit?: bigint): Quote;
+    protected abstract _computeTvl(state: DeepReadonly<S>): [bigint, bigint];
+}

package/build/dex/ekubo-v3/pools/pool.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EkuboPool = exports.NamedEventHandlers = void 0;
+const stateful_event_subscriber_1 = require("../../../stateful-event-subscriber");
+class NamedEventHandlers {
+    iface;
+    handlers;
+    constructor(iface, handlers) {
+        this.iface = iface;
+        this.handlers = handlers;
+    }
+    parseLog(log, oldState, blockHeader) {
+        const event = this.iface.parseLog(log);
+        return (this.handlers[event.name]?.(event.args, oldState, blockHeader) ?? null);
+    }
+}
+exports.NamedEventHandlers = NamedEventHandlers;
+class EkuboPool extends stateful_event_subscriber_1.StatefulEventSubscriber {
+    initBlockNumber;
+    key;
+    namedEventHandlers;
+    anonymousEventHandlers;
+    constructor(parentName, dexHelper, logger, initBlockNumber, key, namedEventHandlers, anonymousEventHandlers) {
+        super(parentName, key.stringId, dexHelper, logger);
+        this.initBlockNumber = initBlockNumber;
+        this.key = key;
+        this.namedEventHandlers = namedEventHandlers;
+        this.anonymousEventHandlers = anonymousEventHandlers;
+        this.addressesSubscribed = [
+            ...new Set(Object.keys(namedEventHandlers).concat(Object.keys(anonymousEventHandlers))),
+        ];
+    }
+    initializationBlockNumber() {
+        return this.initBlockNumber;
+    }
+    async updateState(blockNumber) {
+        this.setState(await this.generateState(blockNumber), blockNumber);
+    }
+    quote(amount, token, blockNumber) {
+        const isToken1 = token === this.key.token1;
+        if (!isToken1 && this.key.token0 !== token) {
+            throw new Error('Invalid token');
+        }
+        if (amount === 0n) {
+            return {
+                consumedAmount: 0n,
+                calculatedAmount: 0n,
+                gasConsumed: 0,
+                skipAhead: 0,
+            };
+        }
+        const state = this.getState(blockNumber);
+        if (state === null) {
+            throw new Error(`Quote for block number ${blockNumber} requested but state is not recent enough`);
+        }
+        const quote = this._quote(amount, isToken1, state);
+        if (quote.calculatedAmount === 0n) {
+            quote.gasConsumed = 0;
+        }
+        return quote;
+    }
+    computeTvl() {
+        const state = this.getStaleState();
+        if (state === null) {
+            throw new Error('pool has no state');
+        }
+        return this._computeTvl(state);
+    }
+    /**
+     * The function is called every time any of the subscribed
+     * addresses release log. The function accepts the current
+     * state, updates the state according to the log, and returns
+     * the updated state.
+     * @param state - Current state of event subscriber
+     * @param log - Log released by one of the subscribed addresses
+     * @returns Updates state of the event subscriber after the log
+     */
+    processLog(state, log, blockHeader) {
+        const emitter = log.address;
+        if (log.topics.length === 0) {
+            return this.anonymousEventHandlers[emitter]?.(log.data, state, blockHeader);
+        }
+        return (this.namedEventHandlers[emitter]?.parseLog(log, state, blockHeader) ??
+            null);
+    }
+}
+exports.EkuboPool = EkuboPool;
+//# sourceMappingURL=pool.js.map

package/build/dex/ekubo-v3/pools/pool.js.map

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

package/build/dex/ekubo-v3/pools/stableswap.d.ts

@@ -0,0 +1,22 @@
+import { DeepReadonly } from 'ts-essentials';
+import { IDexHelper } from '../../../dex-helper/idex-helper';
+import { Logger } from '../../../types';
+import { EkuboContracts } from '../types';
+import { EkuboPool, PoolKeyed, Quote } from './pool';
+import { PoolKey, StableswapPoolTypeConfig } from './utils';
+import { FullRangePoolState } from './full-range';
+export declare class StableswapPool extends EkuboPool<StableswapPoolTypeConfig, FullRangePoolState.Object> {
+    readonly lowerPrice: bigint;
+    readonly upperPrice: bigint;
+    private readonly quoteDataFetcher;
+    constructor(parentName: string, dexHelper: IDexHelper, logger: Logger, contracts: EkuboContracts, initBlockNumber: number, key: PoolKey<StableswapPoolTypeConfig>);
+    generateState(blockNumber?: number | 'latest'): Promise<DeepReadonly<FullRangePoolState.Object>>;
+    protected _quote(amount: bigint, isToken1: boolean, state: DeepReadonly<FullRangePoolState.Object>, sqrtRatioLimit?: bigint): Quote;
+    quoteStableswap(this: PoolKeyed<StableswapPoolTypeConfig> & StableswapBounds, amount: bigint, isToken1: boolean, state: DeepReadonly<FullRangePoolState.Object>, sqrtRatioLimit?: bigint): Quote<FullRangePoolState.Object>;
+    protected _computeTvl(state: FullRangePoolState.Object): [bigint, bigint];
+}
+export interface StableswapBounds {
+    lowerPrice: bigint;
+    upperPrice: bigint;
+}
+export declare function computeStableswapBounds(config: StableswapPoolTypeConfig): StableswapBounds;

package/build/dex/ekubo-v3/pools/stableswap.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StableswapPool = void 0;
+exports.computeStableswapBounds = computeStableswapBounds;
+const pool_1 = require("./pool");
+const swap_1 = require("./math/swap");
+const tick_1 = require("./math/tick");
+const utils_1 = require("./utils");
+const delta_1 = require("./math/delta");
+const base_1 = require("./base");
+const full_range_1 = require("./full-range");
+const GAS_COST_OF_ONE_STABLESWAP_SWAP = 16_818;
+class StableswapPool extends pool_1.EkuboPool {
+    lowerPrice;
+    upperPrice;
+    quoteDataFetcher;
+    constructor(parentName, dexHelper, logger, contracts, initBlockNumber, key) {
+        const { contract: { address }, interface: iface, quoteDataFetcher, } = contracts.core;
+        super(parentName, dexHelper, logger, initBlockNumber, key, {
+            [address]: new pool_1.NamedEventHandlers(iface, {
+                PositionUpdated: (args, oldState) => full_range_1.FullRangePoolState.fromPositionUpdatedEvent(oldState, args.liquidityDelta.toBigInt()),
+            }),
+        }, {
+            [address]: data => full_range_1.FullRangePoolState.fromSwappedEvent((0, utils_1.parseSwappedEvent)(data)),
+        });
+        this.quoteDataFetcher = quoteDataFetcher;
+        const bounds = computeStableswapBounds(key.config.poolTypeConfig);
+        this.lowerPrice = bounds.lowerPrice;
+        this.upperPrice = bounds.upperPrice;
+    }
+    async generateState(blockNumber) {
+        const data = await this.quoteDataFetcher.getQuoteData([this.key.toAbi()], 0, {
+            blockTag: blockNumber,
+        });
+        return full_range_1.FullRangePoolState.fromQuoter(data[0]);
+    }
+    _quote(amount, isToken1, state, sqrtRatioLimit) {
+        return this.quoteStableswap(amount, isToken1, state, sqrtRatioLimit);
+    }
+    quoteStableswap(amount, isToken1, state, sqrtRatioLimit) {
+        const isIncreasing = (0, swap_1.isPriceIncreasing)(amount, isToken1);
+        let { sqrtRatio, liquidity } = state;
+        sqrtRatioLimit ??= isIncreasing ? tick_1.MAX_SQRT_RATIO : tick_1.MIN_SQRT_RATIO;
+        let calculatedAmount = 0n;
+        let initializedTicksCrossed = 0;
+        let amountRemaining = amount;
+        while (amountRemaining !== 0n && sqrtRatio !== sqrtRatioLimit) {
+            let stepLiquidity = liquidity;
+            const inRange = sqrtRatio < this.upperPrice && sqrtRatio > this.lowerPrice;
+            let nextTickSqrtRatio = null;
+            if (inRange) {
+                nextTickSqrtRatio = isIncreasing ? this.upperPrice : this.lowerPrice;
+            }
+            else {
+                stepLiquidity = 0n;
+                if (sqrtRatio <= this.lowerPrice) {
+                    if (isIncreasing) {
+                        nextTickSqrtRatio = this.lowerPrice;
+                    }
+                }
+                else {
+                    if (!isIncreasing) {
+                        nextTickSqrtRatio = this.upperPrice;
+                    }
+                }
+            }
+            const stepSqrtRatioLimit = nextTickSqrtRatio === null ||
+                nextTickSqrtRatio < sqrtRatioLimit !== isIncreasing
+                ? sqrtRatioLimit
+                : nextTickSqrtRatio;
+            const step = (0, swap_1.computeStep)({
+                fee: this.key.config.fee,
+                sqrtRatio,
+                liquidity: stepLiquidity,
+                isToken1,
+                sqrtRatioLimit: stepSqrtRatioLimit,
+                amount: amountRemaining,
+            });
+            amountRemaining -= step.consumedAmount;
+            calculatedAmount += step.calculatedAmount;
+            sqrtRatio = step.sqrtRatioNext;
+            if (sqrtRatio === nextTickSqrtRatio) {
+                initializedTicksCrossed++;
+            }
+        }
+        return {
+            consumedAmount: amount - amountRemaining,
+            calculatedAmount,
+            gasConsumed: GAS_COST_OF_ONE_STABLESWAP_SWAP +
+                (0, base_1.initializedTicksCrossedGasCosts)(initializedTicksCrossed),
+            skipAhead: 0,
+            stateAfter: {
+                sqrtRatio,
+                liquidity,
+            },
+        };
+    }
+    _computeTvl(state) {
+        const { sqrtRatio, liquidity } = state;
+        let [amount0, amount1] = [0n, 0n];
+        if (sqrtRatio < this.upperPrice) {
+            amount0 = (0, delta_1.amount0Delta)(sqrtRatio, this.upperPrice, liquidity, false);
+        }
+        if (sqrtRatio > this.lowerPrice) {
+            amount1 = (0, delta_1.amount1Delta)(this.lowerPrice, sqrtRatio, liquidity, false);
+        }
+        return [amount0, amount1];
+    }
+}
+exports.StableswapPool = StableswapPool;
+function computeStableswapBounds(config) {
+    const { centerTick, amplificationFactor } = config;
+    const liquidityWidth = tick_1.MAX_TICK >> amplificationFactor;
+    const [lowerTick, upperTick] = [
+        centerTick - liquidityWidth,
+        centerTick + liquidityWidth,
+    ];
+    return {
+        lowerPrice: lowerTick > tick_1.MIN_TICK ? (0, tick_1.toSqrtRatio)(lowerTick) : tick_1.MIN_SQRT_RATIO,
+        upperPrice: upperTick < tick_1.MAX_TICK ? (0, tick_1.toSqrtRatio)(upperTick) : tick_1.MAX_SQRT_RATIO,
+    };
+}
+//# sourceMappingURL=stableswap.js.map

package/build/dex/ekubo-v3/pools/stableswap.js.map

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

package/build/dex/ekubo-v3/pools/twamm.d.ts

@@ -0,0 +1,40 @@
+import { Logger } from 'log4js';
+import { DeepReadonly } from 'ts-essentials';
+import { IDexHelper } from '../../../dex-helper/idex-helper';
+import { EkuboContracts, PoolInitializationState, TwammQuoteData } from '../types';
+import { FullRangePoolState } from './full-range';
+import { EkuboPool, Quote } from './pool';
+import { PoolKey, StableswapPoolTypeConfig, SwappedEvent } from './utils';
+export declare class TwammPool extends EkuboPool<StableswapPoolTypeConfig, TwammPoolState.Object> {
+    private readonly twammDataFetcher;
+    constructor(parentName: string, dexHelper: IDexHelper, logger: Logger, contracts: EkuboContracts, initBlockNumber: number, key: PoolKey<StableswapPoolTypeConfig>);
+    generateState(blockNumber?: number | 'latest'): Promise<DeepReadonly<TwammPoolState.Object>>;
+    protected _quote(amount: bigint, isToken1: boolean, state: DeepReadonly<TwammPoolState.Object>): Quote;
+    quoteTwamm(amount: bigint, isToken1: boolean, state: DeepReadonly<TwammPoolState.Object>, overrideTime?: bigint): Quote;
+    protected _computeTvl(state: TwammPoolState.Object): [bigint, bigint];
+}
+interface VirtualOrdersExecutedEvent {
+    token0SaleRate: bigint;
+    token1SaleRate: bigint;
+}
+export declare namespace TwammPoolState {
+    interface SaleRateDelta {
+        time: bigint;
+        saleRateDelta0: bigint;
+        saleRateDelta1: bigint;
+    }
+    interface Object {
+        fullRangePoolState: FullRangePoolState.Object;
+        token0SaleRate: bigint;
+        token1SaleRate: bigint;
+        lastExecutionTime: bigint;
+        virtualOrderDeltas: SaleRateDelta[];
+    }
+    function fromPoolInitialization(state: PoolInitializationState): DeepReadonly<Object>;
+    function fromQuoter(data: TwammQuoteData): DeepReadonly<Object>;
+    function fromSwappedEvent(oldState: DeepReadonly<Object>, ev: SwappedEvent): Object;
+    function fromPositionUpdatedEvent(oldState: DeepReadonly<Object>, liquidityDelta: bigint): Object | null;
+    function fromVirtualOrdersExecutedEvent(oldState: DeepReadonly<Object>, ev: VirtualOrdersExecutedEvent, timestamp: bigint): Object;
+    function fromOrderUpdatedEvent(oldState: DeepReadonly<Object>, [startTime, endTime]: [bigint, bigint], orderSaleRateDelta: bigint, isToken1: boolean): Object | null;
+}
+export {};

package/build/dex/ekubo-v3/pools/twamm.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwammPoolState = exports.TwammPool = void 0;
+const full_range_1 = require("./full-range");
+const pool_1 = require("./pool");
+const constants_1 = require("./math/constants");
+const sqrt_ratio_1 = require("./math/sqrt-ratio");
+const tick_1 = require("./math/tick");
+const sqrt_ratio_2 = require("./math/twamm/sqrt-ratio");
+const utils_1 = require("./utils");
+const base_1 = require("./base");
+const utils_2 = require("ethers/lib/utils");
+const utils_3 = require("../utils");
+const SLOT_DURATION_SECS = 12n;
+const BASE_GAS_COST_OF_ONE_TWAMM_SWAP = 30_716;
+// TODO
+const BASE_GAS_COST_OF_ONE_TWAMM_FULL_RANGE_SWAP = 19_000;
+const GAS_COST_OF_ONE_VIRTUAL_ORDER_DELTA = 7_500;
+const LOG_BASE_256 = Math.log(256);
+class TwammPool extends pool_1.EkuboPool {
+    twammDataFetcher;
+    constructor(parentName, dexHelper, logger, contracts, initBlockNumber, key) {
+        const { contract: { address: coreAddress }, interface: coreIface, } = contracts.core;
+        const { contract: { address: twammAddress }, interface: twammIface, quoteDataFetcher: twammDataFetcher, } = contracts.twamm;
+        super(parentName, dexHelper, logger, initBlockNumber, key, {
+            [coreAddress]: new pool_1.NamedEventHandlers(coreIface, {
+                PositionUpdated: (args, oldState) => TwammPoolState.fromPositionUpdatedEvent(oldState, args.liquidityDelta.toBigInt()),
+            }),
+            [twammAddress]: new pool_1.NamedEventHandlers(twammIface, {
+                OrderUpdated: (args, oldState) => {
+                    const orderKey = args.orderKey;
+                    if (key.token0 !== BigInt(orderKey.token0) ||
+                        key.token1 !== BigInt(orderKey.token1) ||
+                        key.config.fee !== BigInt((0, utils_2.hexDataSlice)(orderKey.config, 0, 8))) {
+                        return null;
+                    }
+                    const isToken1 = Boolean(Number((0, utils_2.hexDataSlice)(orderKey.config, 8, 9)));
+                    return TwammPoolState.fromOrderUpdatedEvent(oldState, [
+                        BigInt((0, utils_2.hexDataSlice)(orderKey.config, 16, 24)),
+                        BigInt((0, utils_2.hexDataSlice)(orderKey.config, 24, 32)),
+                    ], args.saleRateDelta.toBigInt(), isToken1);
+                },
+            }),
+        }, {
+            [coreAddress]: (data, oldState) => TwammPoolState.fromSwappedEvent(oldState, (0, utils_1.parseSwappedEvent)(data)),
+            [twammAddress]: (data, oldState, blockHeader) => TwammPoolState.fromVirtualOrdersExecutedEvent(oldState, parseVirtualOrdersExecutedEvent(data), BigInt(blockHeader.timestamp)),
+        });
+        this.twammDataFetcher = twammDataFetcher;
+    }
+    async generateState(blockNumber) {
+        const quoteData = await this.twammDataFetcher.getPoolState(this.key.toAbi(), {
+            blockTag: blockNumber,
+        });
+        return TwammPoolState.fromQuoter(quoteData);
+    }
+    _quote(amount, isToken1, state) {
+        return this.quoteTwamm(amount, isToken1, state);
+    }
+    quoteTwamm(amount, isToken1, state, overrideTime) {
+        const currentTime = overrideTime ??
+            (0, utils_3.bigintMax)(state.lastExecutionTime + SLOT_DURATION_SECS, BigInt(Math.floor(Date.now() / 1000)));
+        const fee = this.key.config.fee;
+        const quoteFullRangePool = full_range_1.FullRangePool.prototype.quoteFullRange.bind(this);
+        const liquidity = state.fullRangePoolState.liquidity;
+        let nextSqrtRatio = state.fullRangePoolState.sqrtRatio;
+        let token0SaleRate = state.token0SaleRate;
+        let token1SaleRate = state.token1SaleRate;
+        let lastExecutionTime = state.lastExecutionTime;
+        let virtualOrderDeltaTimesCrossed = 0;
+        let swapCount = 0;
+        let nextSaleRateDeltaIndex = state.virtualOrderDeltas.findIndex(srd => srd.time > lastExecutionTime);
+        let fullRangePoolState = state.fullRangePoolState;
+        while (lastExecutionTime != currentTime) {
+            const saleRateDelta = state.virtualOrderDeltas[nextSaleRateDeltaIndex];
+            const nextExecutionTime = saleRateDelta
+                ? (0, utils_3.bigintMin)(saleRateDelta.time, currentTime)
+                : currentTime;
+            const timeElapsed = nextExecutionTime - lastExecutionTime;
+            if (timeElapsed > constants_1.MAX_U32) {
+                throw new Error('Too much time passed since last execution');
+            }
+            const [amount0, amount1] = [
+                (token0SaleRate * BigInt(timeElapsed)) >> 32n,
+                (token1SaleRate * BigInt(timeElapsed)) >> 32n,
+            ];
+            if (amount0 > 0n && amount1 > 0n) {
+                let currentSqrtRatio = nextSqrtRatio;
+                if (currentSqrtRatio > tick_1.MAX_SQRT_RATIO) {
+                    currentSqrtRatio = tick_1.MAX_SQRT_RATIO;
+                }
+                else if (currentSqrtRatio < tick_1.MIN_SQRT_RATIO) {
+                    currentSqrtRatio = tick_1.MIN_SQRT_RATIO;
+                }
+                nextSqrtRatio = (0, sqrt_ratio_2.calculateNextSqrtRatio)(currentSqrtRatio, liquidity, token0SaleRate, token1SaleRate, timeElapsed, fee);
+                const [amount, isToken1] = currentSqrtRatio < nextSqrtRatio ? [amount1, true] : [amount0, false];
+                const quote = quoteFullRangePool(amount, isToken1, fullRangePoolState, nextSqrtRatio);
+                swapCount++;
+                fullRangePoolState = quote.stateAfter;
+            }
+            else if (amount0 > 0n || amount1 > 0n) {
+                const [amount, isToken1] = amount0 !== 0n ? [amount0, false] : [amount1, true];
+                const quote = quoteFullRangePool(amount, isToken1, fullRangePoolState);
+                swapCount++;
+                fullRangePoolState = quote.stateAfter;
+                nextSqrtRatio = quote.stateAfter.sqrtRatio;
+            }
+            if (saleRateDelta) {
+                if (saleRateDelta.time === nextExecutionTime) {
+                    token0SaleRate += saleRateDelta.saleRateDelta0;
+                    token1SaleRate += saleRateDelta.saleRateDelta1;
+                    nextSaleRateDeltaIndex++;
+                    virtualOrderDeltaTimesCrossed++;
+                }
+            }
+            lastExecutionTime = nextExecutionTime;
+        }
+        const finalQuote = quoteFullRangePool(amount, isToken1, fullRangePoolState);
+        return {
+            calculatedAmount: finalQuote.calculatedAmount,
+            consumedAmount: finalQuote.consumedAmount,
+            gasConsumed: BASE_GAS_COST_OF_ONE_TWAMM_SWAP +
+                swapCount * BASE_GAS_COST_OF_ONE_TWAMM_FULL_RANGE_SWAP +
+                virtualOrderDeltaTimesCrossed * GAS_COST_OF_ONE_VIRTUAL_ORDER_DELTA +
+                (Math.log(Number(currentTime - state.lastExecutionTime)) /
+                    LOG_BASE_256) *
+                    base_1.GAS_COST_OF_ONE_EXTRA_BITMAP_SLOAD,
+            skipAhead: finalQuote.skipAhead,
+        };
+    }
+    _computeTvl(state) {
+        return full_range_1.FullRangePoolState.computeTvl(state.fullRangePoolState);
+    }
+}
+exports.TwammPool = TwammPool;
+function parseVirtualOrdersExecutedEvent(data) {
+    let n = BigInt(data);
+    const token1SaleRate = BigInt.asUintN(112, n);
+    n >>= 112n;
+    const token0SaleRate = BigInt.asUintN(112, n);
+    return {
+        token0SaleRate,
+        token1SaleRate,
+    };
+}
+var TwammPoolState;
+(function (TwammPoolState) {
+    function fromPoolInitialization(state) {
+        return {
+            fullRangePoolState: full_range_1.FullRangePoolState.fromPoolInitialization(state),
+            token0SaleRate: 0n,
+            token1SaleRate: 0n,
+            lastExecutionTime: BigInt(state.blockHeader.timestamp),
+            virtualOrderDeltas: [],
+        };
+    }
+    TwammPoolState.fromPoolInitialization = fromPoolInitialization;
+    function fromQuoter(data) {
+        const liquidity = data.liquidity.toBigInt();
+        const sqrtRatioFloat = data.sqrtRatio.toBigInt();
+        return {
+            fullRangePoolState: {
+                sqrtRatio: (0, sqrt_ratio_1.floatSqrtRatioToFixed)(sqrtRatioFloat),
+                liquidity,
+            },
+            token0SaleRate: data.saleRateToken0.toBigInt(),
+            token1SaleRate: data.saleRateToken1.toBigInt(),
+            lastExecutionTime: data.lastVirtualOrderExecutionTime.toBigInt(),
+            virtualOrderDeltas: data.saleRateDeltas.map(srd => ({
+                time: srd.time.toBigInt(),
+                saleRateDelta0: srd.saleRateDelta0.toBigInt(),
+                saleRateDelta1: srd.saleRateDelta1.toBigInt(),
+            })),
+        };
+    }
+    TwammPoolState.fromQuoter = fromQuoter;
+    function fromSwappedEvent(oldState, ev) {
+        const clonedState = structuredClone(oldState);
+        clonedState.fullRangePoolState.liquidity = ev.liquidityAfter;
+        clonedState.fullRangePoolState.sqrtRatio = ev.sqrtRatioAfter;
+        return clonedState;
+    }
+    TwammPoolState.fromSwappedEvent = fromSwappedEvent;
+    function fromPositionUpdatedEvent(oldState, liquidityDelta) {
+        if (liquidityDelta === 0n) {
+            return null;
+        }
+        const clonedState = structuredClone(oldState);
+        clonedState.fullRangePoolState.liquidity += liquidityDelta;
+        return clonedState;
+    }
+    TwammPoolState.fromPositionUpdatedEvent = fromPositionUpdatedEvent;
+    function fromVirtualOrdersExecutedEvent(oldState, ev, timestamp) {
+        const clonedState = structuredClone(oldState);
+        clonedState.lastExecutionTime = timestamp;
+        clonedState.token0SaleRate = ev.token0SaleRate;
+        clonedState.token1SaleRate = ev.token1SaleRate;
+        const virtualOrderDeltas = clonedState.virtualOrderDeltas;
+        for (let virtualOrder = virtualOrderDeltas[0]; typeof virtualOrder !== 'undefined'; virtualOrder = virtualOrderDeltas[0]) {
+            if (virtualOrder.time > timestamp) {
+                break;
+            }
+            virtualOrderDeltas.shift();
+        }
+        return clonedState;
+    }
+    TwammPoolState.fromVirtualOrdersExecutedEvent = fromVirtualOrdersExecutedEvent;
+    function fromOrderUpdatedEvent(oldState, [startTime, endTime], orderSaleRateDelta, isToken1) {
+        if (orderSaleRateDelta === 0n) {
+            return null;
+        }
+        const clonedState = structuredClone(oldState);
+        const virtualOrderDeltas = clonedState.virtualOrderDeltas;
+        let startIndex = 0;
+        for (const [time, saleRateDelta] of [
+            [startTime, orderSaleRateDelta],
+            [endTime, -orderSaleRateDelta],
+        ]) {
+            if (time > clonedState.lastExecutionTime) {
+                let idx = findOrderIndex(virtualOrderDeltas, time, startIndex);
+                if (idx < 0) {
+                    idx = ~idx;
+                    virtualOrderDeltas.splice(idx, 0, {
+                        time,
+                        saleRateDelta0: 0n,
+                        saleRateDelta1: 0n,
+                    });
+                }
+                const virtualOrderDelta = virtualOrderDeltas[idx];
+                virtualOrderDelta[`saleRateDelta${isToken1 ? '1' : '0'}`] +=
+                    saleRateDelta;
+                if (virtualOrderDelta.saleRateDelta0 === 0n &&
+                    virtualOrderDelta.saleRateDelta1 === 0n) {
+                    virtualOrderDeltas.splice(idx, 1);
+                    startIndex = idx;
+                }
+                else {
+                    startIndex = idx + 1;
+                }
+            }
+            else {
+                clonedState[`token${isToken1 ? '1' : '0'}SaleRate`] += saleRateDelta;
+            }
+        }
+        return clonedState;
+    }
+    TwammPoolState.fromOrderUpdatedEvent = fromOrderUpdatedEvent;
+    function findOrderIndex(virtualOrderDeltas, searchTime, startIndex = 0) {
+        let l = startIndex, r = virtualOrderDeltas.length - 1;
+        while (l <= r) {
+            const mid = Math.floor((l + r) / 2);
+            const midOrderTime = virtualOrderDeltas[mid].time;
+            if (midOrderTime === searchTime) {
+                return mid;
+            }
+            else if (midOrderTime < searchTime) {
+                l = mid + 1;
+            }
+            else {
+                r = mid - 1;
+            }
+        }
+        return ~l; // Bitwise NOT of the insertion point
+    }
+})(TwammPoolState || (exports.TwammPoolState = TwammPoolState = {}));
+//# sourceMappingURL=twamm.js.map