@dolomite-exchange/zap-sdk 0.0.1

package/src/DolomiteZap.ts

@@ -0,0 +1,235 @@
+import { ethers } from 'ethers';
+import AggregatorClient from './clients/AggregatorClient';
+import DolomiteClient from './clients/DolomiteClient';
+import ParaswapAggregator from './clients/ParaswapAggregator';
+import {
+  Address,
+  AggregatorOutput,
+  ApiMarket,
+  ApiMarketHelper,
+  ApiToken,
+  GenericTraderParam,
+  GenericTraderType,
+  Integer,
+  MarketId,
+  Network,
+  ZapOutputParam,
+} from './lib/ApiTypes';
+import { INTEGERS } from './lib/Constants';
+import { LocalCache } from './lib/LocalCache';
+import { removeDuplicates, toChecksumOpt, zapOutputParamToJson } from './lib/Utils';
+
+const ONE_HOUR = 60 * 60;
+
+export class DolomiteZap {
+  public readonly network: Network;
+  public readonly subgraphUrl: string;
+  public readonly web3Provider: ethers.providers.Provider;
+
+  private client: DolomiteClient;
+  private paraswapAggregator: ParaswapAggregator;
+  private marketsCache: LocalCache<Record<MarketId, ApiMarket>>;
+  private marketHelpersCache: LocalCache<Record<MarketId, ApiMarketHelper>>;
+  private validAggregators: AggregatorClient[];
+
+  public constructor(
+    network: Network,
+    subgraphUrl: string,
+    web3Provider: ethers.providers.Provider,
+    cacheSeconds: number = ONE_HOUR,
+  ) {
+    this.network = network;
+    this.subgraphUrl = subgraphUrl;
+    this.web3Provider = web3Provider;
+
+    this.client = new DolomiteClient(subgraphUrl, network, web3Provider);
+    this.paraswapAggregator = new ParaswapAggregator(network);
+    this.marketsCache = new LocalCache<Record<MarketId, ApiMarket>>(cacheSeconds);
+    this.marketHelpersCache = new LocalCache<Record<MarketId, ApiMarketHelper>>(cacheSeconds);
+    this.validAggregators = [this.paraswapAggregator].filter(aggregator => aggregator.isValidForNetwork());
+  }
+
+  /**
+   *
+   * @param tokenIn
+   * @param amountIn
+   * @param tokenOut
+   * @param amountOutMin The minimum amount out required for the swap to be considered valid
+   * @param txOrigin The address that will execute the transaction
+   * @return {Promise<ZapOutputParam[]>} A list of outputs that can be used to execute the trade. The outputs are
+   * sorted by execution, with the best ones being first.
+   */
+  public async getSwapExactTokensForTokensParams(
+    tokenIn: ApiToken,
+    amountIn: Integer,
+    tokenOut: ApiToken,
+    amountOutMin: Integer,
+    txOrigin: Address,
+  ): Promise<ZapOutputParam[]> {
+    const marketsMap = await this.getMarketsMap();
+    const marketHelpersMap = await this.getMarketHelpersMap(marketsMap);
+    const inputMarket = marketsMap[tokenIn.marketId];
+    const inputHelper = marketHelpersMap[tokenIn.marketId];
+    const outputMarket = marketsMap[tokenOut.marketId];
+    const outputHelper = marketHelpersMap[tokenOut.marketId];
+
+    if (!inputMarket) {
+      return Promise.reject(new Error(`Invalid tokenIn: ${tokenIn.symbol} / ${tokenIn.marketId}`));
+    } else if (!outputMarket) {
+      return Promise.reject(new Error(`Invalid tokenOut: ${tokenOut.symbol} / ${tokenOut.marketId}`));
+    } else if (amountIn.lte(INTEGERS.ZERO)) {
+      return Promise.reject(new Error('Invalid amountIn. Must be greater than 0'));
+    } else if (amountOutMin.lte(INTEGERS.ZERO)) {
+      return Promise.reject(new Error('Invalid amountOutMin. Must be greater than 0'));
+    } else if (!toChecksumOpt(txOrigin)) {
+      return Promise.reject(new Error('Invalid txOrigin'));
+    }
+
+    const marketIdsPath: number[] = [inputMarket.marketId];
+    const amountsPaths = new Array<Integer[]>(this.validAggregators.length).fill([amountIn]);
+    const traderParamsArrays = new Array<GenericTraderParam[]>(this.validAggregators.length).fill([]);
+    let effectiveInputMarketId = inputMarket.marketId;
+    let effectiveOutputMarketId = outputMarket.marketId;
+
+    const isIsolationModeUnwrapper = inputMarket.isolationModeUnwrapperInfo;
+    const unwrapperInfo = inputMarket.isolationModeUnwrapperInfo ?? inputMarket.liquidityTokenUnwrapperInfo;
+    const unwrapperHelper = inputHelper.isolationModeUnwrapperHelper ?? inputHelper.liquidityTokenUnwrapperHelper;
+    if (unwrapperInfo && unwrapperHelper) {
+      effectiveInputMarketId = unwrapperInfo.outputMarketId;
+      marketIdsPath.push(effectiveInputMarketId);
+
+      const { amountOut, tradeData } = await unwrapperHelper.estimateOutputFunction(
+        amountIn,
+        unwrapperInfo.outputMarketId,
+      );
+
+      amountsPaths.forEach(amountsPath => amountsPath.push(amountOut));
+      traderParamsArrays.forEach(traderParams => {
+        traderParams.push({
+          traderType: isIsolationModeUnwrapper
+            ? GenericTraderType.IsolationModeUnwrapper
+            : GenericTraderType.ExternalLiquidity,
+          makerAccountIndex: 0,
+          trader: unwrapperInfo.unwrapperAddress,
+          tradeData,
+        });
+      });
+    }
+
+    const isIsolationModeWrapper = outputMarket.isolationModeWrapperInfo;
+    const wrapperInfo = outputMarket.isolationModeWrapperInfo ?? outputMarket.liquidityTokenWrapperInfo;
+    const wrapperHelper = outputHelper.isolationModeWrapperHelper ?? outputHelper.liquidityTokenWrapperHelper;
+    if (wrapperInfo) {
+      // We can't get the amount yet until we know if we need to use an aggregator in the middle
+      effectiveOutputMarketId = wrapperInfo.inputMarketId;
+      if (effectiveInputMarketId !== effectiveOutputMarketId) {
+        marketIdsPath.push(wrapperInfo.inputMarketId);
+      }
+    }
+
+    if (effectiveInputMarketId !== effectiveOutputMarketId) {
+      if (!marketIdsPath.includes(effectiveOutputMarketId)) {
+        marketIdsPath.push(effectiveOutputMarketId);
+      }
+      const effectiveInputMarket = marketsMap[effectiveInputMarketId];
+      const effectiveOutputMarket = marketsMap[effectiveOutputMarketId];
+      const aggregatorOutputOrUndefinedList = await Promise.all(
+        this.validAggregators.map((aggregator, i) => {
+          return aggregator.getSwapExactTokensForTokensData(
+            effectiveInputMarket,
+            amountsPaths[i][amountsPaths[i].length - 1],
+            effectiveOutputMarket,
+            INTEGERS.ONE,
+            txOrigin,
+          )
+        }),
+      );
+
+      const aggregatorOutputs = aggregatorOutputOrUndefinedList.filter(trader => !!trader) as AggregatorOutput[];
+      if (aggregatorOutputs.length !== this.validAggregators.length) {
+        throw new Error('Invalid aggregator outputs length')
+      }
+
+      amountsPaths.forEach((amountsPath, i) => amountsPath.push(aggregatorOutputs[i].expectedAmountOut));
+      traderParamsArrays.forEach((traderParams, i) => {
+        traderParams.push({
+          traderType: GenericTraderType.ExternalLiquidity,
+          makerAccountIndex: 0,
+          trader: aggregatorOutputs[i].traderAddress,
+          tradeData: aggregatorOutputs[i].tradeData,
+        });
+      });
+    }
+
+    if (wrapperInfo && wrapperHelper) {
+      // Append the amounts and trader params for the wrapper
+      const amountsAndTraderParams = await Promise.all(
+        amountsPaths.map(async (amountsPath) => {
+          const amountInForEstimation = amountsPath[amountsPath.length - 1];
+          const outputEstimate = await wrapperHelper.estimateOutputFunction(
+            amountInForEstimation,
+            wrapperInfo.inputMarketId,
+          );
+          return {
+            amountOut: outputEstimate.amountOut,
+            traderParam: {
+              traderType: isIsolationModeWrapper
+                ? GenericTraderType.IsolationModeWrapper
+                : GenericTraderType.ExternalLiquidity,
+              makerAccountIndex: 0,
+              trader: wrapperInfo.wrapperAddress,
+              tradeData: outputEstimate.tradeData,
+            },
+          }
+        }),
+      );
+
+      amountsPaths.forEach((amountsPath, i) => {
+        amountsPath.push(amountsAndTraderParams[i].amountOut);
+        traderParamsArrays[i].push(amountsAndTraderParams[i].traderParam);
+      });
+    }
+
+    if (!marketIdsPath.includes(outputMarket.marketId)) {
+      marketIdsPath.push(outputMarket.marketId);
+    }
+
+    const result = this.validAggregators.map<ZapOutputParam>((_, i) => {
+      return {
+        marketIdsPath,
+        amountWeisPath: amountsPaths[i],
+        traderParams: traderParamsArrays[i],
+        makerAccounts: [],
+        amountOutMin,
+      };
+    });
+
+    return removeDuplicates(result, zapOutputParamToJson);
+  }
+
+  private async getMarketsMap(): Promise<Record<MarketId, ApiMarket>> {
+    const marketsKey = 'MARKETS';
+    const cachedMarkets = this.marketsCache.get(marketsKey);
+    if (cachedMarkets) {
+      return cachedMarkets;
+    }
+
+    const marketsMap = await this.client.getDolomiteMarketsMap();
+    this.marketsCache.set(marketsKey, marketsMap);
+    return marketsMap;
+  }
+
+  private async getMarketHelpersMap(
+    marketsMap: Record<MarketId, ApiMarket>,
+  ): Promise<Record<MarketId, ApiMarketHelper>> {
+    const marketHelpersKey = 'MARKET_HELPERS';
+    const cachedMarkets = this.marketHelpersCache.get(marketHelpersKey);
+    if (cachedMarkets) {
+      return cachedMarkets;
+    }
+
+    const marketHelpersMap = await this.client.getDolomiteMarketHelpers(marketsMap);
+    this.marketHelpersCache.set(marketHelpersKey, marketHelpersMap);
+    return marketHelpersMap;
+  }
+}

