@paraswap/dex-lib 2.14.0 → 2.14.2

package/src/config.ts

@@ -25,6 +25,8 @@ type BaseConfig = {
   uniswapV2ExchangeRouterAddress: Address;
   uniswapV3EventLoggingSampleRate?: number;
   rfqConfigs: Record<string, RFQConfig>;
+  rpcPollingMaxAllowedStateDelayInBlocks: number;
+  rpcPollingBlocksBackToTriggerUpdate: number;
   hashFlowAuthToken?: string;
   hashFlowDisabledMMs: string[];
 };
@@ -52,6 +54,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     },
     uniswapV2ExchangeRouterAddress:
       '0xF9234CB08edb93c0d4a4d4c70cC3FfD070e78e07',
+    rpcPollingMaxAllowedStateDelayInBlocks: 0,
+    rpcPollingBlocksBackToTriggerUpdate: 0,
     hashFlowAuthToken: process.env.API_KEY_HASHFLOW_AUTH_TOKEN,
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_1`]?.split(',') || [],
@@ -134,6 +138,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 5,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
   },
   [Network.BSC]: {
     network: Network.BSC,
@@ -155,6 +161,8 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       BscAdapter02: '0xe102429Ef7CAaBaAA3bc2C017aC784c5F665EE82',
       BscBuyAdapter: '0xA7f4fBCEB76a1B1c05C106a4289C28B3b91C17ca',
     },
+    rpcPollingMaxAllowedStateDelayInBlocks: 1,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
@@ -177,13 +185,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_137`]?.split(',') || [],
     adapterAddresses: {
       PolygonAdapter01: '0xE44769f42E1e9592f86B82f206407a8f7C84b4ed',
-      PolygonAdapter02: '0x72C851edA05915F4cbbeF27E3AFd3Bc87F86b001',
+      PolygonAdapter02: '0xfb2a3de6c7B8c77b520E3da16021f3D8A4E93168',
       PolygonBuyAdapter: '0xbE36ddfCDB6D60c1B20FfD73594540E5cc2c7E97',
     },
     uniswapV2ExchangeRouterAddress:
       '0xf3938337F7294fEf84e9B2c6D548A93F956Cc281',
     uniswapV3EventLoggingSampleRate: 0,
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 2,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
   },
   [Network.AVALANCHE]: {
     network: Network.AVALANCHE,
@@ -202,13 +212,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
     hashFlowDisabledMMs:
       process.env[`HASHFLOW_DISABLED_MMS_43114`]?.split(',') || [],
     adapterAddresses: {
-      AvalancheAdapter01: '0x5b99094C3c2129F17b78cE5eBD1Cd8ADB887b340',
+      AvalancheAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
       AvalancheAdapter02: '0x3fd845dE49eBa45565d3b58CDEbf88d9bdA7aBf6',
       AvalancheBuyAdapter: '0xad2f7039B0F4c410654886D049ae8406F5aDe709',
     },
     uniswapV2ExchangeRouterAddress:
       '0x53e693c6C7FFC4446c53B205Cf513105Bf140D7b',
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 2,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
   },
   [Network.FANTOM]: {
     network: Network.FANTOM,
@@ -228,12 +240,14 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_250`]?.split(',') || [],
 
     adapterAddresses: {
-      FantomAdapter01: '0xD9026Ca611EEC89dd4030ae86953F2d8D899535c',
+      FantomAdapter01: '0x66152A2a538644Ae125570De522ADEaC9E41D865',
       FantomBuyAdapter: '0x27eb327B7255a2bF666EBB4D60AB4752dA4611b9',
     },
     uniswapV2ExchangeRouterAddress:
       '0xAB86e2bC9ec5485a9b60E684BA6d49bf4686ACC2',
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 2,
+    rpcPollingBlocksBackToTriggerUpdate: 1,
   },
   [Network.ARBITRUM]: {
     network: Network.ARBITRUM,
@@ -253,13 +267,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_42161`]?.split(',') || [],
     adapterAddresses: {
       ArbitrumAdapter01: '0x745Ec73855CeC7249E5fF4c9DD81cc65b4D297a9',
-      ArbitrumAdapter02: '0xa003dFBA51C9e1e56C67ae445b852bdEd7aC5EEd',
+      ArbitrumAdapter02: '0xCBaeB06C2dF373c07A2Dc205266EC3bCd525DfB6',
       ArbitrumBuyAdapter: '0xfa072107a2CCfE5664794282EF36400735ABB70F',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
     uniswapV3EventLoggingSampleRate: 0,
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 4,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
   },
   [Network.OPTIMISM]: {
     network: Network.OPTIMISM,
@@ -279,13 +295,15 @@ const baseConfigs: { [network: number]: BaseConfig } = {
       process.env[`HASHFLOW_DISABLED_MMS_10`]?.split(',') || [],
 
     adapterAddresses: {
-      OptimismAdapter01: '0xB6EBBB9f9957556Fd798927ae7c250759a235407',
+      OptimismAdapter01: '0x4669D27A649f5451e0D44C20a2b246431F1B0572',
       OptimismBuyAdapter: '0x4Ae8ad57912e207f5bFaFbF2e90486e5feab1634',
     },
     uniswapV2ExchangeRouterAddress:
       '0xB41dD984730dAf82f5C41489E21ac79D5e3B61bC',
     uniswapV3EventLoggingSampleRate: 0,
     rfqConfigs: {},
+    rpcPollingMaxAllowedStateDelayInBlocks: 5,
+    rpcPollingBlocksBackToTriggerUpdate: 3,
   },
 };
 
