@paraswap/dex-lib 2.14.0 → 2.14.1

package/src/config.ts

@@ -25,6 +25,8 @@ type BaseConfig = {
   uniswapV2ExchangeRouterAddress: Address;
   uniswapV3EventLoggingSampleRate?: number;
   rfqConfigs: Record<string, RFQConfig>;
+  rpcPollingMaxAllowedStateDelayInBlocks: number;
+  rpcPollingBlocksBackToTriggerUpdate: number;
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
 };
@@ -52,6 +54,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     },
     uniswapV2ExchangeRouterAddress:
       '0xF9234CB08edb93c0d4a4d4c70cC3FfD070e78e07',
+    rpcPollingMaxAllowedStateDelayInBlocks: 0,
+    rpcPollingBlocksBackToTriggerUpdate: 0,
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN,
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_1`]?.split(',') || [],
@@ -134,6 +138,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 5,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
   },
   [Network.BSC]: {
     network: Network.BSC,
@@ -155,6 +161,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       BscAdapter02: '0xe102429Ef7CAaBaAA3bc2C017aC784c5F665EE82',
       BscBuyAdapter: '0xA7f4fBCEB76a1B1c05C106a4289C28B3b91C17ca',
     },
+    rpcPollingMaxAllowedStateDelayInBlocks: 1,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
@@ -177,13 +185,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_137`]?.split(',') || [],
     adapterAddresses: {
       PolygonAdapter01: '0xE44769f42E1e9592f86B82f206407a8f7C84b4ed',
-      PolygonAdapter02: '0x72C851edA05915F4cbbeF27E3AFd3Bc87F86b001',
+      PolygonAdapter02: '0xfb2a3de6c7B8c77b520E3da16021f3D8A4E93168',
       PolygonBuyAdapter: '0xbE36ddfCDB6D60c1B20FfD73594540E5cc2c7E97',
     },
     uniswapV2ExchangeRouterAddress:
       '0xf3938337F7294fEf84e9B2c6D548A93F956Cc281',
     uniswapV3EventLoggingSampleRate: 0,
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 2,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
   },
   [Network.AVALANCHE]: {
     network: Network.AVALANCHE,
@@ -202,13 +212,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_43114`]?.split(',') || [],
     adapterAddresses: {
-      AvalancheAdapter01: '0x5b99094C3c2129F17b78cE5eBD1Cd8ADB887b340',
+      AvalancheAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
       AvalancheAdapter02: '0x3fd845dE49eBa45565d3b58CDEbf88d9bdA7aBf6',
       AvalancheBuyAdapter: '0xad2f7039B0F4c410654886D049ae8406F5aDe709',
     },
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 2,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
   },
   [Network.FANTOM]: {
     network: Network.FANTOM,
@@ -228,12 +240,14 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_250`]?.split(',') || [],
 
     adapterAddresses: {
-      FantomAdapter01: '0xD9026Ca611EEC89dd4030ae86953F2d8D899535c',
+      FantomAdapter01: '0x66152A2a538644Ae125570De522ADEaC9E41D865',
       FantomBuyAdapter: '0x27eb327B7255a2bF666EBB4D60AB4752dA4611b9',
     },
     uniswapV2ExchangeRouterAddress:
       '0xAB86e2bC9ec5485a9b60E684BA6d49bf4686ACC2',
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 2,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
   },
   [Network.ARBITRUM]: {
     network: Network.ARBITRUM,
@@ -253,13 +267,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_42161`]?.split(',') || [],
     adapterAddresses: {
       ArbitrumAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
-      ArbitrumAdapter02: '0xa003dFBA51C9e1e56C67ae445b852bdEd7aC5EEd',
+      ArbitrumAdapter02: '0xCBaeB06C2dF373c07A2Dc205266EC3bCd525DfB6',
       ArbitrumBuyAdapter: '0xfa072107a2CCfE5664794282EF36400735ABB70F',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
     uniswapV3EventLoggingSampleRate: 0,
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 4,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
   },
   [Network.OPTIMISM]: {
     network: Network.OPTIMISM,
@@ -279,13 +295,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
 
     adapterAddresses: {
-      OptimismAdapter01: '0xB6EBBB9f9957556Fd798927ae7c250759a235407',
+      OptimismAdapter01: '0x4669D27A649f5451e0D44C20a2b246431F1B0572',
       OptimismBuyAdapter: '0x4Ae8ad57912e207f5bFaFbF2e90486e5feab1634',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
     uniswapV3EventLoggingSampleRate: 0,
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 5,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
   },
 };
 
@@ -322,6 +340,10 @@ export function generateConfig(network: number): Config {
     uniswapV2ExchangeRouterAddress: baseConfig.uniswapV2ExchangeRouterAddress,
     uniswapV3EventLoggingSampleRate: baseConfig.uniswapV3EventLoggingSampleRate,
     rfqConfigs: baseConfig.rfqConfigs,
+    rpcPollingMaxAllowedStateDelayInBlocks:
+      baseConfig.rpcPollingMaxAllowedStateDelayInBlocks,
+    rpcPollingBlocksBackToTriggerUpdate:
+      baseConfig.rpcPollingBlocksBackToTriggerUpdate,
     hashFlowAuthToken: baseConfig.hashFlowAuthToken,
     hashFlowDisabledMMs: baseConfig.hashFlowDisabledMMs,
   };

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

@@ -78,7 +78,6 @@ describe('BalancerV2 E2E', () => {
     });
 
     describe('Simpleswap', () => {
-
       it('ETH -> TOKEN', async () => {
         await testE2E(
           tokens['ETH'],

package/src/dex/index.ts

@@ -38,7 +38,7 @@ import { MakerPsm } from './maker-psm/maker-psm';
 import { KyberDmm } from './kyberdmm/kyberdmm';
 import { Platypus } from './platypus/platypus';
 import { GMX } from './gmx/gmx';
-// import { WooFi } from './woo-fi/woo-fi';
+import { WooFiV2 } from './woo-fi-v2/woo-fi-v2';
 import { ParaSwapLimitOrders } from './paraswap-limit-orders/paraswap-limit-orders';
 import { AugustusRFQOrder } from './augustus-rfq';
 import { Solidly } from './solidly/solidly';
@@ -107,7 +107,7 @@ const Dexes = [
   Platypus,
   GMX,
   JarvisV6,
-  // WooFi,
+  WooFiV2,
   ParaSwapLimitOrders,
   Solidly,
   SolidlyEthereum,

package/src/dex/simple-exchange.ts

@@ -4,6 +4,7 @@ import { Address, SimpleExchangeParam, NumberAsString } from '../types';
 import { CACHE_PREFIX, ETHER_ADDRESS } from '../constants';
 import SimpleSwapHelperABI from '../abi/SimpleSwapHelperRouter.json';
 import ERC20ABI from '../abi/erc20.json';
+import augustusABI from '../abi/augustus.json';
 import { isETHAddress } from '../utils';
 import { MAX_UINT } from '../constants';
 import Web3 from 'web3';
@@ -18,6 +19,7 @@ export class SimpleExchange {
   isFeeOnTransferSupported = false;
 
   protected augustusAddress: Address;
+  protected augustusInterface: Interface;
   private provider: Web3;
 
   protected network: number;
@@ -32,6 +34,7 @@ export class SimpleExchange {
 
     this.network = dexHelper.config.data.network;
     this.augustusAddress = dexHelper.config.data.augustusAddress;
+    this.augustusInterface = new Interface(augustusABI);
     this.provider = dexHelper.web3Provider;
 
     this.dexmapKey =

package/src/dex/woo-fi-v2/config.ts

@@ -0,0 +1,87 @@
+import { DexParams } from './types';
+import { DexConfigMap, AdapterMappings } from '../../types';
+import { Network, SwapSide } from '../../constants';
+
+export const WooFiV2Config: DexConfigMap<DexParams> = {
+  WooFiV2: {
+    [Network.OPTIMISM]: {
+      wooPPV2Address: '0xd1778F9DF3eee5473A9640f13682e3846f61fEbC',
+      wooOracleV2Address: '0x464959aD46e64046B891F562cFF202a465D522F3',
+      integrationHelperAddress: '0x96329d66074EB8386Ae8bFD6698B2E3FDA87e15E',
+      // USDC
+      quoteToken: {
+        address: '0x7F5c764cBc14f9669B88837ca1490cCa17c31607',
+        decimals: 6,
+      },
+    },
+    [Network.BSC]: {
+      wooPPV2Address: '0xEc054126922a9a1918435c9072c32f1B60cB2B90',
+      wooOracleV2Address: '0x747f99D619D5612399010Ec5706F13e3345c4a9E',
+      integrationHelperAddress: '0xe12dC1F01ccB71ef00ADd1D8A5116b905261D879',
+      // BUSD
+      quoteToken: {
+        address: '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56',
+        decimals: 18,
+      },
+    },
+    [Network.POLYGON]: {
+      wooPPV2Address: '0x7081A38158BD050Ae4a86e38E0225Bc281887d7E',
+      wooOracleV2Address: '0xeFF23B4bE1091b53205E35f3AfCD9C7182bf3062',
+      integrationHelperAddress: '0x7Ba560eB735AbDCf9a3a5692272652A0cc81850d',
+      // USDC
+      quoteToken: {
+        address: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+        decimals: 6,
+      },
+    },
+    [Network.FANTOM]: {
+      wooPPV2Address: '0x286ab107c5E9083dBed35A2B5fb0242538F4f9bf',
+      wooOracleV2Address: '0x8840e26e0ebf7D100A0644DD8576DC62B03cbf04',
+      integrationHelperAddress: '0x6641959FE5EED7166F2254cF04b0d20c96776D9A',
+      // USDC
+      quoteToken: {
+        address: '0x04068DA6C83AFCFA0e13ba15A6696662335D5B75',
+        decimals: 6,
+      },
+    },
+    [Network.ARBITRUM]: {
+      wooPPV2Address: '0xeFF23B4bE1091b53205E35f3AfCD9C7182bf3062',
+      wooOracleV2Address: '0x37a9dE70b6734dFCA54395D8061d9411D9910739',
+      integrationHelperAddress: '0x28D2B949024FE50627f1EbC5f0Ca3Ca721148E40',
+      // USDC
+      quoteToken: {
+        address: '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8',
+        decimals: 6,
+      },
+    },
+    [Network.AVALANCHE]: {
+      wooPPV2Address: '0x3b3E4b4741e91aF52d0e9ad8660573E951c88524',
+      wooOracleV2Address: '0x9ACA557590F5020BDA4Ba63065Fc3A1253Bf8000',
+      integrationHelperAddress: '0x020630613E296c3E9b06186f630D1bF97A2B6Ad1',
+      // USDC
+      quoteToken: {
+        address: '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E',
+        decimals: 6,
+      },
+    },
+  },
+};
+
+export const Adapters: Record<number, AdapterMappings> = {
+  [Network.OPTIMISM]: {
+    [SwapSide.SELL]: [{ name: 'OptimismAdapter01', index: 11 }],
+  },
+  [Network.BSC]: { [SwapSide.SELL]: [{ name: 'BscAdapter01', index: 13 }] },
+  [Network.POLYGON]: {
+    [SwapSide.SELL]: [{ name: 'PolygonAdapter02', index: 4 }],
+  },
+  [Network.FANTOM]: {
+    [SwapSide.SELL]: [{ name: 'FantomAdapter01', index: 8 }],
+  },
+  [Network.ARBITRUM]: {
+    [SwapSide.SELL]: [{ name: 'ArbitrumAdapter02', index: 3 }],
+  },
+  [Network.AVALANCHE]: {
+    [SwapSide.SELL]: [{ name: 'AvalancheAdapter01', index: 12 }],
+  },
+};

package/src/dex/woo-fi-v2/constants.ts

@@ -0,0 +1,22 @@
+import { PoolState } from './types';
+
+export const WOO_FI_V2_GAS_COST = {
+  // https://dashboard.tenderly.co/paraswap/paraswap/fork/f5a6da2f-fec7-4d00-ac2c-b9c50f5c9554/simulation/25f3b378-632f-4beb-ba37-e21dd3722b5c/gas-usage
+  sellQuote: 145_000,
+  // https://dashboard.tenderly.co/paraswap/paraswap/fork/92f13a98-465d-409e-867d-e255e9f86cf1/simulation/09d5d06a-dd90-40fe-8ae6-a65097e804d4/gas-usage
+  sellBase: 159_000,
+  // https://dashboard.tenderly.co/paraswap/paraswap/fork/d5964ad1-f64f-42b7-8fac-976ad216f05f/simulation/49df18de-8046-463e-a904-5c9f621406d4/gas-usage
+  baseToBase: 204_000,
+};
+
+export const USD_PRECISION = 2;
+
+export const MIN_CONVERSION_RATE = 1;
+
+export const NULL_STATE: PoolState = {
+  tokenInfos: {},
+  tokenStates: {},
+  decimals: {},
+  oracleTimestamp: 0n,
+  isPaused: false,
+};

package/src/dex/woo-fi-v2/decoders.ts

@@ -0,0 +1,45 @@
+import { BytesLike } from 'ethers';
+import { defaultAbiCoder } from 'ethers/lib/utils';
+import { extractSuccessAndValue, generalDecoder } from '../../lib/decoders';
+import { MultiResult } from '../../lib/multi-wrapper';
+import { DecimalInfo, TokenInfo, TokenState } from './types';
+
+export function tokenInfoDecoder(
+  result: MultiResult<BytesLike> | BytesLike,
+): TokenInfo {
+  return generalDecoder(result, ['uint192', 'uint16'], undefined, value => ({
+    reserve: value[0].toBigInt(),
+    feeRate: BigInt(value[1].toString()),
+  }));
+}
+
+export function decimalInfoDecoder(
+  result: MultiResult<BytesLike> | BytesLike,
+): DecimalInfo {
+  return generalDecoder(
+    result,
+    ['tuple(uint64 priceDec, uint64 quoteDec, uint64 baseDec)'],
+    undefined,
+    value => ({
+      priceDec: value[0].priceDec.toBigInt(),
+      quoteDec: value[0].quoteDec.toBigInt(),
+      baseDec: value[0].baseDec.toBigInt(),
+    }),
+  );
+}
+
+// This is state from WooOracleV2 contract
+export function stateDecoder(
+  result: MultiResult<BytesLike> | BytesLike,
+): TokenState {
+  return generalDecoder(
+    result,
+    ['tuple(uint128 price, uint64 spread, uint64 coeff, bool woFeasible)'],
+    undefined,
+    value => ({
+      price: value[0].price.toBigInt(),
+      spread: value[0].spread.toBigInt(),
+      coeff: value[0].coeff.toBigInt(),
+    }),
+  );
+}

package/src/dex/woo-fi-v2/types.ts

@@ -0,0 +1,63 @@
+import { Interface } from 'ethers/lib/utils';
+import { Address, Token } from '../../types';
+
+export type PoolState = {
+  // fetched from WooPPV2.tokenInfos(address baseToken) :
+  // https://arbiscan.io/address/0x8693F9701D6DB361Fe9CC15Bc455Ef4366E39AE0
+  tokenInfos: Record<Address, TokenInfo>;
+
+  // fetched from WooracleV2.state(address baseToken)
+  // https://arbiscan.io/address/0x962d37fb9d75fe1af9aab323727183e4eae1322d
+  tokenStates: Record<Address, TokenState>;
+
+  // fetched from WooPPV2.decimalInfo(address baseToken)
+  // https://arbiscan.io/address/0x8693F9701D6DB361Fe9CC15Bc455Ef4366E39AE0
+  decimals: Record<Address, DecimalInfo>;
+  oracleTimestamp: bigint;
+  isPaused: boolean;
+};
+
+export type WooFiV2Data = {};
+
+export type DexParams = {
+  wooPPV2Address: Address;
+  wooOracleV2Address: Address;
+  integrationHelperAddress: Address;
+  quoteToken: Token;
+};
+
+export type TokenInfo = {
+  reserve: bigint;
+  feeRate: bigint;
+};
+
+export type TokenState = {
+  price: bigint;
+  spread: bigint;
+  coeff: bigint;
+};
+
+export type DecimalInfo = {
+  priceDec: bigint;
+  quoteDec: bigint;
+  baseDec: bigint;
+};
+
+export type LatestRoundData = {
+  answer: bigint;
+};
+
+export type MulticallResultOutputs =
+  | boolean
+  | bigint
+  | TokenInfo
+  | DecimalInfo
+  | TokenState;
+
+export type WooFiV2Interfaces = {
+  PPV2: Interface;
+  oracleV2: Interface;
+  integrationHelper: Interface;
+  chainlink: Interface;
+  erc20BalanceOf: Interface;
+};

package/src/dex/woo-fi-v2/utils.ts

@@ -0,0 +1,19 @@
+import { Interface } from 'ethers/lib/utils';
+import wooPPV2ABI from '../../abi/woo-fi-v2/WooPPV2.abi.json';
+import wooOracleV2ABI from '../../abi/woo-fi-v2/WooOracleV2.abi.json';
+import wooIntegrationHelper from '../../abi/woo-fi-v2/IntegrationHelper.abi.json';
+import { WooFiV2Interfaces } from './types';
+
+export const ifaces: WooFiV2Interfaces = {
+  PPV2: new Interface(wooPPV2ABI),
+  oracleV2: new Interface(wooOracleV2ABI),
+  integrationHelper: new Interface(wooIntegrationHelper),
+  chainlink: new Interface([
+    'function latestRoundData() view returns (tuple(uint80 roundId, ' +
+      'int256 answer, uint256 startedAt, uint256 updatedAt, ' +
+      'uint80 answeredInRound))',
+  ]),
+  erc20BalanceOf: new Interface([
+    'function balanceOf(address) view returns (uint256)',
+  ]),
+};

package/src/dex/woo-fi-v2/woo-fi-v2-e2e.test.ts

@@ -0,0 +1,216 @@
+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,
+  tokenBaseA: string,
+  tokenBaseB: string,
+  tokenQuote: string,
+  tokenBaseAAmount: string,
+  tokenQuoteAmount: string,
+) {
+  const provider = new StaticJsonRpcProvider(
+    generateConfig(network).privateHttpProvider,
+    network,
+  );
+  const tokens = Tokens[network];
+  const holders = Holders[network];
+
+  const sideToContractMethods = new Map([
+    [
+      SwapSide.SELL,
+      [
+        ContractMethod.simpleSwap,
+        ContractMethod.multiSwap,
+        ContractMethod.megaSwap,
+      ],
+    ],
+  ]);
+
+  describe(`${network}`, () => {
+    sideToContractMethods.forEach((contractMethods, side) =>
+      describe(`${side}`, () => {
+        contractMethods.forEach((contractMethod: ContractMethod) => {
+          describe(`${contractMethod}`, () => {
+            it(`${tokenBaseA} -> ${tokenQuote}`, async () => {
+              await testE2E(
+                tokens[tokenBaseA],
+                tokens[tokenQuote],
+                holders[tokenBaseA],
+                tokenBaseAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenQuote} -> ${tokenBaseA}`, async () => {
+              await testE2E(
+                tokens[tokenQuote],
+                tokens[tokenBaseA],
+                holders[tokenQuote],
+                tokenQuoteAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+            it(`${tokenBaseA} -> ${tokenBaseB}`, async () => {
+              await testE2E(
+                tokens[tokenBaseA],
+                tokens[tokenBaseB],
+                holders[tokenBaseA],
+                tokenBaseAAmount,
+                side,
+                dexKey,
+                contractMethod,
+                network,
+                provider,
+              );
+            });
+          });
+        });
+      }),
+    );
+  });
+}
+
+describe('WooFiV2 E2E', () => {
+  const dexKey = 'WooFiV2';
+
+  describe('Optimism', () => {
+    const network = Network.OPTIMISM;
+
+    const baseATokenSymbol = 'WETH';
+    const baseBTokenSymbol = 'WBTC';
+    const quoteTokenSymbol = 'USDC';
+
+    const tokenBaseAAmount = '1000000000000000000';
+    const tokenQuoteAmount = '1000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      baseATokenSymbol,
+      baseBTokenSymbol,
+      quoteTokenSymbol,
+      tokenBaseAAmount,
+      tokenQuoteAmount,
+    );
+  });
+
+  describe('BSC', () => {
+    const network = Network.BSC;
+
+    const baseATokenSymbol = 'WBNB';
+    const baseBTokenSymbol = 'bBTC';
+    const quoteTokenSymbol = 'BUSD';
+
+    const tokenBaseAAmount = '1000000000000000000';
+    const tokenQuoteAmount = '1000000000000000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      baseATokenSymbol,
+      baseBTokenSymbol,
+      quoteTokenSymbol,
+      tokenBaseAAmount,
+      tokenQuoteAmount,
+    );
+  });
+
+  describe('Polygon', () => {
+    const network = Network.POLYGON;
+
+    const baseATokenSymbol = 'WMATIC';
+    const baseBTokenSymbol = 'WETH';
+    const quoteTokenSymbol = 'USDC';
+
+    const tokenBaseAAmount = '1000000000000000000';
+    const tokenQuoteAmount = '1000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      baseATokenSymbol,
+      baseBTokenSymbol,
+      quoteTokenSymbol,
+      tokenBaseAAmount,
+      tokenQuoteAmount,
+    );
+  });
+
+  describe('Fantom', () => {
+    const network = Network.FANTOM;
+
+    const baseATokenSymbol = 'WFTM';
+    const quoteTokenSymbol = 'USDC';
+    const baseBTokenSymbol = 'ETH';
+
+    const tokenBaseAAmount = '1000000000000000000';
+    const tokenQuoteAmount = '1000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      baseATokenSymbol,
+      baseBTokenSymbol,
+      quoteTokenSymbol,
+      tokenBaseAAmount,
+      tokenQuoteAmount,
+    );
+  });
+
+  describe('Arbitrum', () => {
+    const network = Network.ARBITRUM;
+
+    const baseATokenSymbol = 'WETH';
+    const baseBTokenSymbol = 'WBTC';
+    const quoteTokenSymbol = 'USDC';
+
+    const tokenBaseAAmount = '1000000000000000000';
+    const tokenQuoteAmount = '1000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      baseATokenSymbol,
+      baseBTokenSymbol,
+      quoteTokenSymbol,
+      tokenBaseAAmount,
+      tokenQuoteAmount,
+    );
+  });
+
+  describe('Avalanche', () => {
+    const network = Network.AVALANCHE;
+
+    const baseATokenSymbol = 'WAVAX';
+    const baseBTokenSymbol = 'BTCb';
+    const quoteTokenSymbol = 'USDC';
+
+    const tokenBaseAAmount = '1000000000000000000';
+    const tokenQuoteAmount = '1000000';
+
+    testForNetwork(
+      network,
+      dexKey,
+      baseATokenSymbol,
+      baseBTokenSymbol,
+      quoteTokenSymbol,
+      tokenBaseAAmount,
+      tokenQuoteAmount,
+    );
+  });
+});