@paraswap/dex-lib 2.12.12-rfqtests.1 → 2.12.12

package/build/lib/stateful-rpc-poller/types.d.ts

@@ -0,0 +1,35 @@
+import { MultiCallParams, MultiResult } from '../multi-wrapper';
+export declare type ObjWithUpdateInfo<T> = {
+    value: T;
+    blockNumber: number;
+    lastUpdatedAtMs: number;
+};
+export interface IStatefulRpcPoller<State, M> {
+    identifierKey: string;
+    dexKey: string;
+    isPoolParticipateInUpdates: boolean;
+    isPoolInTheMiddleOfUpdate: boolean;
+    network: number;
+    isTimeToTriggerUpdate(blockNumber: number): boolean;
+    getFetchStateWithBlockInfoMultiCalls(): [
+        MultiCallParams<number>,
+        ...MultiCallParams<M>[]
+    ];
+    parseStateFromMultiResultsWithBlockInfo(multiOutputs: [MultiResult<number>, ...MultiResult<M>[]], lastUpdatedAtMs: number): ObjWithUpdateInfo<State>;
+    setState(state: State, blockNumber: number, lastUpdatedAtMs: number): Promise<void>;
+    fetchStateFromCache(): Promise<ObjWithUpdateInfo<State> | null>;
+    fetchLatestStateFromRpc(): Promise<ObjWithUpdateInfo<State> | null>;
+    initializeState(): Promise<void>;
+    getState(blockNumber: number): Promise<ObjWithUpdateInfo<State> | null>;
+    setLiquidity(newLiquidityInUSD: number, lastUpdatedAtMs: number, blockNumber?: number): Promise<void>;
+}
+export declare type PollingManagerControllersCb = {
+    enableStateTracking: (identifierKey: string) => void;
+    disableStateTracking: (identifierKey: string) => void;
+    registerPendingPool: <T, M>(statefulRpcPoller: IStatefulRpcPoller<T, M>) => void;
+};
+export declare enum StateSources {
+    LOCAL_MEMORY = "local_memory",
+    CACHE = "cache",
+    RPC = "rpc"
+}

package/build/lib/stateful-rpc-poller/types.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateSources = void 0;
+var StateSources;
+(function (StateSources) {
+    StateSources["LOCAL_MEMORY"] = "local_memory";
+    StateSources["CACHE"] = "cache";
+    StateSources["RPC"] = "rpc";
+})(StateSources = exports.StateSources || (exports.StateSources = {}));
+//# sourceMappingURL=types.js.map

package/build/lib/stateful-rpc-poller/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/stateful-rpc-poller/types.ts"],"names":[],"mappings":";;;AA6DA,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,6CAA6B,CAAA;IAC7B,+BAAe,CAAA;IACf,2BAAW,CAAA;AACb,CAAC,EAJW,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAIvB"}

package/build/lib/stateful-rpc-poller/utils.d.ts

@@ -0,0 +1,4 @@
+import type { StatePollingManager } from './state-polling-manager';
+import { PollingManagerControllersCb } from './types';
+export declare function getIdentifierKeyForRpcPoller(poolIdentifier: string, network: number): string;
+export declare function pollingManagerCbExtractor(statePollingManager: StatePollingManager): PollingManagerControllersCb;

package/build/lib/stateful-rpc-poller/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollingManagerCbExtractor = exports.getIdentifierKeyForRpcPoller = void 0;
+function getIdentifierKeyForRpcPoller(poolIdentifier, network) {
+    return `${network}_${poolIdentifier}`.toLowerCase();
+}
+exports.getIdentifierKeyForRpcPoller = getIdentifierKeyForRpcPoller;
+// Helper function to extract relevant call backs for later use
+function pollingManagerCbExtractor(statePollingManager) {
+    return {
+        enableStateTracking: statePollingManager.enableStateTracking.bind(statePollingManager),
+        disableStateTracking: statePollingManager.disableStateTracking.bind(statePollingManager),
+        registerPendingPool: statePollingManager.registerPendingPool.bind(statePollingManager),
+    };
+}
+exports.pollingManagerCbExtractor = pollingManagerCbExtractor;
+//# sourceMappingURL=utils.js.map

package/build/lib/stateful-rpc-poller/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/stateful-rpc-poller/utils.ts"],"names":[],"mappings":";;;AAGA,SAAgB,4BAA4B,CAC1C,cAAsB,EACtB,OAAe;IAEf,OAAO,GAAG,OAAO,IAAI,cAAc,EAAE,CAAC,WAAW,EAAE,CAAC;AACtD,CAAC;AALD,oEAKC;AAED,+DAA+D;AAC/D,SAAgB,yBAAyB,CACvC,mBAAwC;IAExC,OAAO;QACL,mBAAmB,EACjB,mBAAmB,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB,CAAC;QACnE,oBAAoB,EAClB,mBAAmB,CAAC,oBAAoB,CAAC,IAAI,CAAC,mBAAmB,CAAC;QACpE,mBAAmB,EACjB,mBAAmB,CAAC,mBAAmB,CAAC,IAAI,CAAC,mBAAmB,CAAC;KACpE,CAAC;AACJ,CAAC;AAXD,8DAWC"}

