@cowprotocol/cow-sdk 6.3.2 → 7.0.0-beta.0

package/README.md

@@ -2,287 +2,371 @@
   <img width="400" src="https://github.com/cowprotocol/cow-sdk/raw/main/docs/images/CoW.png" />
 </p>
 
-# CoW SDK
+# CoW SDK - Umbrella Package
 
-## 📚 [Docs website](https://docs.cow.fi/)
+The **CoW SDK Umbrella Package** is the comprehensive entry point for developers who want to access all CoW Protocol functionalities in a single, unified package. This is the recommended way to interact with CoW Protocol as it provides seamless integration across all SDK modules.
 
-## Test coverage
+## 🎯 **Why Use the Umbrella Package?**
 
-| Statements                                                                                 | Branches                                                                       | Functions                                                                                | Lines                                                                            |
-| ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
-| ![Statements](https://img.shields.io/badge/statements-94.77%25-brightgreen.svg?style=flat) | ![Branches](https://img.shields.io/badge/branches-76.78%25-red.svg?style=flat) | ![Functions](https://img.shields.io/badge/functions-97.43%25-brightgreen.svg?style=flat) | ![Lines](https://img.shields.io/badge/lines-97.67%25-brightgreen.svg?style=flat) |
+- **All-in-One Solution** - Single installation gives you access to all CoW Protocol features
+- **Unified API** - Access all modules through one `CowSdk` instance or import them individually
+- **Simplified Setup** - Adapter configuration is handled once and shared across all modules
+- **Future-Proof** - Automatically includes new features and modules as they're added
 
-## Getting started
+## 📚 **Documentation Hub**
 
-**Usage examples: [VanillaJS](https://github.com/cowprotocol/cow-sdk/blob/main/examples/vanilla/src/index.ts), [Create React App](https://github.com/cowprotocol/cow-sdk/blob/main/examples/cra/src/pages/getOrders/index.tsx), [NodeJS](https://github.com/cowprotocol/cow-sdk/blob/main/examples/nodejs/src/index.ts)**
+This package serves as the **main entry point** for all CoW Protocol SDK documentation. Each individual package has its own detailed documentation, but everything starts here.
+
+### 📂 **SDK Structure**
+
+```
+├── @cowprotocol/cow-sdk (Umbrella - All packages included) 🏠
+│
+├── Provider Adapters
+│   ├── @cowprotocol/sdk-ethers-v5-adapter
+│   ├── @cowprotocol/sdk-ethers-v6-adapter
+│   └── @cowprotocol/sdk-viem-adapter
+│
+├── Core Utilities
+│   ├── @cowprotocol/sdk-common
+│   ├── @cowprotocol/sdk-config
+│   └── @cowprotocol/sdk-contracts-ts
+│
+├── Protocol Components
+│   ├── @cowprotocol/sdk-order-signing
+│   ├── @cowprotocol/sdk-order-book
+│   ├── @cowprotocol/sdk-app-data
+│   ├── @cowprotocol/sdk-trading
+│   ├── @cowprotocol/sdk-composable
+│   ├── @cowprotocol/sdk-cow-shed
+│   ├── @cowprotocol/sdk-subgraph
+│   └── @cowprotocol/sdk-bridging
+│
+└── Additional Packages
+    └── @cowprotocol/app-data
+```
+
+## 🚀 **Getting Started**
 
 ### Installation
 
 ```bash
+npm install @cowprotocol/cow-sdk
+# or
+pnpm add @cowprotocol/cow-sdk
+# or
 yarn add @cowprotocol/cow-sdk
 ```
 
-## [Trading SDK](https://github.com/cowprotocol/cow-sdk/blob/main/src/trading/README.md)
+You'll also need one of the adapter packages:
+
+```bash
+# Choose one based on your Web3 library preference
+npm install @cowprotocol/sdk-ethers-v6-adapter
+npm install @cowprotocol/sdk-ethers-v5-adapter
+npm install @cowprotocol/sdk-viem-adapter
+```
+
+## 💡 **Usage Patterns**
 
-CoW Protocol is intent based, decentralized trading protocol that allows users to trade ERC-20 tokens.
+The umbrella package offers three flexible usage patterns:
 
-The basic swap flow:
-1. 🔎 Get a quote (price) for a trade (_or define your own price with a limit order_)
-2. ✍️ Sign the order
-3. ✅ Post the order to the order-book
+### 1. **Unified CowSdk Instance** (Recommended)
 
-The easiest way to start trading is to use the `TradingSdk`:
+Access all modules through a single SDK instance:
 
 ```typescript
-import { SupportedChainId, OrderKind, TradeParameters, TradingSdk } from '@cowprotocol/cow-sdk'
+import {
+  CowSdk,
+  TradingSdk,
+  OrderBookApi,
+  OrderSigningUtils,
+  setGlobalAdapter,
+  SupportedChainId
+} from '@cowprotocol/cow-sdk'
+import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
+import { createPublicClient, http, privateKeyToAccount } from 'viem'
+import { sepolia } from 'viem/chains'
+
+// Create and configure adapter
+// There are EthersV5Adapter and EthersV6Adapter as well
+// @cowprotocol/sdk-ethers-v5-adapter, @cowprotocol/sdk-ethers-v6-adapter
+const adapter = new ViemAdapter({
+  provider: createPublicClient({
+    chain: sepolia,
+    transport: http('YOUR_RPC_URL')
+  }),
+  signer: privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
+})
 
-// Initialize the SDK
-const sdk = new TradingSdk({
+// Initialize the unified SDK
+const sdk = new CowSdk({
   chainId: SupportedChainId.SEPOLIA,
-  signer: '<privateKeyOrEthersSigner>',
-  appCode: '<YOUR_APP_CODE>',
+  adapter,
+  tradingOptions: {
+    traderParams: {
+      appCode: 'YOUR_APP_CODE',
+      ...
+    },
+    ...
+  },
 })
 
-// Define trade parameters
-const parameters: TradeParameters = {
-  kind: OrderKind.BUY,
-  sellToken: '0xfff9976782d46cc05630d1f6ebab18b2324d6b14',
-  sellTokenDecimals: 18,
-  buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59',
-  buyTokenDecimals: 18,
-  amount: '120000000000000000'
-}
+// Use all modules seamlessly
+const orderId = await sdk.trading.postSwapOrder(parameters)
+const orders = await sdk.orderBook.getOrders({ owner: address })
+const totals = await sdk.subgraph?.getTotals()
+const signature = await sdk.orderSigning.signOrder(order, chainId, signer)
+```
 
-// Post the order
-const orderId = await sdk.postSwapOrder(parameters)
+### 2. **Direct Module Import** (Simplified)
 
-console.log('Order created, id: ', orderId)
-```
+Import modules directly from the umbrella package without the unified instance:
 
-This example is the simplest way to trade on CoW Protocol.
+```typescript
+import { TradingSdk, OrderBookApi, SupportedChainId, OrderKind, TradeParameters } from '@cowprotocol/cow-sdk'
+import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
+import { createPublicClient, http, privateKeyToAccount } from 'viem'
+import { sepolia } from 'viem/chains'
+
+// Create and configure adapter
+// There are EthersV5Adapter and EthersV6Adapter as well
+// @cowprotocol/sdk-ethers-v5-adapter, @cowprotocol/sdk-ethers-v6-adapter
+const adapter = new ViemAdapter({
+  provider: createPublicClient({
+    chain: sepolia,
+    transport: http('YOUR_RPC_URL')
+  }),
+  signer: privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
+})
 
-You might want to use more advanced parameters like `receiver`, `partiallyFillable`, `validTo` and others.
-Check the [Trading SDK documentation](https://github.com/cowprotocol/cow-sdk/blob/main/src/trading/README.md) for more details.
+// Use modules individually - adapter configuration is handled automatically
+const trading = new TradingSdk({ appCode: 'YOUR_APP_CODE' }, { chainId: SupportedChainId.SEPOLIA }, adapter)
 
+const orderBook = new OrderBookApi({ chainId: SupportedChainId.SEPOLIA })
+
+// All modules work together seamlessly
+const orderId = await trading.postSwapOrder(parameters)
+const orders = await orderBook.getOrders({ owner: address })
+```
 
-## Other utilities
+### 3. **Global Adapter Configuration**
 
-- `OrderBookApi` - provides the ability to retrieve orders and trades from the CoW Protocol order-book, as well as add and cancel them
-- `OrderSigningUtils` - serves to sign orders and cancel them using [EIP-712](https://eips.ethereum.org/EIPS/eip-712)
-- `SubgraphApi` - provides statistics data about CoW protocol from [Subgraph](https://github.com/cowprotocol/subgraph), such as trading volume, trade count and others
+Set up the adapter once and use modules without explicit adapter passing:
 
 ```typescript
-import { OrderBookApi, OrderSigningUtils, SubgraphApi } from '@cowprotocol/cow-sdk'
+import { TradingSdk, OrderBookApi, OrderSigningUtils, setGlobalAdapter, SupportedChainId } from '@cowprotocol/cow-sdk'
+import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
+import { createPublicClient, http, privateKeyToAccount } from 'viem'
+import { sepolia } from 'viem/chains'
+
+// Create and configure adapter
+// There are EthersV5Adapter and EthersV6Adapter as well
+// @cowprotocol/sdk-ethers-v5-adapter, @cowprotocol/sdk-ethers-v6-adapter
+const adapter = new ViemAdapter({
+  provider: createPublicClient({
+    chain: sepolia,
+    transport: http('YOUR_RPC_URL')
+  }),
+  signer: privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
+})
 
-const chainId = 100 // Gnosis chain
+setGlobalAdapter(adapter)
 
-const orderBookApi = new OrderBookApi({ chainId })
-const subgraphApi = new SubgraphApi({ chainId })
-const orderSigningUtils = new OrderSigningUtils()
-```
+// Now use modules without passing adapter each time
+const trading = new TradingSdk({ appCode: 'YOUR_APP_CODE' }, { chainId: SupportedChainId.SEPOLIA })
 
-### Sign, fetch, post and cancel order
+const orderBook = new OrderBookApi({ chainId: SupportedChainId.SEPOLIA })
 
-For clarity, let's look at the use of the API with a practical example:
-Exchanging `0.4 GNO` to `WETH` on `Gnosis chain` network.
+// Use OrderSigningUtils directly - no need to instantiate
+// const orderSigning = OrderSigningUtils  // or simply use OrderSigningUtils.signOrder(...)
+```
 
-We will do the following operations:
+## 🧩 **Available Modules**
 
-1. Get a quote
-2. Sign the order
-3. Send the order to the order-book
-4. Get the data of the created order
-5. Get trades of the order
-6. Cancel the order (signing + sending)
+All modules are accessible through the umbrella package:
 
-[You also can check this code in the CRA example](https://github.com/cowprotocol/cow-sdk/blob/main/examples/cra/src/pages/quickStart/index.tsx)
+> **📖 Documentation**: All links below point to the official documentation at [docs.cow.fi](https://docs.cow.fi). For source code, visit the [GitHub repository](https://github.com/cowprotocol/cow-sdk).
+
+### **Trading**
 
 ```typescript
-import { OrderBookApi, OrderSigningUtils, SupportedChainId } from '@cowprotocol/cow-sdk'
-import { Web3Provider } from '@ethersproject/providers'
-
-const account = 'YOUR_WALLET_ADDRESS'
-const chainId = 100 // Gnosis chain
-const provider = new Web3Provider(window.ethereum)
-const signer = provider.getSigner()
-
-const quoteRequest = {
-  sellToken: '0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1', // WETH gnosis chain
-  buyToken: '0x9c58bacc331c9aa871afd802db6379a98e80cedb', // GNO gnosis chain
-  from: account,
-  receiver: account,
-  sellAmountBeforeFee: (0.4 * 10 ** 18).toString(), // 0.4 WETH
-  kind: OrderQuoteSide.kind.SELL,
-}
+import { TradingSdk } from '@cowprotocol/cow-sdk'
+```
 
-const orderBookApi = new OrderBookApi({ chainId: SupportedChainId.GNOSIS_CHAIN })
+Create and manage orders, get quotes, handle swaps and limit orders.
+[📖 Trading Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/protocol-components/sdk-trading)
 
-async function main() {
-  const { quote } = await orderBookApi.getQuote(quoteRequest)
+### **Order Book**
 
-  const orderSigningResult = await OrderSigningUtils.signOrder(quote, chainId, signer)
+```typescript
+import { OrderBookApi } from '@cowprotocol/cow-sdk'
+```
 
-  const orderId = await orderBookApi.sendOrder({ ...quote, ...orderSigningResult })
+Interact with CoW Protocol's order book API for order management.
+[📖 Order Book Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/protocol-components/sdk-order-book)
 
-  const order = await orderBookApi.getOrder(orderId)
+### **Order Signing**
 
-  const trades = await orderBookApi.getTrades({ orderId })
+```typescript
+import { OrderSigningUtils } from '@cowprotocol/cow-sdk'
+```
 
-  const orderCancellationSigningResult = await OrderSigningUtils.signOrderCancellations([orderId], chainId, signer)
+Handle EIP-712 order signing and cancellations.
+[📖 Order Signing Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/protocol-components/sdk-order-signing)
 
-  const cancellationResult = await orderBookApi.sendSignedOrderCancellations({
-    ...orderCancellationSigningResult,
-    orderUids: [orderId],
-  })
+### **App Data**
 
-  console.log('Results: ', { orderId, order, trades, orderCancellationSigningResult, cancellationResult })
-}
+```typescript
+import { MetadataApi } from '@cowprotocol/cow-sdk'
 ```
 
-### OrderBookApi
+Manage order metadata and application-specific data.
+[📖 App Data Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/app-data)
 
-`OrderBookApi` - is a main tool for working with [CoW Protocol API](https://api.cow.fi/docs/#/).
-Since the API supports different networks and environments, there are some options to configure it.
+### **Subgraph**
 
-#### Environment configuration
-
-`chainId` - can be one of `SupportedChainId.MAINNET`, `SupportedChainId.GNOSIS_CHAIN`, `SupportedChainId.ARBITRUM_ONE`, `SupportedChainId.BASE`, `SupportedChainId.AVALANCHE`, `SupportedChainId.POLYGON`, or `SupportedChainId.SEPOLIA`
+```typescript
+import { SubgraphApi } from '@cowprotocol/cow-sdk'
+```
 
-`env` - this parameter affects which environment will be used:
+Access CoW Protocol analytics and historical data.
+[📖 Subgraph Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/protocol-components/sdk-subgraph)
 
-- `https://api.cow.fi` for `prod` (default)
-- `https://barn.api.cow.fi` for `staging`
+### **Contracts**
 
 ```typescript
-import { OrderBookApi } from '@cowprotocol/cow-sdk'
-
-const orderBookApi = new OrderBookApi({
-  chainId: SupportedChainId.GNOSIS_CHAIN,
-  env: 'staging', // <-----
-})
+import { ContractsTs } from '@cowprotocol/cow-sdk'
 ```
 
-#### API urls configuration
+TypeScript contract interfaces for CoW Protocol smart contracts.
+[📖 Contracts Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/core-utilities/sdk-contracts-ts)
 
-In case you need to use custom endpoints (e.g. you use a proxy), you can do it this way:
+### **Composable CoW**
 
 ```typescript
-import { OrderBookApi } from '@cowprotocol/cow-sdk'
-
-const orderBookApi = new OrderBookApi({
-  chainId: SupportedChainId.GNOSIS_CHAIN,
-  baseUrls: {
-    // <-----
-    [SupportedChainId.MAINNET]: 'https://YOUR_ENDPOINT/mainnet',
-    [SupportedChainId.GNOSIS_CHAIN]: 'https://YOUR_ENDPOINT/gnosis_chain',
-    [SupportedChainId.ARBITRUM]: 'https://YOUR_ENDPOINT/arbitrum_one',
-    [SupportedChainId.BASE]: 'https://YOUR_ENDPOINT/base',
-    [SupportedChainId.SEPOLIA]: 'https://YOUR_ENDPOINT/sepolia',
-    [SupportedChainId.POLYGON]: 'https://YOUR_ENDPOINT/polygon',
-    [SupportedChainId.AVALANCHE]: 'https://YOUR_ENDPOINT/avalanche',
-  },
-})
+import { ConditionalOrderFactory, Multiplexer } from '@cowprotocol/cow-sdk'
 ```
 
-The [CoW Protocol API](https://api.cow.fi/docs/#/) has restrictions on the backend side to protect against DDOS and other issues.
-
-> The main restriction is request rate limit of: **5 requests per second for each IP address**
+Advanced conditional and programmable orders.
+[📖 Composable Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/protocol-components/sdk-composable)
 
-The _client's_ limiter settings can be configured as well:
+### **CoW Shed**
 
 ```typescript
-import { OrderBookApi } from '@cowprotocol/cow-sdk'
-import { BackoffOptions } from 'exponential-backoff'
-import { RateLimiterOpts } from 'limiter'
+import { CowShedSdk } from '@cowprotocol/cow-sdk'
+```
 
-const limiterOpts: RateLimiterOpts = {
-  tokensPerInterval: 5,
-  interval: 'second',
-}
+Batch transaction and intent management utilities.
+[📖 CoW Shed Documentation](https://docs.cow.fi/cow-protocol/reference/sdks/protocol-components/sdk-cow-shed)
 
-const backOffOpts: BackoffOptions = {
-  numOfAttempts: 5,
-  maxDelay: Infinity,
-  jitter: 'none',
-}
+## ⚙️ **Adapter Support**
+
+The umbrella package works with all supported blockchain adapters:
+
+### **Ethers v6**
+
+```typescript
+import { EthersV6Adapter } from '@cowprotocol/sdk-ethers-v6-adapter'
+import { JsonRpcProvider, Wallet } from 'ethers'
 
-const orderBookApi = new OrderBookApi({ chainId: SupportedChainId.GNOSIS_CHAIN, limiterOpts, backOffOpts })
+const provider = new JsonRpcProvider('YOUR_RPC_URL')
+const wallet = new Wallet('YOUR_PRIVATE_KEY', provider)
+const adapter = new EthersV6Adapter({ provider, signer: wallet })
 ```
 
-### Querying the CoW Subgraph
+### **Ethers v5**
 
-The [Subgraph](https://github.com/cowprotocol/subgraph) is constantly indexing the protocol, making all the information more accessible. It provides information about trades, users, tokens and settlements. Additionally, it has some data aggregations which provides insights on the hourly/daily/totals USD volumes, trades, users, etc.
+```typescript
+import { EthersV5Adapter } from '@cowprotocol/sdk-ethers-v5-adapter'
+import { ethers } from 'ethers'
 
-The SDK provides an easy way to access all this information.
+const provider = new ethers.providers.JsonRpcProvider('YOUR_RPC_URL')
+const wallet = new ethers.Wallet('YOUR_PRIVATE_KEY', provider)
+const adapter = new EthersV5Adapter({ provider, signer: wallet })
+```
 
-You can query the CoW Subgraph either by running some common queries exposed by the `CowSubgraphApi` or by building your own:
+### **Viem**
 
 ```typescript
-import { SubgraphApi, SupportedChainId } from '@cowprotocol/cow-sdk'
-
-const cowSubgraphApi = new SubgraphApi({ chainId: SupportedChainId.MAINNET })
-
-// Get CoW Protocol totals
-const { tokens, orders, traders, settlements, volumeUsd, volumeEth, feesUsd, feesEth } =
-  await cowSubgraphApi.getTotals()
-console.log({ tokens, orders, traders, settlements, volumeUsd, volumeEth, feesUsd, feesEth })
-
-// Get last 24 hours volume in usd
-const { hourlyTotals } = await cowSubgraphApi.getLastHoursVolume(24)
-console.log(hourlyTotals)
-
-// Get last week volume in usd
-const { dailyTotals } = await cowSubgraphApi.getLastDaysVolume(7)
-console.log(dailyTotals)
-
-// Get the last 5 batches
-const query = `
-  query LastBatches($n: Int!) {
-    settlements(orderBy: firstTradeTimestamp, orderDirection: desc, first: $n) {
-      txHash
-      firstTradeTimestamp
-    }
-  }
-`
-const variables = { n: 5 }
-const response = await cowSubgraphApi.runQuery(query, variables)
-console.log(response)
+import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter'
+import { http, createWalletClient, privateKeyToAccount } from 'viem'
+import { sepolia } from 'viem/chains'
+
+const account = privateKeyToAccount('YOUR_PRIVATE_KEY' as `0x${string}`)
+const transport = http('YOUR_RPC_URL')
+const adapter = new ViemAdapter({ chain: sepolia, transport, account })
 ```
 
-## Architecture
+## 🌐 **Supported Networks**
 
-One way to make the most out of the SDK is to get familiar with its architecture.
+The SDK supports all CoW Protocol enabled networks:
 
-> See [SDK Architecture](https://github.com/cowprotocol/cow-sdk/blob/main/docs/architecture.md)
+- **Ethereum** (1) - `SupportedChainId.MAINNET`
+- **Gnosis Chain** (100) - `SupportedChainId.GNOSIS_CHAIN`
+- **Arbitrum One** (42161) - `SupportedChainId.ARBITRUM_ONE`
+- **Base** (8453) - `SupportedChainId.BASE`
+- **Polygon** (137) - `SupportedChainId.POLYGON`
+- **Avalanche** (43114) - `SupportedChainId.AVALANCHE`
+- **Sepolia** (11155111) - `SupportedChainId.SEPOLIA` (Testnet)
 
-## Development
+## 📝 **Quick Example: Complete Trading Flow**
 
-### Install Dependencies
+```typescript
+import { CowSdk, SupportedChainId, OrderKind, TradeParameters } from '@cowprotocol/cow-sdk'
+import { EthersV6Adapter } from '@cowprotocol/sdk-ethers-v6-adapter'
+import { JsonRpcProvider, Wallet } from 'ethers'
 
-```bash
-yarn
-```
+async function main() {
+  // Setup
+  const provider = new JsonRpcProvider('YOUR_RPC_URL')
+  const wallet = new Wallet('YOUR_PRIVATE_KEY', provider)
+  const adapter = new EthersV6Adapter({ provider, signer: wallet })
+
+  const sdk = new CowSdk({
+    chainId: SupportedChainId.SEPOLIA,
+    adapter,
+    tradingOptions: {
+      traderParams: { appCode: 'MY_APP' },
+    },
+  })
 
-### Build
+  // Define trade
+  const tradeParams: TradeParameters = {
+    kind: OrderKind.SELL,
+    sellToken: '0xfff9976782d46cc05630d1f6ebab18b2324d6b14', // WETH
+    sellTokenDecimals: 18,
+    buyToken: '0x0625afb445c3b6b7b929342a04a22599fd5dbb59', // GNO
+    buyTokenDecimals: 18,
+    amount: '100000000000000000', // 0.1 WETH
+  }
 
-```bash
-yarn build
+  // Execute trade
+  const orderId = await sdk.trading.postSwapOrder(tradeParams)
+  console.log('Order created:', orderId)
 
-# Build in watch mode
-yarn start
-```
+  // Monitor order
+  const order = await sdk.orderBook.getOrder(orderId)
+  console.log('Order status:', order.status)
 
-### Unit testing
+  // Get historical data
+  const stats = await sdk.subgraph?.getTotals()
+  console.log('Protocol stats:', stats)
+}
 
-```bash
-yarn test
+main().catch(console.error)
 ```
 
-### Code generation
+## 🔗 **Related Resources**
 
-Some parts of the SDK are automatically generated. This is the case for the Order Book API and the Subgraph API
+- **[CoW Protocol Documentation](https://docs.cow.fi/)**
+- **[API Reference](https://api.cow.fi/docs/)**
+- **[CoW Protocol Website](https://cow.fi/)**
+- **[Examples Repository](https://github.com/cowprotocol/cow-sdk/tree/main/examples)**
+- **Issues**: [GitHub Issues](https://github.com/cowprotocol/cow-sdk/issues)
+- **Discord**: [CoW Protocol Discord](https://discord.com/invite/cowprotocol)
+- **Documentation**: [docs.cow.fi](https://docs.cow.fi/)
 
-```bash
-# Re-create automatically generated code
-yarn codegen
-```
+---
+
+> **💡 Tip**: Start with the umbrella package and the unified `CowSdk` instance for the best developer experience. You can always optimize later by using individual modules if needed.

package/dist/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## [7.0.0-beta.0](https://github.com/cowprotocol/cow-sdk/compare/cow-sdk-v6.3.2...cow-sdk-v7.0.0-beta.0) (2025-08-28)
+
+
+### ✨ Features
+
+* allow changing backoff and limiter per request ([#208](https://github.com/cowprotocol/cow-sdk/issues/208)) ([ebea5ca](https://github.com/cowprotocol/cow-sdk/commit/ebea5ca0858aeb89ae3e5d5407c8903c3ca5178d))
+* **lib-agnostic:** add nodejs examples for every adapter ([#440](https://github.com/cowprotocol/cow-sdk/issues/440)) ([43972e6](https://github.com/cowprotocol/cow-sdk/commit/43972e68ff728a9a882bbdc667b2c0821b273449))
+* **sdk-agnostic-lib:** create cow trading package ([#368](https://github.com/cowprotocol/cow-sdk/issues/368)) ([0a4534a](https://github.com/cowprotocol/cow-sdk/commit/0a4534aababce4f5d8bab991cd6ae9f51842d719))
+* **sdk-agnostic-lib:** Create weiroll package ([#371](https://github.com/cowprotocol/cow-sdk/issues/371)) ([8f6a2e1](https://github.com/cowprotocol/cow-sdk/commit/8f6a2e16e5e7a43a5afc43cf5faab174be916b2e))
+* simplify OrderSigningUtils to use static methods only ([#417](https://github.com/cowprotocol/cow-sdk/issues/417)) ([899ca43](https://github.com/cowprotocol/cow-sdk/commit/899ca4325be831b6711468d1df3733d98fe913b0))
+
+
+### 🐛 Bug Fixes
+
+* add adapter param to BridgingSdk and update docs ([#450](https://github.com/cowprotocol/cow-sdk/issues/450)) ([667a36e](https://github.com/cowprotocol/cow-sdk/commit/667a36e4437309e1d292b8f9fd5e8f568922749f))
+* **sdk:** reduce sdks in umbrella ([#433](https://github.com/cowprotocol/cow-sdk/issues/433)) ([22b1cb6](https://github.com/cowprotocol/cow-sdk/commit/22b1cb6e572fcd3a7b3878d725113ac420f470e6))
+
+
+### 🔧 Miscellaneous
+
+* **docs:** apply PR suggestions and create subgraph README ([#406](https://github.com/cowprotocol/cow-sdk/issues/406)) ([d09a219](https://github.com/cowprotocol/cow-sdk/commit/d09a219c934289a30677be685915d57e9a4451be))
+* **sdk-agnostic-lib:** improve scripts and types ([#407](https://github.com/cowprotocol/cow-sdk/issues/407)) ([c4b5e08](https://github.com/cowprotocol/cow-sdk/commit/c4b5e086ce46086e9430d5f03ed330502349fbf3))