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

package/src/dex/jarvis-v6/jarvis-v6.ts

@@ -93,22 +93,21 @@ export class JarvisV6
   // 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) {
-    const poolStates = await getOnChainState(
-      this.dexHelper,
-      this.poolConfigs,
-      blockNumber,
-      {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
+    const { blockNumber: _blockNumber, state: poolStates } =
+      await getOnChainState(this.dexHelper, this.poolConfigs, blockNumber, {
         poolInterface: this.poolInterface,
         priceFeedContract: this.priceFeedContract,
-      },
-    );
+      });
 
     await Promise.all(
       this.poolConfigs.map(async (pool, index) => {
         const eventPool = this.eventPools[pool.address.toLowerCase()];
-        await eventPool.initialize(blockNumber, {
-          state: poolStates[index],
+        await eventPool.initialize(_blockNumber, {
+          stateWithBn: {
+            state: poolStates[index],
+            blockNumber: _blockNumber,
+          },
         });
       }),
     );
@@ -145,10 +144,13 @@ export class JarvisV6
     blockNumber: number,
   ): Promise<PoolState> {
     const eventState = pool.getState(blockNumber);
-    if (eventState) return eventState;
-    const onChainState = await pool.generateState(blockNumber);
-    pool.setState(onChainState, blockNumber);
-    return onChainState;
+    if (eventState) {
+      return eventState;
+    }
+
+    const onChainStateWithBn = await pool.generateState(blockNumber);
+    pool.setState(onChainStateWithBn.state, onChainStateWithBn.blockNumber);
+    return onChainStateWithBn.state;
   }
 
   // Returns pool prices for amounts.
@@ -162,7 +164,7 @@ export class JarvisV6
     amounts: bigint[],
     side: SwapSide,
     blockNumber: number,
-    limitPools?: string[], // unusued since DEX is constant price, safe to reuse pools
+    limitPools?: string[], // unused since DEX is constant price, safe to reuse pools
   ): Promise<null | ExchangePrices<JarvisV6Data>> {
     if (side !== SwapSide.SELL) return null;
 

package/src/dex/jarvis-v6/utils.ts

@@ -6,6 +6,7 @@ import { getBigIntPow } from '../../utils';
 import { JarvisSwapFunctions, PoolConfig, PoolState } from './types';
 import { Interface } from '@ethersproject/abi';
 import { Contract } from 'web3-eth-contract';
+import { StateWithBlock } from '../../stateful-event-subscriber';
 
 export const THIRTY_MINUTES = 60 * 30;
 
@@ -18,27 +19,38 @@ export async function getOnChainState(
     priceFeedContract,
     poolInterface,
   }: { priceFeedContract: Contract; poolInterface: Interface },
-): Promise<PoolState[]> {
+): Promise<StateWithBlock<PoolState[]>> {
+  const _blockNumber =
+    blockNumber === 'latest'
+      ? await dexHelper.web3Provider.eth.getBlockNumber()
+      : blockNumber;
+
+  // These two calls can not be packed into multicall because Jarvis contract
+  // is callable either from Jarvis or EOA. If you try to call from Multicall,
+  // it will fail
   const [pricesFeedValues, poolFeePercentages] = await Promise.all([
     _getPricesFeedValues(
       dexHelper,
       poolConfigs,
-      blockNumber,
+      _blockNumber,
       priceFeedContract,
     ),
-    _getPoolFeePercentages(dexHelper, poolConfigs, blockNumber, poolInterface),
+    _getPoolFeePercentages(dexHelper, poolConfigs, _blockNumber, poolInterface),
   ]);
 
-  return poolConfigs.map((_, index) => ({
-    priceFeed: pricesFeedValues[index],
-    pool: poolFeePercentages[index],
-  }));
+  return {
+    blockNumber: _blockNumber,
+    state: poolConfigs.map((_, index) => ({
+      priceFeed: pricesFeedValues[index],
+      pool: poolFeePercentages[index],
+    })),
+  };
 }
 
 async function _getPoolFeePercentages(
   dexHelper: IDexHelper,
   poolConfigs: PoolConfig[],
-  blockNumber: number | 'latest',
+  blockNumber: number,
   poolInterface: Interface,
 ) {
   const multiContract = dexHelper.multiContract;
@@ -65,7 +77,7 @@ async function _getPoolFeePercentages(
 async function _getPricesFeedValues(
   dexHelper: IDexHelper,
   poolConfigs: PoolConfig[],
-  blockNumber: number | 'latest',
+  blockNumber: number,
   priceFeedContract: Contract,
 ) {
   const pairList = poolConfigs.map(pool =>

package/src/dex/kyberdmm/kyberdmm.ts

@@ -251,7 +251,10 @@ export class KyberDmm
       pair.pools[poolAddress] = pool;
       pool.addressesSubscribed.push(poolAddress);
       await pool.initialize(blockNumber, {
-        state: poolData,
+        stateWithBn: {
+          state: poolData,
+          blockNumber,
+        },
       });
     }
   }

package/src/dex/kyberdmm/pool.ts

@@ -3,10 +3,13 @@ import { DeepReadonly } from 'ts-essentials';
 import kyberDmmPoolABI from '../../abi/kyberdmm/kyber-dmm-pool.abi.json';
 import { getFee, getRFactor } from './fee-formula';
 import { KyberDmmAbiEvents, TradeInfo } from './types';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../stateful-event-subscriber';
 import { Address, BlockHeader, Log, Logger, Token } from '../../types';
 import { IDexHelper } from '../../dex-helper/idex-helper';
-import { BI_POWS } from '../../bigint-constants';
+import { blockAndTryAggregate } from '../../utils';
 
 export type KyberDmmPools = { [poolAddress: string]: KyberDmmPool };
 
@@ -113,7 +116,6 @@ export class KyberDmmPool extends StatefulEventSubscriber<KyberDmmPoolState> {
           },
         };
     }
