@dolomite-exchange/zap-sdk 0.0.1

package/__tests__/DolomiteZap.test.ts

@@ -0,0 +1,552 @@
+import Deployments from '@dolomite-exchange/dolomite-margin-modules/scripts/deployments.json';
+import BigNumber from 'bignumber.js';
+import { ethers } from 'ethers';
+import { DolomiteZap, GenericTraderType, Network } from '../src';
+import { BYTES_EMPTY } from '../src/lib/Constants';
+import {
+  ARB_MARKET,
+  GLP_MARKET,
+  MAGIC_GLP_MARKET,
+  PLV_GLP_MARKET,
+  setUnwrapperMarketIdByMarketId,
+  USDC_MARKET,
+  WETH_MARKET,
+} from './helpers/TestConstants';
+
+const txOrigin = '0x52256ef863a713Ef349ae6E97A7E8f35785145dE';
+
+describe('DolomiteZap', () => {
+  const network = Network.ARBITRUM_ONE;
+  const subgraphUrl = process.env.SUBGRAPH_URL;
+  if (!subgraphUrl) {
+    throw new Error('SUBGRAPH_URL env var not set')
+  }
+  const web3Provider = new ethers.providers.JsonRpcProvider(process.env.WEB3_PROVIDER_URL);
+  const NO_CACHE = -1;
+  const zap = new DolomiteZap(network, subgraphUrl, web3Provider, NO_CACHE);
+
+  describe('#getSwapExactTokensForTokensData', () => {
+    it('should work when there is no Isolation Mode tokens nor Liquidity tokens involved', async () => {
+      const amountIn = new BigNumber('1000000000000000000'); // 1 ETH
+      const minAmountOut = new BigNumber('100000000'); // 100 USDC
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        WETH_MARKET,
+        amountIn,
+        USDC_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(2);
+      expect(outputParam.marketIdsPath[0]).toEqual(WETH_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+
+      expect(outputParam.amountWeisPath.length).toEqual(2);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(1);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+      expect(outputParam.traderParams[0].tradeData.length).toBeGreaterThan(100);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Isolation Mode token to be unwrapped and no aggregator', async () => {
+      const amountIn = new BigNumber('1000000000000000000'); // 100 GLP
+      const minAmountOut = new BigNumber('1000000'); // 1 USDC
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        GLP_MARKET,
+        amountIn,
+        USDC_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(2);
+      expect(outputParam.marketIdsPath[0]).toEqual(GLP_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+
+      expect(outputParam.amountWeisPath.length).toEqual(2);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(1);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeUnwrapper);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.GLPIsolationModeUnwrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Isolation Mode token to be wrapped and no aggregator', async () => {
+      const amountIn = new BigNumber('100000000'); // 100 USDC
+      const minAmountOut = new BigNumber('50000000000000000000'); // 50 GLP
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        USDC_MARKET,
+        amountIn,
+        GLP_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(2);
+      expect(outputParam.marketIdsPath[0]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(GLP_MARKET.marketId);
+
+      expect(outputParam.amountWeisPath.length).toEqual(2);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(1);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeWrapper);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.GLPIsolationModeWrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Liquidity Token to be unwrapped and no aggregator', async () => {
+      const amountIn = new BigNumber('1000000000000000000'); // 100 mGLP
+      const minAmountOut = new BigNumber('1000000'); // 1 USDC
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        MAGIC_GLP_MARKET,
+        amountIn,
+        USDC_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(2);
+      expect(outputParam.marketIdsPath[0]).toEqual(MAGIC_GLP_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+
+      expect(outputParam.amountWeisPath.length).toEqual(2);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(1);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.MagicGLPUnwrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Liquidity Token to be wrapped and no aggregator', async () => {
+      const amountIn = new BigNumber('100000000'); // 100 USDC
+      const minAmountOut = new BigNumber('50000000000000000000'); // 50 mGLP
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        USDC_MARKET,
+        amountIn,
+        MAGIC_GLP_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(2);
+      expect(outputParam.marketIdsPath[0]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(MAGIC_GLP_MARKET.marketId);
+
+      expect(outputParam.amountWeisPath.length).toEqual(2);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(1);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.MagicGLPWrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Isolation Mode token to be unwrapped and uses an aggregator', async () => {
+      const amountIn = new BigNumber('100000000000000000000'); // 100 GLP
+      const minAmountOut = new BigNumber('1000000000000000000'); // 1 ARB
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        GLP_MARKET,
+        amountIn,
+        ARB_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(3);
+      expect(outputParam.marketIdsPath[0]).toEqual(GLP_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[2]).toEqual(ARB_MARKET.marketId);
+
+      const _50_USDC = new BigNumber('50000000');
+      expect(outputParam.amountWeisPath.length).toEqual(3);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(_50_USDC)).toBeTruthy();
+      expect(outputParam.amountWeisPath[2].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(2);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeUnwrapper);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.GLPIsolationModeUnwrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[1].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+      expect(outputParam.traderParams[1].tradeData.length).toBeGreaterThan(100);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Isolation Mode token to be wrapped and uses an aggregator', async () => {
+      const amountIn = new BigNumber('100000000000000000000'); // 100 ARB
+      const minAmountOut = new BigNumber('50000000000000000000'); // 50 GLP
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        ARB_MARKET,
+        amountIn,
+        GLP_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(3);
+      expect(outputParam.marketIdsPath[0]).toEqual(ARB_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[2]).toEqual(GLP_MARKET.marketId);
+
+      const _50_USDC = new BigNumber('50000000');
+      expect(outputParam.amountWeisPath.length).toEqual(3);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(_50_USDC)).toBeTruthy();
+      expect(outputParam.amountWeisPath[2].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(2);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+      expect(outputParam.traderParams[0].tradeData.length).toBeGreaterThan(100);
+
+      expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.IsolationModeWrapper);
+      expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[1].trader)
+        .toEqual(Deployments.GLPIsolationModeWrapperTraderV2[network].address);
+      expect(outputParam.traderParams[1].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Liquidity Token to be unwrapped and uses an aggregator', async () => {
+      const amountIn = new BigNumber('100000000000000000000'); // 100 mGLP
+      const minAmountOut = new BigNumber('1000000000000000000'); // 1 ARB
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        MAGIC_GLP_MARKET,
+        amountIn,
+        ARB_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(3);
+      expect(outputParam.marketIdsPath[0]).toEqual(MAGIC_GLP_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[2]).toEqual(ARB_MARKET.marketId);
+
+      const _50_USDC = new BigNumber('50000000');
+      expect(outputParam.amountWeisPath.length).toEqual(3);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(_50_USDC)).toBeTruthy();
+      expect(outputParam.amountWeisPath[2].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(2);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.MagicGLPUnwrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[1].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+      expect(outputParam.traderParams[1].tradeData.length).toBeGreaterThan(100);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Liquidity Token to be wrapped and uses an aggregator', async () => {
+      const amountIn = new BigNumber('100000000000000000000'); // 100 ARB
+      const minAmountOut = new BigNumber('50000000000000000000'); // 50 GLP
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        ARB_MARKET,
+        amountIn,
+        MAGIC_GLP_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(3);
+      expect(outputParam.marketIdsPath[0]).toEqual(ARB_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[2]).toEqual(MAGIC_GLP_MARKET.marketId);
+
+      const _50_USDC = new BigNumber('50000000');
+      expect(outputParam.amountWeisPath.length).toEqual(3);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(_50_USDC)).toBeTruthy();
+      expect(outputParam.amountWeisPath[2].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(2);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+      expect(outputParam.traderParams[0].tradeData.length).toBeGreaterThan(100);
+
+      expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[1].trader)
+        .toEqual(Deployments.MagicGLPWrapperTraderV2[network].address);
+      expect(outputParam.traderParams[1].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Isolation Mode token to be unwrapped into a wrapper', async () => {
+      const amountIn = new BigNumber('100000000000000000000'); // 100 GLP
+      const minAmountOut = new BigNumber('50000000000000000000'); // 50 plvGLP
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        GLP_MARKET,
+        amountIn,
+        PLV_GLP_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(3);
+      expect(outputParam.marketIdsPath[0]).toEqual(GLP_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[2]).toEqual(PLV_GLP_MARKET.marketId);
+
+      const _50_USDC = new BigNumber('50000000');
+      expect(outputParam.amountWeisPath.length).toEqual(3);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(_50_USDC)).toBeTruthy();
+      expect(outputParam.amountWeisPath[2].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(2);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeUnwrapper);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.GLPIsolationModeUnwrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.IsolationModeWrapper);
+      expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[1].trader)
+        .toEqual(Deployments.PlutusVaultGLPIsolationModeWrapperTraderV2[network].address);
+      expect(outputParam.traderParams[1].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it('should work when there is an Isolation Mode token to be unwrapped into a Liquidity Token', async () => {
+      const amountIn = new BigNumber('100000000000000000000'); // 100 GLP
+      const minAmountOut = new BigNumber('50000000000000000000'); // 50 mGLP
+      const outputParams = await zap.getSwapExactTokensForTokensParams(
+        GLP_MARKET,
+        amountIn,
+        MAGIC_GLP_MARKET,
+        minAmountOut,
+        txOrigin,
+      );
+
+      expect(outputParams.length).toBe(1);
+
+      const outputParam = outputParams[0];
+      expect(outputParam.marketIdsPath.length).toEqual(3);
+      expect(outputParam.marketIdsPath[0]).toEqual(GLP_MARKET.marketId);
+      expect(outputParam.marketIdsPath[1]).toEqual(USDC_MARKET.marketId);
+      expect(outputParam.marketIdsPath[2]).toEqual(MAGIC_GLP_MARKET.marketId);
+
+      const _50_USDC = new BigNumber('50000000');
+      expect(outputParam.amountWeisPath.length).toEqual(3);
+      expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+      expect(outputParam.amountWeisPath[1].isGreaterThan(_50_USDC)).toBeTruthy();
+      expect(outputParam.amountWeisPath[2].isGreaterThan(minAmountOut)).toBeTruthy();
+
+      expect(outputParam.traderParams.length).toEqual(2);
+      expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeUnwrapper);
+      expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[0].trader)
+        .toEqual(Deployments.GLPIsolationModeUnwrapperTraderV2[network].address);
+      expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+      expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+      expect(outputParam.traderParams[1].trader)
+        .toEqual(Deployments.MagicGLPWrapperTraderV2[network].address);
+      expect(outputParam.traderParams[1].tradeData).toEqual(BYTES_EMPTY);
+
+      expect(outputParam.makerAccounts.length).toEqual(0);
+      expect(outputParam.amountOutMin).toEqual(minAmountOut);
+    });
+
+    it(
+      'should work when there is an Isolation Mode token to be unwrapped into a wrapper and uses an aggregator',
+      async () => {
+        setUnwrapperMarketIdByMarketId(GLP_MARKET.marketId, WETH_MARKET.marketId, network);
+
+        const amountIn = new BigNumber('100000000000000000000'); // 100 GLP
+        const minAmountOut = new BigNumber('50000000000000000000'); // 50 mGLP
+        const outputParams = await zap.getSwapExactTokensForTokensParams(
+          GLP_MARKET,
+          amountIn,
+          MAGIC_GLP_MARKET,
+          minAmountOut,
+          txOrigin,
+        );
+
+        expect(outputParams.length).toBe(1);
+
+        const outputParam = outputParams[0];
+        expect(outputParam.marketIdsPath.length).toEqual(4);
+        expect(outputParam.marketIdsPath[0]).toEqual(GLP_MARKET.marketId);
+        expect(outputParam.marketIdsPath[1]).toEqual(WETH_MARKET.marketId);
+        expect(outputParam.marketIdsPath[2]).toEqual(USDC_MARKET.marketId);
+        expect(outputParam.marketIdsPath[3]).toEqual(MAGIC_GLP_MARKET.marketId);
+
+        const _0_025_WETH = new BigNumber('25000000000000000');
+        const _50_USDC = new BigNumber('50000000');
+        expect(outputParam.amountWeisPath.length).toEqual(4);
+        expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+        expect(outputParam.amountWeisPath[1].isGreaterThan(_0_025_WETH)).toBeTruthy();
+        expect(outputParam.amountWeisPath[2].isGreaterThan(_50_USDC)).toBeTruthy();
+        expect(outputParam.amountWeisPath[3].isGreaterThan(minAmountOut)).toBeTruthy();
+
+        expect(outputParam.traderParams.length).toEqual(3);
+        expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeUnwrapper);
+        expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+        expect(outputParam.traderParams[0].trader)
+          .toEqual(Deployments.GLPIsolationModeUnwrapperTraderV2[network].address);
+        expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+        expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+        expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+        expect(outputParam.traderParams[1].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+        expect(outputParam.traderParams[1].tradeData.length).toBeGreaterThan(100);
+
+        expect(outputParam.traderParams[2].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+        expect(outputParam.traderParams[2].makerAccountIndex).toEqual(0);
+        expect(outputParam.traderParams[2].trader)
+          .toEqual(Deployments.MagicGLPWrapperTraderV2[network].address);
+        expect(outputParam.traderParams[2].tradeData).toEqual(BYTES_EMPTY);
+
+        expect(outputParam.makerAccounts.length).toEqual(0);
+        expect(outputParam.amountOutMin).toEqual(minAmountOut);
+      },
+    );
+
+    it(
+      'should work when there is an Isolation Mode token to be unwrapped into a Liquidity Token and uses an aggregator',
+      async () => {
+        setUnwrapperMarketIdByMarketId(GLP_MARKET.marketId, WETH_MARKET.marketId, network);
+
+        const amountIn = new BigNumber('100000000000000000000'); // 100 GLP
+        const minAmountOut = new BigNumber('50000000000000000000'); // 50 mGLP
+        const outputParams = await zap.getSwapExactTokensForTokensParams(
+          GLP_MARKET,
+          amountIn,
+          MAGIC_GLP_MARKET,
+          minAmountOut,
+          txOrigin,
+        );
+
+        expect(outputParams.length).toBe(1);
+
+        const outputParam = outputParams[0];
+        expect(outputParam.marketIdsPath.length).toEqual(4);
+        expect(outputParam.marketIdsPath[0]).toEqual(GLP_MARKET.marketId);
+        expect(outputParam.marketIdsPath[1]).toEqual(WETH_MARKET.marketId);
+        expect(outputParam.marketIdsPath[2]).toEqual(USDC_MARKET.marketId);
+        expect(outputParam.marketIdsPath[3]).toEqual(MAGIC_GLP_MARKET.marketId);
+
+        const _0_025_WETH = new BigNumber('25000000000000000');
+        const _50_USDC = new BigNumber('50000000');
+        expect(outputParam.amountWeisPath.length).toEqual(4);
+        expect(outputParam.amountWeisPath[0]).toEqual(amountIn);
+        expect(outputParam.amountWeisPath[1].isGreaterThan(_0_025_WETH)).toBeTruthy();
+        expect(outputParam.amountWeisPath[2].isGreaterThan(_50_USDC)).toBeTruthy();
+        expect(outputParam.amountWeisPath[3].isGreaterThan(minAmountOut)).toBeTruthy();
+
+        expect(outputParam.traderParams.length).toEqual(3);
+        expect(outputParam.traderParams[0].traderType).toEqual(GenericTraderType.IsolationModeUnwrapper);
+        expect(outputParam.traderParams[0].makerAccountIndex).toEqual(0);
+        expect(outputParam.traderParams[0].trader)
+          .toEqual(Deployments.GLPIsolationModeUnwrapperTraderV2[network].address);
+        expect(outputParam.traderParams[0].tradeData).toEqual(BYTES_EMPTY);
+
+        expect(outputParam.traderParams[1].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+        expect(outputParam.traderParams[1].makerAccountIndex).toEqual(0);
+        expect(outputParam.traderParams[1].trader).toEqual(Deployments.ParaswapAggregatorTrader[network].address);
+        expect(outputParam.traderParams[1].tradeData.length).toBeGreaterThan(100);
+
+        expect(outputParam.traderParams[2].traderType).toEqual(GenericTraderType.ExternalLiquidity);
+        expect(outputParam.traderParams[2].makerAccountIndex).toEqual(0);
+        expect(outputParam.traderParams[2].trader)
+          .toEqual(Deployments.MagicGLPWrapperTraderV2[network].address);
+        expect(outputParam.traderParams[2].tradeData).toEqual(BYTES_EMPTY);
+
+        expect(outputParam.makerAccounts.length).toEqual(0);
+        expect(outputParam.amountOutMin).toEqual(minAmountOut);
+      },
+    );
+  });
+});

package/__tests__/clients/DolomiteClient.test.ts

@@ -0,0 +1,47 @@
+import { ethers } from 'ethers';
+import { Network } from '../../src';
+import DolomiteClient from '../../src/clients/DolomiteClient';
+
+describe('DolomiteClient', () => {
+  const networkId = Network.ARBITRUM_ONE;
+  const subgraphUrl = process.env.SUBGRAPH_URL;
+  if (!subgraphUrl) {
+    throw new Error('SUBGRAPH_URL env var not set')
+  }
+  const web3Provider = new ethers.providers.JsonRpcProvider(process.env.WEB3_PROVIDER_URL);
+  const dolomite = new DolomiteClient(subgraphUrl, networkId, web3Provider);
+
+  describe('#getDolomiteMarkets', () => {
+    it('should work for specific block number', async () => {
+      const blockNumber = 100_000_000;
+      const marketsMap = await dolomite.getDolomiteMarketsMap(blockNumber);
+      expect(Object.keys(marketsMap).length).toEqual(10);
+    });
+
+    it('should work for latest block tag', async () => {
+      const marketsMap = await dolomite.getDolomiteMarketsMap('latest');
+      expect(Object.keys(marketsMap).length).toBeGreaterThanOrEqual(10);
+
+      const dfsGlp = marketsMap['6'];
+      expect(dfsGlp).toBeDefined();
+      expect(dfsGlp!.isolationModeUnwrapperInfo).toBeDefined();
+      expect(dfsGlp!.isolationModeWrapperInfo).toBeDefined();
+      expect(dfsGlp!.liquidityTokenWrapperInfo).toBeUndefined();
+      expect(dfsGlp!.liquidityTokenWrapperInfo).toBeUndefined();
+
+      const dplvGlp = marketsMap['9'];
+      expect(dplvGlp).toBeDefined();
+      expect(dplvGlp!.isolationModeUnwrapperInfo).toBeDefined();
+      expect(dplvGlp!.isolationModeWrapperInfo).toBeDefined();
+      expect(dplvGlp!.liquidityTokenWrapperInfo).toBeUndefined();
+      expect(dplvGlp!.liquidityTokenWrapperInfo).toBeUndefined();
+
+      const mGlp = marketsMap['8'];
+      expect(mGlp).toBeDefined();
+      expect(mGlp!.isolationModeUnwrapperInfo).toBeUndefined();
+      expect(mGlp!.isolationModeWrapperInfo).toBeUndefined();
+      expect(mGlp!.liquidityTokenWrapperInfo).toBeDefined();
+      expect(mGlp!.liquidityTokenWrapperInfo).toBeDefined();
+    });
+  });
+});

package/__tests__/clients/ParaswapAggregator.test.ts

@@ -0,0 +1,34 @@
+import Deployments from '@dolomite-exchange/dolomite-margin-modules/scripts/deployments.json';
+import BigNumber from 'bignumber.js';
+import { ApiMarket, Network } from '../../src';
+import ParaswapAggregator from '../../src/clients/ParaswapAggregator';
+import { USDC_MARKET, WETH_MARKET } from '../helpers/TestConstants';
+
+describe('ParaswapAggregator', () => {
+  const networkIdOverride = Network.ARBITRUM_ONE;
+  const paraswap = new ParaswapAggregator(networkIdOverride);
+
+  describe('#getSwapExactTokensForTokensData', () => {
+    it('should work under normal conditions', async () => {
+      const inputMarket: ApiMarket = WETH_MARKET;
+      const outputMarket: ApiMarket = USDC_MARKET;
+      const inputAmount = new BigNumber('1000000000000000000'); // 1 ETH
+      const minOutputAmount = new BigNumber('100000000'); // 100 USDC
+      const solidAccount = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
+      const aggregatorOutput = await paraswap.getSwapExactTokensForTokensData(
+        inputMarket,
+        inputAmount,
+        outputMarket,
+        minOutputAmount,
+        solidAccount,
+      );
+      expect(aggregatorOutput).toBeDefined();
+
+      const { tradeData, traderAddress, expectedAmountOut } = aggregatorOutput!;
+      expect(tradeData).toBeDefined();
+      expect(tradeData.length).toBeGreaterThanOrEqual(100);
+      expect(traderAddress).toEqual(Deployments.ParaswapAggregatorTrader[Network.ARBITRUM_ONE].address);
+      expect(expectedAmountOut.gt(minOutputAmount)).toBe(true);
+    });
+  });
+});

package/__tests__/helpers/Setup.ts

@@ -0,0 +1,4 @@
+module.exports = () => {
+  // eslint-disable-next-line global-require
+  require('dotenv-flow').config();
+};