CoW Protocol Intent-Based Trading Integration

Integration with CoW Protocol (intent-based trading)

CoW Protocol (Coincidence of Wants) solves one specific problem: MEV attacks on DEX traders. On classic Uniswap, your swap is visible in the mempool — sandwich bots insert their transactions before and after yours, extracting profit from your slippage. CoW Protocol hides transactions from the public mempool until execution.

Mechanics: a user signs an "intent" — I want to sell X tokens of A, receive at least Y tokens of B, without specifying a specific path. A solver network takes the pool of intents, looks for matches (coincidences of wants) or the best route through DEX, executes the batch on-chain. The user doesn't interact with the pool directly.

How intent-based architecture works

Order structure

An intent in CoW Protocol is an EIP-712 signed structure:

interface Order {
  sellToken: Address;
  buyToken: Address;
  receiver: Address;
  sellAmount: bigint;
  buyAmount: bigint;        // minimum willing to accept
  validTo: number;          // unix timestamp expiration
  appData: Hex;             // arbitrary metadata (IPFS hash)
  feeAmount: bigint;        // fee for solver (usually 0 for off-chain orders)
  kind: "sell" | "buy";
  partiallyFillable: boolean;
  sellTokenBalance: "erc20" | "external" | "internal";
  buyTokenBalance: "erc20" | "internal";
}

The order is signed with the user's private key (EIP-712 signTypedData). No on-chain gas at the moment of signing.

Solver competition

Multiple solver nodes compete for the right to execute a batch of orders. The solver offering the best outcome for users (higher buyAmount or lower sellAmount) wins. This creates competition in favor of the trader, not against them.

CoW swap is not just MEV protection. If a solver finds a coincidence of wants (user A wants to sell ETH for USDC, user B wants to sell USDC for ETH) — both get execution without an on-chain swap at all. Zero slippage, zero AMM fees. Only settlement gas.

Integration via CoW SDK

Installation and setup

npm install @cowprotocol/cow-sdk viem

import { OrderBookApi, OrderSigningUtils, SupportedChainId } from "@cowprotocol/cow-sdk";
import { createWalletClient, http } from "viem";
import { mainnet } from "viem/chains";

const orderBookApi = new OrderBookApi({ chainId: SupportedChainId.MAINNET });

CoW Protocol works on Ethereum mainnet, Gnosis Chain, Arbitrum One, and Sepolia testnet.

Creating and sending an order

// 1. Get fee quote
const quoteRequest = {
  sellToken: WETH_ADDRESS,
  buyToken: USDC_ADDRESS,
  from: walletAddress,
  receiver: walletAddress,
  sellAmountBeforeFee: parseEther("1").toString(),
  kind: OrderKind.SELL
};

const { quote } = await orderBookApi.getQuote(quoteRequest);

// 2. Sign the order
const orderToSign = {
  ...quote,
  receiver: walletAddress,
};

const signedOrder = await OrderSigningUtils.signOrder(
  orderToSign,
  SupportedChainId.MAINNET,
  walletClient
);

// 3. Send to orderbook
const orderId = await orderBookApi.sendOrder({
  ...orderToSign,
  ...signedOrder,
  from: walletAddress
});

Monitoring execution

After sending, an order is in one of the states: open, filled, cancelled, expired. Polling via getOrder(orderId) or WebSocket via orderBookApi.subscribe().

// Polling until execution or expiration
const pollOrder = async (orderId: string) => {
  const order = await orderBookApi.getOrder(orderId);
  if (order.status === "fulfilled") {
    console.log(`Executed at: ${order.executedSellAmount} → ${order.executedBuyAmount}`);
  }
  return order.status;
};

Important: the validTo timestamp is the order expiration. After it, the order is automatically marked expired. Set a reasonable time (20-60 minutes for normal orders, a few minutes for urgent ones).

Pre-sign orders (for contracts)

Smart contracts cannot sign EIP-712 messages. For on-chain integration, we use the pre-sign mechanism: the contract calls setPreSignature(orderId, true) on GPv2Settlement — this allows the solver to include this order in settlement.

interface IGPv2Settlement {
    function setPreSignature(bytes calldata orderUid, bool signed) external;
}

// In your contract:
function createOrder(bytes calldata orderUid) external {
    settlement.setPreSignature(orderUid, true);
}

When to use CoW Protocol

Suitable for:

• Large swaps where MEV protection is critical ($10K+)
• Protocols executing swaps on behalf of users (yield aggregators, rebalancers)
• Situations where coincidence of wants is likely (stablecoin-to-stablecoin trading)
• Gnosis Safe integrations (CoW is well integrated with Safe)

Not suitable for:

• High-frequency trading (latency incompatible)
• Tokens with low liquidity (solver may not find a path)
• When guaranteed immediate execution is needed

Common integration mistakes

Wrong appData: appData should be a keccak256 hash of a JSON document with metadata. If you pass an arbitrary hash without a real document — the order may be rejected by some solvers.

fee amount: for off-chain orders, feeAmount is usually taken from the quote. Don't set it to 0 manually — this can lead to order rejection.

Allowance: before creating an order, the user must grant allowance to CoW vault relayer (0xC92E8bdf79f0507f65a392b0ab4667716BFE0110 on mainnet), not to the settlement contract itself.

Timeline estimates

Simple integration (signing and sending orders via SDK in frontend) — 1-2 days. On-chain contract with pre-sign integration (e.g., vault that automatically creates CoW orders) — 3-5 days. Full protocol with monitoring, retry logic and fallback to Uniswap when solver unavailable — 1 week. Cost is calculated after clarifying the architecture.