@paraswap/dex-lib 2.14.0 → 2.14.2

package/src/dex/generic-rfq/validators.test.ts

@@ -112,10 +112,11 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    const pricesInvalidBidsNotSortedDesc = {
+    const pricesNegativeSpread = {
       prices: {
         'WETH/DAI': {
           bids: [
+            ['1337.425240000000000000', '1.166200000000000000'],
             ['1333.024812000000000000', '1.166200000000000000'],
             ['1333.425240000000000000', '1.166200000000000000'],
             ['1332.624384000000000000', '1.166200000000000000'],
@@ -135,29 +136,6 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    const pricesInvalidAskNotSortedAsc = {
-      prices: {
-        'WETH/DAI': {
-          bids: [
-            ['1333.425240000000000000', '1.166200000000000000'],
-            ['1333.024812000000000000', '1.166200000000000000'],
-            ['1332.624384000000000000', '1.166200000000000000'],
-            ['1332.223956000000000000', '1.166200000000000000'],
-            ['1331.823528000000000000', '1.166200000000000000'],
-            ['1331.423100000000000000', '1.169000000000000000'],
-          ],
-          asks: [
-            ['1337.146033000000000000', '1.166200000000000000'],
-            ['1336.745410000000000000', '1.166200000000000000'],
-            ['1337.546656000000000000', '1.166200000000000000'],
-            ['1337.947279000000000000', '1.166200000000000000'],
-            ['1338.347902000000000000', '1.166200000000000000'],
-            ['1338.748525000000000000', '1.169000000000000000'],
-          ],
-        },
-      },
-    };
-
     const noPrices = {
       prices: {
         'WETH/DAI': {},
@@ -200,12 +178,6 @@ describe('GenericRFQ Validator test', () => {
 
     it('Price test', () => {
       expect(() => validateAndCast(prices, pricesResponse)).not.toThrowError();
-      expect(() =>
-        validateAndCast(pricesInvalidBidsNotSortedDesc, pricesResponse),
-      ).toThrowError();
-      expect(() =>
-        validateAndCast(pricesInvalidAskNotSortedAsc, pricesResponse),
-      ).toThrowError();
       expect(() =>
         validateAndCast(noPrices, pricesResponse),
       ).not.toThrowError();
@@ -218,6 +190,9 @@ describe('GenericRFQ Validator test', () => {
       expect(() =>
         validateAndCast(onlyAsks, pricesResponse),
       ).not.toThrowError();
+      expect(() =>
+        validateAndCast(pricesNegativeSpread, pricesResponse),
+      ).toThrowError('the maximum bid is higher than minimum ask');
     });
   });
 
@@ -261,11 +236,10 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    it('Blacklist test', () => {
+    it('Order test', () => {
       expect(() =>
         validateAndCast(order, firmRateResponseValidator),
       ).not.toThrowError();
-      // expect(() => validateAndCast(invalidBlacklist, blacklistResponseValidator)).toThrowError();
     });
   });
 });

package/src/dex/generic-rfq/validators.ts

@@ -56,7 +56,7 @@ const stringNumberValidator = (
   return value;
 };
 
-const pricesValidatorWithoutSorting = joi
+const pricesValidator = joi
   .array()
   .items(
     joi
@@ -66,47 +66,58 @@ const pricesValidatorWithoutSorting = joi
   );
 
 const ext: joi.Extension = {
-  type: 'sortedArray',
-  base: pricesValidatorWithoutSorting,
+  type: 'validatedPrices',
+  base: joi.object({
+    bids: pricesValidator,
+    asks: pricesValidator,
+  }),
   rules: {
-    asc: {
-      validate: (values: string[], helpers: CustomHelpers) => {
-        const prices = values.map(numbers => new BigNumber(numbers[0]));
-        const isAscOrder = prices.every(
-          (x, i) => i === 0 || x.gte(prices[i - 1]),
-        );
-        return isAscOrder
+    bidsLowerThanAsks: {
+      validate: (
+        values: { bids: string[]; asks: string[] },
+        helpers: CustomHelpers,
+      ) => {
+        if (
+          !values.bids ||
+          !values.asks ||
+          values.bids.length === 0 ||
+          values.asks.length === 0
+        ) {
+          return values;
+        }
+        const maxBid = values.bids
+          .map(numbers => new BigNumber(numbers[0]))
+          .reduce(
+            (previousValue, currentValue) =>
+              currentValue.gte(previousValue) ? currentValue : previousValue,
+            new BigNumber(0),
+          );
+        const minAsk = values.asks
+          .map(numbers => new BigNumber(numbers[0]))
+          .reduce(
+            (previousValue, currentValue) =>
+              currentValue.lte(previousValue) ? currentValue : previousValue,
+            new BigNumber('123456789012345678901234567890'),
+          );
+        return maxBid < minAsk
           ? values
           : helpers.message({
-              custom: `array is not asc sorted ${JSON.stringify(values)}`,
-            });
-      },
-    },
-    desc: {
-      validate: (values: string[][], helpers: CustomHelpers) => {
-        const prices = values.map(numbers => new BigNumber(numbers[0]));
-        const isAscOrder = prices.every(
-          (x, i) => i === 0 || x.lte(prices[i - 1]),
-        );
-        return isAscOrder
-          ? values
-          : helpers.message({
-              custom: `array is not desc sorted ${JSON.stringify(values)}`,
+              custom: 'the maximum bid is higher than minimum ask',
             });
       },
     },
   },
 };
 
-const pricesArrayValidator = joi.extend(ext);
-
-export const priceValidator = joi.object({
-  bids: pricesArrayValidator.sortedArray().desc(),
-  asks: pricesArrayValidator.sortedArray().asc(),
-});
+export const priceValidator = joi.extend(ext);
 
 export const pricesResponse = joi.object({
-  prices: joi.object().pattern(joi.string().min(1), priceValidator),
+  prices: joi
+    .object()
+    .pattern(
+      joi.string().min(1),
+      priceValidator.validatedPrices().bidsLowerThanAsks(),
+    ),
 });
 
 export const validateAndCast = <T>(
@@ -171,12 +182,26 @@ const stringStartWithHex0x = (
   return value;
 };
 
+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 orderWithSignatureValidator = joi
   .object({
     nonceAndMeta: joi.string().custom(stringPositiveBigIntValidator),
     expiry: joi.number().min(0),
     maker: addressSchema.required(),
-    taker: addressSchema.required(),
+    taker: addressSchema.required().custom(mustBeAugustusSwapper),
     makerAsset: addressSchema.required(),
     takerAsset: addressSchema.required(),
     makerAmount: joi

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)',
+  ]),
+};