@@ -322,6 +340,10 @@ export function generateConfig(network: number): Config {
     uniswapV2ExchangeRouterAddress: baseConfig.uniswapV2ExchangeRouterAddress,
     uniswapV3EventLoggingSampleRate: baseConfig.uniswapV3EventLoggingSampleRate,
     rfqConfigs: baseConfig.rfqConfigs,
+    rpcPollingMaxAllowedStateDelayInBlocks:
+      baseConfig.rpcPollingMaxAllowedStateDelayInBlocks,
+    rpcPollingBlocksBackToTriggerUpdate:
+      baseConfig.rpcPollingBlocksBackToTriggerUpdate,
     hashFlowAuthToken: baseConfig.hashFlowAuthToken,
     hashFlowDisabledMMs: baseConfig.hashFlowDisabledMMs,
   };

package/src/dex/balancer-v2/balancer-v2-e2e.test.ts

@@ -78,7 +78,6 @@ describe('BalancerV2 E2E', () => {
     });
 
     describe('Simpleswap', () => {
-
       it('ETH -> TOKEN', async () => {
         await testE2E(
           tokens['ETH'],

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

@@ -0,0 +1,37 @@
+import { Network, SwapSide } from '../../constants';
+
+export const testConfig: {
+  [network: number]: Array<{
+    srcToken: string;
+    destToken: string;
+    swapSide: SwapSide;
+    amount: string;
+  }>;
+} = {
+  [Network.MAINNET]: [
+    {
+      srcToken: 'USDT',
+      destToken: 'WETH',
+      swapSide: SwapSide.BUY,
+      amount: '10000000000000000',
+    },
+    {
+      srcToken: 'WETH',
+      destToken: 'USDT',
+      swapSide: SwapSide.BUY,
+      amount: '1000000',
+    },
+    {
+      srcToken: 'USDT',
+      destToken: 'WETH',
+      swapSide: SwapSide.SELL,
+      amount: '1000000',
+    },
+    {
+      srcToken: 'WETH',
+      destToken: 'USDT',
+      swapSide: SwapSide.SELL,
+      amount: '10000000000000000',
+    },
+  ],
+};

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

@@ -6,8 +6,8 @@ import { Network, ContractMethod, SwapSide, MAX_UINT } from '../../constants';
 import { generateConfig } from '../../config';
 import { newTestE2E, getEnv } from '../../../tests/utils-e2e';
 import { SmartTokens, GENERIC_ADDR1 } from '../../../tests/constants-e2e';
-import { startTestServer } from './example-api.test';
 import { RFQConfig } from './types';
+import { testConfig } from './e2e-test-config';
 
 const PK_KEY = process.env.TEST_PK_KEY;
 
@@ -19,113 +19,13 @@ const testAccount = new ethers.Wallet(PK_KEY!);
 
 jest.setTimeout(1000 * 60 * 3);
 
-describe('GenericRFQ E2E Mainnet', () => {
-  let stopServer: undefined | Function = undefined;
-
-  beforeAll(() => {
-    stopServer = startTestServer(testAccount);
-  });
-
-  const network = Network.MAINNET;
-  const smartTokens = SmartTokens[network];
-
-  const srcToken = smartTokens.WETH;
-  const destToken = smartTokens.DAI;
-
-  const config = generateConfig(network);
-
-  describe('GenericRFQ', () => {
-    const dexKey = 'DummyParaSwapPool';
-
-    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 -> DAI', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-        });
-      });
-
-      it('SELL DAI -> WETH', async () => {
-        await newTestE2E({
-          config,
-          destToken,
-          srcToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-        });
-      });
-
-      it('BUY WETH -> DAI', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-        });
-      });
-
-      it('BUY DAI -> WETH', async () => {
-        await newTestE2E({
-          config,
-          destToken,
-          srcToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000000000000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-        });
-      });
-    });
-  });
-
-  afterAll(() => {
-    if (stopServer) {
-      stopServer();
-    }
-  });
-});
-
 const buildConfigForGenericRFQ = (): RFQConfig => {
   const url = getEnv('GENERIC_RFQ_URL');
 
   const secret = {
-    secretKey: atob(getEnv('GENERIC_RFQ_SECRET_KEY')),
+    secretKey: Buffer.from(getEnv('GENERIC_RFQ_SECRET_KEY'), 'base64').toString(
+      'binary',
+    ),
     accessKey: getEnv('GENERIC_RFQ_ACCESS_KEY'),
     domain: 'paraswap',
   };
@@ -179,160 +79,65 @@ const buildConfigForGenericRFQ = (): RFQConfig => {
   };
 };
 