package/build/lib/validators.d.ts

@@ -0,0 +1,7 @@
+import joi from 'joi';
+export declare class ValidationError extends Error {
+    readonly rawMessage: string;
+    readonly key?: string;
+    constructor(message: string, key?: string);
+}
+export declare const validateAndCast: <T>(value: unknown, schema: joi.Schema, name?: string | undefined) => T;

package/build/lib/validators.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndCast = exports.ValidationError = void 0;
+class ValidationError extends Error {
+    constructor(message, key) {
+        super(key !== undefined ? `'${key}': ${message}` : message);
+        this.rawMessage = message;
+        this.key = key;
+    }
+}
+exports.ValidationError = ValidationError;
+const validateAndCast = (value, schema, name) => {
+    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;
+};
+exports.validateAndCast = validateAndCast;
+//# sourceMappingURL=validators.js.map

package/build/lib/validators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.js","sourceRoot":"","sources":["../../src/lib/validators.ts"],"names":[],"mappings":";;;AAEA,MAAa,eAAgB,SAAQ,KAAK;IAKxC,YAAY,OAAe,EAAE,GAAY;QACvC,KAAK,CAAC,GAAG,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,OAAO,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;QAC5D,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC;QAC1B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;CACF;AAVD,0CAUC;AAEM,MAAM,eAAe,GAAG,CAC7B,KAAc,EACd,MAAkB,EAClB,IAAa,EACV,EAAE;IACL,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAExD,IAAI,KAAK,KAAK,SAAS,EAAE;QACvB,IAAI,OAAO,CAAC;QACZ,IAAI,IAAI,EAAE;YACR,OAAO,GAAG,IAAI,IAAI,KAAK,KAAK,CAAC,OAAO,CAAC,KAAK,CACxC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAC9B,EAAE,CAAC;SACL;aAAM;YACL,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;SACzB;QACD,MAAM,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;KACpC;IACD,OAAO,MAAW,CAAC;AACrB,CAAC,CAAC;AAnBW,QAAA,eAAe,mBAmB1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paraswap/dex-lib",
-  "version": "2.12.12-rfqtests.1",
+  "version": "2.12.12",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "repository": "https://github.com/paraswap/paraswap-dex-lib",

package/src/config.ts

