feat: trading API

apps/api/src/app/inversify.config.ts

@@ -1,3 +1,7 @@
+import ms from 'ms';
+import { PublicClient } from 'viem';
+import { Container } from 'inversify';
+
 import {
   CacheRepository,
   CacheRepositoryMemory,
@@ -27,26 +31,27 @@ import {
   viemClients,
 } from '@cowprotocol/repositories';
 
-const DEFAULT_CACHE_VALUE_SECONDS = ms('2min') / 1000; // 2min cache time by default for values
-const DEFAULT_CACHE_NULL_SECONDS = ms('30min') / 1000; // 30min cache time by default for NULL values (when the repository isn't known)
-
-const CACHE_TOKEN_INFO_SECONDS = ms('24h') / 1000; // 24h
-
-import { Container } from 'inversify';
 import {
   SimulationService,
   SlippageService,
   SlippageServiceMain,
   TokenHolderService,
   TokenHolderServiceMain,
+  TradingService,
   UsdService,
   UsdServiceMain,
   simulationServiceSymbol,
   slippageServiceSymbol,
   tokenHolderServiceSymbol,
   usdServiceSymbol,
+  tradingServiceSymbol
 } from '@cowprotocol/services';
-import ms from 'ms';
+import { SupportedChainId } from '@cowprotocol/cow-sdk';
+
+const DEFAULT_CACHE_VALUE_SECONDS = ms('2min') / 1000; // 2min cache time by default for values
+const DEFAULT_CACHE_NULL_SECONDS = ms('30min') / 1000; // 30min cache time by default for NULL values (when the repository isn't known)
+
+const CACHE_TOKEN_INFO_SECONDS = ms('24h') / 1000; // 24h
 
 function getErc20Repository(cacheRepository: CacheRepository): Erc20Repository {
   return new Erc20RepositoryCache(
@@ -133,13 +138,20 @@ function getTokenHolderRepository(
   ]);
 }
 
+function getTradingService(
+  erc20Repository: Erc20Repository
+): TradingService {
+  return new TradingService(erc20Repository, viemClients as Record<SupportedChainId, PublicClient>);
+}
+
 function getApiContainer(): Container {
   const apiContainer = new Container();
   // Repositories
   const cacheRepository = getCacheRepository(apiContainer);
   const erc20Repository = getErc20Repository(cacheRepository);
   const simulationRepository = new SimulationRepositoryTenderly();
   const tokenHolderRepository = getTokenHolderRepository(cacheRepository);
+  const tradingService = getTradingService(erc20Repository)
 
   apiContainer
     .bind<Erc20Repository>(erc20RepositorySymbol)
@@ -176,6 +188,10 @@ function getApiContainer(): Container {
     .bind<SimulationService>(simulationServiceSymbol)
     .to(SimulationService);
 
+  apiContainer
+    .bind<TradingService>(tradingServiceSymbol)
+    .toConstantValue(tradingService);
+
   return apiContainer;
 }
 

apps/api/src/app/routes/__chainId/markets/__baseTokenAddress-__quoteTokenAddress/slippageTolerance.ts

@@ -3,7 +3,7 @@ import {
   slippageServiceSymbol,
   VolatilityDetails,
 } from '@cowprotocol/services';
-import { ChainIdSchema, ETHEREUM_ADDRESS_PATTERN } from '../../../../schemas';
+import { ChainIdSchema, ETHEREUM_ADDRESS_PATTERN, SlippageSchema } from '../../../../schemas';
 import { FastifyPluginAsync } from 'fastify';
 import { FromSchema, JSONSchema } from 'json-schema-to-ts';
 import { apiContainer } from '../../../../inversify.config';
@@ -52,15 +52,7 @@ const successSchema = {
   required: ['slippageBps'],
   additionalProperties: false,
   properties: {
-    slippageBps: {
-      title: 'Slippage tolerance in basis points',
-      description:
-        'Slippage tolerance in basis points. One basis point is equivalent to 0.01% (1/100th of a percent)',
-      type: 'number',
-      examples: [50, 100, 200],
-      minimum: 0,
-      maximum: 10000,
-    },
+    slippageBps: SlippageSchema,
   },
 } as const satisfies JSONSchema;
 

apps/api/src/app/routes/trading/README.md

@@ -0,0 +1,185 @@
+# CoW Trading API
+
+
+The **CoW Protocol** offers powerful and highly flexible trading capabilities, designed to facilitate complex decentralized finance (DeFi) interactions. However, its flexibility can also make it challenging for developers to interact directly with the protocol.
+
+This **CoW Trading API** aims to simplify the interaction by abstracting the complexities. It automatically handles critical aspects such as parameter configuration, accurate calculations for token amounts, and signing orders.
+
+This API functions as a wrapper around the [`@cowprotocol/cow-sdk`](https://github.com/cowprotocol/cow-sdk/blob/feat/swap-for-people/src/trading/README.md), making it easy to integrate CoW trading into your applications.
+
+---
+
+## Core Features
+- **Simplified Order Management:** Abstracts the complexity of preparing, signing, and submitting orders.
+- **Native Token Support:** Allows trading Ethereum and other native tokens seamlessly.
+- **Smart-Contract Wallet Compatibility:** Includes support for wallets using EIP-1271 presigning.
+- **Robust Transaction Handling:** Automatically computes necessary amounts and costs for trades.
+
+---
+
+## 1. **Get Quote**
+
+The `getQuote` method provides a price quote for your desired trade. This includes information necessary to prepare, sign, and submit the order.
+
+### API Endpoint
+**POST** `https://bff.cow.fi/trading/getQuote`
+
+### Request Example
+
+```js
+fetch('https://bff.cow.fi/trading/getQuote', {method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({
+    trader: {
+        account: '0xfb3c7eb936cAA12B5A884d612393969A557d4307',
+        appCode: 'test1',
+        chainId: 1,
+    },
+    params: {
+        kind: 'sell',
+        sellToken: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+        buyToken: "0xdef1ca1fb7fbcdc777520aa7f396b4e015f497ab",
+        amount: '12000000000000000'
+    }
+})})
+```
+
+## 2. Full Trading Flow
+
+This section demonstrates the complete trading flow, from retrieving a quote to signing and sending an order to the order book.
+
+### Steps
+1. **Get Quote**: Use the getQuote endpoint to retrieve the trade details.
+2. **Sign Order**: Connect your wallet and sign the order using EIP-712 typed data.
+3. **Submit Order**: Send the signed order to the order book.
+
+### Code Example
+
+```js
+(async function() {
+  const trader = {
+    account: '0xfb3c7eb936cAA12B5A884d612393969A557d4307',
+    appCode: 'test1',
+    chainId: 11155111
+  }
+  const params = {
+    kind: 'sell',
+    sellToken: '0xfff9976782d46cc05630d1f6ebab18b2324d6b14',
+    buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59',
+    amount: '100000000000000000'
+  }
+
+  const callApi = (method, body) => fetch('https://bff.cow.fi/trading/' + method, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body)
+  }).then(res => res.json())
+
+  // Get quote
+  const { quoteResponse, orderToSign, orderTypedData, appDataInfo } = await callApi('getQuote', { trader, params })
+  // Connect wallet
+  const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' })
+  // Sign order
+  const signature = await window.ethereum.request({
+    method: 'eth_signTypedData_v4',
+    params: [accounts[0], JSON.stringify(orderTypedData)]
+  })
+  // Send order
+  const orderId = await callApi('postOrder', {
+    trader,
+    quoteId: quoteResponse.id,
+    signature, // Add order typed data signature (EIP-712)
+    orderToSign,
+    appDataInfo
+  })
+
+  console.log('Order Id:', orderId)
+})()
+```
+
+## 3. Smart-Contract Wallet (EIP-1271 Pre-signing)
+
+For smart-contract wallets, orders are signed using the [EIP-1271](https://eips.ethereum.org/EIPS/eip-1271) standard. This involves presigning the order and sending a transaction.
+
+### Code Example
+
+```js
+(async function() {
+  const trader = {
+    account: '0xF568A3a2dfFd73C000E8E475B2D335A4A3818EBa',
+    appCode: 'test1',
+    chainId: 11155111
+  }
+  const params = {
+    kind: 'sell',
+    sellToken: '0xfff9976782d46cc05630d1f6ebab18b2324d6b14',
+    buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59',
+    amount: '100000000000000000'
+  }
+
+  const callApi = (method, body) => fetch('https://bff.cow.fi/trading/' + method, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body)
+  }).then(res => res.json())
+
+  // Get quote
+  const { quoteResponse, orderToSign, appDataInfo } = await callApi('getQuote', { trader, params })
+  // Connect wallet
+  const accounts = await window.ethereum.request({ method: 'eth_requestAccounts' })
+  // Send order
+  const { orderId, preSignTransaction } = await callApi('postOrder', {
+    trader,
+    quoteId: quoteResponse.id,
+    signingScheme: 'presign', // Signal to use pre-signing (smart-contract wallet)
+    orderToSign,
+    appDataInfo
+  })
+
+  // ACTION NEEDED: Send <preSignTransaction> from smart-contract wallet
+
+  console.log('Order Id:', orderId)
+  console.log('preSignTransaction:', preSignTransaction)
+})()
+```
+
+## 4. Trading Native Tokens (ETH Flow)
+
+To trade Ethereum (native token), use the `getEthFlowTransaction` method, which generates a transaction object for direct submission to the network.
+
+### Code Example
+
+```js
+(async function() {
+  const trader = {
+    account: '0xfb3c7eb936cAA12B5A884d612393969A557d4307',
+    appCode: 'test1',
+    chainId: 11155111
+  }
+  const params = {
+    kind: 'sell',
+    sellToken: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+    buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59',
+    amount: '100000000000000000'
+  }
+
+  const callApi = (method, body) => fetch('https://bff.cow.fi/trading/' + method, {
+    method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body)
+  }).then(res => res.json())
+
+  // Get quote
+  const { quoteResponse, orderTypedData, appDataInfo, amountsAndCosts, tradeParameters } = await callApi('getQuote', { trader, params })
+  // Get transaction
+  const { orderId, transaction } = await callApi('getEthFlowTransaction', {
+    trader,
+    quoteId: quoteResponse.id,
+    tradeParameters,
+    amountsAndCosts,
+    appDataInfo,
+  })
+  // Connect wallet
+  const [account] = await window.ethereum.request({ method: 'eth_requestAccounts' })
+  // Send transaction
+  const txHash = await window.ethereum.request({
+    method: 'eth_sendTransaction',
+    params: [{ ...transaction, from: account }]
+  })
+
+  console.log('txHash:', txHash)
+  console.log('orderId:', orderId)
+})()
+```

apps/api/src/app/routes/trading/getEthFlowTransaction.ts

@@ -0,0 +1,59 @@
+import { FastifyPluginAsync } from 'fastify';
+
+import { FromSchema } from 'json-schema-to-ts';
+import { apiContainer } from '../../inversify.config';
+import {
+  TradingService,
+  tradingServiceSymbol
+} from '@cowprotocol/services';
+
+import { errorSchema, ethFlowTxBodySchema, ethFlowTxSuccessSchema } from './schemas';
+import { getErrorMessage } from './utils';
+import { deserializeQuoteAmountsAndCosts } from './mapQuoteAmountsAndCosts';
+
+type SuccessSchema = FromSchema<typeof ethFlowTxSuccessSchema>;
+type BodySchema = FromSchema<typeof ethFlowTxBodySchema>;
+type ErrorSchema = FromSchema<typeof errorSchema>;
+
+const tradingService: TradingService = apiContainer.get(
+  tradingServiceSymbol
+);
+
+const root: FastifyPluginAsync = async (fastify): Promise<void> => {
+  fastify.post<{
+    Reply: SuccessSchema | ErrorSchema;
+    Body: BodySchema;
+  }>(
+    '/getEthFlowTransaction',
+    {
+      schema: {
+        body: ethFlowTxBodySchema,
+        response: {
+          '2XX': ethFlowTxSuccessSchema,
+          '400': errorSchema,
+        },
+      },
+    },
+    async function (request, reply) {
+      const { trader, amountsAndCosts, quoteId, tradeParameters, appDataInfo } = request.body
+
+      try {
+        const result = await tradingService.getEthFlowTransaction(
+          trader,
+          quoteId,
+          tradeParameters as Parameters<typeof tradingService.getEthFlowTransaction>[2],
+          deserializeQuoteAmountsAndCosts(amountsAndCosts),
+          appDataInfo,
+        );
+
+        reply.send(result);
+      } catch (e) {
+        const errorMessage = getErrorMessage(e)
+        console.error('[Trading API] getEthFlowTransaction error', errorMessage)
+        reply.code(500).send({ message: errorMessage });
+      }
+    }
+  );
+};
+
+export default root;