-describe('GenericRFQ YOUR_NAME E2E Mainnet', () => {
-  const dexKey = 'YOUR_NAME';
-
-  const network = Network.MAINNET;
-  const smartTokens = SmartTokens[network];
-  const config = generateConfig(network);
-
-  config.rfqConfigs[dexKey] = buildConfigForGenericRFQ();
-
-  describe('GenericRFQ B/Q BUY', () => {
-    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 USDC -> WBTC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-          sleepMs: 5000,
-        });
-      });
-    });
-  });
-
-  describe('GenericRFQ Q/B BUY', () => {
-    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 WBTC -> USDC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
-          swapSide: SwapSide.BUY,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleBuy,
-          network: network,
-          sleepMs: 5000,
-        });
-      });
-    });
-  });
-
-  describe('GenericRFQ B/Q SELL', () => {
-    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 USDC -> WBTC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '1000000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-          sleepMs: 5000,
-        });
-      });
-    });
-  });
-
-  describe('GenericRFQ Q/B SELL', () => {
-    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 WBTC -> USDC', async () => {
-        await newTestE2E({
-          config,
-          srcToken,
-          destToken,
-          senderAddress: GENERIC_ADDR1,
-          thirdPartyAddress: testAccount.address,
-          _amount: '10000',
-          swapSide: SwapSide.SELL,
-          dexKey: dexKey,
-          contractMethod: ContractMethod.simpleSwap,
-          network: network,
-          sleepMs: 5000,
+const SKIP_TENDERLY = !!getEnv('GENERIC_RFQ_SKIP_TENDERLY', true);
+const dexKey = 'YOUR_NAME';
+
+describe(`GenericRFQ ${dexKey} E2E`, () => {
+  for (const [_network, testCases] of Object.entries(testConfig)) {
+    const network = parseInt(_network, 10);
+    const smartTokens = SmartTokens[network];
+    const config = generateConfig(network);
+
+    config.rfqConfigs[dexKey] = buildConfigForGenericRFQ();
+    describe(`${Network[network]}`, () => {
+      for (const testCase of testCases) {
+        if (!smartTokens.hasOwnProperty(testCase.srcToken)) {
+          throw new Error(`Please add "addBalance" and "addAllowance" functions for ${testCase.srcToken} on ${Network[network]} (in constants-e2e.ts).`);
+        }
+        if (!smartTokens.hasOwnProperty(testCase.destToken)){ 
+          throw new Error(`Please add "addBalance" and "addAllowance" functions for ${testCase.destToken} on ${Network[network]} (in constants-e2e.ts).`);
+        }
+        const srcToken = smartTokens[testCase.srcToken];
+        const destToken = smartTokens[testCase.destToken];
+
+        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 contractMethod =
+          testCase.swapSide === SwapSide.BUY
+            ? ContractMethod.simpleBuy
+            : ContractMethod.simpleSwap;
+        describe(`${contractMethod}`, () => {
+          it(`${testCase.swapSide} ${testCase.srcToken} -> ${testCase.destToken}`, async () => {
+            await newTestE2E({
+              config,
+              srcToken,
+              destToken,
+              senderAddress: GENERIC_ADDR1,
+              thirdPartyAddress: testAccount.address,
+              _amount: testCase.amount,
+              swapSide: testCase.swapSide as SwapSide,
+              dexKey: dexKey,
+              contractMethod,
+              network,
+              sleepMs: 5000,
+              skipTenderly: SKIP_TENDERLY,
+            });
+          });
         });
-      });
+      }
     });
-  });
+  }
 });

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