@@ -151,9 +151,9 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_56`]?.split(',') || [],
     adapterAddresses: {
-      BscAdapter01: '0x27eb327B7255a2bF666EBB4D60AB4752dA4611b9',
-      BscAdapter02: '0xa003dFBA51C9e1e56C67ae445b852bdEd7aC5EEd',
-      BscBuyAdapter: '0xfa072107a2CCfE5664794282EF36400735ABB70F',
+      BscAdapter01: '0xA31d9C571DF00e0F428B0bD24c34D103E8112222',
+      BscAdapter02: '0xe102429Ef7CAaBaAA3bc2C017aC784c5F665EE82',
+      BscBuyAdapter: '0xA7f4fBCEB76a1B1c05C106a4289C28B3b91C17ca',
     },
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',

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

@@ -125,7 +125,7 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
   const url = getEnv('GENERIC_RFQ_URL');
 
   const secret = {
-    secretKey: Buffer.from(getEnv('GENERIC_RFQ_SECRET_KEY'), 'base64').toString('binary'),
+    secretKey: atob(getEnv('GENERIC_RFQ_SECRET_KEY')),
     accessKey: getEnv('GENERIC_RFQ_ACCESS_KEY'),
     domain: 'paraswap',
   };
@@ -179,8 +179,6 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
   };
 };
 
-const SKIP_TENDERLY = !!getEnv('GENERIC_RFQ_SKIP_TENDERLY', true);
-
 describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
   const dexKey = 'YOUR_NAME';
 
@@ -191,67 +189,62 @@ describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
   config.rfqConfigs[dexKey] = buildConfigForGenericRFQ();
 
   describe('GenericRFQ B/Q BUY', () => {
-    const srcToken = smartTokens.USDT;
-    const destToken = smartTokens.WETH;
-
-    if (!SKIP_TENDERLY) {
-      srcToken.addBalance(testAccount.address, MAX_UINT);
-      srcToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-
-      destToken.addBalance(testAccount.address, MAX_UINT);
-      destToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-    }
+    const srcToken = smartTokens.USDC;
+    const destToken = smartTokens.WBTC;
+
+    srcToken.addBalance(testAccount.address, MAX_UINT);
+    srcToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
+
+    destToken.addBalance(testAccount.address, MAX_UINT);
+    destToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
 
     describe('Simpleswap', () => {
-      it('BUY USDT -> WETH', async () => {
+      it('BUY USDC -> WBTC', async () => {
         await newTestE2E({
           config,
           srcToken,
           destToken,
           senderAddress: GENERIC_ADDR1,
           thirdPartyAddress: testAccount.address,
-          _amount: '10000000000000000',
+          _amount: '1000000',
           swapSide: SwapSide.BUY,
           dexKey: dexKey,
           contractMethod: ContractMethod.simpleBuy,
           network: network,
           sleepMs: 5000,
-          skipTenderly: SKIP_TENDERLY,
         });
       });
     });
   });
 
   describe('GenericRFQ Q/B BUY', () => {
-    const srcToken = smartTokens.WETH;
-    const destToken = smartTokens.USDT;
-
-    if (!SKIP_TENDERLY) {
-      srcToken.addBalance(testAccount.address, MAX_UINT);
-      srcToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-
-      destToken.addBalance(testAccount.address, MAX_UINT);
-      destToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-    }
+    const srcToken = smartTokens.WBTC;
+    const destToken = smartTokens.USDC;
+
+    srcToken.addBalance(testAccount.address, MAX_UINT);
+    srcToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
+
+    destToken.addBalance(testAccount.address, MAX_UINT);
+    destToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
 
     describe('Simpleswap', () => {
-      it('BUY WETH -> USDT', async () => {
+      it('BUY WBTC -> USDC', async () => {
         await newTestE2E({
           config,
           srcToken,
@@ -264,34 +257,31 @@ describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
           contractMethod: ContractMethod.simpleBuy,
           network: network,
           sleepMs: 5000,
-          skipTenderly: SKIP_TENDERLY,
         });
       });
     });
   });
 
   describe('GenericRFQ B/Q SELL', () => {
-    const srcToken = smartTokens.USDT;
-    const destToken = smartTokens.WETH;
-
-    if (!SKIP_TENDERLY) {
-      srcToken.addBalance(testAccount.address, MAX_UINT);
-      srcToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-
-      destToken.addBalance(testAccount.address, MAX_UINT);
-      destToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-    }
+    const srcToken = smartTokens.USDC;
+    const destToken = smartTokens.WBTC;
+
+    srcToken.addBalance(testAccount.address, MAX_UINT);
+    srcToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
+
+    destToken.addBalance(testAccount.address, MAX_UINT);
+    destToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
 
     describe('Simpleswap', () => {
-      it('SELL USDT -> WETH', async () => {
+      it('SELL USDC -> WBTC', async () => {
         await newTestE2E({
           config,
           srcToken,
@@ -304,47 +294,43 @@ describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
           contractMethod: ContractMethod.simpleSwap,
           network: network,
           sleepMs: 5000,
-          skipTenderly: SKIP_TENDERLY,
         });
       });
     });
   });
 
   describe('GenericRFQ Q/B SELL', () => {
-    const srcToken = smartTokens.WETH;
-    const destToken = smartTokens.USDT;
-
-    if (!SKIP_TENDERLY) {
-      srcToken.addBalance(testAccount.address, MAX_UINT);
-      srcToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-
-      destToken.addBalance(testAccount.address, MAX_UINT);
-      destToken.addAllowance(
-        testAccount.address,
-        config.augustusRFQAddress,
-        MAX_UINT,
-      );
-    }
+    const srcToken = smartTokens.WBTC;
+    const destToken = smartTokens.USDC;
+
+    srcToken.addBalance(testAccount.address, MAX_UINT);
+    srcToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
+
+    destToken.addBalance(testAccount.address, MAX_UINT);
+    destToken.addAllowance(
+      testAccount.address,
+      config.augustusRFQAddress,
+      MAX_UINT,
+    );
 
     describe('Simpleswap', () => {
-      it('SELL WETH -> USDT', async () => {
+      it('SELL WBTC -> USDC', async () => {
         await newTestE2E({
           config,
           srcToken,
           destToken,
           senderAddress: GENERIC_ADDR1,
           thirdPartyAddress: testAccount.address,
-          _amount: '10000000000000000',
+          _amount: '10000',
           swapSide: SwapSide.SELL,
           dexKey: dexKey,
           contractMethod: ContractMethod.simpleSwap,
           network: network,
           sleepMs: 5000,
-          skipTenderly: SKIP_TENDERLY,
         });
       });
     });

package/src/dex/generic-rfq/rate-fetcher.ts

@@ -406,7 +406,6 @@ export class RateFetcher {
       const { data } = await this.dexHelper.httpRequest.request<unknown>(
         payload,
       );
-      this.logger.info(`Firm quote response for payload ${payload} is ${data}`);
 
       const firmRateResp = validateAndCast<RFQFirmRateResponse>(
         data,

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

@@ -112,11 +112,10 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    const pricesNegativeSpread = {
+    const pricesInvalidBidsNotSortedDesc = {
       prices: {
         'WETH/DAI': {
           bids: [
-            ['1337.425240000000000000', '1.166200000000000000'],
             ['1333.024812000000000000', '1.166200000000000000'],
             ['1333.425240000000000000', '1.166200000000000000'],
             ['1332.624384000000000000', '1.166200000000000000'],
@@ -136,6 +135,29 @@ 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': {},
@@ -178,6 +200,12 @@ 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();
@@ -190,9 +218,6 @@ describe('GenericRFQ Validator test', () => {
       expect(() =>
         validateAndCast(onlyAsks, pricesResponse),
       ).not.toThrowError();
-      expect(() =>
-        validateAndCast(pricesNegativeSpread, pricesResponse),
-      ).toThrowError('the maximum bid is higher than minimum ask');
     });
   });
 
@@ -236,10 +261,11 @@ describe('GenericRFQ Validator test', () => {
       },
     };
 
-    it('Order test', () => {
+    it('Blacklist 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 pricesValidator = joi
+const pricesValidatorWithoutSorting = joi
   .array()
   .items(
     joi
@@ -66,58 +66,47 @@ const pricesValidator = joi
   );
 
 const ext: joi.Extension = {
-  type: 'validatedPrices',
-  base: joi.object({
-    bids: pricesValidator,
-    asks: pricesValidator,
-  }),
+  type: 'sortedArray',
+  base: pricesValidatorWithoutSorting,
   rules: {
-    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
+    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
           ? values
           : helpers.message({
-              custom: 'the maximum bid is higher than minimum ask',
+              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)}`,
             });
       },
     },
   },
 };
 
