@paraswap/dex-lib 2.28.7 → 2.28.9-ramses-v2

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

@@ -826,6 +826,8 @@ export class BalancerV2
             prices: resOut.prices,
             data: {
               poolId: pool.id,
+              tokenIn: _from.address.toLowerCase(),
+              tokenOut: _to.address.toLowerCase(),
             },
             poolAddresses: [poolAddress],
             exchange: this.dexKey,

package/src/dex/balancer-v2/optimizer.ts

@@ -1,70 +1,83 @@
-import { UnoptimizedRate, OptimalSwapExchange } from '../../types';
-import { BalancerSwapV2 } from './types';
+import _ from 'lodash';
+import { UnoptimizedRate } from '../../types';
 import { SwapSide } from '../../constants';
 import { BalancerConfig } from './config';
-
-const MAX_UINT256 =
-  '115792089237316195423570985008687907853269984665640564039457584007913129639935';
-
-const AllBalancerV2Forks = Object.keys(BalancerConfig);
+import { OptimalSwap } from '@paraswap/core';
 
 export function balancerV2Merge(or: UnoptimizedRate): UnoptimizedRate {
-  const fixSwap = (
-    rawSwap: OptimalSwapExchange<any>[],
-    side: SwapSide,
-  ): OptimalSwapExchange<any>[] => {
-    const newBalancers: { [key: string]: OptimalSwapExchange<any> } = {};
-    let optimizedSwap = new Array<OptimalSwapExchange<any>>();
-    rawSwap.forEach((s: OptimalSwapExchange<any>) => {
-      const exchangeKey = s.exchange.toLowerCase();
-      if (AllBalancerV2Forks.some(d => d.toLowerCase() === exchangeKey)) {
-        if (!(exchangeKey in newBalancers)) {
-          newBalancers[exchangeKey] = {
-            exchange: s.exchange,
-            srcAmount: '0',
-            destAmount: '0',
-            percent: 0,
-            poolAddresses: [],
-            data: {
-              swaps: new Array<BalancerSwapV2>(),
-              gasUSD: '0',
-            },
-          };
-        }
-        newBalancers[exchangeKey].srcAmount = (
-          BigInt(newBalancers[exchangeKey].srcAmount) + BigInt(s.srcAmount)
+  const balancerForksList = Object.keys(BalancerConfig).map(b =>
+    b.toLowerCase(),
+  );
+  const fixSwap = (rawRate: OptimalSwap[], side: SwapSide): OptimalSwap[] => {
+    let lastExchange: false | OptimalSwap = false;
+    let optimizedRate = new Array<OptimalSwap>();
+    rawRate.forEach((s: OptimalSwap) => {
+      if (
+        s.swapExchanges.length !== 1 ||
+        !balancerForksList.includes(s.swapExchanges[0].exchange.toLowerCase())
+      ) {
+        lastExchange = false;
+        optimizedRate.push(s);
+      } else if (
+        lastExchange &&
+        lastExchange.swapExchanges[0].exchange.toLowerCase() ===
+          s.swapExchanges[0].exchange.toLowerCase() &&
+        _.last(
+          <any[]>lastExchange.swapExchanges[0].data.swaps,
+        )!.tokenOut.toLowerCase() ===
+          s.swapExchanges[0].data.tokenIn.toLowerCase()
+      ) {
+        const [lastExchangeSwap] = lastExchange.swapExchanges;
+        const [currentSwap] = s.swapExchanges;
+        lastExchangeSwap.srcAmount = (
+          BigInt(lastExchangeSwap.srcAmount) + BigInt(currentSwap.srcAmount)
         ).toString();
 
-        newBalancers[exchangeKey].destAmount = (
-          BigInt(newBalancers[exchangeKey].destAmount) + BigInt(s.destAmount)
+        lastExchangeSwap.destAmount = (
+          BigInt(lastExchangeSwap.destAmount) + BigInt(currentSwap.destAmount)
         ).toString();
 
-        newBalancers[exchangeKey].percent += s.percent;
-        newBalancers[exchangeKey].data.exchangeProxy = s.data.exchangeProxy;
-        newBalancers[exchangeKey].data.gasUSD = (
-          parseFloat(newBalancers[exchangeKey].data.gasUSD) +
-          parseFloat(s.data.gasUSD)
+        lastExchangeSwap.percent += currentSwap.percent;
+        lastExchangeSwap.data.gasUSD = (
+          parseFloat(lastExchangeSwap.data.gasUSD) +
+          parseFloat(currentSwap.data.gasUSD)
         ).toFixed(6);
 
-        newBalancers[exchangeKey].data.swaps.push({
-          poolId: s.data.poolId,
-          amount: side === SwapSide.SELL ? s.srcAmount : s.destAmount,
+        lastExchangeSwap.data.swaps.push({
+          poolId: currentSwap.data.poolId,
+          amount:
+            side === SwapSide.SELL
+              ? currentSwap.srcAmount
+              : currentSwap.destAmount,
+          tokenIn: currentSwap.data.tokenIn,
+          tokenOut: currentSwap.data.tokenOut,
         });
-        newBalancers[exchangeKey].poolAddresses!.push(s.poolAddresses![0]);
+        lastExchangeSwap.poolAddresses!.push(currentSwap.poolAddresses![0]);
       } else {
-        optimizedSwap.push(s);
+        lastExchange = _.cloneDeep(s);
+        lastExchange.swapExchanges[0].data = {};
+        lastExchange.swapExchanges[0].data.gasUSD =
+          s.swapExchanges[0].data.gasUSD;
+        lastExchange.swapExchanges[0].data.swaps = [
+          {
+            poolId: s.swapExchanges[0].data.poolId,
+            amount:
+              side === SwapSide.SELL
+                ? s.swapExchanges[0].srcAmount
+                : s.swapExchanges[0].destAmount,
+            tokenIn: s.swapExchanges[0].data.tokenIn,
+            tokenOut: s.swapExchanges[0].data.tokenOut,
+          },
+        ];
+        optimizedRate.push(lastExchange);
       }
     });
-    optimizedSwap = optimizedSwap.concat(Object.values(newBalancers));
-    return optimizedSwap;
+    return optimizedRate;
   };
 
   or.bestRoute = or.bestRoute.map(r => ({
     ...r,
-    swaps: r.swaps.map(s => ({
-      ...s,
-      swapExchanges: fixSwap(s.swapExchanges, or.side),
-    })),
+    swaps: fixSwap(r.swaps, or.side),
   }));
   return or;
 }

package/src/dex/balancer-v2/types.ts

@@ -82,6 +82,8 @@ export interface SubgraphPoolBase {
 export type BalancerSwapV2 = {
   poolId: string;
   amount: string;
+  tokenIn: string;
+  tokenOut: string;
 };
 
 export type OptimizedBalancerV2Data = {
@@ -139,6 +141,8 @@ export type BalancerV2DirectParam = [
 
 export type BalancerV2Data = {
   poolId: string;
+  tokenIn: string;
+  tokenOut: string;
 };
 
 export type DexParams = {

package/src/dex/curve-v1-factory/price-handlers/functions/calc_token_amount.ts

@@ -35,6 +35,38 @@ const customPlain3CoinThree: calc_token_amount = (
   return (diff * token_amount) / D0;
 };
 
+const factoryPlain2Basic: calc_token_amount = (
+  self: IPoolContext,
+  state: PoolState,
+  amounts: bigint[],
+  is_deposit: boolean,
+) => {
+  const { N_COINS } = self.constants;
+  const amp = state.A;
+  const balances = [...state.balances];
+  const D0 = self.get_D(self, balances, amp);
+  for (const i of _.range(N_COINS)) {
+    if (is_deposit) balances[i] += amounts[i];
+    else balances[i] -= amounts[i];
+  }
+  const D1 = self.get_D(self, balances, amp);
+
+  if (state.totalSupply === undefined) {
+    throw new Error(
+      `${self.IMPLEMENTATION_NAME} customPlain3CoinThree: totalSupply is not provided`,
+    );
+  }
+
+  const token_amount = state.totalSupply;
+  let diff = 0n;
+  if (is_deposit) {
+    diff = D1 - D0;
+  } else {
+    diff = D0 - D1;
+  }
+  return (diff * token_amount) / D0;
+};
+
 const customAvalanche3CoinLending: calc_token_amount = (
   self: IPoolContext,
   state: PoolState,
@@ -114,7 +146,7 @@ const implementations: Record<ImplementationNames, calc_token_amount> = {
   [ImplementationNames.FACTORY_META_USD_BALANCES_FRAX_USDC]: notImplemented,
 
   [ImplementationNames.FACTORY_PLAIN_2_BALANCES]: notImplemented,
-  [ImplementationNames.FACTORY_PLAIN_2_BASIC]: notImplemented,
+  [ImplementationNames.FACTORY_PLAIN_2_BASIC]: factoryPlain2Basic,
   [ImplementationNames.FACTORY_PLAIN_2_ETH]: notImplemented,
   [ImplementationNames.FACTORY_PLAIN_2_OPTIMIZED]: notImplemented,
 

package/src/dex/index.ts

@@ -69,6 +69,7 @@ import { SwaapV2 } from './swaap-v2/swaap-v2';
 import { SpiritSwapV3 } from './quickswap/spiritswap-v3';
 import { TraderJoeV21 } from './trader-joe-v2.1';
 import { PancakeswapV3 } from './pancakeswap-v3/pancakeswap-v3';
+import { RamsesV2 } from './ramses-v2/ramses-v2';
 import { Algebra } from './algebra/algebra';
 
 const LegacyDexes = [
@@ -137,6 +138,7 @@ const Dexes = [
   MaverickV1,
   Camelot,
   SwaapV2,
+  RamsesV2,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

package/src/dex/ramses-v2/config.ts

@@ -0,0 +1,31 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+const RAMSES_SUPPORTED_FEES = [10000n, 2500n, 500n, 100n];
+
+export const RamsesV2Config: DexConfigMap<DexParams> = {
+  RamsesV2: {
+    [Network.ARBITRUM]: {
+      factory: '0xAA2cd7477c451E703f3B9Ba5663334914763edF8',
+      deployer: '0xb3e423ab9cE6C03D98326A3A2a0D7D96b0829f22',
+      quoter: '0xAA20EFF7ad2F523590dE6c04918DaAE0904E3b20',
+      router: '0xAA23611badAFB62D37E7295A682D21960ac85A90',
+      supportedFees: RAMSES_SUPPORTED_FEES,
+      stateMulticall: '0x50EE4112Cab9c79812F23bE079aB3911395ACc8e',
+      uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
+      chunksCount: 10,
+      initHash:
+        '0x1565b129f2d1790f12d45301b9b084335626f0c92410bc43130763b69971135d',
+      subgraphURL:
+        'https://api.thegraph.com/subgraphs/name/ramsesexchange/concentrated-liquidity-graph',
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter01', index: 3 }],
+    [SwapSide.BUY]: [{ name: 'ArbitrumBuyAdapter', index: 2 }],
+  },
+};

package/src/dex/ramses-v2/constants.ts

@@ -0,0 +1,41 @@
+export const UNISWAPV3_TICK_GAS_COST = 24_000; // Ceiled
+export const UNISWAPV3_TICK_BASE_OVERHEAD = 75_000;
+export const UNISWAPV3_POOL_SEARCH_OVERHEAD = 10_000;
+
+// This is used for price calculation. If out of scope, return 0n
+export const TICK_BITMAP_TO_USE = 4n;
+
+// This is used to check if the state is still valid.
+export const TICK_BITMAP_BUFFER = 8n;
+
+export const MAX_PRICING_COMPUTATION_STEPS_ALLOWED = 128;
+
+export const UNISWAPV3_SUBGRAPH_URL =
+  'https://api.thegraph.com/subgraphs/name/ramsesexchange/concentrated-liquidity-graph';
+
+export const UNISWAPV3_EFFICIENCY_FACTOR = 3;
+
+export const ZERO_TICK_INFO = {
+  liquidityGross: 0n,
+  liquidityNet: 0n,
+  tickCumulativeOutside: 0n,
+  secondsPerLiquidityOutsideX128: 0n,
+  secondsOutside: 0n,
+  initialized: false,
+};
+
+export const ZERO_ORACLE_OBSERVATION = {
+  blockTimestamp: 0n,
+  tickCumulative: 0n,
+  secondsPerLiquidityCumulativeX128: 0n,
+  initialized: false,
+};
+
+export const OUT_OF_RANGE_ERROR_POSTFIX = `INVALID_TICK_BIT_MAP_RANGES`;
+
+export const DEFAULT_POOL_INIT_CODE_HASH = `0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54`;
+
+export enum DirectMethods {
+  directSell = 'directUniV3Swap',
+  directBuy = 'directUniV3Buy',
+}

package/src/dex/ramses-v2/contract-math/BitMath.ts

@@ -0,0 +1,90 @@
+import {
+  BI_MAX_UINT128,
+  BI_MAX_UINT16,
+  BI_MAX_UINT32,
+  BI_MAX_UINT64,
+  BI_MAX_UINT8,
+} from '../../../bigint-constants';
+import { _require } from '../../../utils';
+
+export class BitMath {
+  static mostSignificantBit(x: bigint): bigint {
+    _require(x > 0, '', { x }, 'x > 0');
+    let r = 0n;
+
+    if (x >= 0x100000000000000000000000000000000n) {
+      x >>= 128n;
+      r += 128n;
+    }
+    if (x >= 0x10000000000000000n) {
+      x >>= 64n;
+      r += 64n;
+    }
+    if (x >= 0x100000000n) {
+      x >>= 32n;
+      r += 32n;
+    }
+    if (x >= 0x10000n) {
+      x >>= 16n;
+      r += 16n;
+    }
+    if (x >= 0x100n) {
+      x >>= 8n;
+      r += 8n;
+    }
+    if (x >= 0x10n) {
+      x >>= 4n;
+      r += 4n;
+    }
+    if (x >= 0x4n) {
+      x >>= 2n;
+      r += 2n;
+    }
+    if (x >= 0x2n) r += 1n;
+
+    return r;
+  }
+
+  static leastSignificantBit(x: bigint): bigint {
+    _require(x > 0, '', { x }, 'x > 0');
+
+    let r = 255n;
+    if ((x & BI_MAX_UINT128) > 0n) {
+      r -= 128n;
+    } else {
+      x >>= 128n;
+    }
+    if ((x & BI_MAX_UINT64) > 0n) {
+      r -= 64n;
+    } else {
+      x >>= 64n;
+    }
+    if ((x & BI_MAX_UINT32) > 0n) {
+      r -= 32n;
+    } else {
+      x >>= 32n;
+    }
+    if ((x & BI_MAX_UINT16) > 0n) {
+      r -= 16n;
+    } else {
+      x >>= 16n;
+    }
+    if ((x & BI_MAX_UINT8) > 0n) {
+      r -= 8n;
+    } else {
+      x >>= 8n;
+    }
+    if ((x & 0xfn) > 0n) {
+      r -= 4n;
+    } else {
+      x >>= 4n;
+    }
+    if ((x & 0x3n) > 0n) {
+      r -= 2n;
+    } else {
+      x >>= 2n;
+    }
+    if ((x & 0x1n) > 0n) r -= 1n;
+    return r;
+  }
+}

package/src/dex/ramses-v2/contract-math/FixedPoint128.ts

@@ -0,0 +1,3 @@
+export class FixedPoint128 {
+  static readonly Q128 = 0x100000000000000000000000000000000n;
+}

package/src/dex/ramses-v2/contract-math/FixedPoint96.ts

@@ -0,0 +1,4 @@
+export class FixedPoint96 {
+  static readonly RESOLUTION = 96n;
+  static readonly Q96 = 0x1000000000000000000000000n;
+}

package/src/dex/ramses-v2/contract-math/FullMath.ts

@@ -0,0 +1,30 @@
+import { BI_MAX_UINT256 } from '../../../bigint-constants';
+import { _require } from '../../../utils';
+
+export class FullMath {
+  static mulDiv(a: bigint, b: bigint, denominator: bigint) {
+    const result = (a * b) / denominator;
+
+    _require(
+      result <= BI_MAX_UINT256,
+      '',
+      { result, BI_MAX_UINT: BI_MAX_UINT256 },
+      'result <= BI_MAX_UINT',
+    );
+
+    return result;
+  }
+
+  static mulDivRoundingUp(a: bigint, b: bigint, denominator: bigint) {
+    const result = (a * b + denominator - 1n) / denominator;
+
+    _require(
+      result <= BI_MAX_UINT256,
+      '',
+      { result, BI_MAX_UINT: BI_MAX_UINT256 },
+      'result <= BI_MAX_UINT',
+    );
+
+    return result;
+  }
+}

package/src/dex/ramses-v2/contract-math/LiquidityMath.ts

@@ -0,0 +1,17 @@
+import { _require } from '../../../utils';
+
+export class LiquidityMath {
+  static addDelta(x: bigint, y: bigint): bigint {
+    let z;
+    if (y < 0) {
+      const _y = BigInt.asUintN(128, -y);
+      z = x - _y;
+      _require(z < x, 'LS', { z, x, y, _y }, 'z < x');
+    } else {
+      const _y = BigInt.asUintN(128, y);
+      z = x + _y;
+      _require(z >= x, 'LA', { z, x, y, _y }, 'z >= x');
+    }
+    return z;
+  }
+}

package/src/dex/ramses-v2/contract-math/Oracle.ts

@@ -0,0 +1,226 @@
+import {
+  OracleObservation,
+  OracleObservationCandidates,
+  PoolState,
+} from '../types';
+import { _require } from '../../../utils';
+import { DeepReadonly } from 'ts-essentials';
+import { ZERO_ORACLE_OBSERVATION } from '../constants';
+
+function replaceUndefinedObservationWithZero(state: PoolState, index: number) {
+  if (state.observations[index] === undefined) {
+    state.observations[index] = { ...ZERO_ORACLE_OBSERVATION };
+  }
+}
+
+export class Oracle {
+  static transform(
+    state: DeepReadonly<PoolState>,
+    last: OracleObservation,
+    blockTimestamp: bigint,
+    tick: bigint,
+    liquidity: bigint,
+  ): OracleObservation {
+    const delta = blockTimestamp - last.blockTimestamp;
+    return {
+      blockTimestamp: state.blockTimestamp,
+      tickCumulative: last.tickCumulative + BigInt.asIntN(56, tick) * delta,
+      secondsPerLiquidityCumulativeX128:
+        last.secondsPerLiquidityCumulativeX128 +
+        (BigInt.asUintN(160, delta) << 128n) /
+          (liquidity > 0n ? liquidity : 1n),
+      initialized: true,
+    };
+  }
+
+  static write(
+    state: PoolState,
+    index: number,
+    blockTimestamp: bigint,
+    tick: bigint,
+    liquidity: bigint,
+    cardinality: number,
+    cardinalityNext: number,
+  ): [number, number] {
+    const last = state.observations[index];
+
+    if (last.blockTimestamp == state.blockTimestamp)
+      return [index, cardinality];
+
+    let indexUpdated = 0;
+    let cardinalityUpdated = 0;
+
+    if (cardinalityNext > cardinality && index == cardinality - 1) {
+      cardinalityUpdated = cardinalityNext;
+    } else {
+      cardinalityUpdated = cardinality;
+    }
+
+    indexUpdated = (index + 1) % cardinalityUpdated;
+
+    state.observations[indexUpdated] = Oracle.transform(
+      state,
+      last,
+      blockTimestamp,
+      tick,
+      liquidity,
+    );
+    if (indexUpdated !== index) {
+      delete state.observations[index];
+    }
+    return [indexUpdated, cardinalityUpdated];
+  }
+
+  static lte(time: bigint, a: bigint, b: bigint): boolean {
+    if (a <= time && b <= time) return a <= b;
+
+    const aAdjusted = a > time ? a : a + 2n ** 32n;
+    const bAdjusted = b > time ? b : b + 2n ** 32n;
+    return aAdjusted <= bAdjusted;
+  }
+
+  static binarySearch(
+    state: DeepReadonly<PoolState>,
+    time: bigint,
+    target: bigint,
+    index: number,
+    cardinality: number,
+  ): OracleObservationCandidates {
+    let l = (index + 1) % cardinality;
+    let r = l + cardinality - 1;
+    let i;
+
+    let beforeOrAt;
+    let atOrAfter;
+    while (true) {
+      i = (l + r) / 2;
+
+      beforeOrAt = state.observations[i % cardinality];
+
+      // we've landed on an uninitialized tick, keep searching higher (more recently)
+      if (!beforeOrAt.initialized) {
+        l = i + 1;
+        continue;
+      }
+
+      atOrAfter = state.observations[(i + 1) % cardinality];
+
+      const targetAtOrAfter = Oracle.lte(
+        time,
+        beforeOrAt.blockTimestamp,
+        target,
+      );
+
+      // check if we've found the answer!
+      if (targetAtOrAfter && Oracle.lte(time, target, atOrAfter.blockTimestamp))
+        break;
+
+      if (!targetAtOrAfter) r = i - 1;
+      else l = i + 1;
+    }
+    return { beforeOrAt, atOrAfter };
+  }
+
+  static getSurroundingObservations(
+    state: DeepReadonly<PoolState>,
+    time: bigint,
+    target: bigint,
+    tick: bigint,
+    index: number,
+    liquidity: bigint,
+    cardinality: number,
+  ): OracleObservationCandidates {
+    let beforeOrAt = state.observations[index];
+
+    if (Oracle.lte(time, beforeOrAt.blockTimestamp, target)) {
+      if (beforeOrAt.blockTimestamp === target) {
+        return { beforeOrAt, atOrAfter: beforeOrAt };
+      } else {
+        return {
+          beforeOrAt,
+          atOrAfter: Oracle.transform(
+            state,
+            beforeOrAt,
+            target,
+            tick,
+            liquidity,
+          ),
+        };
+      }
+    }
+
+    beforeOrAt = state.observations[(index + 1) % cardinality];
+    if (!beforeOrAt.initialized) beforeOrAt = state.observations[0];
+
+    _require(
+      Oracle.lte(time, beforeOrAt.blockTimestamp, target),
+      'OLD',
+      { time, beforeOrAtBlockTimestamp: beforeOrAt.blockTimestamp, target },
+      'Oracle.lte(time, beforeOrAt.blockTimestamp, target)',
+    );
+
+    return Oracle.binarySearch(state, time, target, index, cardinality);
+  }
+
+  static observeSingle(
+    state: DeepReadonly<PoolState>,
+    time: bigint,
+    secondsAgo: bigint,
+    tick: bigint,
+    index: number,
+    liquidity: bigint,
+    cardinality: number,
+  ): [bigint, bigint] {
+    if (secondsAgo == 0n) {
+      let last = state.observations[index];
+      if (last.blockTimestamp != time)
+        last = Oracle.transform(state, last, time, tick, liquidity);
+      return [last.tickCumulative, last.secondsPerLiquidityCumulativeX128];
+    }
+
+    const target = time - secondsAgo;
+
+    const { beforeOrAt, atOrAfter } = Oracle.getSurroundingObservations(
+      state,
+      time,
+      target,
+      tick,
+      index,
+      liquidity,
+      cardinality,
+    );
+
+    if (target === beforeOrAt.blockTimestamp) {
+      return [
+        beforeOrAt.tickCumulative,
+        beforeOrAt.secondsPerLiquidityCumulativeX128,
+      ];
+    } else if (target === atOrAfter.blockTimestamp) {
+      return [
+        atOrAfter.tickCumulative,
+        atOrAfter.secondsPerLiquidityCumulativeX128,
+      ];
+    } else {
+      const observationTimeDelta =
+        atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
+      const targetDelta = target - beforeOrAt.blockTimestamp;
+      return [
+        beforeOrAt.tickCumulative +
+          ((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) /
+            observationTimeDelta) *
+            targetDelta,
+        beforeOrAt.secondsPerLiquidityCumulativeX128 +
+          BigInt.asUintN(
+            160,
+            (BigInt.asUintN(
+              256,
+              atOrAfter.secondsPerLiquidityCumulativeX128 -
+                beforeOrAt.secondsPerLiquidityCumulativeX128,
+            ) *
+              targetDelta) /
+              observationTimeDelta,
+          ),
+      ];
+    }
+  }
+}