@@ -0,0 +1,121 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { ethers } from 'ethers';
+import { Network, ContractMethod, SwapSide, MAX_UINT } from '../../constants';
+import { generateConfig } from '../../config';
+import { newTestE2E } from '../../../tests/utils-e2e';
+import { SmartTokens, GENERIC_ADDR1 } from '../../../tests/constants-e2e';
+import { startTestServer } from './example-api.test';
+
+const PK_KEY = process.env.TEST_PK_KEY;
+
+if (!PK_KEY) {
+  throw new Error('Missing TEST_PK_KEY');
+}
+
+const testAccount = new ethers.Wallet(PK_KEY!);
+
+jest.setTimeout(1000 * 60 * 3);
+
+describe('GenericRFQ E2E Mainnet', () => {
+  let stopServer: undefined | Function = undefined;
+
+  beforeAll(() => {
+    stopServer = startTestServer(testAccount);
+  });
+
+  const network = Network.MAINNET;
+  const smartTokens = SmartTokens[network];
+
+  const srcToken = smartTokens.WETH;
+  const destToken = smartTokens.DAI;
+
+  const config = generateConfig(network);
+
+  describe('GenericRFQ', () => {
+    const dexKey = 'DummyParaSwapPool';
+
+    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 -> DAI', async () => {
+        await newTestE2E({
+          config,
+          srcToken,
+          destToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.SELL,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleSwap,
+          network: network,
+        });
+      });
+
+      it('SELL DAI -> WETH', async () => {
+        await newTestE2E({
+          config,
+          destToken,
+          srcToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.SELL,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleSwap,
+          network: network,
+        });
+      });
+
+      it('BUY WETH -> DAI', async () => {
+        await newTestE2E({
+          config,
+          srcToken,
+          destToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.BUY,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleBuy,
+          network: network,
+        });
+      });
+
+      it('BUY DAI -> WETH', async () => {
+        await newTestE2E({
+          config,
+          destToken,
+          srcToken,
+          senderAddress: GENERIC_ADDR1,
+          thirdPartyAddress: testAccount.address,
+          _amount: '1000000000000000000',
+          swapSide: SwapSide.BUY,
+          dexKey: dexKey,
+          contractMethod: ContractMethod.simpleBuy,
+          network: network,
+        });
+      });
+    });
+  });
+
+  afterAll(() => {
+    if (stopServer) {
+      stopServer();
+    }
+  });
+});

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

@@ -403,9 +403,11 @@ export class RateFetcher {
         delete payload.secret;
       }
 
+      this.logger.info('FirmRate Request:', payload);
       const { data } = await this.dexHelper.httpRequest.request<unknown>(
         payload,
       );
+      this.logger.info('FirmRate Response: ', data);
 
       const firmRateResp = validateAndCast<RFQFirmRateResponse>(
         data,