-    return null;
   }
 
   isAmpPool(): boolean {
@@ -122,10 +124,12 @@ export class KyberDmmPool extends StatefulEventSubscriber<KyberDmmPoolState> {
 
   async generateState(
     blockNumber: number | 'latest' = 'latest',
-  ): Promise<DeepReadonly<KyberDmmPoolState>> {
-    const data: { returnData: any[] } =
-      await this.dexHelper.multiContract.methods
-        .aggregate([
+  ): Promise<StateWithBlock<KyberDmmPoolState>> {
+    const { results: data, blockNumber: _blockNumber } =
+      await blockAndTryAggregate(
+        true,
+        this.dexHelper.multiContract,
+        [
           {
             target: this.poolAddress,
             callData: iface.encodeFunctionData('getTradeInfo', []),
@@ -134,18 +138,19 @@ export class KyberDmmPool extends StatefulEventSubscriber<KyberDmmPoolState> {
             target: this.poolAddress,
             callData: iface.encodeFunctionData('getVolumeTrendData', []),
           },
-        ])
-        .call({}, blockNumber);
+        ],
+        blockNumber,
+      );
 
     const [reserves0, reserves1, vReserves0, vReserves1] = coder
-      .decode(['uint256', 'uint256', 'uint256', 'uint256'], data.returnData[0])
+      .decode(['uint256', 'uint256', 'uint256', 'uint256'], data[0].returnData)
       .map(a => BigInt(a.toString()));
 
     const [shortEMA, longEMA, , lastTradeBlock] = coder
-      .decode(['uint256', 'uint256', 'uint128', 'uint256'], data.returnData[1])
+      .decode(['uint256', 'uint256', 'uint128', 'uint256'], data[1].returnData)
       .map(a => BigInt(a.toString()));
 
-    if (blockNumber == 'latest')
+    if (blockNumber === 'latest')
       blockNumber = await this.dexHelper.web3Provider.eth.getBlockNumber();
 
     const prevBlockData: { returnData: any[] } =
@@ -166,19 +171,22 @@ export class KyberDmmPool extends StatefulEventSubscriber<KyberDmmPoolState> {
       .map(a => BigInt(a.toString()));
 
     return {
-      trendData: {
-        shortEMA,
-        longEMA,
-        lastBlockVolume,
-        lastTradeBlock,
-      },
-      reserves: {
-        reserves0,
-        reserves1,
-        vReserves0,
-        vReserves1,
+      blockNumber,
+      state: {
+        trendData: {
+          shortEMA,
+          longEMA,
+          lastBlockVolume,
+          lastTradeBlock,
+        },
+        reserves: {
+          reserves0,
+          reserves1,
+          vReserves0,
+          vReserves1,
+        },
+        ampBps: this.ampBps,
       },
-      ampBps: this.ampBps,
     };
   }
 }

package/src/dex/maker-psm/maker-psm.ts

@@ -14,8 +14,15 @@ import {
 } from '../../types';
 import { SwapSide, Network } from '../../constants';
 import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
-import { getDexKeysWithNetwork, getBigIntPow } from '../../utils';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../stateful-event-subscriber';
+import {
+  getDexKeysWithNetwork,
+  getBigIntPow,
+  blockAndTryAggregate,
+} from '../../utils';
 import { IDex } from '../../dex/idex';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import { MakerPsmData, PoolState, PoolConfig } from './types';
@@ -37,7 +44,7 @@ async function getOnChainState(
   poolConfigs: PoolConfig[],
   vatAddress: Address,
   blockNumber: number | 'latest',
-): Promise<PoolState[]> {
+): Promise<StateWithBlock<PoolState[]>> {
   const callData = poolConfigs
     .map(c => [
       {
@@ -55,30 +62,35 @@ async function getOnChainState(
     ])
     .flat();
 
-  const res = await multiContract.methods
-    .aggregate(callData)
-    .call({}, blockNumber);
+  const { blockNumber: _blockNumber, results: res } =
+    await blockAndTryAggregate(true, multiContract, callData, blockNumber);
 
   let i = 0;
-  return poolConfigs.map(c => {
-    const tin = bigIntify(
-      psmInterface.decodeFunctionResult('tin', res.returnData[i++])[0],
-    );
-    const tout = bigIntify(
-      psmInterface.decodeFunctionResult('tout', res.returnData[i++])[0],
-    );
-    const ilks = vatInterface.decodeFunctionResult('ilks', res.returnData[i++]);
-    const Art = bigIntify(ilks.Art);
-    const line = bigIntify(ilks.line);
-    const rate = bigIntify(ilks.rate);
-    return {
-      tin,
-      tout,
-      Art,
-      line,
-      rate,
-    };
-  });
+  return {
+    blockNumber: _blockNumber,
+    state: poolConfigs.map(c => {
+      const tin = bigIntify(
+        psmInterface.decodeFunctionResult('tin', res[i++].returnData)[0],
+      );
+      const tout = bigIntify(
+        psmInterface.decodeFunctionResult('tout', res[i++].returnData)[0],
+      );
+      const ilks = vatInterface.decodeFunctionResult(
+        'ilks',
+        res[i++].returnData,
+      );
+      const Art = bigIntify(ilks.Art);
+      const line = bigIntify(ilks.line);
+      const rate = bigIntify(ilks.rate);
+      return {
+        tin,
+        tout,
+        Art,
+        line,
+        rate,
+      };
+    }),
+  };
 }
 
 export class MakerPsmEventPool extends StatefulEventSubscriber<PoolState> {
@@ -174,15 +186,20 @@ export class MakerPsmEventPool extends StatefulEventSubscriber<PoolState> {
    * should be generated
    * @returns state of the event subscriber at blocknumber
    */
-  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
-    return (
-      await getOnChainState(
-        this.dexHelper.multiContract,
-        [this.poolConfig],
-        this.vatAddress,
-        blockNumber,
-      )
-    )[0];
+  async generateState(
+    blockNumber: number | 'latest',
+  ): Promise<StateWithBlock<PoolState>> {
+    const { blockNumber: _blockNumber, state } = await getOnChainState(
+      this.dexHelper.multiContract,
+      [this.poolConfig],
+      this.vatAddress,
+      blockNumber,
+    );
+
+    return {
+      blockNumber: _blockNumber,
+      state: state[0],
+    };
   }
 }
 
@@ -223,18 +240,22 @@ export class MakerPsm extends SimpleExchange implements IDex<MakerPsmData> {
     );
   }
 
-  async initializePricing(blockNumber: number) {
-    const poolStates = await getOnChainState(
-      this.dexHelper.multiContract,
-      this.poolConfigs,
-      this.vatAddress,
-      blockNumber,
-    );
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
+    const { blockNumber: _blockNumber, state: poolStates } =
+      await getOnChainState(
+        this.dexHelper.multiContract,
+        this.poolConfigs,
+        this.vatAddress,
+        blockNumber,
+      );
     await Promise.all(
       this.poolConfigs.map(async (p, i) => {
         const eventPool = this.eventPools[p.gem.address.toLowerCase()];
-        await eventPool.initialize(blockNumber, {
-          state: poolStates[i],
+        await eventPool.initialize(_blockNumber, {
+          stateWithBn: {
+            state: poolStates[i],
+            blockNumber: _blockNumber,
+          },
         });
       }),
     );
@@ -276,9 +297,10 @@ export class MakerPsm extends SimpleExchange implements IDex<MakerPsmData> {
   ): Promise<PoolState> {
     const eventState = pool.getState(blockNumber);
     if (eventState) return eventState;
-    const onChainState = await pool.generateState(blockNumber);
-    pool.setState(onChainState, blockNumber);
-    return onChainState;
+    const onChainStateWithBn = await pool.generateState(blockNumber);
+    pool.setState(onChainStateWithBn.state, onChainStateWithBn.blockNumber);
+
+    return onChainStateWithBn.state;
   }
 
   computePrices(
@@ -523,7 +545,7 @@ export class MakerPsm extends SimpleExchange implements IDex<MakerPsmData> {
       : [];
     if (!validPoolConfigs.length) return [];
 
-    const poolStates = await getOnChainState(
+    const { state: poolStates } = await getOnChainState(
       this.dexHelper.multiContract,
       validPoolConfigs,
       this.vatAddress,

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

@@ -1,24 +1,21 @@
-import { AbiCoder, Interface } from '@ethersproject/abi';
-import { assert, DeepReadonly } from 'ts-essentials';
+import _ from 'lodash';
+import { Interface } from '@ethersproject/abi';
+import { DeepReadonly } from 'ts-essentials';
 import { Log, Logger, Address } from '../../types';
-import { StatefulEventSubscriber } from '../../stateful-event-subscriber';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../stateful-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
-import { Bin, MaverickV1Data, PoolState } from './types';
+import { Bin, PoolState } from './types';
 import { Token } from '../../types';
-
-import { MaverickV1Config } from './config';
-import PoolABI from '../../abi/maverick-v1/pool.json';
-import PoolInspectorABI from '../../abi/maverick-v1/pool-inspector.json';
-
-import { Contract } from 'web3-eth-contract';
-import { AbiItem } from 'web3-utils';
 import { MaverickBinMap } from './maverick-math/maverick-bin-map';
 import { MaverickPoolMath } from './maverick-math/maverick-pool-math';
 import { MMath } from './maverick-math/maverick-basic-math';
-
-import * as _ from 'lodash';
 import { BI_POWS } from '../../bigint-constants';
-import { getBigIntPow } from '../../utils';
+import { blockAndTryAggregate, getBigIntPow } from '../../utils';
+import PoolABI from '../../abi/maverick-v1/pool.json';
+import PoolInspectorABI from '../../abi/maverick-v1/pool-inspector.json';
 
 (BigInt.prototype as any).toJSON = function () {
   return this.toString();
@@ -32,8 +29,7 @@ export class MaverickV1EventPool extends StatefulEventSubscriber<PoolState> {
   logDecoder: (log: Log) => any;
 
   addressesSubscribed: string[];
-  poolContract: Contract;
-  poolInspectorContract: Contract;
+  poolInspectorInterface: Interface;
   poolMath: MaverickPoolMath;
 
   constructor(
@@ -68,15 +64,7 @@ export class MaverickV1EventPool extends StatefulEventSubscriber<PoolState> {
 
     this.addressesSubscribed = [address];
 
-    this.poolInspectorContract = new this.dexHelper.web3Provider.eth.Contract(
-      PoolInspectorABI as AbiItem[],
-      this.inspectorAddress,
-    );
-
-    this.poolContract = new this.dexHelper.web3Provider.eth.Contract(
-      PoolABI as AbiItem[],
-      this.address,
-    );
+    this.poolInspectorInterface = new Interface(PoolInspectorABI);
 
     this.poolMath = new MaverickPoolMath(
       parentName,
@@ -128,16 +116,37 @@ export class MaverickV1EventPool extends StatefulEventSubscriber<PoolState> {
    * should be generated
    * @returns state of the event subscriber at blocknumber
    */
-  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
-    const rawBins = await this.poolInspectorContract.methods['getActiveBins'](
-      this.address,
-      0,
-      0,
-    ).call({}, blockNumber);
-    const rawState = await this.poolContract.methods['getState']().call(
-      {},
+  async generateState(
+    blockNumber: number | 'latest',
+  ): Promise<Readonly<StateWithBlock<PoolState>>> {
+    const { blockNumber: _blockNumber, results } = await blockAndTryAggregate(
+      true,
+      this.dexHelper.multiContract,
+      [
+        {
+          target: this.inspectorAddress,
+          callData: this.poolInspectorInterface.encodeFunctionData(
+            'getActiveBins',
+            [this.address, 0, 0],
+          ),
+        },
+        {
+          target: this.address,
+          callData: this.poolInterface.encodeFunctionData('getState', []),
+        },
+      ],
       blockNumber,
     );
+
+    const rawBins = this.poolInspectorInterface.decodeFunctionResult(
+      'getActiveBins',
+      results[0].returnData,
+    );
+    const rawState = this.poolInterface.decodeFunctionResult(
+      'getState',
+      results[1].returnData,
+    );
+
     let binPositions: { [tick: string]: { [kind: string]: bigint } } = {};
     let bins: { [id: string]: Bin } = {};
     let binMap: { [id: string]: bigint } = {};
@@ -164,11 +173,14 @@ export class MaverickV1EventPool extends StatefulEventSubscriber<PoolState> {
     });
 
     return {
-      activeTick: BigInt(rawState.activeTick),
-      binCounter: BigInt(rawState.binCounter),
-      bins: bins,
-      binPositions: binPositions,
-      binMap: binMap,
+      blockNumber: await this.dexHelper.web3Provider.eth.getBlockNumber(),
+      state: {
+        activeTick: BigInt(rawState.activeTick),
+        binCounter: BigInt(rawState.binCounter),
+        bins: bins,
+        binPositions: binPositions,
+        binMap: binMap,
+      },
     };
   }
 

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

@@ -76,7 +76,7 @@ export class MaverickV1
       MaverickV1Config[this.dexKey][this.network].routerAddress;
   }
 
-  async setupEventPools(blockNumber: number) {
+  async setupEventPools(blockNumber: number | 'latest' = 'latest') {
     const pools = await this.fetchAllSubgraphPools();
     await Promise.all(
       pools.map(async (pool: any) => {
@@ -102,13 +102,14 @@ export class MaverickV1
           MaverickV1Config[this.dexKey][this.network].poolInspectorAddress,
           this.logger,
         );
-        const onChainState = await eventPool.generateState(blockNumber);
+        const { state: generatedState, blockNumber: generatedBlockNumber } =
+          await eventPool.generateState(blockNumber);
         if (blockNumber) {
-          eventPool.setState(onChainState, blockNumber);
+          eventPool.setState(generatedState, generatedBlockNumber);
           this.dexHelper.blockManager.subscribeToLogs(
             eventPool,
             eventPool.addressesSubscribed,
-            blockNumber,
+            generatedBlockNumber,
           );
         }
         this.pools[eventPool.address] = eventPool;
@@ -120,7 +121,7 @@ export class MaverickV1
   // 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.setupEventPools(blockNumber);
   }
 
@@ -224,8 +225,11 @@ export class MaverickV1
             try {
               let state = pool.getState(blockNumber);
               if (state === null) {
-                state = await pool.generateState(blockNumber);
-                pool.setState(state, blockNumber);
+                const {
+                  state: generatedState,
+                  blockNumber: generatedBlockNumber,
+                } = await pool.generateState(blockNumber);
+                pool.setState(generatedState, generatedBlockNumber);
               }
               if (state === null) {
                 this.logger.debug(
@@ -266,7 +270,7 @@ export class MaverickV1
               let gasCosts: number[] = dataList.map(
                 ([d, t]: [BigInt, number]) => {
                   if (d == 0n) return 0;
-                  // I think it is reasonable estimation assuming "kind" gas cost is almost everytime around 1
+                  // I think it is reasonable estimation assuming "kind" gas cost is almost every time around 1
                   return (
                     MAV_V1_BASE_GAS_COST +
                     (MAV_V1_TICK_GAS_COST + MAV_V1_KIND_GAS_COST) * t