package/src/abis/IDolomiteMarginExchangeWrapper.json

@@ -0,0 +1,80 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_tradeOriginator",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_receiver",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_outputToken",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_inputToken",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_inputAmount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_orderData",
+        "type": "bytes"
+      }
+    ],
+    "name": "exchange",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_inputToken",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_outputToken",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_desiredInputAmount",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_orderData",
+        "type": "bytes"
+      }
+    ],
+    "name": "getExchangeCost",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/src/clients/AggregatorClient.ts

@@ -0,0 +1,19 @@
+import { Address, AggregatorOutput, ApiMarket, ApiToken, Integer, Network } from '../lib/ApiTypes';
+
+export default abstract class AggregatorClient {
+  public readonly network: Network;
+
+  protected constructor(network: Network) {
+    this.network = network;
+  }
+
+  public abstract isValidForNetwork(): boolean;
+
+  public abstract getSwapExactTokensForTokensData(
+    inputMarket: ApiMarket | ApiToken,
+    inputAmountWei: Integer,
+    outputMarket: ApiMarket | ApiToken,
+    minOutputAmountWei: Integer,
+    txOrigin: Address,
+  ): Promise<AggregatorOutput | undefined>
+}

package/src/clients/DolomiteClient.ts

@@ -0,0 +1,234 @@
+import axios from 'axios';
+import { ethers } from 'ethers';
+import {
+  ApiMarket,
+  ApiMarketHelper,
+  ApiUnwrapperInfo,
+  ApiWrapperInfo,
+  BlockTag,
+  MarketId,
+  Network,
+} from '../lib/ApiTypes';
+import { StandardEstimator } from '../lib/estimators/StandardEstimator';
+import { GraphqlMarketResult } from '../lib/graphql-types';
+import GraphqlPageable from '../lib/GraphqlPageable';
+import Logger from '../lib/Logger';
+import IsolationModeClient from './IsolationModeClient';
+
+const defaultAxiosConfig = {
+  headers: { 'Accept-Encoding': 'gzip,deflate,compress' },
+};
+
+export default class DolomiteClient {
+  private readonly subgraphUrl: string;
+  private readonly networkId: Network;
+  private readonly web3Provider: ethers.providers.Provider;
+
+  public constructor(
+    subgraphUrl: string,
+    networkId: Network,
+    web3Provider: ethers.providers.Provider,
+  ) {
+    this.subgraphUrl = subgraphUrl;
+    this.networkId = networkId;
+    this.web3Provider = web3Provider;
+  }
+
+  public async getDolomiteMarketsMap(
+    blockTag: BlockTag = 'latest',
+  ): Promise<Record<MarketId, ApiMarket>> {
+    const marketsList = await GraphqlPageable.getPageableValues((pageIndex) => this.getDolomiteMarketsWithPaging(
+      blockTag,
+      pageIndex,
+    ));
+    return marketsList.reduce<Record<MarketId, ApiMarket>>((acc, market) => {
+      acc[market.marketId] = market;
+      return acc;
+    }, {});
+  }
+
+  public async getDolomiteMarketHelpers(
+    marketsMap: Record<MarketId, ApiMarket>,
+  ): Promise<Record<MarketId, ApiMarketHelper>> {
+    const standardEstimator = new StandardEstimator(this.web3Provider, marketsMap);
+    return Object.values(marketsMap).reduce<Record<MarketId, ApiMarketHelper>>((acc, market) => {
+      const marketHelper: ApiMarketHelper = {
+        marketId: market.marketId,
+        isolationModeUnwrapperHelper: undefined,
+        liquidityTokenUnwrapperHelper: undefined,
+        isolationModeWrapperHelper: undefined,
+        liquidityTokenWrapperHelper: undefined,
+      }
+
+      const isolationModeUnwrapper = market.isolationModeUnwrapperInfo;
+      if (isolationModeUnwrapper) {
+        marketHelper.isolationModeUnwrapperHelper = {
+          estimateOutputFunction: async (
+            amountIn,
+            outputMarketId,
+          ) => standardEstimator.getUnwrappedAmount(
+            market.tokenAddress,
+            isolationModeUnwrapper.unwrapperAddress,
+            amountIn,
+            outputMarketId,
+          ),
+        }
+      }
+      const liquidityTokenUnwrapper = market.liquidityTokenUnwrapperInfo;
+      if (liquidityTokenUnwrapper) {
+        marketHelper.liquidityTokenUnwrapperHelper = {
+          estimateOutputFunction: async (
+            amountIn,
+            outputMarketId,
+          ) => standardEstimator.getUnwrappedAmount(
+            market.tokenAddress,
+            liquidityTokenUnwrapper.unwrapperAddress,
+            amountIn,
+            outputMarketId,
+          ),
+        }
+      }
+      const isolationModeWrapper = market.isolationModeWrapperInfo;
+      if (isolationModeWrapper) {
+        marketHelper.isolationModeWrapperHelper = {
+          estimateOutputFunction: async (
+            amountIn,
+            inputMarketId,
+          ) => standardEstimator.getWrappedAmount(
+            market.tokenAddress,
+            isolationModeWrapper.wrapperAddress,
+            amountIn,
+            inputMarketId,
+          ),
+        }
+      }
+      const liquidityTokenWrapper = market.liquidityTokenWrapperInfo;
+      if (liquidityTokenWrapper) {
+        marketHelper.liquidityTokenWrapperHelper = {
+          estimateOutputFunction: async (
+            amountIn,
+            inputMarketId,
+          ) => standardEstimator.getWrappedAmount(
+            market.tokenAddress,
+            liquidityTokenWrapper.wrapperAddress,
+            amountIn,
+            inputMarketId,
+          ),
+        }
+      }
+
+      acc[market.marketId] = marketHelper;
+      return acc;
+    }, {});
+  }
+
+  private async getDolomiteMarketsWithPaging(
+    blockTag: BlockTag = 'latest',
+    pageIndex: number = 0,
+  ): Promise<ApiMarket[]> {
+    let query: string;
+    if (blockTag === 'latest') {
+      // omit the time travel predicate
+      query = `query getMarketRiskInfos($skip: Int) {
+                marketRiskInfos(first: ${GraphqlPageable.MAX_PAGE_SIZE} skip: $skip) {
+                  id
+                  token {
+                    id
+                    marketId
+                    name
+                    symbol
+                    decimals
+                  }
+                }
+              }`
+    } else {
+      query = `query getMarketRiskInfos($blockNumber: Int, $skip: Int) {
+                marketRiskInfos(block: { number: $blockNumber } first: ${GraphqlPageable.MAX_PAGE_SIZE} skip: $skip) {
+                  id
+                  token {
+                    id
+                    marketId
+                    name
+                    symbol
+                    decimals
+                  }
+                }
+              }`;
+    }
+    const result: GraphqlMarketResult = await axios.post(
+      this.subgraphUrl,
+      {
+        query,
+        variables: {
+          blockNumber: blockTag === 'latest' ? undefined : blockTag,
+          skip: pageIndex * GraphqlPageable.MAX_PAGE_SIZE,
+        },
+      },
+      defaultAxiosConfig,
+    )
+      .then(response => response.data)
+      .then(json => json as GraphqlMarketResult);
+
+    if (result.errors && typeof result.errors === 'object') {
+      // noinspection JSPotentiallyInvalidTargetOfIndexedPropertyAccess
+      return Promise.reject(result.errors[0]);
+    }
+
+    const markets: Promise<ApiMarket | undefined>[] = result.data.marketRiskInfos.map(async (market) => {
+      const isolationModeClient = new IsolationModeClient(this.networkId);
+      let isolationModeUnwrapperInfo: ApiUnwrapperInfo | undefined;
+      let isolationModeWrapperInfo: ApiWrapperInfo | undefined;
+      if (isolationModeClient.isIsolationModeToken(market.token)) {
+        const unwrapperAddress = isolationModeClient.getIsolationModeUnwrapperByMarketId(market.token);
+        const outputMarketId = isolationModeClient.getIsolationModeUnwrapperMarketIdByMarketId(market.token);
+        const wrapperAddress = isolationModeClient.getIsolationModeWrapperByMarketId(market.token);
+        const inputMarketId = isolationModeClient.getIsolationModeWrapperMarketIdByMarketId(market.token);
+
+        if (!unwrapperAddress || typeof outputMarketId === 'undefined') {
+          Logger.warn({
+            message: 'Isolation Mode token cannot find unwrapper info!',
+            marketId: market.token.marketId,
+          });
+          return undefined;
+        } else if (!wrapperAddress || typeof inputMarketId === 'undefined') {
+          Logger.warn({
+            message: 'Isolation Mode token cannot find wrapper info!',
+            marketId: market.token.marketId,
+          });
+          return undefined;
+        }
+
+        isolationModeUnwrapperInfo = { unwrapperAddress, outputMarketId };
+        isolationModeWrapperInfo = { wrapperAddress, inputMarketId };
+      }
+
+      let liquidityTokenUnwrapperInfo: ApiUnwrapperInfo | undefined;
+      let liquidityTokenWrapperInfo: ApiWrapperInfo | undefined;
+      if (isolationModeClient.isLiquidityToken(market.token)) {
+        liquidityTokenUnwrapperInfo = {
+          unwrapperAddress: isolationModeClient.getLiquidityTokenUnwrapperByToken(market.token),
+          outputMarketId: isolationModeClient.getLiquidityTokenUnwrapperMarketIdByToken(market.token),
+        };
+        liquidityTokenWrapperInfo = {
+          wrapperAddress: isolationModeClient.getLiquidityTokenWrapperByToken(market.token),
+          inputMarketId: isolationModeClient.getLiquidityTokenWrapperMarketIdByToken(market.token),
+        };
+      }
+
+      const apiMarket: ApiMarket = {
+        marketId: Number(market.token.marketId),
+        symbol: market.token.symbol,
+        name: market.token.name,
+        tokenAddress: ethers.utils.getAddress(market.token.id),
+        decimals: Number(market.token.decimals),
+        isolationModeUnwrapperInfo,
+        isolationModeWrapperInfo,
+        liquidityTokenUnwrapperInfo,
+        liquidityTokenWrapperInfo,
+      };
+      return apiMarket;
+    });
+
+    return (await Promise.all(markets)).filter(market => !!market) as ApiMarket[];
+  }
+}

