@paraswap/dex-lib 2.14.7 → 2.15.2-curve-v1-issue

package/src/dex/hashflow/rate-fetcher.ts

@@ -0,0 +1,120 @@
+import { IDexHelper } from '../../dex-helper';
+import { Fetcher, SkippingRequest } from '../../lib/fetcher/fetcher';
+import { validateAndCast } from '../../lib/validators';
+import { Logger } from '../../types';
+import {
+  HashflowRateFetcherConfig,
+  HashflowRatesResponse,
+  HashflowMarketMakersResponse,
+} from './types';
+import { pricesResponseValidator, marketMakersValidator } from './validators';
+import { Network } from '../../constants';
+
+export class RateFetcher {
+  private rateFetcher: Fetcher<HashflowRatesResponse>;
+  private pricesCacheKey: string;
+  private pricesCacheTTL: number;
+
+  private marketMakersFetcher: Fetcher<HashflowMarketMakersResponse>;
+  private marketMakersCacheKey: string;
+  private marketMakersCacheTTL: number;
+
+  constructor(
+    private dexHelper: IDexHelper,
+    private dexKey: string,
+    private network: Network,
+    private logger: Logger,
+    config: HashflowRateFetcherConfig,
+  ) {
+    this.pricesCacheKey = config.rateConfig.pricesCacheKey;
+    this.pricesCacheTTL = config.rateConfig.pricesCacheTTLSecs;
+    this.marketMakersCacheKey = config.rateConfig.marketMakersCacheKey;
+    this.marketMakersCacheTTL = config.rateConfig.marketMakersCacheTTLSecs;
+
+    this.marketMakersFetcher = new Fetcher<HashflowMarketMakersResponse>(
+      dexHelper.httpRequest,
+      {
+        info: {
+          requestOptions: config.rateConfig.marketMakersReqParams,
+          caster: (data: unknown) => {
+            return validateAndCast<HashflowMarketMakersResponse>(
+              data,
+              marketMakersValidator,
+            );
+          },
+        },
+        handler: this.handleMarketMakersResponse.bind(this),
+      },
+      config.rateConfig.markerMakersIntervalMs,
+      logger,
+    );
+
+    this.rateFetcher = new Fetcher<HashflowRatesResponse>(
+      dexHelper.httpRequest,
+      {
+        info: {
+          requestOptions: config.rateConfig.pricesReqParams,
+          requestFunc: async options => {
+            const { filterMarketMakers, getCachedMarketMakers } =
+              config.rateConfig;
+
+            const cachedMarketMakers = (await getCachedMarketMakers()) || [];
+            const filteredMarketMakers = await filterMarketMakers(
+              cachedMarketMakers,
+            );
+
+            if (filteredMarketMakers.length === 0) {
+              return new SkippingRequest(
+                `${dexKey}-${network}: got ${filteredMarketMakers.length} market makers.`,
+              );
+            }
+
+            const prices = await dexHelper.httpRequest.request({
+              ...options,
+              params: { ...options.params, marketMakers: filteredMarketMakers },
+            });
+
+            return prices;
+          },
+          caster: (data: unknown) => {
+            return validateAndCast<HashflowRatesResponse>(
+              data,
+              pricesResponseValidator,
+            );
+          },
+        },
+        handler: this.handleRatesResponse.bind(this),
+      },
+      config.rateConfig.pricesIntervalMs,
+      logger,
+    );
+  }
+
+  start() {
+    this.marketMakersFetcher.startPolling();
+    this.rateFetcher.startPolling();
+  }
+
+  stop() {
+    this.marketMakersFetcher.stopPolling();
+    this.rateFetcher.stopPolling();
+  }
+
+  private handleMarketMakersResponse(resp: HashflowMarketMakersResponse): void {
+    const { marketMakers } = resp;
+    this.dexHelper.cache.rawset(
+      this.marketMakersCacheKey,
+      JSON.stringify(marketMakers),
+      this.marketMakersCacheTTL,
+    );
+  }
+
+  private handleRatesResponse(resp: HashflowRatesResponse): void {
+    const { levels } = resp;
+    this.dexHelper.cache.rawset(
+      this.pricesCacheKey,
+      JSON.stringify(levels),
+      this.pricesCacheTTL,
+    );
+  }
+}

