@paraswap/dex-lib 2.16.0 → 2.16.1-generate-state-latest.0

package/src/dex/nerve/nerve-pool.ts

@@ -3,13 +3,17 @@ import { Interface, JsonFragment } from '@ethersproject/abi';
 import { DeepReadonly } from 'ts-essentials';
 import erc20ABI from '../../abi/erc20.json';
 import { Log, Logger } from '../../types';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../stateful-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import { EventHandler, NervePoolConfig, PoolState } from './types';
 import { NerveConfig } from './config';
 import { BlockHeader } from 'web3-eth';
 import { bigIntify, typeCastPoolState } from './utils';
 import { NervePoolMath } from './nerve-math';
+import { blockAndTryAggregate } from '../../utils';
 
 export class NerveEventPool extends StatefulEventSubscriber<PoolState> {
   readonly math: NervePoolMath;
@@ -125,7 +129,7 @@ export class NerveEventPool extends StatefulEventSubscriber<PoolState> {
 
   async generateState(
     blockNumber: number | 'latest' = 'latest',
-  ): Promise<DeepReadonly<PoolState>> {
+  ): Promise<StateWithBlock<PoolState>> {
     const calldata = _.flattenDeep([
       {
         target: this.address,
@@ -147,25 +151,30 @@ export class NerveEventPool extends StatefulEventSubscriber<PoolState> {
       })),
     ]);
 
-    const data = await this.dexHelper.multiContract.methods
-      .aggregate(calldata)
-      .call({}, blockNumber);
+    const results = await blockAndTryAggregate(
+      true,
+      this.dexHelper.multiContract,
+      calldata,
+      blockNumber,
+    );
+
+    const data = results.results;
 
     const [swapStorage, lpToken_supply, paused, balances] = [
-      this.poolIface.decodeFunctionResult('swapStorage', data.returnData[0]),
+      this.poolIface.decodeFunctionResult('swapStorage', data[0].returnData),
       bigIntify(
         this.lpTokenIface.decodeFunctionResult(
           'totalSupply',
-          data.returnData[1],
+          data[1].returnData,
         )[0]._hex,
       ),
-      this.poolIface.decodeFunctionResult('paused', data.returnData[2]),
+      this.poolIface.decodeFunctionResult('paused', data[2].returnData),
       _.flatten(
         _.range(3, this.numTokens + 3).map(i =>
           bigIntify(
             this.poolIface.decodeFunctionResult(
               'getTokenBalance',
-              data.returnData[i],
+              data[i].returnData,
             )[0]._hex,
           ),
         ),
@@ -173,27 +182,30 @@ export class NerveEventPool extends StatefulEventSubscriber<PoolState> {
     ];
 
     return {
-      initialA: bigIntify(swapStorage.initialA._hex),
-      futureA: bigIntify(swapStorage.futureA._hex),
-      initialATime: bigIntify(swapStorage.initialATime._hex),
-      futureATime: bigIntify(swapStorage.futureATime._hex),
-      // If we have swapFee or fee, use these values, otherwise set to zero
-      swapFee:
-        ((swapStorage.swapFee || swapStorage.fee) &&
-          bigIntify((swapStorage.swapFee || swapStorage.fee)._hex)) ||
-        0n,
-      adminFee: bigIntify(swapStorage.adminFee._hex),
-      defaultDepositFee:
-        swapStorage.defaultDepositFee &&
-        bigIntify(swapStorage.defaultDepositFee._hex),
-      defaultWithdrawFee:
-        swapStorage.defaultWithdrawFee &&
-        bigIntify(swapStorage.defaultWithdrawFee._hex),
-      lpToken_supply,
-      balances,
-      tokenPrecisionMultipliers: this.tokenPrecisionMultipliers,
-      isValid: true,
-      paused: paused[0],
+      blockNumber: results.blockNumber,
+      state: {
+        initialA: bigIntify(swapStorage.initialA._hex),
+        futureA: bigIntify(swapStorage.futureA._hex),
+        initialATime: bigIntify(swapStorage.initialATime._hex),
+        futureATime: bigIntify(swapStorage.futureATime._hex),
+        // If we have swapFee or fee, use these values, otherwise set to zero
+        swapFee:
+          ((swapStorage.swapFee || swapStorage.fee) &&
+            bigIntify((swapStorage.swapFee || swapStorage.fee)._hex)) ||
+          0n,
+        adminFee: bigIntify(swapStorage.adminFee._hex),
+        defaultDepositFee:
+          swapStorage.defaultDepositFee &&
+          bigIntify(swapStorage.defaultDepositFee._hex),
+        defaultWithdrawFee:
+          swapStorage.defaultWithdrawFee &&
+          bigIntify(swapStorage.defaultWithdrawFee._hex),
+        lpToken_supply,
+        balances,
+        tokenPrecisionMultipliers: this.tokenPrecisionMultipliers,
+        isValid: true,
+        paused: paused[0],
+      },
     };
   }
 

package/src/dex/nerve/nerve.ts

@@ -70,7 +70,10 @@ export class Nerve
     return Object.values(this.eventPools);
   }
 
-  async setupEventPool(poolConfig: NervePoolConfig, blockNumber: number) {
+  async setupEventPool(
+    poolConfig: NervePoolConfig,
+    blockNumber: number | 'latest' = 'latest',
+  ) {
     const poolIdentifier = Nerve.getIdentifier(this.dexKey, poolConfig.address);
 
     if (!poolConfig.isMetapool) {
@@ -93,7 +96,7 @@ export class Nerve
     }
   }
 
-  async initializePricing(blockNumber: number) {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
     await Promise.all(
       Object.values(this.poolConfigs).map(
         async poolConfig => await this.setupEventPool(poolConfig, blockNumber),
@@ -124,9 +127,10 @@ export class Nerve
           this.logger.info(
             `State for ${this.dexKey} pool ${eventPool.name} on ${this.network} is stale or invalid on block ${_blockNumber}. Generating new one`,
           );
-          const newState = await eventPool.generateState(_blockNumber);
-          eventPool.setState(newState, _blockNumber);
-          return { state: newState, pool: eventPool };
+          const newStateWithBn = await eventPool.generateState(_blockNumber);
+
+          eventPool.setState(newStateWithBn.state, newStateWithBn.blockNumber);
+          return { state: newStateWithBn.state, pool: eventPool };
         } else {
           return { state, pool: eventPool };
         }

package/src/dex/platypus/platypus.ts

@@ -71,7 +71,9 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
     this.logger = dexHelper.getLogger(`${dexKey}-${network}`);
   }
 
-  async generateConfigInfo(blockNumber: number): Promise<PlatypusConfigInfo> {
+  async generateConfigInfo(
+    blockNumber: number | 'latest',
+  ): Promise<PlatypusConfigInfo> {
     const cfgInfo: PlatypusConfigInfo = {
       poolAddresses: [],
       pools: {},
@@ -244,7 +246,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
     return cfgInfo;
   }
 
-  async init(blockNumber: number) {
+  async init(blockNumber: number | 'latest') {
     if (this.cfgInfo) return;
     this.cfgInfo = await this.generateConfigInfo(blockNumber);
   }
@@ -253,7 +255,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
   // pricing service. It is intended to setup the integration
   // for pricing requests. It is optional for a DEX to
   // implement this function
-  async initializePricing(blockNumber: number) {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
     await this.init(blockNumber);
     if (!this.cfgInfo)
       throw new Error(
@@ -329,7 +331,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
   }
 
   // Returns list of pool identifiers that can be used
-  // for a given swap. poolIdentifers must be unique
+  // for a given swap. poolIdentifiers must be unique
   // across DEXes. It is recommended to use
   // ${dexKey}_${poolAddress} as a poolIdentifier
   async getPoolIdentifiers(
@@ -385,8 +387,10 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
             ) => {
               let state = pool.getState(blockNumber);
               if (!state) {
-                state = await pool.generateState(blockNumber);
-                pool.setState(state, blockNumber);
+                const newState = await pool.generateState(blockNumber);
+
+                pool.setState(newState.state, newState.blockNumber);
+                state = newState.state;
               }
               if (state.params.paused) return null;
               const [unit, ...prices] = pool.computePrices(
@@ -426,7 +430,7 @@ export class Platypus extends SimpleExchange implements IDex<PlatypusData> {
 
   // Encode params required by the exchange adapter
   // Used for multiSwap, buy & megaSwap
-  // Hint: abiCoder.encodeParameter() couls be useful
+  // Hint: abiCoder.encodeParameter() could be useful
   getAdapterParam(
     srcToken: string,
     destToken: string,

package/src/dex/swaap-v1/config.ts

@@ -6,7 +6,7 @@ export const MAX_GAS_COST_ESTIMATION = 375 * 1000;
 export const SUBGRAPH_TIMEOUT = 1000 * 10;
 export const MAX_POOL_CNT = 1000;
 export const POOL_CACHE_TTL = 60 * 60; // 1hr
-export const RECCURING_POOL_FETCH_INTERVAL_MS = 12 * 3600 * 1000; // 12h (in ms)
+export const RECURRING_POOL_FETCH_INTERVAL_MS = 12 * 3600 * 1000; // 12h (in ms)
 
 export const SwaapV1Config: DexConfigMap<DexParams> = {
   SwaapV1: {

package/src/dex/swaap-v1/swaap-v1-pool.ts

@@ -11,7 +11,10 @@ import {
   OracleInitialData,
   ChainLinkData,
 } from './types';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../stateful-event-subscriber';
 import { Log, MultiCallInput, MultiCallOutput } from '../../types';
 import PoolABI from '../../abi/swaap-v1/pool.json';
 import ProxyABI from '../../abi/chainlink.json';
@@ -533,7 +536,7 @@ export class SwaapV1Pool extends StatefulEventSubscriber<SwaapV1PoolState> {
   }
 
   public async getTokensAndParameters(
-    blockNumber: number,
+    blockNumber: number | 'latest',
   ): Promise<[Address[], SwaapV1PoolParameters]> {
     const multiCallInputs: MultiCallInput[] = [
       {
@@ -886,28 +889,34 @@ export class SwaapV1Pool extends StatefulEventSubscriber<SwaapV1PoolState> {
   //function should not use any previous states to derive a new state, it should
   //generate one from scratch.
   public async generateState(
-    blockNumber?: number | 'latest',
-  ): Promise<DeepReadonly<SwaapV1PoolState>> {
-    if (blockNumber === 'latest' || blockNumber === undefined) {
-      blockNumber = await this.dexHelper.provider.getBlockNumber();
-    }
-
-    const [tokens, parameters] = await this.getTokensAndParameters(blockNumber);
+    blockNumber: number | 'latest',
+  ): Promise<StateWithBlock<SwaapV1PoolState>> {
+    const [_blockNumber, tokensAndParameters] = await Promise.all([
+      blockNumber === 'latest'
+        ? this.dexHelper.provider.getBlockNumber()
+        : blockNumber,
+      this.getTokensAndParameters(blockNumber),
+    ]);
+
+    const [tokens, parameters] = tokensAndParameters;
     const [proxies, liquidities] = await this.getProxiesAndLiquidities(
       tokens,
-      blockNumber,
+      _blockNumber,
     );
     const oracles = await this.getOraclesData(
       tokens,
       proxies,
       parameters,
-      blockNumber,
+      _blockNumber,
     );
 
     return {
-      parameters: parameters,
-      liquidities: liquidities,
-      oracles: oracles,
+      blockNumber: _blockNumber,
+      state: {
+        parameters: parameters,
+        liquidities: liquidities,
+        oracles: oracles,
+      },
     };
   }
 

package/src/dex/swaap-v1/swaap-v1.ts

@@ -8,7 +8,6 @@ import {
   SimpleExchangeParam,
   PoolLiquidity,
   Logger,
-  MultiCallInput,
 } from '../../types';
 import { SwapSide, Network, MAX_INT, MAX_UINT } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
@@ -21,9 +20,7 @@ import {
   SwaapV1Data,
   SwaapV1PoolState,
   SubgraphPoolBase,
-  SwaapV1ProxySwapArguments,
   SwaapV1PoolSwapArguments,
-  SwaapV1Swap,
 } from './types';
 import { SimpleExchange } from '../simple-exchange';
 import {
@@ -34,7 +31,7 @@ import {
   MAX_POOL_CNT,
   POOL_CACHE_TTL,
   MAX_GAS_COST_ESTIMATION,
-  RECCURING_POOL_FETCH_INTERVAL_MS,
+  RECURRING_POOL_FETCH_INTERVAL_MS,
 } from './config';
 import { SwaapV1Pool } from './swaap-v1-pool';
 import PoolABI from '../../abi/swaap-v1/pool.json';
@@ -74,18 +71,20 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
   // pricing service. It is intended to setup the integration
   // for pricing requests. It is optional for a DEX to
   // implement this function
-  async initializePricing(blockNumber: number) {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
     await this.getPools(blockNumber, true);
     setInterval(
-      () => this.getPools(null, false),
-      RECCURING_POOL_FETCH_INTERVAL_MS,
+      () => this.getPools(blockNumber, false),
+      RECURRING_POOL_FETCH_INTERVAL_MS,
     );
   }
 
-  async getPools(_blockNumber: number | null, init: boolean) {
-    const blockNumber = _blockNumber
-      ? _blockNumber
-      : await this.dexHelper.provider.getBlockNumber();
+  async getPools(_blockNumber: number | 'latest', init: boolean) {
+    const blockNumber =
+      _blockNumber === 'latest'
+        ? await this.dexHelper.provider.getBlockNumber()
+        : _blockNumber;
+
     const allPools = await this.fetchAllSubgraphPools(blockNumber);
 
     await SwaapV1.initPools(
@@ -93,12 +92,14 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
       blockNumber,
       Object.values(allPools),
     );
+
     if (!allPools)
       if (init) {
         throw new Error(
           'initializePricing: SwaapV1 cfgInfo still null after init',
         );
       }
+
     for (const poolConfig of allPools.values()) {
       if (
         init ||
@@ -155,7 +156,7 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
   }
 
   // Returns list of pool identifiers that can be used
-  // for a given swap. poolIdentifers must be unique
+  // for a given swap. poolIdentifiers must be unique
   // across DEXes. It is recommended to use
   // ${dexKey}_${poolAddress} as a poolIdentifier
   async getPoolIdentifiers(
@@ -172,7 +173,7 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
 
   // Encode params required by the exchange adapter
   // Used for multiSwap, buy & megaSwap
-  // Hint: abiCoder.encodeParameter() couls be useful
+  // Hint: abiCoder.encodeParameter() could be useful
   getAdapterParam(
     srcToken: string,
     destToken: string,
@@ -585,7 +586,13 @@ export class SwaapV1 extends SimpleExchange implements IDex<SwaapV1Data> {
       allowedPools.map(async poolAddress => {
         let state = this.eventPools[poolAddress].getState(blockNumber);
         if (!state) {
-          state = await this.eventPools[poolAddress].generateState(blockNumber);
+          const newStateWithBn = await this.eventPools[
+            poolAddress
+          ].generateState(blockNumber);
+          state = newStateWithBn.state;
+          blockNumber = newStateWithBn.blockNumber;
+
+          this.eventPools[poolAddress].setState(state, blockNumber);
         }
         let [unit, prices] = this.getPricesPool(
           from.address,

package/src/dex/synthetix/synthetix-state.ts

@@ -400,14 +400,14 @@ export class SynthetixState {
       await this.multiWrapper.tryAggregate<string | bigint>(
         true,
         this._buildInitialStateCallData(),
-        blockNumber,
+        blockNumber === undefined ? 'latest' : blockNumber,
       )
     ).map(d => d.returnData) as [
       Address,
       Address,
       bigint,
       bigint,
-      ...Address[]
+      ...Address[],
     ];
 
     const [
@@ -437,7 +437,7 @@ export class SynthetixState {
       Address,
       Address,
       bigint,
-      ...string[]
+      ...string[],
     ];
 
     _require(

package/src/dex/synthetix/synthetix.ts

@@ -87,15 +87,16 @@ export class Synthetix extends SimpleExchange implements IDex<SynthetixData> {
     return this.synthetixState.onchainConfigValues;
   }
 
-  async initializePricing(blockNumber: number) {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
+    const _blockNumber = blockNumber === 'latest' ? undefined : blockNumber;
     if (this.synthetixState.onchainConfigValuesWithUndefined === undefined) {
-      await this.synthetixState.updateOnchainConfigValues(blockNumber);
+      await this.synthetixState.updateOnchainConfigValues(_blockNumber);
     }
     if (!this.statePollingTimer) {
-      await this.synthetixState.updateOnchainState();
+      await this.synthetixState.updateOnchainState(_blockNumber);
       this.statePollingTimer = setInterval(async () => {
         try {
-          await this.synthetixState.updateOnchainState();
+          await this.synthetixState.updateOnchainState(_blockNumber);
           this.logger.info(
             `${this.dexKey}: onchain state was updated for network=${this.network}`,
           );

package/src/dex/uniswap-v2/uniswap-v2.ts

@@ -2,7 +2,10 @@ import { AbiCoder, Interface } from '@ethersproject/abi';
 import _ from 'lodash';
 import { AsyncOrSync, DeepReadonly } from 'ts-essentials';
 import erc20ABI from '../../abi/erc20.json';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import {
+  StateWithBlock,
+  StatefulEventSubscriber,
+} from '../../stateful-event-subscriber';
 import {
   AdapterExchangeParam,
   Address,
@@ -43,6 +46,7 @@ import {
   isETHAddress,
   prependWithOx,
   getBigIntPow,
+  blockAndTryAggregate,
 } from '../../utils';
 import uniswapV2ABI from '../../abi/uniswap-v2/uniswap-v2-pool.json';
 import uniswapV2factoryABI from '../../abi/uniswap-v2/uniswap-v2-factory.json';
@@ -137,7 +141,7 @@ export class UniswapV2EventPool extends StatefulEventSubscriber<UniswapV2PoolSta
 
   async generateState(
     blockNumber: number | 'latest' = 'latest',
-  ): Promise<DeepReadonly<UniswapV2PoolState>> {
+  ): Promise<StateWithBlock<UniswapV2PoolState>> {
     let calldata = [
       {
         target: this.poolAddress,
@@ -149,22 +153,29 @@ export class UniswapV2EventPool extends StatefulEventSubscriber<UniswapV2PoolSta
       calldata.push(this.feesMultiCallEntry!);
     }
 
-    const data: { returnData: any[] } =
-      await this.dexHelper.multiContract.methods
-        .aggregate(calldata)
-        .call({}, blockNumber);
+    const results = await blockAndTryAggregate(
+      true,
+      this.dexHelper.multiContract,
+      calldata,
+      blockNumber,
+    );
+
+    const data = results.results;
 
     const decodedData = coder.decode(
       ['uint112', 'uint112', 'uint32'],
-      data.returnData[0],
+      data[0].returnData,
     );
 
     return {
-      reserves0: decodedData[0].toString(),
-      reserves1: decodedData[1].toString(),
-      feeCode: this.dynamicFees
-        ? this.feesMultiCallDecoder!(data.returnData[1])
-        : this.feeCode,
+      blockNumber: results.blockNumber,
+      state: {
+        reserves0: decodedData[0].toString(),
+        reserves1: decodedData[1].toString(),
+        feeCode: this.dynamicFees
+          ? this.feesMultiCallDecoder!(data[1].returnData)
+          : this.feeCode,
+      },
     };
   }
 }
@@ -274,7 +285,10 @@ export class UniswapV2
     pair.pool.addressesSubscribed.push(pair.exchange!);
 
     await pair.pool.initialize(blockNumber, {
-      state: { reserves0, reserves1, feeCode },
+      stateWithBn: {
+        blockNumber: blockNumber,
+        state: { reserves0, reserves1, feeCode },
+      },
     });
   }
 

package/src/dex/uniswap-v3/uniswap-v3-pool.ts

@@ -5,6 +5,7 @@ import { ethers } from 'ethers';
 import { assert, DeepReadonly } from 'ts-essentials';
 import { Log, Logger, BlockHeader, Address } from '../../types';
 import {
+  StateWithBlock,
   InitializeStateOptions,
   StatefulEventSubscriber,
 } from '../../stateful-event-subscriber';
@@ -115,7 +116,7 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
   }
 
   async initialize(
-    blockNumber: number,
+    blockNumber: number | 'latest',
     options?: InitializeStateOptions<PoolState>,
   ) {
     await super.initialize(blockNumber, options);
@@ -128,7 +129,9 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
   ): Promise<DeepReadonly<PoolState> | null> {
     const newState = await super.processBlockLogs(state, logs, blockHeader);
     if (newState && !newState.isValid) {
-      return await this.generateState(blockHeader.number);
+      const newStateWithBn = await this.generateState('latest');
+      this.setState(newStateWithBn.state, newStateWithBn.blockNumber);
+      return newStateWithBn.state;
     }
     return newState;
   }
@@ -239,19 +242,17 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     return TICK_BITMAP_TO_USE + TICK_BITMAP_BUFFER;
   }
 
-  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
+  async generateState(
+    blockNumber: number | 'latest',
+  ): Promise<StateWithBlock<PoolState>> {
     const callData = this._getStateRequestCallData();
 
-    const [resBalance0, resBalance1, resState] =
-      await this.dexHelper.multiWrapper.tryAggregate<
+    const { results, blockNumber: _blockNumber } =
+      await this.dexHelper.multiWrapper.blockTryAggregateWithoutBatching<
         bigint | DecodedStateMultiCallResultWithRelativeBitmaps
-      >(
-        false,
-        callData,
-        blockNumber,
-        this.dexHelper.multiWrapper.defaultBatchSize,
-        false,
-      );
+      >(false, callData, blockNumber, false);
+
+    const [resBalance0, resBalance1, resState] = results;
 
     // Quite ugly solution, but this is the one that fits to current flow.
     // I think UniswapV3 callbacks subscriptions are complexified for no reason.
@@ -288,34 +289,37 @@ export class UniswapV3EventPool extends StatefulEventSubscriber<PoolState> {
     const requestedRange = this.getBitmapRangeToRequest();
 
     return {
-      pool: _state.pool,
-      blockTimestamp: bigIntify(_state.blockTimestamp),
-      slot0: {
-        sqrtPriceX96: bigIntify(_state.slot0.sqrtPriceX96),
-        tick: currentTick,
-        observationIndex: +_state.slot0.observationIndex,
-        observationCardinality: +_state.slot0.observationCardinality,
-        observationCardinalityNext: +_state.slot0.observationCardinalityNext,
-        feeProtocol: bigIntify(_state.slot0.feeProtocol),
-      },
-      liquidity: bigIntify(_state.liquidity),
-      fee: this.feeCode,
-      tickSpacing,
-      maxLiquidityPerTick: bigIntify(_state.maxLiquidityPerTick),
-      tickBitmap,
-      ticks,
-      observations,
-      isValid: true,
-      startTickBitmap,
-      lowestKnownTick:
-        (BigInt.asIntN(24, startTickBitmap - requestedRange) << 8n) *
-        tickSpacing,
-      highestKnownTick:
-        ((BigInt.asIntN(24, startTickBitmap + requestedRange) << 8n) +
-          BigInt.asIntN(24, 255n)) *
+      blockNumber: _blockNumber,
+      state: {
+        pool: _state.pool,
+        blockTimestamp: bigIntify(_state.blockTimestamp),
+        slot0: {
+          sqrtPriceX96: bigIntify(_state.slot0.sqrtPriceX96),
+          tick: currentTick,
+          observationIndex: +_state.slot0.observationIndex,
+          observationCardinality: +_state.slot0.observationCardinality,
+          observationCardinalityNext: +_state.slot0.observationCardinalityNext,
+          feeProtocol: bigIntify(_state.slot0.feeProtocol),
+        },
+        liquidity: bigIntify(_state.liquidity),
+        fee: this.feeCode,
         tickSpacing,
-      balance0,
-      balance1,
+        maxLiquidityPerTick: bigIntify(_state.maxLiquidityPerTick),
+        tickBitmap,
+        ticks,
+        observations,
+        isValid: true,
+        startTickBitmap,
+        lowestKnownTick:
+          (BigInt.asIntN(24, startTickBitmap - requestedRange) << 8n) *
+          tickSpacing,
+        highestKnownTick:
+          ((BigInt.asIntN(24, startTickBitmap + requestedRange) << 8n) +
+            BigInt.asIntN(24, 255n)) *
+          tickSpacing,
+        balance0,
+        balance1,
+      },
     };
   }