package/src/clients/IsolationModeClient.ts

@@ -0,0 +1,55 @@
+import { Network } from '../lib/ApiTypes';
+import { ISOLATION_MODE_CONVERSION_MARKET_ID_MAP, LIQUIDITY_TOKEN_CONVERSION_MARKET_ID_MAP } from '../lib/Constants';
+import { GraphqlToken } from '../lib/graphql-types';
+
+export default class IsolationModeClient {
+  public readonly network: Network;
+
+  constructor(network: Network) {
+    this.network = network;
+  }
+
+  // ==================== Isolation Mode Getters ====================
+
+  public isIsolationModeToken(token: GraphqlToken): boolean {
+    return token.name.includes('Dolomite Isolation:') || token.symbol === 'dfsGLP';
+  }
+
+  public getIsolationModeUnwrapperMarketIdByMarketId(token: GraphqlToken): number | undefined {
+    return ISOLATION_MODE_CONVERSION_MARKET_ID_MAP[this.network][token.marketId]?.unwrapperMarketId;
+  }
+
+  public getIsolationModeWrapperMarketIdByMarketId(token: GraphqlToken): number | undefined {
+    return ISOLATION_MODE_CONVERSION_MARKET_ID_MAP[this.network][token.marketId]?.wrapperMarketId;
+  }
+
+  public getIsolationModeUnwrapperByMarketId(token: GraphqlToken): string | undefined {
+    return ISOLATION_MODE_CONVERSION_MARKET_ID_MAP[this.network][token.marketId]?.unwrapper;
+  }
+
+  public getIsolationModeWrapperByMarketId(token: GraphqlToken): string | undefined {
+    return ISOLATION_MODE_CONVERSION_MARKET_ID_MAP[this.network][token.marketId]?.wrapper;
+  }
+
+  // ==================== Liquidity Token Getters ====================
+
+  public isLiquidityToken(token: GraphqlToken): boolean {
+    return LIQUIDITY_TOKEN_CONVERSION_MARKET_ID_MAP[this.network][token.marketId] !== undefined;
+  }
+
+  public getLiquidityTokenUnwrapperMarketIdByToken(token: GraphqlToken): number {
+    return LIQUIDITY_TOKEN_CONVERSION_MARKET_ID_MAP[this.network][token.marketId].unwrapperMarketId;
+  }
+
+  public getLiquidityTokenWrapperMarketIdByToken(token: GraphqlToken): number {
+    return LIQUIDITY_TOKEN_CONVERSION_MARKET_ID_MAP[this.network][token.marketId].wrapperMarketId;
+  }
+
+  public getLiquidityTokenUnwrapperByToken(token: GraphqlToken): string {
+    return LIQUIDITY_TOKEN_CONVERSION_MARKET_ID_MAP[this.network][token.marketId].unwrapper;
+  }
+
+  public getLiquidityTokenWrapperByToken(token: GraphqlToken): string {
+    return LIQUIDITY_TOKEN_CONVERSION_MARKET_ID_MAP[this.network][token.marketId].wrapper;
+  }
+}