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

package/src/dex/index.ts

@@ -102,6 +102,7 @@ import { UsualBond } from './usual/usual-bond';
 import { UsualMWrappedM } from './usual/usual-m-wrapped-m';
 import { UsualMUsd0 } from './usual/usual-m-usd0';
 import { UsualPP } from './usual-pp/usual-pp';
+import { MWrappedM } from './m-token/m-wrapped-m';
 
 const LegacyDexes = [
   CurveV2,
@@ -198,6 +199,7 @@ const Dexes = [
   UsualMWrappedM,
   UsualMUsd0,
   UsualPP,
+  MWrappedM,
 ];
 
 export type LegacyDexConstructor = new (dexHelper: IDexHelper) => IDexTxBuilder<

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

@@ -0,0 +1,18 @@
+import { DexConfigMap } from '../../types';
+import { DexParams } from './types';
+import { Network } from '../../constants';
+
+export const Config: DexConfigMap<DexParams> = {
+  MWrappedM: {
+    [Network.MAINNET]: {
+      MToken: {
+        address: '0x866A2BF4E572CbcF37D5071A7a58503Bfb36be1b',
+        decimals: 6,
+      },
+      WrappedM: {
+        address: '0x437cc33344a0B27A429f795ff6B469C72698B291',
+        decimals: 6,
+      },
+    },
+  },
+};

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/tests/constants-e2e.ts

@@ -576,6 +576,11 @@ export const Tokens: {
       decimals: 18,
       symbol: 'USDL',
     },
+    M: {
+      address: '0x866A2BF4E572CbcF37D5071A7a58503Bfb36be1b',
+      decimals: 6,
+      symbol: 'M',
+    },
     WrappedM: {
       address: '0x437cc33344a0B27A429f795ff6B469C72698B291',
       decimals: 6,
@@ -1879,7 +1884,8 @@ export const Holders: {
     rUSD: '0xEC2eda1C4F981E468ABF62424a10B69B738b498E',
     arUSD: '0xeFc24206053a452e2299BF3b8f964512b041Db4C',
     USD0: '0x224762e69169E425239EeEE0012d1B0e041C123D',
-    WrappedM: '0xE0663f2372cAa1459b7ade90812Dc737CE587FA6',
+    M: '0xA370275bb06b7416184A967C5B8593942784CDFe',
+    WrappedM: '0xfAc0973a7D0B847367F6DD46FD470Ee069aAB845',
     'USD0++': '0x2227b6806339906707b43F36a1f07B52FF7Fa776',
     USDM: '0x57F5E098CaD7A3D1Eed53991D4d66C45C9AF7812',
     wUSDM: '0x3B95bC951EE0f553ba487327278cAc44f29715E5',