@paraswap/dex-lib 4.1.6 → 4.1.7-mwrappedm.0

package/src/dex/m-token/m-token-e2e.test.ts

@@ -0,0 +1,93 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { testE2E } from '../../../tests/utils-e2e';
+import { Tokens, Holders } from '../../../tests/constants-e2e';
+import { Network, ContractMethod, SwapSide } from '../../constants';
+import { StaticJsonRpcProvider } from '@ethersproject/providers';
+import { generateConfig } from '../../config';
+
+function testForNetwork(
+  network: Network,
+  dexKey: string,
+  tokenASymbol: string,
+  tokenBSymbol: string,
+  tokenAAmount: string,
+  tokenBAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [SwapSide.SELL, [ContractMethod.swapExactAmountIn]],
+    [SwapSide.BUY, [ContractMethod.swapExactAmountOut]],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        const isSell = side === SwapSide.SELL;
+
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenASymbol} -> ${tokenBSymbol}`, async () => {
+              await testE2E(
+                tokens[tokenASymbol],
+                tokens[tokenBSymbol],
+                holders[tokenASymbol],
+                isSell ? tokenAAmount : tokenBAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+
+            it(`${tokenBSymbol} -> ${tokenASymbol}`, async () => {
+              await testE2E(
+                tokens[tokenBSymbol],
+                tokens[tokenASymbol],
+                holders[tokenBSymbol],
+                isSell ? tokenBAmount : tokenAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('MWrappedM E2E', () => {
+  const dexKey = 'MWrappedM';
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+
+    const tokenASymbol: string = 'M';
+    const tokenBSymbol: string = 'WrappedM';
+
+    const tokenAAmount: string = '1000000000';
+    const tokenBAmount: string = '1000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      tokenASymbol,
+      tokenBSymbol,
+      tokenAAmount,
+      tokenBAmount,
+    );
+  });
+});

package/src/dex/m-token/m-token-integration.test.ts

@@ -0,0 +1,199 @@
+/* eslint-disable no-console */
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { DummyDexHelper } from '../../dex-helper/index';
+import { Network, SwapSide } from '../../constants';
+import { BI_POWS } from '../../bigint-constants';
+import { MToken } from './m-token';
+import { MWrappedM } from './m-wrapped-m';
+import {
+  checkPoolPrices,
+  checkPoolsLiquidity,
+  checkConstantPoolPrices,
+} from '../../../tests/utils';
+import { Tokens } from '../../../tests/constants-e2e';
+
+async function testPricingOnNetwork(
+  mWrappedM: MToken,
+  network: Network,
+  dexKey: string,
+  blockNumber: number,
+  srcTokenSymbol: string,
+  destTokenSymbol: string,
+  side: SwapSide,
+  amounts: bigint[],
+  funcNameToCheck: string,
+) {
+  const networkTokens = Tokens[network];
+
+  const pools = await mWrappedM.getPoolIdentifiers(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    side,
+    blockNumber,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Identifiers: `,
+    pools,
+  );
+
+  expect(pools.length).toBeGreaterThan(0);
+
+  const poolPrices = await mWrappedM.getPricesVolume(
+    networkTokens[srcTokenSymbol],
+    networkTokens[destTokenSymbol],
+    amounts,
+    side,
+    blockNumber,
+    pools,
+  );
+  console.log(
+    `${srcTokenSymbol} <> ${destTokenSymbol} Pool Prices: `,
+    poolPrices,
+  );
+
+  expect(poolPrices).not.toBeNull();
+  if (mWrappedM.hasConstantPriceLargeAmounts) {
+    checkConstantPoolPrices(poolPrices!, amounts, dexKey);
+  } else {
+    checkPoolPrices(poolPrices!, amounts, side, dexKey);
+  }
+
+  // Check if onchain pricing equals to calculated ones
+  checkPoolPrices(poolPrices!, amounts, side, dexKey);
+}
+
+describe('MWrappedM', function () {
+  const dexKey = 'MWrappedM';
+  let blockNumber: number;
+  let mWrappedM: MWrappedM;
+
+  describe('Mainnet', () => {
+    const network = Network.MAINNET;
+    const dexHelper = new DummyDexHelper(network);
+
+    const tokens = Tokens[network];
+
+    const srcTokenSymbol = 'M';
+    const destTokenSymbol = 'WrappedM';
+
+    // Don't forget to update relevant tokens in constant-e2e.ts
+
+    const amounts = [
+      0n,
+      1n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      2n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      3n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      4n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      5n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      6n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      7n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      8n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      9n * BI_POWS[tokens[srcTokenSymbol].decimals],
+      10n * BI_POWS[tokens[srcTokenSymbol].decimals],
+    ];
+
+    beforeAll(async () => {
+      blockNumber = await dexHelper.web3Provider.eth.getBlockNumber();
+      mWrappedM = new MWrappedM(network, dexKey, dexHelper);
+      if (mWrappedM.initializePricing) {
+        await mWrappedM.initializePricing();
+      }
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL M -> WrappedM', async function () {
+      await testPricingOnNetwork(
+        mWrappedM,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.SELL,
+        amounts,
+        '',
+      );
+    });
+
+    it('getPoolIdentifiers and getPricesVolume SELL WrappedM -> M', async function () {
+      await testPricingOnNetwork(
+        mWrappedM,
+        network,
+        dexKey,
+        blockNumber,
+        destTokenSymbol,
+        srcTokenSymbol,
+        SwapSide.SELL,
+        amounts,
+        '',
+      );
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY M -> WrappedM', async function () {
+      await testPricingOnNetwork(
+        mWrappedM,
+        network,
+        dexKey,
+        blockNumber,
+        srcTokenSymbol,
+        destTokenSymbol,
+        SwapSide.BUY,
+        amounts,
+        '',
+      );
+    });
+
+    it('getPoolIdentifiers and getPricesVolume BUY WrappedM -> M', async function () {
+      await testPricingOnNetwork(
+        mWrappedM,
+        network,
+        dexKey,
+        blockNumber,
+        destTokenSymbol,
+        srcTokenSymbol,
+        SwapSide.BUY,
+        amounts,
+        '',
+      );
+    });
+
+    it('getTopPoolsForToken: M', async function () {
+      const symbol = srcTokenSymbol;
+
+      const poolLiquidity = await mWrappedM.getTopPoolsForToken(
+        tokens[symbol].address,
+        10,
+      );
+      console.log(
+        `${symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(
+        poolLiquidity,
+        Tokens[network][symbol].address,
+        dexKey,
+      );
+    });
+
+    it('getTopPoolsForToken: WrappedM', async function () {
+      const symbol = destTokenSymbol;
+
+      const poolLiquidity = await mWrappedM.getTopPoolsForToken(
+        tokens[symbol].address,
+        10,
+      );
+      console.log(
+        `${symbol} Top Pools:`,
+        JSON.stringify(poolLiquidity, null, 2),
+      );
+
+      checkPoolsLiquidity(
+        poolLiquidity,
+        Tokens[network][symbol].address,
+        dexKey,
+      );
+    });
+  });
+});

package/src/dex/m-token/m-token.ts

@@ -0,0 +1,167 @@
+import { AsyncOrSync } from 'ts-essentials';
+import type {
+  Token,
+  Address,
+  ExchangePrices,
+  PoolPrices,
+  AdapterExchangeParam,
+  Logger,
+  PoolLiquidity,
+} from '../../types';
+import { SwapSide, Network } from '../../constants';
+import * as CALLDATA_GAS_COST from '../../calldata-gas-cost';
+import { IDex } from '../idex';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import type { MTokenData, DexParams } from './types';
+import { SimpleExchange } from '../simple-exchange';
+import { BI_POWS } from '../../bigint-constants';
+
+export class MToken extends SimpleExchange implements IDex<MTokenData> {
+  readonly hasConstantPriceLargeAmounts = true;
+
+  readonly needWrapNative = false;
+
+  readonly isFeeOnTransferSupported = false;
+
+  logger: Logger;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+    readonly config: DexParams,
+  ) {
+    super(dexHelper, dexKey);
+    this.logger = dexHelper.getLogger(dexKey);
+  }
+
+  // No initialization needed for constant price
+  async initializePricing() {}
+
+  // Legacy: was only used for V5
+  // Returns the list of contract adapters (name and index)
+  // for a buy/sell. Return null if there are no adapters.
+  getAdapters() {
+    return null;
+  }
+
+  // Returns list of pool identifiers that can be used
+  // for a given swap. poolIdentifiers must be unique
+  // across DEXes. It is recommended to use
+  // ${dexKey}_${poolAddress} as a poolIdentifier
+  async getPoolIdentifiers(
+    from: Token,
+    to: Token,
+    side: SwapSide,
+    blockNumber: number,
+  ): Promise<string[]> {
+    if (!this.ensureOrigin({ from, to })) {
+      return [];
+    }
+
+    return [`${this.dexKey}_${this.config.WrappedM.address}`];
+  }
+
+  // Returns pool prices for amounts.
+  // If limitPools is defined only pools in limitPools
+  // should be used. If limitPools is undefined then
+  // any pools can be used.
+  async getPricesVolume(
+    from: Token,
+    to: Token,
+    amounts: bigint[],
+    side: SwapSide,
+    blockNumber: number,
+    limitPools?: string[],
+  ): Promise<null | ExchangePrices<MTokenData>> {
+    if (!this.ensureOrigin({ from, to })) {
+      return null;
+    }
+
+    // 1:1 swap
+    // Amounts need no adjustment
+    const unitOut = BI_POWS[to.decimals];
+
+    return [
+      {
+        unit: unitOut,
+        prices: amounts,
+        data: {},
+        poolAddresses: [this.config.WrappedM.address],
+        exchange: this.dexKey,
+        gasCost: 70000,
+        poolIdentifier: this.dexKey,
+      },
+    ];
+  }
+
+  // Returns estimated gas cost of calldata for this DEX in multiSwap
+  getCalldataGasCost(poolPrices: PoolPrices<MTokenData>): number | number[] {
+    return CALLDATA_GAS_COST.DEX_NO_PAYLOAD;
+  }
+
+  // Encode params required by the exchange adapter
+  // V5: Used for multiSwap, buy & megaSwap
+  // V6: Not used, can be left blank
+  // Hint: abiCoder.encodeParameter() could be useful
+  getAdapterParam(
+    srcToken: string,
+    destToken: string,
+    srcAmount: string,
+    destAmount: string,
+    data: MTokenData,
+    side: SwapSide,
+  ): AdapterExchangeParam {
+    const exchange = this.config.WrappedM.address;
+    const payload = '0x';
+
+    return {
+      targetExchange: exchange,
+      payload,
+      networkFee: '0',
+    };
+  }
+
+  // Returns list of top pools based on liquidity. Max
+  // limit number pools should be returned.
+  async getTopPoolsForToken(
+    tokenAddress: Address,
+    limit: number,
+  ): Promise<PoolLiquidity[]> {
+    if (!this.isMOrWrappedM(tokenAddress)) {
+      return [];
+    }
+
+    const isM =
+      tokenAddress.toLowerCase() === this.config.MToken.address.toLowerCase();
+
+    return [
+      {
+        exchange: this.dexKey,
+        address: this.config.WrappedM.address,
+        connectorTokens: [isM ? this.config.WrappedM : this.config.MToken],
+        liquidityUSD: 1000000000, // Returning a big number to prefer this DEX
+      },
+    ];
+  }
+
+  // Checks if the token addresses is M or WrappedM
+  isMOrWrappedM(tokenAddress: Address): boolean {
+    return (
+      tokenAddress.toLowerCase() === this.config.MToken.address.toLowerCase() ||
+      tokenAddress.toLowerCase() === this.config.WrappedM.address.toLowerCase()
+    );
+  }
+
+  // Ensures that the token addresses are correct
+  ensureOrigin(args: Partial<{ from: Token; to: Token }>): boolean {
+    const areDifferentAddresses =
+      args?.from?.address?.toLowerCase() !== args?.to?.address?.toLowerCase();
+
+    return (
+      areDifferentAddresses &&
+      this.isMOrWrappedM(args?.from?.address || '') &&
+      this.isMOrWrappedM(args?.to?.address || '')
+    );
+  }
+}

package/src/dex/m-token/m-wrapped-m.ts

@@ -0,0 +1,68 @@
+import { Network, SwapSide } from '../../constants';
+import { getDexKeysWithNetwork } from '../../utils';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { MToken } from './m-token';
+import type {
+  Address,
+  DexExchangeParam,
+  NumberAsString,
+  Token,
+} from '../../types';
+import { Interface } from '@ethersproject/abi';
+import WRAPPED_M_ABI from '../../abi/m-token/WrappedM.abi.json';
+import { Config } from './config';
+
+export class MWrappedM extends MToken {
+  public static dexKeysWithNetwork: { key: string; networks: Network[] }[] =
+    getDexKeysWithNetwork(Config);
+
+  wrappedMInterface: Interface;
+
+  constructor(
+    readonly network: Network,
+    readonly dexKey: string,
+    readonly dexHelper: IDexHelper,
+  ) {
+    const config = Config[dexKey][network];
+    super(network, dexKey, dexHelper, config);
+
+    this.wrappedMInterface = new Interface(WRAPPED_M_ABI);
+  }
+
+  async getDexParam(
+    from: Address,
+    to: Address,
+    srcAmount: NumberAsString,
+    destAmount: NumberAsString,
+    recipient: Address,
+    data: {},
+    side: SwapSide,
+  ): Promise<DexExchangeParam> {
+    if (
+      !this.ensureOrigin({
+        from: { address: from } as Token,
+        to: { address: to } as Token,
+      })
+    ) {
+      throw new Error('Unexpected token addresses');
+    }
+
+    const fn =
+      from.toLowerCase() === this.config.MToken.address.toLowerCase()
+        ? 'wrap(address, uint256)'
+        : 'unwrap(address, uint256)';
+
+    const exchangeData = this.wrappedMInterface.encodeFunctionData(fn, [
+      recipient,
+      srcAmount,
+    ]);
+
+    return {
+      needWrapNative: false,
+      dexFuncHasRecipient: true,
+      exchangeData,
+      targetExchange: this.config.WrappedM.address,
+      returnAmountPos: undefined,
+    };
+  }
+}

package/src/dex/m-token/types.ts

@@ -0,0 +1,10 @@
+import { Address } from '../../types';
+
+// Data that returned by the API that can be used for
+// tx building.
+export type MTokenData = {};
+
+export type DexParams = {
+  MToken: { address: Address; decimals: number };
+  WrappedM: { address: Address; decimals: number };
+};

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

@@ -326,7 +326,6 @@ export class PancakeSwapV3EventPool extends StatefulEventSubscriber<PoolState> {
     const requestedRange = this.getBitmapRangeToRequest();
 
     return {
-      networkId: this.dexHelper.config.data.network,
       pool: _state.pool,
       blockTimestamp: bigIntify(_state.blockTimestamp),
       slot0: {

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

@@ -1,5 +1,3 @@
-import { Network } from '../../constants';
-
 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;
@@ -10,14 +8,6 @@ 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 TICK_BITMAP_TO_USE_BY_CHAIN: Record<number, bigint> = {
-  [Network.MAINNET]: 8n,
-};
-
-export const TICK_BITMAP_BUFFER_BY_CHAIN: Record<number, bigint> = {
-  [Network.MAINNET]: 16n,
-};
-
 export const MAX_PRICING_COMPUTATION_STEPS_ALLOWED = 128;
 
 export const UNISWAPV3_SUBGRAPH_URL =

package/src/dex/uniswap-v3/contract-math/TickBitMap.ts

@@ -6,9 +6,7 @@ import { DeepReadonly } from 'ts-essentials';
 import {
   OUT_OF_RANGE_ERROR_POSTFIX,
   TICK_BITMAP_BUFFER,
-  TICK_BITMAP_BUFFER_BY_CHAIN,
   TICK_BITMAP_TO_USE,
-  TICK_BITMAP_TO_USE_BY_CHAIN,
 } from '../constants';
 
 function isWordPosOut(
@@ -17,24 +15,18 @@ function isWordPosOut(
   // For pricing we use wider range to check price impact. If function called from event
   // it must always be within buffer
   isPriceQuery: boolean,
-  networkId: number,
 ) {
   let lowerTickBitmapLimit;
   let upperTickBitmapLimit;
 
-  const tickBitMapToUse =
-    TICK_BITMAP_TO_USE_BY_CHAIN[networkId] ?? TICK_BITMAP_TO_USE;
-  const tickBitMapBuffer =
-    TICK_BITMAP_BUFFER_BY_CHAIN[networkId] ?? TICK_BITMAP_BUFFER;
-
   if (isPriceQuery) {
     lowerTickBitmapLimit =
-      startTickBitmap - (tickBitMapBuffer + tickBitMapToUse);
+      startTickBitmap - (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE);
     upperTickBitmapLimit =
-      startTickBitmap + (tickBitMapBuffer + tickBitMapToUse);
+      startTickBitmap + (TICK_BITMAP_BUFFER + TICK_BITMAP_TO_USE);
   } else {
-    lowerTickBitmapLimit = startTickBitmap - tickBitMapBuffer;
-    upperTickBitmapLimit = startTickBitmap + tickBitMapBuffer;
+    lowerTickBitmapLimit = startTickBitmap - TICK_BITMAP_BUFFER;
+    upperTickBitmapLimit = startTickBitmap + TICK_BITMAP_BUFFER;
   }
 
   _require(
@@ -51,7 +43,7 @@ export class TickBitMap {
   }
 
   static flipTick(
-    state: Pick<PoolState, 'startTickBitmap' | 'tickBitmap' | 'networkId'>,
+    state: Pick<PoolState, 'startTickBitmap' | 'tickBitmap'>,
     tick: bigint,
     tickSpacing: bigint,
   ) {
@@ -66,7 +58,7 @@ export class TickBitMap {
 
     // flipTick is used only in _updatePosition which is always state changing event
     // Therefore it is never used in price query
-    isWordPosOut(wordPos, state.startTickBitmap, false, state.networkId);
+    isWordPosOut(wordPos, state.startTickBitmap, false);
 
     const stringWordPos = wordPos.toString();
     if (state.tickBitmap[stringWordPos] === undefined) {
@@ -77,9 +69,7 @@ export class TickBitMap {
   }
 
   static nextInitializedTickWithinOneWord(
-    state: DeepReadonly<
-      Pick<PoolState, 'startTickBitmap' | 'tickBitmap' | 'networkId'>
-    >,
+    state: DeepReadonly<Pick<PoolState, 'startTickBitmap' | 'tickBitmap'>>,
     tick: bigint,
     tickSpacing: bigint,
     lte: boolean,
@@ -95,12 +85,7 @@ export class TickBitMap {
       const [wordPos, bitPos] = TickBitMap.position(compressed);
       const mask = (1n << bitPos) - 1n + (1n << bitPos);
 
-      isWordPosOut(
-        wordPos,
-        state.startTickBitmap,
-        isPriceQuery,
-        state.networkId,
-      );
+      isWordPosOut(wordPos, state.startTickBitmap, isPriceQuery);
       let tickBitmapValue = state.tickBitmap[wordPos.toString()];
       tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
 
@@ -117,12 +102,7 @@ export class TickBitMap {
       const [wordPos, bitPos] = TickBitMap.position(compressed + 1n);
       const mask = ~((1n << bitPos) - 1n);
 
-      isWordPosOut(
-        wordPos,
-        state.startTickBitmap,
-        isPriceQuery,
-        state.networkId,
-      );
+      isWordPosOut(wordPos, state.startTickBitmap, isPriceQuery);
       let tickBitmapValue = state.tickBitmap[wordPos.toString()];
       tickBitmapValue = tickBitmapValue === undefined ? 0n : tickBitmapValue;
 

package/src/dex/uniswap-v3/contract-math/uniswap-v3-math.ts

@@ -59,7 +59,6 @@ function _priceComputationCycles(
   sqrtPriceLimitX96: bigint,
   zeroForOne: boolean,
   exactInput: boolean,
-  side: SwapSide,
 ): [
   // result
   PriceComputationState,
@@ -226,7 +225,7 @@ function _priceComputationCycles(
     latestFullCycleCache.tickCount += i - 1;
   }
 
-  if (state.amountSpecifiedRemaining !== 0n && side === SwapSide.BUY) {
+  if (state.amountSpecifiedRemaining !== 0n) {
     state.amountSpecifiedRemaining = 0n;
     state.amountCalculated = 0n;
   }
@@ -326,7 +325,6 @@ class UniswapV3Math {
             sqrtPriceLimitX96,
             zeroForOne,
             exactInput,
-            side,
           );
         if (
           finalState.amountSpecifiedRemaining === 0n &&

package/src/dex/uniswap-v3/forks/ramses-v2/ramses-v2-pool.ts

@@ -123,7 +123,6 @@ export class RamsesV2EventPool extends UniswapV3EventPool {
     const requestedRange = this.getBitmapRangeToRequest();
 
     return {
-      networkId: this.dexHelper.config.data.network,
       pool: _state.pool,
       blockTimestamp: bigIntify(_state.blockTimestamp),
       slot0: {

package/src/dex/uniswap-v3/forks/velodrome-slipstream/velodrome-slipstream-pool.ts

@@ -125,7 +125,6 @@ export class VelodromeSlipstreamEventPool extends UniswapV3EventPool {
     const requestedRange = this.getBitmapRangeToRequest();
 
     return {
-      networkId: this.dexHelper.config.data.network,
       pool: _state.pool,
       fee,
       blockTimestamp: bigIntify(_state.blockTimestamp),