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

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

@@ -355,7 +355,10 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
       );
 
       for (let i = 0; i < poolsToFetch.length; i++) {
-        await poolsToFetch[i].setup(blockNumber, poolStates[i] as any);
+        await poolsToFetch[i].setup(
+          poolStates.blockNumber,
+          poolStates.states[i] as any,
+        );
         this.eventPools.push(poolsToFetch[i]);
       }
       return unavailablePools;
@@ -405,7 +408,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
     amounts: bigint[],
     pools: string[],
     indexes: [number, number, number][],
-    blockNumber: number,
+    blockNumber: number | 'latest',
   ) {
     const chunks = amounts.length - 1;
     const srcAmount = amounts[chunks]!;
@@ -439,9 +442,6 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
       })),
     );
 
-    //const data = await this.multi.methods
-    //  .tryAggregate(false, calldata.flat())
-    //  .call({}, 'latest');
     const data = (
       await Promise.all(
         calldata.map(async poolCalldata => {
@@ -449,7 +449,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
             const result = await Utils.timeoutPromise<MultiResult<any>[]>(
               this.dexHelper.multiContract.methods
                 .tryAggregate(false, poolCalldata)
-                .call({}, 'latest'),
+                .call({}, blockNumber),
               2000,
               `Timed out multicall for curve pool ${poolCalldata[0].target}`,
             );
@@ -515,7 +515,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
     let pool = this.getPoolByAddress(exchange);
     if (!pool) {
       throw new Error(
-        `Error_${this.dexKey}_getRatesEvent pool is not initialised`,
+        `Error_${this.dexKey}_getRatesEvent pool is not initialized`,
       );
     }
 
@@ -704,7 +704,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
           amountsWithUnitAndFee,
           onChainPools,
           onChainPoolIndexes,
-          blockNumber,
+          'latest',
         );
         _prices = _prices.concat(pricesOnChain);
       }
@@ -934,7 +934,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
       [],
     );
 
-    return this.dexHelper.multiWrapper!.tryAggregate(true, calls);
+    return this.dexHelper.multiWrapper.tryAggregate(true, calls);
   }
 
   async fetchAllPools() {
@@ -943,7 +943,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
       // the balances array in the pool as it was a mess to have each curve abi
       // Some have balances[uint128] some have balances[uint256]
       // One of the consequence for such a hack is below for ETH Pools
-      // TODO: below can be highly optimised
+      // TODO: below can be highly optimized
       // * we don't need to query token decimals every iteration
       // * we can use the decimals from the tokens list using the api
 
@@ -976,7 +976,7 @@ export class CurveV1 extends SimpleExchange implements IDex<CurveV1Data> {
         [],
       );
 
-      const results = await this.dexHelper.multiWrapper!.tryAggregate(
+      const results = await this.dexHelper.multiWrapper.tryAggregate(
         true,
         calls,
       );

package/src/dex/curve-v1/pools/curve-metapool.ts

@@ -3,7 +3,10 @@ import { Interface } from '@ethersproject/abi';
 import BigNumber from 'bignumber.js';
 import { Logger } from 'log4js';
 import { Address, Log } from '../../../types';
-import { StatefulEventSubscriber } from '../../../stateful-event-subscriber';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../../stateful-event-subscriber';
 import { DeepReadonly } from 'ts-essentials';
 import { PoolState as BasepoolState } from './curve-pool';
 import { ThreePool } from './3pool';
@@ -196,8 +199,14 @@ export abstract class CurveMetapool extends StatefulEventSubscriber<MetapoolStat
   }
 
   async setup(blockNumber: number, poolState: MetapoolState | null = null) {
-    if (!poolState) poolState = await this.generateState(blockNumber);
-    if (blockNumber) this.setState(poolState, blockNumber);
+    if (!poolState) {
+      const poolStateWithBn = await this.generateState(blockNumber);
+      poolState = poolStateWithBn.state as MetapoolState;
+      blockNumber = poolStateWithBn.blockNumber;
+    }
+    if (blockNumber) {
+      this.setState(poolState, blockNumber);
+    }
   }
 
   protected getRates() {
@@ -207,10 +216,17 @@ export abstract class CurveMetapool extends StatefulEventSubscriber<MetapoolStat
 
   async generateState(
     blockNumber: number | 'latest' = 'latest',
-  ): Promise<Readonly<MetapoolState>> {
-    return (
-      await getManyPoolStates([this], this.dexHelper.multiContract, blockNumber)
-    )[0] as MetapoolState;
+  ): Promise<StateWithBlock<MetapoolState>> {
+    const results = await getManyPoolStates(
+      [this],
+      this.dexHelper.multiContract,
+      blockNumber,
+    );
+
+    return {
+      blockNumber: results.blockNumber,
+      state: results.states[0] as MetapoolState,
+    };
     // const getBalancesCalls = _.range(0, this.N_COINS).map<MultiCallParams<BigNumber>>(n => ({
     //   target: this.address,
     //   callData: this.poolIface.encodeFunctionData('balances', [n]),

package/src/dex/curve-v1/pools/curve-pool.ts

@@ -3,7 +3,10 @@ import { Interface } from '@ethersproject/abi';
 import BigNumber from 'bignumber.js';
 import { Logger } from 'log4js';
 import { Address, Log } from '../../../types';
-import { StatefulEventSubscriber } from '../../../stateful-event-subscriber';
+import {
+  StatefulEventSubscriber,
+  StateWithBlock,
+} from '../../../stateful-event-subscriber';
 import { DeepReadonly } from 'ts-essentials';
 // import { getManyPoolStates } from './getstate-multicall';
 import { BN_0, BN_1, BN_POWS } from '../../../bignumber-constants';
@@ -102,9 +105,18 @@ export abstract class CurvePool extends StatefulEventSubscriber<PoolState> {
     return _state;
   }
 
-  async setup(blockNumber: number, poolState: PoolState | null = null) {
-    if (!poolState) poolState = await this.generateState(blockNumber);
-    if (blockNumber) this.setState(poolState, blockNumber);
+  async setup(
+    blockNumber: number,
+    poolState: DeepReadonly<PoolState> | null = null,
+  ) {
+    if (!poolState) {
+      const poolStateWithBn = await this.generateState(blockNumber);
+      poolState = poolStateWithBn.state;
+      blockNumber = poolStateWithBn.blockNumber;
+    }
+    if (blockNumber) {
+      this.setState(poolState, blockNumber);
+    }
   }
 
   protected getRates() {
@@ -114,10 +126,19 @@ export abstract class CurvePool extends StatefulEventSubscriber<PoolState> {
 
   async generateState(
     blockNumber: number | 'latest' = 'latest',
-  ): Promise<Readonly<PoolState>> {
-    return (
-      await getManyPoolStates([this], this.dexHelper.multiContract, blockNumber)
-    )[0];
+  ): Promise<StateWithBlock<PoolState>> {
+    const resultsWithBn = await getManyPoolStates(
+      [this],
+      this.dexHelper.multiContract,
+      blockNumber,
+    );
+
+    const state = resultsWithBn.states[0];
+
+    return {
+      blockNumber: resultsWithBn.blockNumber,
+      state,
+    };
   }
 
   handleNewParameters(event: any, state: PoolState, log: Log): PoolState {

package/src/dex/curve-v1/pools/getstate-multicall.ts

@@ -2,15 +2,21 @@ import { CurveMetapool, MetapoolState } from './curve-metapool';
 import { CurvePool, PoolState } from './curve-pool';
 import _ from 'lodash';
 import { erc20Iface } from '../../../lib/utils-interfaces';
-import { bigNumberify, stringify } from '../../../utils';
+import { bigNumberify, blockAndTryAggregate, stringify } from '../../../utils';
+import { MultiCallInput } from '../../../types';
 
 const strbnify = (val: any) => bigNumberify(stringify(val));
 
+type _GetManyPoolStatesResult = {
+  blockNumber: number;
+  states: (PoolState | Partial<MetapoolState>)[];
+};
+
 async function _getManyPoolStates(
   pools: (CurvePool | CurveMetapool)[],
   multi: any,
   blockNumber: number | 'latest' = 'latest',
-): Promise<(PoolState | Partial<MetapoolState>)[]> {
+): Promise<_GetManyPoolStatesResult> {
   const calldata = _(pools)
     .map((pool: CurvePool | CurveMetapool) => [
       {
@@ -54,62 +60,80 @@ async function _getManyPoolStates(
     ])
     .flattenDeep()
     .filter(a => !!a)
-    .value();
+    .value() as MultiCallInput[];
+
+  const results = await blockAndTryAggregate(
+    true,
+    multi,
+    calldata,
+    blockNumber,
+  );
 
-  const data = await multi.methods.aggregate(calldata).call({}, blockNumber);
+  const data = results.results;
 
   let p = 0;
-  return pools.map((pool: CurvePool | CurveMetapool) => {
-    const _state = {
-      admin_fee: strbnify(
-        pool.poolIface.decodeFunctionResult(
-          'admin_fee',
-          data.returnData[p++],
-        )[0],
-      ),
-      fee: strbnify(
-        pool.poolIface.decodeFunctionResult('fee', data.returnData[p++])[0],
-      ),
-      A: strbnify(
-        pool.poolIface.decodeFunctionResult('A', data.returnData[p++])[0],
-      ),
-      supply: strbnify(
-        erc20Iface.decodeFunctionResult('totalSupply', data.returnData[p++])[0],
-      ),
-      balances: _.range(0, pool.N_COINS).map(i =>
-        strbnify(
+  return {
+    blockNumber: results.blockNumber,
+    states: pools.map((pool: CurvePool | CurveMetapool) => {
+      const _state = {
+        admin_fee: strbnify(
           pool.poolIface.decodeFunctionResult(
-            'balances',
-            data.returnData[p++],
+            'admin_fee',
+            data[p++].returnData,
           )[0],
         ),
-      ),
-    };
-    return (pool as CurveMetapool).basepool
-      ? {
-          ..._state,
-          base_cache_updated: strbnify(
-            pool.poolIface.decodeFunctionResult(
-              'base_cache_updated',
-              data.returnData[p++],
-            )[0],
-          ),
-          base_virtual_price: strbnify(
+        fee: strbnify(
+          pool.poolIface.decodeFunctionResult('fee', data[p++].returnData)[0],
+        ),
+        A: strbnify(
+          pool.poolIface.decodeFunctionResult('A', data[p++].returnData)[0],
+        ),
+        supply: strbnify(
+          erc20Iface.decodeFunctionResult(
+            'totalSupply',
+            data[p++].returnData,
+          )[0],
+        ),
+        balances: _.range(0, pool.N_COINS).map(i =>
+          strbnify(
             pool.poolIface.decodeFunctionResult(
-              'base_virtual_price',
-              data.returnData[p++],
+              'balances',
+              data[p++].returnData,
             )[0],
           ),
-        }
-      : _state;
-  });
+        ),
+      };
+      return (pool as CurveMetapool).basepool
+        ? {
+            ..._state,
+            base_cache_updated: strbnify(
+              pool.poolIface.decodeFunctionResult(
+                'base_cache_updated',
+                data[p++].returnData,
+              )[0],
+            ),
+            base_virtual_price: strbnify(
+              pool.poolIface.decodeFunctionResult(
+                'base_virtual_price',
+                data[p++].returnData,
+              )[0],
+            ),
+          }
+        : _state;
+    }),
+  };
 }
 
+type GetManyPoolStatesResult = {
+  blockNumber: number;
+  states: (PoolState | MetapoolState)[];
+};
+
 export async function getManyPoolStates(
   pools: (CurvePool | CurveMetapool)[],
   multi: any,
   blockNumber: number | 'latest' = 'latest',
-): Promise<(PoolState | MetapoolState)[]> {
+): Promise<GetManyPoolStatesResult> {
   const _poolsMap = _.reduce(
     pools,
     (
@@ -123,7 +147,7 @@ export async function getManyPoolStates(
     },
     {},
   );
-  const _poolStates = await _getManyPoolStates(
+  const _poolStatesWithBn = await _getManyPoolStates(
     Object.values(_poolsMap),
     multi,
     blockNumber,
@@ -136,21 +160,24 @@ export async function getManyPoolStates(
       add: string,
       i: number,
     ) => {
-      acc[add] = _poolStates[i];
+      acc[add] = _poolStatesWithBn.states[i];
       return acc;
     },
     {},
   );
 
-  return _.map(pools, (pool: CurvePool | CurveMetapool) =>
-    (pool as CurveMetapool).basepool
-      ? ({
-          ..._poolStatesMap[pool.address.toLowerCase()],
-          basepool:
-            _poolStatesMap[
-              (pool as CurveMetapool).basepool.address.toLowerCase()
-            ],
-        } as MetapoolState)
-      : (_poolStatesMap[pool.address.toLowerCase()] as PoolState),
-  );
+  return {
+    blockNumber: _poolStatesWithBn.blockNumber,
+    states: _.map(pools, (pool: CurvePool | CurveMetapool) =>
+      (pool as CurveMetapool).basepool
+        ? ({
+            ..._poolStatesMap[pool.address.toLowerCase()],
+            basepool:
+              _poolStatesMap[
+                (pool as CurveMetapool).basepool.address.toLowerCase()
+              ],
+          } as MetapoolState)
+        : (_poolStatesMap[pool.address.toLowerCase()] as PoolState),
+    ),
+  };
 }

package/src/dex/curve-v1-factory/curve-v1-factory.ts

@@ -155,7 +155,7 @@ export class CurveV1Factory
     );
   }
 
-  async initializePricing(blockNumber: number) {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
     // This is only to start timer, each pool is initialized with updated state
     this.poolManager.initializePollingPools();
     await this.fetchFactoryPools(blockNumber);
@@ -163,7 +163,7 @@ export class CurveV1Factory
   }
 
   async initializeCustomPollingPools(
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
     // We don't want to initialize state for PoolTracker. It doesn't make any sense
     initializeInitialState: boolean = true,
   ) {
@@ -299,7 +299,7 @@ export class CurveV1Factory
   }
 
   async fetchFactoryPools(
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
     // Variable initializeInitialState is only for poolTracker. We don't want to keep state updated with scheduler
     // We just want to initialize factory pools and send request to CurveAPI
     // Other values are not used
@@ -310,7 +310,7 @@ export class CurveV1Factory
     }
 
     // There is no scenario when we need to call initialize custom pools without factory pools
-    // So I put it here to not forget call, because custom pools must be initialised before factory pools
+    // So I put it here to not forget call, because custom pools must be initialized before factory pools
     // This function may be called multiple times, but will execute only once
     await this.initializeCustomPollingPools(
       blockNumber,

package/src/dex/curve-v1-factory/curve-v1-pool-manager.ts

@@ -104,7 +104,7 @@ export class CurveV1FactoryPoolManager {
   async initializeIndividualPollingPoolState(
     identifier: string,
     isSrcFeeOnTransferTokenToBeExchanged: boolean,
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
   ) {
     const pool = this.getPool(identifier, isSrcFeeOnTransferTokenToBeExchanged);
     if (pool === null) {

package/src/dex/curve-v1-factory/state-polling-pools/custom-pool-polling.ts

@@ -209,7 +209,7 @@ export class CustomBasePoolForFactory extends PoolPollingBase {
 
   parseMultiResultsToStateValues(
     multiOutputs: MulticallReturnedTypes[],
-    blockNumber: number,
+    blockNumber: number | 'latest',
     updatedAtMs: number,
   ): PoolState {
     const A = multiOutputs[0] as bigint;

package/src/dex/curve-v1-factory/state-polling-pools/factory-pool-polling.ts

@@ -98,7 +98,7 @@ export class FactoryStateHandler extends PoolPollingBase {
 
   parseMultiResultsToStateValues(
     multiOutputs: MulticallReturnedTypes[],
-    blockNumber: number,
+    blockNumber: number | 'latest',
     updatedAtMs: number,
   ): PoolState {
     const [A, fees, balances] = multiOutputs as [bigint, bigint[], bigint[]];

package/src/dex/curve-v1-factory/state-polling-pools/polling-manager.ts

@@ -14,7 +14,7 @@ export class StatePollingManager {
   static async fetchAndSetStatesFromRPC(
     dexHelper: IDexHelper,
     pools: PoolPollingBase[],
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
   ): Promise<PoolState[]> {
     if (pools.length === 0) {
       return [];
@@ -31,17 +31,6 @@ export class StatePollingManager {
       })
       .flat();
 
-    let _blockNumber = blockNumber;
-    if (_blockNumber === undefined) {
-      // If we were not given with blockNumber, set state blockNumber to 0,
-      // that is indicating that block number was the latest.
-      // If we request here latest blockNumber and try to send query, we frequently
-      // hit problem with late nodes. Some node may give us blockNumber 10,
-      // but when trying to do query we may hit node that is only on 9 blocknumber
-      // And it is a problem. Especially on Optimism and Avalanche.
-      _blockNumber = 0;
-    }
-
     const result = await dexHelper.multiWrapper.aggregate(
       callDatas,
       blockNumber,
@@ -54,7 +43,7 @@ export class StatePollingManager {
     for (const [i, p] of pools.entries()) {
       const newState = p.parseMultiResultsToStateValues(
         result.slice(lastStart, lastStart + poolResultDividers[i]),
-        _blockNumber,
+        blockNumber,
         updatedAt,
       );
       p.setState(newState);
@@ -69,7 +58,7 @@ export class StatePollingManager {
     logger: Logger,
     dexHelper: IDexHelper,
     pools: PoolPollingBase[],
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
   ) {
     const dexKey = pools.length > 0 ? pools[0].dexKey : 'CurveV1Factory';
     try {
@@ -113,7 +102,7 @@ export class StatePollingManager {
     logger: Logger,
     dexHelper: IDexHelper,
     pools: PoolPollingBase[],
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
   ) {
     const dexKey = pools.length > 0 ? pools[0].dexKey : 'CurveV1Factory';
     const poolsForRPCUpdate: PoolPollingBase[] = [];
@@ -187,7 +176,7 @@ export class StatePollingManager {
     logger: Logger,
     dexHelper: IDexHelper,
     pools: PoolPollingBase[],
-    blockNumber?: number,
+    blockNumber: number | 'latest' = 'latest',
     liquidityUpdateFunc?: Function,
   ) {
     if (pools.length === 0) {

package/src/dex/curve-v1-factory/state-polling-pools/pool-polling-base.ts

@@ -77,7 +77,7 @@ export abstract class PoolPollingBase {
 
   abstract parseMultiResultsToStateValues(
     multiOutputs: MulticallReturnedTypes[],
-    blockNumber: number,
+    blockNumber: number | 'latest',
     updatedAtMs: number,
   ): PoolState;
 

package/src/dex/curve-v1-factory/types.ts

@@ -45,7 +45,7 @@ export type PoolConstants = {
 };
 
 export type PoolState = {
-  blockNumber: number;
+  blockNumber: number | 'latest';
   updatedAtMs: number;
   A: bigint; // factory get_A()
   balances: bigint[]; // factory get_balances()

package/src/dex/generic-rfq/generic-rfq.ts

@@ -53,7 +53,9 @@ export class GenericRFQ extends ParaSwapLimitOrders {
     this.rateFetcher = new RateFetcher(dexHelper, config, dexKey, this.logger);
   }
 
-  async initializePricing(blockNumber: number): Promise<void> {
+  async initializePricing(
+    blockNumber: number | 'latest' = 'latest',
+  ): Promise<void> {
     await this.rateFetcher.initialize();
     if (!this.dexHelper.config.isSlave) {
       this.rateFetcher.start();

package/src/dex/generic-rfq/utils.ts

@@ -53,7 +53,7 @@ export const checkOrder = async (
     },
   ]);
 
-  const balance = balances[0];
+  const balance = balances.balances[0];
 
   const makerAmountBigInt = BigInt(order.makerAmount);
   const makerBalance = BigInt(balance.amounts[DEFAULT_ID_ERC20_AS_STRING]);

package/src/dex/gmx/gmx.ts

@@ -56,7 +56,7 @@ export class GMX extends SimpleExchange implements IDex<GMXData> {
   // Initialize pricing is called once in the start of
   // pricing service. It is intended to setup the integration
   // for pricing requests.
-  async initializePricing(blockNumber: number) {
+  async initializePricing(blockNumber: number | 'latest' = 'latest') {
     const config = await GMXEventPool.getConfig(
       this.params,
       blockNumber,

package/src/dex/gmx/pool.ts

@@ -100,10 +100,15 @@ export class GMXEventPool extends ComposedEventSubscriber<PoolState> {
 
   async getStateOrGenerate(blockNumber: number): Promise<Readonly<PoolState>> {
     const evenState = this.getState(blockNumber);
-    if (evenState) return evenState;
-    const onChainState = await this.generateState(blockNumber);
-    this.setState(onChainState, blockNumber);
-    return onChainState;
+    if (evenState) {
+      return evenState;
+    }
+
+    const onChainStateWithBn = await this.generateState(blockNumber);
+
+    this.setState(onChainStateWithBn.state, onChainStateWithBn.blockNumber);
+
+    return onChainStateWithBn.state;
   }
 
   async getMaxAmountIn(_tokenIn: Address, _tokenOut: Address): Promise<bigint> {

package/src/dex/idex.ts

@@ -137,7 +137,7 @@ export interface IDexPricing<ExchangeData> {
   // pricing service. It is intended to setup the integration
   // for pricing requests. It is optional for a DEX to
   // implement this function
-  initializePricing?(blockNumber: number): AsyncOrSync<void>;
+  initializePricing?(blockNumber: number | 'latest'): AsyncOrSync<void>;
 
   // Returns the list of contract adapters (name and index)
   // for a buy/sell. Return null if there are no adapters.

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

@@ -1,5 +1,6 @@
 import { DeepReadonly } from 'ts-essentials';
 import { Logger } from '../../types';
+import { StateWithBlock } from '../../stateful-event-subscriber';
 import { ComposedEventSubscriber } from '../../composed-event-subscriber';
 import { IDexHelper } from '../../dex-helper/idex-helper';
 import { lens } from '../../lens';
@@ -17,7 +18,7 @@ export class JarvisV6EventPool extends ComposedEventSubscriber<PoolState> {
     protected dexHelper: IDexHelper,
     logger: Logger,
     public poolConfig: PoolConfig,
-    public priceFeedAdress: Address,
+    public priceFeedAddress: Address,
     public poolInterface: Interface,
     public priceFeedContract: Contract,
   ) {
@@ -56,12 +57,22 @@ export class JarvisV6EventPool extends ComposedEventSubscriber<PoolState> {
    * should be generated
    * @returns state of the event subscriber at blocknumber
    */
-  async generateState(blockNumber: number): Promise<Readonly<PoolState>> {
-    return (
-      await getOnChainState(this.dexHelper, [this.poolConfig], blockNumber, {
+  async generateState(
+    blockNumber: number | 'latest',
+  ): Promise<StateWithBlock<PoolState>> {
+    const { blockNumber: _blockNumber, state } = await getOnChainState(
+      this.dexHelper,
+      [this.poolConfig],
+      blockNumber,
+      {
         poolInterface: this.poolInterface,
         priceFeedContract: this.priceFeedContract,
-      })
-    )[0];
+      },
+    );
+
+    return {
+      blockNumber: _blockNumber,
+      state: state[0],
+    };
   }
 }