@paraswap/dex-lib 2.18.4 → 2.18.6-swaap-v2

package/src/dex/swaap-v2/types.ts

@@ -0,0 +1,74 @@
+import { RequestHeaders } from '../../dex-helper';
+import { Method } from '../../dex-helper/irequest-wrapper';
+
+export type SwaapV2Data = {
+  router: string;
+  callData: string;
+};
+
+export type DexParams = {
+  routerAddress: string;
+};
+
+export class SwaapV2QuoteError extends Error {}
+
+export interface SwaapV2PriceLevel {
+  level: number;
+  price: number;
+}
+
+export type SwaapV2PriceLevels = {
+  bids: Array<SwaapV2PriceLevel>;
+  asks: Array<SwaapV2PriceLevel>;
+  quote: string;
+  base: string;
+};
+
+export type SwaapV2PriceLevelsResponse = {
+  levels: Record<string, SwaapV2PriceLevels>;
+  success: boolean;
+};
+
+export type SwaapV2RateFetcherConfig = {
+  rateConfig: {
+    pricesReqParams: SwaapV2APIParameters;
+    pricesIntervalMs: number;
+    pricesCacheTTLSecs: number;
+  };
+};
+
+export type SwaapV2QuoteResponse = {
+  id: string;
+  calldata: string;
+  router: string;
+  expiration: number;
+  amount: string;
+  recipient: string;
+  guaranteed_price: number;
+  success: boolean;
+};
+
+export declare enum SwaapV2OrderType {
+  SELL = 1,
+  BUY = 2,
+}
+
+export type SwaapV2QuoteRequest = {
+  network_id: number;
+  origin: string;
+  sender: string;
+  recipient: string;
+  timestamp: number;
+  order_type: SwaapV2OrderType;
+  token_in: string;
+  token_out: string;
+  amount: string;
+  tolerance: number;
+};
+
+export type SwaapV2APIParameters = {
+  url: string;
+  headers?: RequestHeaders;
+  params?: any;
+  method?: Method;
+};

package/src/dex/swaap-v2/utils.ts

@@ -0,0 +1,44 @@
+import { Address } from '../../types';
+import { CACHE_PREFIX, ETHER_ADDRESS, NULL_ADDRESS } from '../../constants';
+
+export const getIdentifierPrefix = (
+  dexKey: string,
+  srcAddress: Address,
+  destAddress: Address,
+) => {
+  return `${dexKey}_${getPairName(srcAddress, destAddress)}`.toLowerCase();
+};
+
+export const getPairName = (srcAddress: Address, destAddress: Address) => {
+  const sortedAddresses =
+  srcAddress < destAddress
+    ? [srcAddress, destAddress]
+    : [destAddress, srcAddress];
+  return `${sortedAddresses[0]}_${sortedAddresses[1]}`.toLowerCase();
+}
+
+export const getCacheKey = (dexKey: string, cacheType: string) => {
+  return `${CACHE_PREFIX}_${dexKey}_${cacheType}`.toLowerCase();
+};
+
+export const getPriceLevelsCacheKey = (dexKey: string) => {
+  return getCacheKey(dexKey, 'price_levels');
+};
+
+export const getPoolIdentifier = (
+  dexKey: string,
+  srcAddress: Address,
+  destAddress: Address,
+) => {
+  return `${getIdentifierPrefix(
+    dexKey,
+    srcAddress,
+    destAddress,
+  )}`.toLowerCase();
+};
+
+export const normalizeTokenAddress = (address: string): string => {
+  return address.toLowerCase() === ETHER_ADDRESS
+    ? NULL_ADDRESS
+    : address.toLowerCase();
+};

package/src/dex/swaap-v2/validators.ts

