SOR: compare local results, not query results (#45)

* remove log * add option to queryBatchSwap for v2, never queryBatchSwap v1
balancer · Jan 18, 2024 · f035ea4 · f035ea4
1 parent 5cf75da
commit f035ea4
Show file tree

Hide file tree

Showing 5 changed files with 5 additions and 60 deletions.
diff --git a/modules/sor/sor.gql b/modules/sor/sor.gql
@@ -47,6 +47,7 @@ input GqlSorSwapOptionsInput {
     timestamp: Int #used for caching purposes
     maxPools: Int
     forceRefresh: Boolean #don't use any cached responses
+    queryBatchSwap: Boolean #run queryBatchSwap to update with onchain values
 }
 
 """

diff --git a/modules/sor/sor.service.ts b/modules/sor/sor.service.ts
@@ -76,7 +76,7 @@ export class SorService {
 
         try {
             // Updates with latest onchain data before returning
-            return swap.getSorSwapResponse(true);
+            return swap.getSorSwapResponse(args.swapOptions.queryBatchSwap ? args.swapOptions.queryBatchSwap : false);
         } catch (err) {
             console.log(`Error Retrieving QuerySwap`, err);
             return emptyResponse;

diff --git a/modules/sor/sorV1Beets/balancer-sor.service.ts b/modules/sor/sorV1Beets/balancer-sor.service.ts
@@ -14,9 +14,7 @@ import VaultAbi from '../../pool/abi/Vault.json';
 import { env } from '../../../app/env';
 import { networkContext } from '../../network/network-context.service';
 import { DeploymentEnv } from '../../network/network-config-types';
-import * as Sentry from '@sentry/node';
 import _ from 'lodash';
-import { Logger } from '@ethersproject/logger';
 import { SwapInfoRoute } from '@balancer-labs/sor';
 import { NATIVE_ADDRESS, ZERO_ADDRESS } from '@balancer/sdk';
 
@@ -60,61 +58,12 @@ export class BalancerSorService {
             return this.zeroResponse(swapType, tokenIn, tokenOut, swapAmount);
         }
 
-        let deltas: string[] = [];
-
-        try {
-            deltas = await this.queryBatchSwap(
-                swapType === 'EXACT_IN' ? SwapTypes.SwapExactIn : SwapTypes.SwapExactOut,
-                swapInfo.swaps,
-                swapInfo.tokenAddresses,
-            );
-        } catch (error: any) {
-            const poolIds = _.uniq(swapInfo.swaps.map((swap) => swap.poolId));
-            if (error.code === Logger.errors.CALL_EXCEPTION) {
-                // Chances are a 304 means that we missed a pool draining event, and the pool data is stale.
-                // We force an update on any pools inside of the swapInfo
-                if (error.error?.error?.message?.includes('BAL#304')) {
-                    Sentry.captureException(
-                        `Received a BAL#304 during getSwaps, forcing an on-chain refresh for: ${poolIds.join(',')}`,
-                        {
-                            tags: {
-                                tokenIn,
-                                tokenOut,
-                                swapType,
-                                swapAmount,
-                                swapPools: `${poolIds.join(',')}`,
-                            },
-                        },
-                    );
-
-                    const blockNumber = await networkContext.provider.getBlockNumber();
-
-                    poolService.updateOnChainDataForPools(poolIds, blockNumber).catch();
-                } else if (error.error?.error?.message?.includes('BAL#')) {
-                    Sentry.captureException(
-                        `Received an unhandled BAL error during getSwaps: ${error.error?.error?.message}`,
-                        {
-                            tags: {
-                                tokenIn,
-                                tokenOut,
-                                swapType,
-                                swapAmount,
-                                swapPools: `${poolIds.join(',')}`,
-                            },
-                        },
-                    );
-                }
-            }
-
-            throw new Error(error);
-        }
-
         const pools = await poolService.getGqlPools({
             where: { idIn: swapInfo.routes.map((route) => route.hops.map((hop) => hop.poolId)).flat() },
         });
 
-        const tokenInAmount = BigNumber.from(deltas[swapInfo.tokenAddresses.indexOf(tokenIn)]);
-        const tokenOutAmount = BigNumber.from(deltas[swapInfo.tokenAddresses.indexOf(tokenOut)]).abs();
+        const tokenInAmount = swapType === 'EXACT_IN' ? swapAmountScaled : BigNumber.from(swapInfo.returnAmount);
+        const tokenOutAmount = swapType === 'EXACT_IN' ? BigNumber.from(swapInfo.returnAmount) : swapAmountScaled;
 
         return this.formatResponse({
             tokenIn: swapInfo.tokenIn,

diff --git a/modules/sor/sorV1Beets/sorV1Beets.service.ts b/modules/sor/sorV1Beets/sorV1Beets.service.ts
@@ -29,7 +29,7 @@ class SwapResultV1 implements SwapResult {
 
     async getSorSwapResponse(queryFirst: boolean): Promise<GqlSorGetSwapsResponse> {
         if (!this.isValid || this.swap === null) throw new Error('No Response - Invalid Swap');
-        // Beets service is already querying onchain
+        // never query onchain for old v1 service
         return this.swap;
     }
 }

diff --git a/modules/sor/sorV2/sorV2.service.ts b/modules/sor/sorV2/sorV2.service.ts
@@ -307,11 +307,6 @@ export class SorV2Service implements SwapService {
                           maxNonBoostedPathDepth,
                       },
                   };
-
-            console.info(
-                `SOR: Fetching SORv2 on ${chain} for ${tokenIn} -> ${tokenOut} with maxNonBoostedPathDepth`,
-                maxNonBoostedPathDepth,
-            );
             const swap = await sorGetSwapsWithPools(tIn, tOut, swapKind, swapAmount, poolsFromDb, config);
             if (!swap && maxNonBoostedPathDepth < 5) {
                 return this.getSwapResult(arguments[0], maxNonBoostedPathDepth + 1);