package/src/dex/hashflow/types.ts

@@ -1,4 +1,5 @@
 import { QuoteData } from '@hashflow/taker-js/dist/types/common';
+import { RequestHeaders } from '../../dex-helper';
 
 export type HashflowData = {
   mm: string;
@@ -24,3 +25,42 @@ export enum RFQType {
 }
 
 export class SlippageCheckError extends Error {}
+
+export type HashflowRatesLevel = {
+  pair: Record<string, string>;
+  levels: Array<Record<string, string>>;
+  includesFees: boolean;
+};
+
+export type HashflowMarketMakersResponse = {
+  marketMakers: string[];
+};
+
+export type HashflowRatesResponse = {
+  status: string;
+  networkId: string;
+  levels: Record<string, Array<HashflowRatesLevel>>;
+};
+
+export type HashflowRateFetcherConfig = {
+  rateConfig: {
+    marketMakersReqParams: {
+      url: string;
+      headers?: RequestHeaders;
+      params?: any;
+    };
+    pricesReqParams: {
+      url: string;
+      headers?: RequestHeaders;
+      params?: any;
+    };
+    pricesIntervalMs: number;
+    markerMakersIntervalMs: number;
+    getCachedMarketMakers: () => Promise<string[] | null>;
+    filterMarketMakers: (makers: string[]) => Promise<string[]>;
+    pricesCacheKey: string;
+    marketMakersCacheKey: string;
+    pricesCacheTTLSecs: number;
+    marketMakersCacheTTLSecs: number;
+  };
+};

package/src/dex/hashflow/validators.ts

@@ -0,0 +1,27 @@
+import joi from 'joi';
+
+export const levelValidator = joi.array().items(joi.object({
+  pair: joi.object({
+    baseTokenName: joi.string().min(1).required(),
+    quoteTokenName: joi.string().min(1).required(),
+    baseToken: joi.string().min(1).required(),
+    quoteToken: joi.string().min(1).required(),
+    baseTokenDecimals: joi.number().min(1).required(),
+    quoteTokenDecimals: joi.number().min(1).required(),
+  }),
+  levels: joi.array().items(joi.object({
+    level: joi.string().min(1).required(),
+    price: joi.string().min(1).required(),
+  })),
+  includesFees: joi.boolean().required(),
+}));
+
+export const pricesResponseValidator = joi.object({
+  status: joi.string().required(),
+  networkId: joi.number().required(),
+  levels: joi.object().pattern(joi.string().min(1), levelValidator),
+});
+
+export const marketMakersValidator = joi.object({
+  marketMakers: joi.array().items(joi.string().min(1).required()),
+});

package/src/lib/fetcher/fetcher.ts

@@ -1,12 +1,20 @@
 import { IRequestWrapper } from '../../dex-helper';
 import { Logger } from 'log4js';
 import { RequestConfig, Response } from '../../dex-helper/irequest-wrapper';
+import { isFunction } from 'lodash';
 
 const FETCH_TIMEOUT_MS = 10 * 1000;
 const FETCH_FAIL_MAX_ATTEMPT = 5;
 const FETCH_FAIL_RETRY_TIMEOUT_MS = 60 * 1000;
 
+export class SkippingRequest {
+  constructor(
+    public message = '',
+  ) {}
+};
+
 export type RequestInfo<T> = {
+  requestFunc?: (options: RequestConfig) => Promise<Response<T> | SkippingRequest>;
   requestOptions: RequestConfig;
   caster: (data: unknown) => T;
   authenticate?: (options: RequestConfig) => RequestConfig;
@@ -18,7 +26,7 @@ export type RequestInfoWithHandler<T> = {
   handler: (data: T) => void;
 };
 
-export default class Fetcher<T> {
+export class Fetcher<T> {
   private requests: RequestInfoWithHandler<T>[];
   public lastFetchSucceeded: boolean = false;
   private failedCount = 0;
@@ -52,19 +60,29 @@ export default class Fetcher<T> {
       return;
     }
 
-    const promises = this.requests.map<Promise<Error | Response<T>>>(
+    const promises = this.requests.map<Promise<Error | Response<T> | SkippingRequest>>(
       async (reqInfo: RequestInfoWithHandler<T>) => {
         const info = reqInfo.info;
         let options = info.requestOptions;
+
         if (info.authenticate) {
           info.authenticate(options);
         }
 
         try {
-          const result = await this.requestWrapper.request({
-            timeout: FETCH_TIMEOUT_MS,
-            ...options,
-          });
+          let result;
+          if (isFunction(info.requestFunc)) {
+            result = await info.requestFunc({
+              timeout: FETCH_TIMEOUT_MS,
+              ...options,
+            });
+          } else {
+            result = await this.requestWrapper.request({
+              timeout: FETCH_TIMEOUT_MS,
+              ...options,
+            });
+          }
+
           return result;
         } catch (e) {
           return e as Error;
@@ -76,17 +94,28 @@ export default class Fetcher<T> {
       .map((_, i) => i)
       .filter(i => results[i] instanceof Error);
 
-    results
-      .filter(result => !(result instanceof Error))
-      .map(result => {
-        debugger;
+    const skipped = results
+      .map((_, i) => i)
+      .filter(i => results[i] instanceof SkippingRequest);
+
+    results.map(result => {
+      if(!(result instanceof Error || result instanceof SkippingRequest)) {
         this.logger.info(
           'Results Data:',
           JSON.stringify((result as any).data)
             .replace(/(?:\r\n|\r|\n)/g, ' ')
             .substring(0, 1000),
         );
-      });
+      }
+    });
+
+    skipped.forEach(i => {
+      const skippedRes = results[i] as SkippingRequest;
+      this.logger.warn(
+        `skipped request ${this.requests[i].info.requestOptions.url} ${skippedRes.message}`,
+      );
+    });
+
     failures.forEach(i => {
       this.logger.warn(
         `failed polling ${this.requests[i].info.requestOptions.url} ${results[i]}`,
@@ -102,7 +131,7 @@ export default class Fetcher<T> {
 
     results
       .map((_, i) => i)
-      .filter(i => !(results[i] instanceof Error))
+      .filter(i => !(results[i] instanceof Error || results[i] instanceof SkippingRequest))
       .forEach(i => {
         const response = results[i] as Response<T>;
         const reqInfo = this.requests[i];

package/src/lib/validators.ts

@@ -0,0 +1,34 @@
+import joi from 'joi';
+
+export class ValidationError extends Error {
+  readonly rawMessage: string;
+
+  readonly key?: string;
+
+  constructor(message: string, key?: string) {
+    super(key !== undefined ? `'${key}': ${message}` : message);
+    this.rawMessage = message;
+    this.key = key;
+  }
+}
+
+export const validateAndCast = <T>(
+  value: unknown,
+  schema: joi.Schema,
+  name?: string,
+): T => {
+  const { error, value: parsed } = schema.validate(value);
+
+  if (error !== undefined) {
+    let message;
+    if (name) {
+      message = `"${name}" ${error.message.slice(
+        error.message.indexOf('must'),
+      )}`;
+    } else {
+      message = error.message;
+    }
+    throw new ValidationError(message);
+  }
+  return parsed as T;
+};

package/tests/utils-e2e.ts

@@ -282,8 +282,8 @@ export async function testE2E(
 
 export type TestParamE2E = {
   config: Config;
-  srcToken: Token | SmartToken;
-  destToken: Token | SmartToken;
+  srcToken: SmartToken;
+  destToken: SmartToken;
   senderAddress: Address;
   thirdPartyAddress?: Address;
   _amount: string;
@@ -372,12 +372,12 @@ export async function newTestE2E({
       stateOverrides: {},
     };
 
-    (destToken as SmartToken).addBalance(GIFTER_ADDRESS, MAX_UINT);
-    (destToken as SmartToken).applyOverrides(stateOverrides);
+    destToken.addBalance(GIFTER_ADDRESS, MAX_UINT);
+    destToken.applyOverrides(stateOverrides);
 
     const giftTx = makeFakeTransferToSenderAddress(
       thirdPartyAddress,
-      (destToken as SmartToken).token,
+      destToken.token,
       swapSide === SwapSide.SELL
         ? twiceAmount.toString()
         : (BigInt(MAX_UINT) / 4n).toString(),
@@ -402,8 +402,8 @@ export async function newTestE2E({
   }
   try {
     const priceRoute = await paraswap.getPrices(
-      skipTenderly ? (srcToken as Token) : (srcToken as SmartToken).token,
-      skipTenderly ? (destToken as Token) : (destToken as SmartToken).token,
+      srcToken.token,
+      destToken.token,
       amount,
       swapSide,
       contractMethod,
@@ -432,11 +432,11 @@ export async function newTestE2E({
         networkID: `${network}`,
         stateOverrides: {},
       };
-      (srcToken as SmartToken).applyOverrides(stateOverrides);
-      (destToken as SmartToken).applyOverrides(stateOverrides);
+      srcToken.applyOverrides(stateOverrides);
+      destToken.applyOverrides(stateOverrides);
 
       if (swapSide === SwapSide.SELL) {
-        (srcToken as SmartToken)
+        srcToken
           .addBalance(senderAddress, twiceAmount.toString())
           .addAllowance(
             senderAddress,
@@ -444,7 +444,7 @@ export async function newTestE2E({
             amount.toString(),
           );
       } else {
-        (srcToken as SmartToken)
+        srcToken
           .addBalance(senderAddress, MAX_UINT)
           .addAllowance(
             senderAddress,
@@ -453,8 +453,8 @@ export async function newTestE2E({
           );
       }
 
-      (srcToken as SmartToken).applyOverrides(stateOverrides);
-      (destToken as SmartToken).applyOverrides(stateOverrides);
+      srcToken.applyOverrides(stateOverrides);
+      destToken.applyOverrides(stateOverrides);
 
       const swapTx = await (ts as TenderlySimulation).simulate(
         swapParams,

package/.vscode/launch.json

@@ -1,21 +0,0 @@
-{
-    // Use IntelliSense to learn about possible attributes.
-    // Hover to view descriptions of existing attributes.
-    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Launch Program",
-            "skipFiles": [
-                "<node_internals>/**"
-            ],
-            "program": "${workspaceFolder}/build/index.js",
-            "preLaunchTask": "tsc: build - tsconfig.json",
-            "outFiles": [
-                "${workspaceFolder}/build/**/*.js"
-            ]
-        }
-    ]
-}

package/build/dex/aave-v3/tokens/mainnet.json

@@ -1,44 +0,0 @@
-[
-    {
-        "aSymbol": "aDAI",
-        "aAddress": "0x018008bfb33d285247A21d44E50697654f754e63",
-        "address": "0x6b175474e89094c44da98b954eedeac495271d0f",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "aUSDC",
-        "aAddress": "0x98C23E9d8f34FEFb1B7BD6a91B7FF122F4e16F5c",
-        "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
-        "decimals": 6
-    },
-    {
-        "aSymbol": "aAAVE",
-        "aAddress": "0xA700b4eB416Be35b2911fd5Dee80678ff64fF6C9",
-        "address": "0x7fc66500c84a76ad7e9c93437bfc5ac33e2ddae9",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "aLINK",
-        "aAddress": "0x5E8C8A7243651DB1384C0dDfDbE39761E8e7E51a",
-        "address": "0x514910771af9ca656af840dff83e8264ecf986ca",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "aWBTC",
-        "aAddress": "0x5Ee5bf7ae06D1Be5997A1A72006FE6C607eC6DE8",
-        "address": "0x2260fac5e5542a773aa44fbcfedf7c193bc2c599",
-        "decimals": 8
-    },
-    {
-        "aSymbol": "aWETH",
-        "aAddress": "0x4d5F47FA6A74757f35C14fD3a6Ef8E3C9BC514E8",
-        "address": "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
-        "decimals": 18
-    },
-    {
-        "aSymbol": "awstETH",
-        "aAddress": "0x0B925eD163218f6662a35e0f0371Ac234f9E9371",
-        "address": "0x7f39c581f595b53c5cb19bd0b3f8da6c935e2ca0",
-        "decimals": 18
-    }
-]

package/build/dex/balancer-v2/VirtualBoostedPool.d.ts

@@ -1,79 +0,0 @@
-import { Interface } from '@ethersproject/abi';
-import { PoolState, SubgraphPoolBase, callData, BalancerSwap } from './types';
-import { SwapSide } from '../../constants';
-export declare type BoostedPools = {
-    [id: string]: BoostedPool;
-};
-export declare type BoostedPool = {
-    mainTokens: MainToken[];
-    phantomStablePoolAddr: string;
-};
-export declare type MainToken = {
-    address: string;
-    decimals: number;
-    linearPoolAddr: string;
-    linearPoolId: string;
-};
-export declare type VirtualBoostedPools = {
-    dictionary: BoostedPools;
-    subgraph: SubgraphPoolBase[];
-};
-declare type BoostedPoolPairData = {
-    tokenIn: string;
-    tokenOut: string;
-    phantomPoolId: any;
-    poolStates: {
-        [address: string]: PoolState;
-    };
-    boostedPools: BoostedPools;
-    gasCost: number;
-};
-export declare type SwapData = {
-    swaps: BalancerSwap[];
-    assets: string[];
-};
-export declare class VirtualBoostedPool {
-    /**
-     * Creates VirtualBoostedPools from list of input pools. A VirtualBoostedPool is a combination of Linear pools nested in a PhantomStable pool. i.e. bb-a-USD.
-     * @param pools Array of subgraph pools (should contain Phantom/Linear pools of interest)
-     * @returns Array of VirtualBoosted subgraph pools. Dictionary object of virtualBoosted pool data.
-     */
-    static createPools(pools: SubgraphPoolBase[]): VirtualBoostedPools;
-    static poolType: string;
-    vaultAddress: string;
-    vaultInterface: Interface;
-    linearPoolInterface: Interface;
-    phantomStablePoolInterface: Interface;
-    constructor(vaultAddress: string, vaultInterface: Interface, linearPoolInterface: Interface, metaStablePoolInterface: Interface);
-    getOnChainCalls(pool: SubgraphPoolBase, virtualBoostedPools: BoostedPools): callData[];
-    decodeOnChainCalls(pool: SubgraphPoolBase, data: {
-        success: boolean;
-        returnData: any;
-    }[], startIndex: number, boostedPools: BoostedPools): [{
-        [address: string]: PoolState;
-    }, number];
-    static getTokenPool(phantomPoolAddr: string, phantomPoolId: string, tokenAddr: string, boostedPools: BoostedPools): {
-        address: string;
-        type: string;
-        id: string;
-    };
-    parsePoolPairData(pool: SubgraphPoolBase, poolStates: {
-        [address: string]: PoolState;
-    }, tokenIn: string, tokenOut: string, boostedPools: BoostedPools): BoostedPoolPairData;
-    checkBalance(amounts: bigint[], unitVolume: bigint, side: SwapSide, poolPairData: BoostedPoolPairData): boolean;
-    onSell(amounts: bigint[], poolPairData: BoostedPoolPairData): bigint[];
-    _calcOutGivenIn(tokenAmountsIn: bigint[], tokenIn: string, tokenOut: string, phantomPoolId: string, poolStates: {
-        [address: string]: PoolState;
-    }, boostedPools: BoostedPools): bigint[];
-    /**
-     * Creates Balancer multihop swaps and asset info required to swap a pair of underlying tokens through the Boosted pools.
-     * @param tokenIn Underlying token in.
-     * @param tokenOut Underlying token out.
-     * @param boostedPoolId ID of the VirtualBoostedPool that tokenIn/Out belong to.
-     * @param amount Amount being traded.
-     * @param boostedPools Dictionary of boosted pools.
-     * @returns Swaps and assets.
-     */
-    static getSwapData(tokenIn: string, tokenOut: string, boostedPoolId: string, amount: string, boostedPools: BoostedPools): SwapData;
-}
-export {};