@@ -0,0 +1,123 @@
+import BigNumber from 'bignumber.js';
+import joi, { CustomHelpers, ErrorReport } from 'joi';
+import * as ethers from 'ethers';
+import { SwaapV2PriceLevel } from './types';
+
+
+const priceLevelsValidator = joi.array().items(
+  joi.object({
+    level: joi.number().required(),
+    price: joi.number().required(),
+  }),
+);
+
+const ext: joi.Extension = {
+  type: 'validatedpriceLevels',
+  base: joi.object({
+    bids: priceLevelsValidator,
+    asks: priceLevelsValidator,
+  }),
+  rules: {
+    bidsLowerThanAsks: {
+      validate: (
+        values: { bids: SwaapV2PriceLevel[]; asks: SwaapV2PriceLevel[] },
+        helpers: CustomHelpers,
+      ) => {
+        if (
+          !values.bids ||
+          !values.asks ||
+          values.bids.length === 0 ||
+          values.asks.length === 0
+        ) {
+          return values;
+        }
+        const maxBid = values.bids
+          .map(pl => new BigNumber(pl.price))
+          .reduce(
+            (previousValue, currentValue) =>
+              currentValue.gte(previousValue) ? currentValue : previousValue,
+            new BigNumber(0),
+          );
+        const minAsk = values.asks
+          .map(pl => new BigNumber(pl.price))
+          .reduce(
+            (previousValue, currentValue) =>
+              currentValue.lte(previousValue) ? currentValue : previousValue,
+            new BigNumber('123456789012345678901234567890'),
+          );
+        return maxBid < minAsk
+          ? values
+          : helpers.message({
+              custom: 'the maximum bid is higher than minimum ask',
+            });
+      },
+    },
+  },
+};
+
+export const priceLevelsResponseValidator = joi.object({
+  levels: joi
+    .object()
+    .pattern(
+      joi.string().min(1),
+      joi.extend(ext).validatedpriceLevels().bidsLowerThanAsks(),
+    ),
+  success: joi.boolean().required(),
+});
+
+export const addressSchema = joi.string().custom((value, helpers) => {
+  if (ethers.utils.isAddress(value)) {
+    return value.toLowerCase();
+  }
+  return helpers.message({ custom: `'${value}' is not valid address` });
+});
+
+export const blacklistResponseValidator = joi.object({
+  blacklist: joi.array().items(addressSchema),
+});
+
+const stringPositiveBigIntValidator = (
+  value: string,
+  helpers: CustomHelpers,
+): string | ErrorReport => {
+  try {
+    const val = BigInt(value);
+    if (val < 0) {
+      return helpers.message({ custom: `${value} is < 0` });
+    }
+    return value;
+  } catch (e) {
+    return helpers.message({
+      custom: `${value} is not castable to BigInt`,
+    });
+  }
+};
+
+const mustBeAugustusSwapper = (
+  value: string,
+  helpers: CustomHelpers,
+): string | ErrorReport => {
+  const allowedTakers = [
+    '0xDEF171Fe48CF0115B1d80b88dc8eAB59176FEe57'.toLowerCase(),
+  ];
+  return allowedTakers.includes(value.toLowerCase())
+    ? value
+    : helpers.message({
+        custom: `"order.taker" must be any of ${JSON.stringify(allowedTakers)}`,
+      });
+};
+
+export const getQuoteResponseValidator = joi
+  .object({
+    id: joi.string().required(),
+    recipient: addressSchema.required().custom(mustBeAugustusSwapper),
+    expiration: joi.number().min(0),
+    amount: joi
+      .string()
+      .min(0)
+      .custom(stringPositiveBigIntValidator)
+      .required(),
+    calldata: joi.string().required(),
+    success: joi.boolean().required(),
+  })
+  .unknown(true);

package/src/types.ts

@@ -275,6 +275,7 @@ export type Config = {
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
   uniswapV3EventLoggingSampleRate?: number;
+  swaapV2AuthToken?: string;
 };
 
 export type BigIntAsString = string;

package/tests/constants-e2e.ts

@@ -901,7 +901,7 @@ export const Holders: {
     WETH: '0x72a53cdbbcc1b9efa39c834a540550e23463aacb',
     WMATIC: '0xFffbCD322cEace527C8ec6Da8de2461C6D9d4e6e',
     AMWMATIC: '0x8832924854e3Cedb0a6Abf372e6CCFF9F7654332',
-    USDC: '0x06959153B974D0D5fDfd87D561db6d8d4FA0bb0B',
+    USDC: '0xf89d7b9c864f589bbf53a82105107622b35eaa40',
     POPS: '0x2693b57ee51f4e2a26dfb339a911fa8731061f49',
     MUST: '0x9f2a409848fb9b7bd058b24a23e8dbf1e166a109',
     AMDAI: '0xFA0DCe8280FCDf369a4cbFc1830d3302789307a6',

package/tests/utils-e2e.ts

@@ -189,6 +189,7 @@ export async function testE2E(
   transferFees?: TransferFeeParams,
   // Specified in BPS: part of 10000
   slippage?: number,
+  sleepMs?: number,
 ) {
   const amount = BigInt(_amount);
   const ts = new TenderlySimulation(network);
@@ -231,6 +232,10 @@ export async function testE2E(
     : new LocalParaswapSDK(network, dexKey, '', limitOrderProvider);
 
   if (paraswap.initializePricing) await paraswap.initializePricing();
+  
+  if (sleepMs) {
+    await sleep(sleepMs);
+  }
 
   if (paraswap.dexHelper?.replaceProviderWithRPC) {
     paraswap.dexHelper?.replaceProviderWithRPC(