@cowprotocol/cow-sdk 0.0.15 → 1.0.0-RC.1

package/README.md

@@ -2,16 +2,12 @@
   <img width="400" src="https://raw.githubusercontent.com/cowprotocol/cow-sdk/main/docs/images/CoW.png">
 </p>
 
-# CoW protocol SDK
+# CoW SDK
 
 [![Styled With Prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg)](https://prettier.io/)
 [![Coverage Status](https://coveralls.io/repos/github/cowprotocol/cow-sdk/badge.svg?branch=main)](https://coveralls.io/github/cowprotocol/cow-sdk?branch=main)
 
-> ⚠️⚠️ THE SDK IS IN Beta ⚠️⚠️
-> It is being currently develop and is a work in progress, also it's API is subjected to change.
-> If you experience any problems, please open an issue in Github trying to describe your problem.
-
-### Getting started
+## Getting started
 
 Install the SDK:
 
@@ -22,14 +18,29 @@ yarn add @cowprotocol/cow-sdk
 Instantiate the SDK:
 
 ```js
-import { CowSdk } from 'cow-sdk'
+import { CowSdk } from '@cowprotocol/cow-sdk'
 
 const chainId = 4 // Rinkeby
 const cowSdk = new CowSdk(chainId)
 ```
 
-The SDK will expose the CoW API operations (`cowSdk.cowApi`) and some convenient method that will facilitate signing orders (`cowSdk.signOrder`). Future version will provide easy access to The Graph data and some other convenient utils.
+The SDK will expose:
+* The CoW API (`cowSdk.cowApi`)
+* The CoW Subgraph (`cowSdk.cowSubgraphApi`)
+* Convenient method to facilitate signing orders (i.e `cowSdk.signOrder`)
+
+
+> For a quick snippet with the full process on posting an order see the [Post an Order Example](./docs/post-order-example.ts)
+
 
+## CoW API
+The SDK provides access to the CoW API. The CoW API allows you:
+- Post orders
+- Get fee quotes
+- Get order details
+- Get history of orders: i.e. filtering by account, transaction hash, etc.
+
+For example, you can easily get the last 5 order of a trader:
 ```js
 // i.e. Get last 5 orders for a given trader
 const trades = await cowSdk.cowApi.getOrders({
@@ -40,29 +51,62 @@ const trades = await cowSdk.cowApi.getOrders({
 console.log(trades)
 ```
 
-Let's see a full example on how to submit an order to CowSwap.
+> For more information about the API methods, you can check [api.cow.fi/docs](https://api.cow.fi/docs).
 
-> ⚠️ Before starting, the protocol requires you to approve the sell token before the order can be considered.
-> For more details see https://docs.cow.fi/tutorials/how-to-submit-orders-via-the-api/1.-set-allowance-for-the-sell-token
+## Sign and Post orders
+In order to trade, you will need to create a valid order first.
+
+On the contraty to other decentralised exchanges, creating orders is free in CoW Protocol. This is because, one of the 
+most common ways to do it is by created offchain signed messages (meta-transactions, uses `EIP-712` or `EIP-1271`).
+
+Posting orders is a three steps process:
 
-In this example, we will:
+- 1. **Get Market Pricea**: Fee & Price
+- 2. **Sign the order**: Using off-chain signing or Meta-transactions
+- 3. **Post the signed order to the API**: So, the order becomes `OPEN`
 
-- 1. **Instantiate the SDK and a wallet**: Used for signing orders
-- 2. **Get a price/fee quote from the API**: Get current market price and required protocol fee to settle your trade.
-- 3. **Sign the order using your wallet**: Only signed orders are considered by the protocol.
-- 4. **Post the signed order to the API**: Post the order so it can be executed.
+The next sections will guide you through the process of creating a valid order.
+
+> For a quick snippet with the full process on posting an order see the [Post an Order Example](./docs/post-order-example.ts).
+
+### Enable tokens (token approval)
+Because of the use of off-chain signing (meta-transactions), users will need to **Enable the sell token**  before signed
+orders can be considered as valid ones. 
+
+This enabling is technically an `ERC-20` approval, and is something that needs to be done only once. After this all 
+order creation can be done for free using offchain signing.
+
+> For more details see https://docs.cow.fi/tutorials/how-to-submit-orders-via-the-api/1.-set-allowance-for-the-sell-token
+
+### Instantiate SDK with a signer
+Before you can sign any transaction, you have to instantiate the SDK with a [Ethers.JS signer](https://docs.ethers.io/v5/api/signer/):
 
 ```js
 import { Wallet } from 'ethers'
-import { CowSdk, OrderKind } from 'cow-sdk'
+import { CowSdk, OrderKind } from '@cowprotocol/cow-sdk'
 
-// 1. Instantiate wallet and SDK
 const mnemonic = 'fall dirt bread cactus...'
 const wallet = Wallet.fromMnemonic(mnemonic)
-const cowSdk = new CowSdk(4, { signer: wallet }) // Leaving chainId empty will default to MAINNET
+const cowSdk = new CowSdk(
+  4, {            // Leaving chainId empty will default to MAINNET
+  signer: wallet  // Provide a signer, so you can sign order
+  }) 
+```
 
-// 2. Get a price/fee quote from the API
-//    It will return the price and fee to "Sell 1 ETH for USDC"
+### STEP 1: Get Market Price
+To create an order, you need to get a price/fee quote first:
+
+  * The SDK will give you easy access to the API, which returns the `Market Price` and the `Fee` for any given trade you intent to do.
+  * The returned `Market Price` is not strictly needed, you can use your own pricing logic. 
+    * You can choose a price that is below this Market price (**Market Order**), or above Market Price (**Limit Order**).
+  * The `Fee` however is very important. 
+    * It is the required amount in sell token the trader agrees on paying for executing the order onchain. 
+    * Normally, its value is proportional to the current Gas Price of the network. 
+    * This fee is never charged if you don't trade.
+
+To get the quote, you simply specify the trade you intent to do:
+
+```js
 const quoteResponse = await cowSdk.cowApi.getQuote({
   kind: OrderKind.SELL, // Sell order (could also be BUY)
   sellToken: '0xc778417e063141139fce010982780140aa0cd5ab', // WETH
@@ -73,122 +117,236 @@ const quoteResponse = await cowSdk.cowApi.getQuote({
 })
 
 const { sellToken, buyToken, validTo, buyAmount, sellAmount, receiver, feeAmount } = quoteResponse.quote
+```
+
+### STEP 2: Sign the order
+Once you know the price and fee, we can create the order and sign it:
+
+  * Technically the order is just a signed message with your intent to trade, and contains your `Limit Price` and `Fee`.
+  * As explained before, you can choose your `Limit Price`, but some general approach is to take the current Market Price
+  and apply some slippage tolerance to it. `Received Amount = Expected Amount * (1 - Slippage Tolerance)`
+  * The SDK will provide an easy way to sign orders given the raw data
+
+
+```js
+const { sellToken, buyToken, validTo, buyAmount, sellAmount, receiver, feeAmount } = quoteResponse.quote
+
+// Prepare the RAW order
 const order = {
-  kind: OrderKind.SELL,
-  partiallyFillable: false, // Allow partial executions of an order (true would be for a "Fill or Kill" order, which is not yet supported but will be added soon)
+  kind: OrderKind.SELL, // SELL || BUY  
+  receiver, // Your account or any other
   sellToken,
   buyToken,
+
+  partiallyFillable: false, // ("false" is for a "Fill or Kill" order, "true" for allowing "Partial execution" which is not supported yet)
+
+  // Deadline
   validTo,
-  buyAmount,
+
+  // Limit Price
+  //    You can apply some slippage tolerance here to make sure the trade is executed. 
+  //    CoW protocol protects from MEV, so it can work with higher slippages
   sellAmount,
-  receiver,
+  buyAmount, 
+
+  // Use the fee you received from the API
   feeAmount,
+
+  // The appData allows you to attach arbitrary information (meta-data) to the order. Its explained in their own section. For now, you can use this 0x0 value
+  appData: '0x0000000000000000000000000000000000000000000000000000000000000000'
 }
 
-// 3. Sign the order using your wallet
+// Sign the order
 const signedOrder = await cowSdk.signOrder(order)
+```
+
+At this point, you have a signed order. So next step will be to post it to the API so it's considered by the solvers and executed.
+
+  
+## STEP 3: **Post the signed order to the API**: 
+Once you have a signed order, last step is to send it to the API.
+  * The API will accept the order if its correctly signed, the deadline is correct, and the fee is enough to settle it
+  * Once accepted, the order will be `OPEN` until the specified `validTo` date (expiration)
+  * The possible outcomes once accepted is:
+      * The order is `EXECUTED`: you will pay the signed fee, and get at least the `buyAmount` tokens you specified, although you will probably get more! (you will probably get a so-called **Surplus**).
+      * The order `EXPIRES`: If your price is not good enough, and the order is out of the market price before
+      expiration, your order will expire. This doesn't have any cost to the user, which **only pays the fee if the trade is executed**.
+      * You cancel the order, so it becomes `CANCELLED`. Cancelling an order can be done both as a free meta-transaction
+       (**soft cancelations**) or as a regular on-chain transaction (**hard cancelations**).
+  * The API will return an `orderId` which identifies the order, and is created as a summary (hash) of it. In other words, the `orderId` is deterministic given all the order parameters.
+
 
-// 4. Post the signed order to the API
+Post an order using the SDK:
+
+```js
 const orderId = await cowSdk.cowApi.sendOrder({
   order: { ...order, ...signedOrder },
   owner: '0x1811be0994930fe9480eaede25165608b093ad7a',
 })
+```
+
 
-// We can inspect the Order details in the CoW Protocol Explorer
+### BONUS: Show link to Explorer
+Once the order is posted, its good to allow to check the state of it. 
+
+One easy is to check in the CoW Explorer. You can create a CoW Explorer link if you have the `orderId`:
+
+```js
+// View order in explorer
 console.log(`https://explorer.cow.fi/rinkeby/orders/${orderId}`)
+```
 
-// You can also override defaults params when using CowApi methods
-const orderId = await cowSdk.cowApi.sendOrder(
-  {
-    order: { ...order, ...signedOrder },
-    owner: '0x1811be0994930fe9480eaede25165608b093ad7a',
-  },
-  { chainId: 1, isDevEnvironment: false }
-)
+
+## Create a meta-data document for attaching to an order
+Orders in CoW Protocol can contain arbitrary data in a field called `AppData`.
+
+The SDK facilitates the creation of these documents, and getting the `AppData` Hex number that summarizes it.
+
+The most important thing to define in the meta-data is the name of your app, so the order-flow can be credited to it.
+
+```js
+const appDataDoc = cowSdk.metadataApi.generateAppDataDoc({
+  appDataParams: { appCode: "YourApp" }
+})
+```
+
+This will create a document similar to:
+```json
+{
+  "version": "0.4.0",
+  "appCode": "YourApp",
+  "metadata": {}
+} 
 ```
 
-SDK also includes a Metadata API to interact with AppData documents and IPFS CIDs
+After creating the most basic document, you can see how to attach additional meta-data items.
+
+For example, you could give information about who referred the user creating the order.
 
 ```js
-const chainId = 4 // Rinkeby
-const cowSdk = new CowSdk(chainId)
-let hash = '0xa6c81f4ca727252a05b108f1742a07430f28d474d2a3492d8f325746824d22e5'
-
-// Decode AppData document given a CID hash
-const appDataDoc = await cowSdk.metadataApi.decodeAppData(hash)
-console.log(appDataDoc)
-/* {
-      "appCode": "CowSwap",
-      "metadata": {
-          "referrer": {
-              "address": "0x1f5B740436Fc5935622e92aa3b46818906F416E9",
-              "version": "0.1.0"
-          }
-      },
+const appDataDoc = cowSdk.metadataApi.generateAppDataDoc({
+  appDataParams: { appCode: "YourApp" },
+  metadataParas: {
+    referrerParams: {
+      address: '0x1f5B740436Fc5935622e92aa3b46818906F416E9'
+    }
+  }
+})
+```
+
+This will create a document similar to:
+
+```json
+{
+  "version": "0.4.0",
+  "appCode": "YourApp",
+  "metadata": {
+    "referrer": {
+      "address": "0x1f5B740436Fc5935622e92aa3b46818906F416E9",
       "version": "0.1.0"
-  } */
+    }
+  }
+}
+```
 
-const cid = 'QmUf2TrpSANVXdgcYfAAACe6kg551cY3rAemB7xfEMjYvs'
+The method `cowSdk.metadataApi.generateAppDataDoc` will always create the latest schema version.
 
-// Decode CID hash to AppData Hex
-const decodedAppDataHex = await cowSdk.metadataApi.cidToAppDataHex(cid)
-console.log(decodedAppDataHex) //0x5ddb2c8207c10b96fac92cb934ef9ba004bc007a073c9e5b13edc422f209ed80
+For a complete list of metadata that can be attached and for previous versions
+check `@cowprotocol/app-data` [repository](https://github.com/cowprotocol/app-data)
+and [NPM package](https://www.npmjs.com/package/@cowprotocol/app-data)
 
-hash = '0x5ddb2c8207c10b96fac92cb934ef9ba004bc007a073c9e5b13edc422f209ed80'
+## Get the AppData Hex
+The `AppData` Hex points to an IPFS document with the meta-data attached to the order.
 
-// Decode AppData Hex to CID
-const decodedAppDataHex = await cowSdk.metadataApi.appDataHexToCid(hash)
-console.log(decodedAppDataHex) //QmUf2TrpSANVXdgcYfAAACe6kg551cY3rAemB7xfEMjYvs
-
-/*Create an AppData Document with empty metadata and default appCode
-  generateAppDataDoc receives as parameters: 
-    - metadata: MetadataDoc (Default: {})
-    - appCode: string (Default: 'Cowswap')
-*/
-const appDataDoc = cowSdk.metadataApi.generateAppDataDoc({})
-/* {
-      version: '0.1.0',
-      appCode: 'CowSwap',
-      metadata: {},
-    } 
-*/
-
-// Create an AppData Document with custom metadata and appCode
-const appDataDoc = cowSdk.metadataApi.generateAppDataDoc(
-  {
-    referrer: {
-      address: '0x1f5B740436Fc5935622e92aa3b46818906F416E9',
-      version: '0.1.0',
-    },
-  },
-  'CowApp'
-)
-/* {
-      version: '0.1.0',
-      appCode: 'CowApp',
-      metadata: {
-        referrer: {
-          address: '0x1f5B740436Fc5935622e92aa3b46818906F416E9',
-          version: '0.1.0',
-        },
-      },
-    } 
-*/
-
-// Calculate appDataHash (and cidV0) for given doc without uploading to IPFS
-// This operation is deterministic and can be used to know before the upload the actual hash
+You can calculate the `AppData` Hex, and its corresponding `cidV0` using the SDK:
+
+```js
 const { appDataHash, cidv0 } = await cowSdk.metadataApi.calculateAppDataHash(appDataDoc)
+```
+
+Note how this operation is deterministic, so given the same document, it will always generate the same hash. 
+
+This method can be used to calculate the actual hash before uploading the document to IPFS.
+
+
+## Get meta-data document uploaded to IPFS from AppData
+Given the `AppData` of a document that has been uploaded to IPFS, you can easily retrieve the document.
+
+```js
+const appDataDoc = await cowSdk.metadataApi.decodeAppData('0x5ddb2c8207c10b96fac92cb934ef9ba004bc007a073c9e5b13edc422f209ed80')
+```
+
+This will return a document similar to:
+
+```json
+{
+  "version": "0.1.0",
+  "appCode": "YourApp",
+  "metadata": {
+    "referrer": {
+      "address": "0x1f5B740436Fc5935622e92aa3b46818906F416E9",
+      "version": "0.1.0"
+    }
+  }
+}
+```
 
-// Upload AppDataDoc to IPFS (Pinata)
+## Upload document to IPFS
+The SDK uses Pinata to upload it to IPFS, so you will need an API Key in order to upload it using the SDK.
+
+Alternatively, you can upload the document on your own using any other service.
+
+```js
+// Make sure you provide the IPFS params when instantiating the SDK
 const cowSdk = new CowSdk(4, {
-  ipfs: { pinataApiKey: 'YOUR_PINATA_API_KEY', pinataApiSecret: 'YOUR_PINATA_API_SECRET' },
+  ipfs: { 
+    pinataApiKey: 'YOUR_PINATA_API_KEY', 
+    pinataApiSecret: 'YOUR_PINATA_API_SECRET'
+  },
 })
 
+// Upload to IPFS
 const uploadedAppDataHash = await cowSdk.metadataApi.uploadMetadataDocToIpfs(appDataDoc)
-/* 0x5ddb2c8207c10b96fac92cb934ef9ba004bc007a073c9e5b13edc422f209ed80 */
 ```
 
-#### Querying the Cow Subgraph
+## Convert IPFS CIDv0 to AppData (and back)
+Given an IPFS CIDv0 you can convert it to an `AppData` 
+
+```js
+const decodedAppDataHex = await cowSdk.metadataApi.cidToAppDataHex('QmUf2TrpSANVXdgcYfAAACe6kg551cY3rAemB7xfEMjYvs')
+```
+
+This will return an `AppData` hex: `0x5ddb2c8207c10b96fac92cb934ef9ba004bc007a073c9e5b13edc422f209ed80`
+
+
+> This might be handy if you decide to upload the document to IPFS yourself and then you need the AppData to post your order
+
+
+Similarly, you can do the opposite and convert an `AppData` into an IPFS document:
+
+```js
+const decodedAppDataHex = await cowSdk.metadataApi.appDataHexToCid(hash)
+```
+
+This will return an IPFS CIDv0: `QmUf2TrpSANVXdgcYfAAACe6kg551cY3rAemB7xfEMjYvs`
+
+
+## Getting appData schema files
+It's possible to get schema files directly for each exported version using `getAppDataSchema`
+
+```js
+const schema = await cowSdk.metadataApi.getAppDataSchema('0.4.0')
+```
+
+## Validating appDataDocs
+If for some reason you decide to create an `appDataDoc` without using the helper function, you can use `validateAppDataDoc` to validate it against the schema
+
+```js
+const { success, error } = await cowSdk.metadataApi.validateAppDataDoc({ version: '0.1.0', ... })
+```
+
+
+## Querying the Cow Subgraph
 
 You can query the Cow Subgraph either by running some common queries exposed by the `CowSubgraphApi` or by building your own ones:
 

package/dist/CowSdk.d.ts

@@ -2,21 +2,25 @@ import { Signer } from 'ethers';
 import { LogLevelDesc } from 'loglevel';
 import { CowApi, CowSubgraphApi, MetadataApi } from './api';
 import { SupportedChainId as ChainId } from './constants/chains';
-import { validateAppDataDocument } from './utils/appData';
 import { Context, CowContext } from './utils/context';
 import { UnsignedOrder } from './utils/sign';
+import { ZeroXApi } from './api/0x';
+import { MatchaOptions } from './api/0x/types';
+import ParaswapApi from './api/paraswap';
 declare type Options = {
     loglevel?: LogLevelDesc;
+    matchaOptions?: MatchaOptions;
 };
 export declare class CowSdk<T extends ChainId> {
     context: Context;
     cowApi: CowApi;
     metadataApi: MetadataApi;
     cowSubgraphApi: CowSubgraphApi;
+    zeroXApi: ZeroXApi;
+    paraswapApi: ParaswapApi;
     constructor(chainId?: T, cowContext?: CowContext, options?: Options);
     updateChainId: (chainId: ChainId) => void;
-    updateContext: (cowContext: CowContext, chainId?: ChainId | undefined) => Promise<void>;
-    validateAppDataDocument: typeof validateAppDataDocument;
+    updateContext: (cowContext: CowContext, chainId?: ChainId) => Promise<void>;
     signOrder(order: Omit<UnsignedOrder, 'appData'>): Promise<import("./utils/sign").SigningResult>;
     signOrderCancellation(orderId: string): Promise<import("./utils/sign").SigningResult>;
     _checkSigner(signer?: Signer | undefined): Signer;

package/dist/api/0x/error/index.d.ts

@@ -0,0 +1,21 @@
+import { CowError } from '../../../utils/common';
+interface ValidationError {
+    field: string;
+    code: number;
+    reason: string;
+}
+export interface ZeroXErrorResponse {
+    code: number;
+    reason: string;
+    validationErrors?: ValidationError[];
+}
+export declare const logPrefix = "0x-sdk:";
+export default class ZeroXError extends CowError {
+    name: string;
+    description: string;
+    message: string;
+    static getErrorMessage(response: Response): Promise<string>;
+    static getErrorFromStatusCode(response: Response): Promise<string>;
+    constructor(apiError: ZeroXErrorResponse);
+}
+export {};

package/dist/api/0x/index.d.ts

@@ -0,0 +1,11 @@
+import { SupportedChainId } from '../../constants/chains';
+import BaseApi from '../base';
+import { Options, PriceQuoteLegacyParams } from '../cow/types';
+import { MatchaOptions, MatchaPriceQuote } from './types';
+export declare class ZeroXApi extends BaseApi {
+    MATCHA_OPTIONS: MatchaOptions;
+    MATCHA_OPTIONS_URL: string;
+    constructor(chainId: SupportedChainId, { affiliateAddressMap, excludedSources }?: MatchaOptions);
+    getQuote(params: PriceQuoteLegacyParams, options?: Options): Promise<MatchaPriceQuote | null>;
+    updateOptions({ affiliateAddressMap, excludedSources }: Partial<MatchaOptions>): Promise<void>;
+}

package/dist/api/0x/utils.d.ts

@@ -0,0 +1,17 @@
+import { OrderKind } from '@cowprotocol/contracts';
+import { SupportedChainId } from '../../constants/chains';
+import { PriceInformation, PriceQuoteLegacyParams } from '../cow/types';
+import { MatchaOptions, MatchaPriceQuote } from './types';
+export declare function get0xUrls(): Partial<Record<SupportedChainId, string>>;
+export declare function normaliseQuoteResponse(priceRaw: MatchaPriceQuote | null, kind: OrderKind): PriceInformation | null;
+export declare function getMatchaChainId(chainId: SupportedChainId): SupportedChainId | null;
+export declare function optionsToMatchaParamsUrl({ excludedSources, affiliateAddress, }: {
+    excludedSources: MatchaOptions['excludedSources'];
+    affiliateAddress: string;
+}): string;
+export declare function handleQuoteResponse<T = unknown, P extends PriceQuoteLegacyParams = PriceQuoteLegacyParams>(response: Response, params?: P): Promise<T>;
+export declare function throwOrReturnAffiliateAddress({ affiliateAddressMap, chainId, }: {
+    affiliateAddressMap: MatchaOptions['affiliateAddressMap'];
+    chainId: SupportedChainId;
+}): string;
+export declare function extractExcludedSources({ excludedSources }: Pick<MatchaOptions, 'excludedSources'>): string;

package/dist/api/base/index.d.ts

@@ -0,0 +1,25 @@
+import { SupportedChainId } from '../../constants/chains';
+import { Context } from '../../utils/context';
+import { Options } from '../cow/types';
+interface ConstructorParams {
+    context: Context;
+    name: string;
+    apiVersion?: string;
+    getApiUrl: (...params: any[]) => Partial<Record<SupportedChainId, string>>;
+    defaultHeaders?: HeadersInit;
+}
+export default class BaseApi {
+    context: Context;
+    API_NAME: string;
+    API_VERSION: string;
+    API_URL_GETTER: (...params: any[]) => Partial<Record<SupportedChainId, string>>;
+    DEFAULT_HEADERS: HeadersInit;
+    constructor({ context, name, getApiUrl, defaultHeaders, apiVersion, }: ConstructorParams);
+    protected getApiBaseUrl(...params: unknown[]): Promise<string>;
+    protected post(url: string, data: unknown, options?: Options): Promise<Response>;
+    protected get(url: string, options?: Options): Promise<Response>;
+    protected delete(url: string, data: unknown, options?: Options): Promise<Response>;
+    protected handleMethod(url: string, method: 'GET' | 'POST' | 'DELETE', fetchFn: BaseApi['fetch'], getApiUrl: BaseApi['API_URL_GETTER'], options?: Options, data?: unknown): Promise<Response>;
+    protected fetch(url: string, method: 'GET' | 'POST' | 'DELETE', baseUrl: string, data?: unknown, requestOptions?: RequestInit): Promise<Response>;
+}
+export {};

package/dist/api/cow/index.d.ts

@@ -1,37 +1,27 @@
-import { SupportedChainId as ChainId } from '../../constants/chains';
+import { QuoteQuery } from '@cowprotocol/contracts';
 import { OrderCreation } from '../../utils/sign';
-import { FeeQuoteParams, PriceInformation, PriceQuoteParams, SimpleGetQuoteResponse } from './types';
+import { FeeQuoteParams, PriceInformation, PriceQuoteLegacyParams, SimpleGetQuoteResponse } from './types';
 import { GetOrdersParams, GetTradesParams, OrderCancellationParams, OrderID, OrderMetaData, ProfileData, TradeMetaData, Options } from './types';
 import { Context } from '../../utils/context';
-export declare class CowApi {
-    context: Context;
-    API_NAME: string;
+import BaseApi from '../base';
+export declare class CowApi extends BaseApi {
     constructor(context: Context);
-    get DEFAULT_HEADERS(): {
-        'Content-Type': string;
-        'X-AppId': string;
-    };
-    get API_BASE_URL(): Partial<Record<ChainId, string>>;
     getProfileData(address: string, options?: Options): Promise<ProfileData | null>;
     getTrades(params: GetTradesParams, options?: Options): Promise<TradeMetaData[]>;
     getOrders(params: GetOrdersParams, options?: Options): Promise<OrderMetaData[]>;
     getTxOrders(txHash: string, options?: Options): Promise<OrderMetaData[]>;
     getOrder(orderId: string, options?: Options): Promise<OrderMetaData | null>;
-    getPriceQuoteLegacy(params: PriceQuoteParams, options?: Options): Promise<PriceInformation | null>;
-    getQuote(params: FeeQuoteParams, options?: Options): Promise<SimpleGetQuoteResponse>;
+    getPriceQuoteLegacy(params: PriceQuoteLegacyParams, options?: Options): Promise<PriceInformation | null>;
+    getQuoteLegacyParams(params: FeeQuoteParams, options?: Options): Promise<SimpleGetQuoteResponse>;
+    getQuote(params: QuoteQuery, options?: Options): Promise<SimpleGetQuoteResponse>;
     sendSignedOrderCancellation(params: OrderCancellationParams, options?: Options): Promise<void>;
     sendOrder(params: {
         order: Omit<OrderCreation, 'appData'>;
         owner: string;
     }, options?: Options): Promise<OrderID>;
     getOrderLink(orderId: OrderID): Promise<string>;
+    private getProfile;
     private mapNewToLegacyParams;
-    private getApiBaseUrl;
-    private fetch;
+    protected getApiBaseUrl(): Promise<string>;
     private fetchProfile;
-    private post;
-    private get;
-    private getProfile;
-    private delete;
-    private handleMethod;
 }

package/dist/api/cow/types.d.ts

@@ -1,6 +1,7 @@
 import { GetQuoteResponse, OrderKind } from '@cowprotocol/contracts';
 import { StrictUnion } from 'utilities';
 import { SupportedChainId as ChainId } from '../../constants/chains';
+import { Env } from '../../utils/context';
 import { OrderCancellation, SigningSchemeValue } from '../../utils/sign';
 /**
  * Unique identifier for the order, calculated by keccak256(orderDigest, ownerAddress, validTo),
@@ -107,12 +108,14 @@ export declare type FeeQuoteParams = Pick<OrderMetaData, 'sellToken' | 'buyToken
     receiver?: string | null;
     validTo: number;
 };
-export declare type PriceQuoteParams = Omit<FeeQuoteParams, 'sellToken' | 'buyToken'> & {
+export declare type PriceQuoteLegacyParams = Omit<FeeQuoteParams, 'sellToken' | 'buyToken'> & {
     baseToken: string;
     quoteToken: string;
 };
 export declare type Options = {
     chainId?: ChainId;
-    isDevEnvironment?: boolean;
+    env?: Env;
+    requestOptions?: RequestInit;
+    apiUrlGetterParams?: unknown[];
 };
 export {};