-export const priceValidator = joi.extend(ext);
+const pricesArrayValidator = joi.extend(ext);
+
+export const priceValidator = joi.object({
+  bids: pricesArrayValidator.sortedArray().desc(),
+  asks: pricesArrayValidator.sortedArray().asc(),
+});
 
 export const pricesResponse = joi.object({
-  prices: joi
-    .object()
-    .pattern(
-      joi.string().min(1),
-      priceValidator.validatedPrices().bidsLowerThanAsks(),
-    ),
+  prices: joi.object().pattern(joi.string().min(1), priceValidator),
 });
 
 export const validateAndCast = <T>(
@@ -182,26 +171,12 @@ 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().custom(mustBeAugustusSwapper),
+    taker: addressSchema.required(),
     makerAsset: addressSchema.required(),
     takerAsset: addressSchema.required(),
     makerAmount: joi

package/src/dex/uniswap-v3/config.ts

@@ -35,6 +35,15 @@ export const UniswapV3Config: DexConfigMap<DexParams> = {
       uniswapMulticall: '0x1F98415757620B543A52E61c46B32eB19261F984',
       chunksCount: 10,
     },
+    [Network.BSC]: {
+      factory: '0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7',
+      quoter: '0x78D78E420Da98ad378D7799bE8f4AF69033EB077',
+      router: '0x83c346ba3d4bf36b308705e24fad80999401854b',
+      supportedFees: SUPPORTED_FEES,
+      stateMulticall: '0x593F39A4Ba26A9c8ed2128ac95D109E8e403C485',
+      uniswapMulticall: '0x963Df249eD09c358A4819E39d9Cd5736c3087184',
+      chunksCount: 10,
+    },
     [Network.POLYGON]: {
       factory: '0x1F98431c8aD98523631AE4a59f267346ea31F984',
       quoter: '0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6',
@@ -70,6 +79,10 @@ export const Adapters: Record<number, AdapterMappings> = {
     [SwapSide.SELL]: [{ name: 'Adapter01', index: 6 }],
     [SwapSide.BUY]: [{ name: 'BuyAdapter', index: 2 }],
   },
+  [Network.BSC]: {
+    [SwapSide.SELL]: [{ name: 'BscAdapter02', index: 4 }],
+    [SwapSide.BUY]: [{ name: 'BscBuyAdapter', index: 5 }],
+  },
   [Network.POLYGON]: {
     [SwapSide.SELL]: [{ name: 'PolygonAdapter01', index: 13 }],
     [SwapSide.BUY]: [{ name: 'PolygonBuyAdapter', index: 2 }],