[WIP] Add b-sdk for trade queries

.github/workflows/checks.yml

@@ -20,9 +20,9 @@ jobs:
       - name: Use Node.js
         uses: actions/setup-node@v3
         with:
-          node-version: '16.x'
+          node-version: '18.x'
       - name: Install deps
-        run: yarn 
+        run: yarn
       - name: Generate Schema
         run: yarn generate
       - name: Prisma Generate

modules/balancer/balancer.gql

@@ -1,7 +1,39 @@
+extend type Mutation {
+    balancerMutationTest: String!
+}
+
 extend type Query {
-    balancerQueryTest: String!
+    sorGetCowSwaps(
+        chain: GqlChain!
+        tokenIn: String!
+        tokenOut: String!
+        swapType: GqlSorSwapType!
+        swapAmount: BigDecimal! #expected in raw amount
+    ): GqlCowSwapApiResponse!
 }
 
-extend type Mutation {
-    balancerMutationTest: String!
+enum GqlSorSwapType {
+    EXACT_IN
+    EXACT_OUT
+}
+
+type GqlCowSwapApiResponse {
+    tokenAddresses: [String!]!
+    swaps: [GqlSwap!]!
+    swapAmount: String!
+    swapAmountForSwaps: String!
+    returnAmount: String!
+    returnAmountFromSwaps: String!
+    returnAmountConsideringFees: String!
+    tokenIn: String!
+    tokenOut: String!
+    marketSp: String!
+}
+
+type GqlSwap {
+    poolId: String!
+    assetInIndex: Int!
+    assetOutIndex: Int!
+    amount: String!
+    userData: String!
 }

modules/balancer/balancer.resolvers.ts

@@ -1,10 +1,16 @@
-import moment from 'moment';
 import { Resolvers } from '../../schema';
+import { sorService } from '../sor/sor.service';
+import { getTokenAmountRaw } from '../sor/utils';
 
 const balancerResolvers: Resolvers = {
     Query: {
-        balancerQueryTest: async (parent, {}, context) => {
-            return `${moment().utc().valueOf()}`;
+        sorGetCowSwaps: async (parent, args, context) => {
+            const amountToken = args.swapType === "EXACT_IN" ? args.tokenIn : args.tokenOut;
+            // Use TokenAmount to help follow scaling requirements in later logic
+            // args.swapAmount is RawScale, e.g. 1USDC should be passed as 1000000
+            const amount = await getTokenAmountRaw(amountToken, args.swapAmount, args.chain);
+            const swaps = await sorService.getCowSwaps({ ...args, swapAmount: amount, swapOptions: {} });
+            return { ...swaps, __typename: 'GqlCowSwapApiResponse' };
         },
     },
     Mutation: {

modules/beethoven/balancer-sdk.gql

@@ -1,10 +1,12 @@
 extend type Query {
     sorGetSwaps(
+        chain: GqlChain!
         tokenIn: String!
         tokenOut: String!
         swapType: GqlSorSwapType!
         swapAmount: BigDecimal! #expected in human readable form
         swapOptions: GqlSorSwapOptionsInput!
+        graphTraversalConfig: GqlGraphTraversalConfigInput
     ): GqlSorGetSwapsResponse!
     sorGetBatchSwapForTokensIn(
         tokensIn: [GqlTokenAmountHumanReadable!]!
@@ -24,6 +26,14 @@ input GqlSorSwapOptionsInput {
     forceRefresh: Boolean #don't use any cached responses
 }
 
+input GqlGraphTraversalConfigInput {
+    maxDepth: Int # default 6
+    maxNonBoostedPathDepth: Int # default 3
+    maxNonBoostedHopTokensInBoostedPath: Int # default 2
+    approxPathsToReturn: Int # default 5
+    poolIdsToInclude: [String]
+}
+
 type GqlSorGetSwapsResponse {
     tokenIn: String!
     tokenOut: String!
@@ -77,3 +87,24 @@ type GqlSorGetBatchSwapForTokensInResponse {
     swaps: [GqlSorSwap!]!
     assets: [String!]!
 }
+
+type GqlCowSwapApiResponse {
+    tokenAddresses: [String!]!
+    swaps: [GqlSwap!]!
+    swapAmount: String!
+    swapAmountForSwaps: String!
+    returnAmount: String!
+    returnAmountFromSwaps: String!
+    returnAmountConsideringFees: String!
+    tokenIn: String!
+    tokenOut: String!
+    marketSp: String!
+}
+
+type GqlSwap {
+    poolId: String!
+    assetInIndex: Int!
+    assetOutIndex: Int!
+    amount: String!
+    userData: String!
+}

modules/beethoven/balancer-sdk.resolvers.ts

@@ -1,13 +1,30 @@
 import { Resolvers } from '../../schema';
 import { balancerSorService } from './balancer-sor.service';
 import { tokenService } from '../token/token.service';
+import { sorService } from '../sor/sor.service';
+import { getTokenAmountHuman } from '../sor/utils';
+import { GraphTraversalConfig } from '../sor/types';
 
 const balancerSdkResolvers: Resolvers = {
     Query: {
         sorGetSwaps: async (parent, args, context) => {
-            const tokens = await tokenService.getTokens();
+            const tokenIn = args.tokenIn.toLowerCase();
+            const tokenOut = args.tokenOut.toLowerCase();
+            const amountToken = args.swapType === 'EXACT_IN' ? tokenIn : tokenOut;
+            // Use TokenAmount to help follow scaling requirements in later logic
+            // args.swapAmount is HumanScale
+            const amount = await getTokenAmountHuman(amountToken, args.swapAmount, args.chain);
+            const graphTraversalConfig = args.graphTraversalConfig as GraphTraversalConfig;
+
+            const swaps = await sorService.getBeetsSwaps({
+                ...args,
+                tokenIn,
+                tokenOut,
+                graphTraversalConfig,
+                swapAmount: amount,
+            });
 
-            return balancerSorService.getSwaps({ ...args, tokens });
+            return { ...swaps, __typename: 'GqlSorGetSwapsResponse' };
         },
         sorGetBatchSwapForTokensIn: async (parent, args, context) => {
             const tokens = await tokenService.getTokens();

modules/beethoven/balancer-sor.service.ts

@@ -1,4 +1,4 @@
-import { GqlSorGetSwapsResponse, GqlSorSwapOptionsInput, GqlSorSwapType } from '../../schema';
+import { GqlSorGetSwapsResponse, GqlSorSwapOptionsInput, GqlSorSwapType, GqlPoolMinimal } from '../../schema';
 import { formatFixed, parseFixed } from '@ethersproject/bignumber';
 import { PrismaToken } from '@prisma/client';
 import { poolService } from '../pool/pool.service';
@@ -17,6 +17,7 @@ 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';
 
 interface GetSwapsInput {
     tokenIn: string;
@@ -55,35 +56,7 @@ export class BalancerSorService {
         let swapInfo = await this.querySor(swapType, tokenIn, tokenOut, swapAmountScaled, swapOptions);
         // no swaps found, return 0
         if (swapInfo.swaps.length === 0) {
-            return {
-                ...swapInfo,
-                tokenIn: replaceZeroAddressWithEth(swapInfo.tokenIn),
-                tokenOut: replaceZeroAddressWithEth(swapInfo.tokenOut),
-                swapType,
-                tokenInAmount: swapType === 'EXACT_IN' ? swapAmount : BigNumber.from('0').toString(),
-                tokenOutAmount: swapType === 'EXACT_IN' ? BigNumber.from('0').toString() : swapAmount,
-                swapAmount: swapType === 'EXACT_IN' ? BigNumber.from('0').toString() : swapAmount,
-                swapAmountScaled: BigNumber.from('0').toString(),
-                swapAmountForSwaps: swapInfo.swapAmountForSwaps
-                    ? BigNumber.from(swapInfo.swapAmountForSwaps).toString()
-                    : undefined,
-                returnAmount: BigNumber.from('0').toString(),
-                returnAmountScaled: BigNumber.from('0').toString(),
-                returnAmountConsideringFees: BigNumber.from(swapInfo.returnAmountConsideringFees).toString(),
-                returnAmountFromSwaps: swapInfo.returnAmountFromSwaps
-                    ? BigNumber.from(swapInfo.returnAmountFromSwaps).toString()
-                    : undefined,
-                routes: swapInfo.routes.map((route) => ({
-                    ...route,
-                    hops: route.hops.map((hop) => ({
-                        ...hop,
-                        pool: pools.find((pool) => pool.id === hop.poolId)!,
-                    })),
-                })),
-                effectivePrice: BigNumber.from('0').toString(),
-                effectivePriceReversed: BigNumber.from('0').toString(),
-                priceImpact: BigNumber.from('0').toString(),
-            };
+            return this.zeroResponse(swapType, tokenIn, tokenOut, swapAmount);
         }
 
         let deltas: string[] = [];
@@ -142,27 +115,70 @@ export class BalancerSorService {
         const tokenInAmount = BigNumber.from(deltas[swapInfo.tokenAddresses.indexOf(tokenIn)]);
         const tokenOutAmount = BigNumber.from(deltas[swapInfo.tokenAddresses.indexOf(tokenOut)]).abs();
 
-        const swapAmountQuery = swapType === 'EXACT_OUT' ? tokenOutAmount : tokenInAmount;
-        const returnAmount = swapType === 'EXACT_IN' ? tokenOutAmount : tokenInAmount;
-
-        const returnAmountFixed = formatFixed(
-            returnAmount,
-            this.getTokenDecimals(swapType === 'EXACT_IN' ? tokenOut : tokenIn, tokens),
-        );
-
-        const swapAmountQueryFixed = formatFixed(
-            swapAmountQuery,
-            this.getTokenDecimals(swapType === 'EXACT_OUT' ? tokenOut : tokenIn, tokens),
-        );
+        return this.formatResponse({
+            tokenIn: swapInfo.tokenIn,
+            tokenOut: swapInfo.tokenOut,
+            tokens,
+            tokenInAmtEvm: tokenInAmount.toString(),
+            tokenOutAmtEvm: tokenOutAmount.toString(),
+            swapAmountForSwaps: BigNumber.from(swapInfo.swapAmountForSwaps).toString(),
+            returnAmountConsideringFees: BigNumber.from(swapInfo.returnAmountConsideringFees).toString(),
+            returnAmountFromSwaps: BigNumber.from(swapInfo.returnAmountFromSwaps).toString(),
+            routes: swapInfo.routes,
+            pools,
+            marketSp: swapInfo.marketSp,
+            swaps: swapInfo.swaps,
+            tokenAddresses: swapInfo.tokenAddresses,
+            swapType,
+        });
+    }
 
-        const tokenInAmountFixed = formatFixed(tokenInAmount, this.getTokenDecimals(tokenIn, tokens));
-        const tokenOutAmountFixed = formatFixed(tokenOutAmount, this.getTokenDecimals(tokenOut, tokens));
+    formatResponse(swapData: {
+        tokenIn: string;
+        tokenOut: string;
+        swapType: GqlSorSwapType;
+        tokens: PrismaToken[];
+        tokenInAmtEvm: string;
+        tokenOutAmtEvm: string;
+        swapAmountForSwaps: string;
+        returnAmountConsideringFees: string;
+        returnAmountFromSwaps: string;
+        routes: SwapInfoRoute[];
+        pools: GqlPoolMinimal[];
+        marketSp: string;
+        swaps: SwapV2[];
+        tokenAddresses: string[];
+    }): GqlSorGetSwapsResponse {
+        const {
+            tokenIn,
+            tokenOut,
+            swapType,
+            tokens,
+            tokenInAmtEvm,
+            tokenOutAmtEvm,
+            swapAmountForSwaps,
+            returnAmountConsideringFees,
+            returnAmountFromSwaps,
+            routes,
+            pools,
+            marketSp,
+            swaps,
+            tokenAddresses,
+        } = swapData;
+
+        const tokenInAmountFixed = formatFixed(tokenInAmtEvm, this.getTokenDecimals(tokenIn, tokens));
+        const tokenOutAmountFixed = formatFixed(tokenOutAmtEvm, this.getTokenDecimals(tokenOut, tokens));
+
+        const swapAmountQuery = swapType === 'EXACT_OUT' ? tokenOutAmtEvm : tokenInAmtEvm;
+        const returnAmount = swapType === 'EXACT_IN' ? tokenOutAmtEvm : tokenInAmtEvm;
+        const swapAmountQueryFixed = swapType === 'EXACT_OUT' ? tokenOutAmountFixed : tokenInAmountFixed;
+        const returnAmountFixed = swapType === 'EXACT_IN' ? tokenOutAmountFixed : tokenInAmountFixed;
 
         const effectivePrice = oldBnum(tokenInAmountFixed).div(tokenOutAmountFixed);
         const effectivePriceReversed = oldBnum(tokenOutAmountFixed).div(tokenInAmountFixed);
-        const priceImpact = effectivePrice.div(swapInfo.marketSp).minus(1);
+        const priceImpact = effectivePrice.div(marketSp).minus(1);
 
-        for (const route of swapInfo.routes) {
+        for (const route of routes) {
             route.tokenInAmount = oldBnum(tokenInAmountFixed)
                 .multipliedBy(route.share)
                 .dp(this.getTokenDecimals(tokenIn, tokens))
@@ -174,24 +190,22 @@ export class BalancerSorService {
         }
 
         return {
-            ...swapInfo,
-            tokenIn: replaceZeroAddressWithEth(swapInfo.tokenIn),
-            tokenOut: replaceZeroAddressWithEth(swapInfo.tokenOut),
+            swaps,
+            marketSp,
+            tokenAddresses,
+            tokenIn: replaceZeroAddressWithEth(tokenIn),
+            tokenOut: replaceZeroAddressWithEth(tokenOut),
             swapType,
             tokenInAmount: tokenInAmountFixed,
             tokenOutAmount: tokenOutAmountFixed,
             swapAmount: swapAmountQueryFixed,
-            swapAmountScaled: swapAmountQuery.toString(),
-            swapAmountForSwaps: swapInfo.swapAmountForSwaps
-                ? BigNumber.from(swapInfo.swapAmountForSwaps).toString()
-                : undefined,
+            swapAmountScaled: swapAmountQuery,
+            swapAmountForSwaps: swapAmountForSwaps ? BigNumber.from(swapAmountForSwaps).toString() : undefined,
             returnAmount: returnAmountFixed,
-            returnAmountScaled: returnAmount.toString(),
-            returnAmountConsideringFees: BigNumber.from(swapInfo.returnAmountConsideringFees).toString(),
-            returnAmountFromSwaps: swapInfo.returnAmountFromSwaps
-                ? BigNumber.from(swapInfo.returnAmountFromSwaps).toString()
-                : undefined,
-            routes: swapInfo.routes.map((route) => ({
+            returnAmountScaled: returnAmount,
+            returnAmountConsideringFees: BigNumber.from(returnAmountConsideringFees).toString(),
+            returnAmountFromSwaps: returnAmountFromSwaps ? BigNumber.from(returnAmountFromSwaps).toString() : undefined,
+            routes: routes.map((route) => ({
                 ...route,
                 hops: route.hops.map((hop) => ({
                     ...hop,
@@ -204,6 +218,35 @@ export class BalancerSorService {
         };
     }
 
+    zeroResponse(
+        swapType: GqlSorSwapType,
+        tokenIn: string,
+        tokenOut: string,
+        swapAmount: string,
+    ): GqlSorGetSwapsResponse {
+        return {
+            marketSp: '0',
+            tokenAddresses: [],
+            swaps: [],
+            tokenIn: replaceZeroAddressWithEth(tokenIn),
+            tokenOut: replaceZeroAddressWithEth(tokenOut),
+            swapType,
+            tokenInAmount: swapType === 'EXACT_IN' ? swapAmount : '0',
+            tokenOutAmount: swapType === 'EXACT_IN' ? '0' : swapAmount,
+            swapAmount: swapType === 'EXACT_IN' ? '0' : swapAmount,
+            swapAmountScaled: '0',
+            swapAmountForSwaps: '0',
+            returnAmount: '0',
+            returnAmountScaled: '0',
+            returnAmountConsideringFees: '0',
+            returnAmountFromSwaps: '0',
+            routes: [],
+            effectivePrice: '0',
+            effectivePriceReversed: '0',
+            priceImpact: '0',
+        };
+    }
+
     private async querySor(
         swapType: string,
         tokenIn: string,
@@ -293,11 +336,13 @@ export class BalancerSorService {
         tokenAddress = tokenAddress.toLowerCase();
         const match = tokens.find((token) => token.address === tokenAddress);
 
-        if (!match) {
-            throw new Error('Unknown token: ' + tokenAddress);
+        let decimals = match?.decimals;
+        if (!decimals) {
+            console.error(`Unknown token: ${tokenAddress}`);
+            decimals = 18;
         }
 
-        return match.decimals;
+        return decimals;
     }
 
     private batchSwaps(assetArray: string[][], swaps: SwapV2[][]): { swaps: SwapV2[]; assets: string[] } {