Private Trade Links
Summary
I’d like to propose a simple P2P trading primitive for CoW Protocol: Private Trade Links.
The idea is to make it easy for two parties who have already agreed on a trade to settle it on-chain without having to trust each other.
A user creates a trade by specifying:
-
what they are offering
-
what they want in return
-
the amount
-
an expiration time
-
optionally, the address that is allowed to accept the trade
They then receive a link which they can send to the other person.
The counterparty opens the link, reviews the terms and accepts the trade.
The two assets are then exchanged atomically and directly between the two parties.
There is no public order book, no price discovery and no solver competition.
The basic idea is:
We already agreed on the trade. CoW provides the trustless settlement.
The problem
There are plenty of situations where two people have already agreed on a trade.
For example:
“I’ll give you 100 USDC for 0.05 WBTC.”
At this point neither party needs price discovery. They don’t need an aggregator to find a better price and they don’t need their order to compete with other orders.
They simply need a safe way to exchange the assets.
Today, this usually means one of the following:
-
one party sends first and trusts the other
-
using an escrow
-
using a CEX or OTC desk
-
manually coordinating the transfers
It would be useful to have a simple primitive for:
“We already agreed on the terms. Now let’s exchange the assets atomically.”
How it works
A user creates a Private Trade:
CREATE PRIVATE TRADE
I OFFER
100 USDC
I WANT
0.05 WBTC
EXPIRES
24 hours
COUNTERPARTY
[ Optional address ]
[ CREATE TRADE ]
After creating the trade, they receive a link:
PRIVATE TRADE
100 USDC
⇅
0.05 WBTC
[ Copy trade link ]
They can send it to the person they negotiated the trade with.
The recipient opens the link:
PRIVATE TRADE
You receive:
100 USDC
You pay:
0.05 WBTC
Expires:
23h 41m
[ ACCEPT TRADE ]
After the counterparty accepts, the trade is settled directly between the two wallets.
P2P by design
This is an important part of the proposal.
Private Trades should not enter the normal CoW solver competition.
There is no auction for the order and no search for alternative execution.
The creator has already specified the exact terms of the trade.
For example:
Maker:
0xAAA
Taker:
0xBBB
Maker gives:
100 USDC
Taker gives:
0.05 WBTC
When 0xBBB accepts, the settlement should simply execute those terms:
0xAAA ── 100 USDC ──► 0xBBB
0xAAA ◄── 0.05 WBTC ── 0xBBB
The exchange should be atomic.
If the required conditions aren’t met, the trade doesn’t happen.
This is closer to a P2P atomic swap / OTC settlement primitive than to a private limit order.
Optional counterparty restriction
The creator can optionally specify the wallet that is allowed to accept the trade.
No restriction
100 USDC → 0.05 WBTC
Counterparty:
Anyone
Anyone who has the link can accept the trade.
This could be useful for sharing offers publicly or within a community.
Address-restricted
100 USDC → 0.05 WBTC
Counterparty:
0x1234...5678
Only that address can accept the trade.
The restriction should be enforced by the settlement layer rather than by the frontend.
This means the link can be forwarded without giving another wallet the ability to execute the trade.
The address lock is therefore completely optional.
Why the link?
I think the link is one of the more interesting parts of the UX.
The actual negotiation can happen anywhere:
-
Telegram
-
Discord
-
Farcaster
-
email
-
DAO forums
-
inside an application
-
in a game
Once the two parties agree, one person simply creates the trade and shares the link.
For example:
“We agreed on 100 USDC for 0.05 WBTC. Here’s the CoW trade link.”
The recipient doesn’t need to manually recreate the transaction or enter token addresses and amounts.
They just open the link, verify the terms and accept.
The link is essentially a portable representation of the agreed trade.
Beyond crypto OTC
This is where I think the idea gets more interesting.
The primitive doesn’t necessarily have to be exposed only through the CoW frontend.
If exposed through an SDK, Private Trades could become a generic P2P settlement component that other applications can build on top of.
For example, consider digital item marketplaces.
A marketplace for game items could use CoW’s settlement layer to handle the payment side of a trade between a buyer and seller.
Example: game item marketplace
Imagine a marketplace similar to CSFloat for Counter-Strike skins.
A seller has an item and agrees with a buyer on a price.
The application could create a Private Trade containing:
SELLER
0xAAA
BUYER
0xBBB
PAYMENT
100 USDC
ITEM
Skin / Item ID #12345
The marketplace could then present the buyer with a trade link or embed the trade directly into its UI.
The buyer accepts.
The settlement layer ensures that the agreed assets are exchanged atomically.
The same concept could potentially apply to:
-
game items
-
skins
-
collectibles
-
tickets
-
digital goods
-
NFT marketplaces
-
P2P marketplaces
-
OTC platforms
-
DAO applications
-
other applications where two users already agreed on a transaction
The important part is that the application doesn’t need to build its own escrow and settlement mechanism from scratch.
It could use the Private Trade primitive through an SDK.
Why an SDK matters
I think the long-term opportunity here is bigger than adding another page to the CoW frontend.
The frontend could be the first implementation, but the underlying functionality could be exposed as an SDK/API.
An application could essentially do something like:
createPrivateTrade({
offer: {
token: USDC,
amount: 100
},
request: {
token: WBTC,
amount: 0.05
},
taker: "0xBBB...", // optional
expiry: ...
})
and receive a trade identifier/link.
The application could then decide how it wants to present the trade:
Private Trade SDK
│
┌──────────────┼──────────────┐
│ │ │
CoW UI Game marketplace DAO app
│ │ │
▼ ▼ ▼
Trade link Embedded UI Custom UI
│ │ │
└──────────────┼──────────────┘
▼
P2P Settlement
This would make CoW less of a destination users have to visit and more of a settlement primitive that applications can integrate directly.
Atomic settlement
The main value of using CoW here is the settlement.
The two parties should not have to trust each other or use an intermediary.
Instead of:
Alice sends USDC
↓
Bob is supposed to send WBTC
↓
???
the desired flow is:
P2P TRADE
│
┌───────┴───────┐
│ │
Alice Bob
│ │
-100 USDC -0.05 WBTC
│ │
└───────┬───────┘
│
ATOMIC SETTLEMENT
│
┌───────┴───────┐
│ │
Alice Bob
+0.05 WBTC +100 USDC
Either the trade happens according to the agreed terms, or it doesn’t.
No trusted escrow should be required.
How this fits CoW
I see this as a different use of the CoW infrastructure rather than another type of CoW market order.
A normal CoW trade is about finding good execution.
A Private Trade is about settling a trade that has already been negotiated.
So there are two different flows:
NORMAL COW ORDER
User
↓
Intent
↓
Solver competition
↓
Best execution
↓
Settlement
versus:
PRIVATE TRADE
Party A + Party B
↓
Agreed terms
↓
P2P settlement
↓
Atomic exchange
The second flow doesn’t need an auction.
The value CoW provides here is the trustless settlement mechanism.
Potential use cases
Peer-to-peer OTC
Two people agree on a trade privately and use CoW only for settlement.
DAO / treasury deals
A DAO negotiates a bilateral transaction with a known counterparty.
Game item marketplaces
A marketplace can use the SDK to settle transactions between buyers and sellers.
This could be particularly useful for marketplaces where the application already handles the item ownership side and needs a reliable payment/settlement layer.
P2P digital goods
The same primitive could potentially be used for other digital assets and marketplaces where a buyer and seller already agreed on a transaction.
Community trading
Someone can create an offer and share the link in a Discord or Telegram community.
Address-restricted deals
A trade can be explicitly locked to one wallet when the parties have already agreed who the counterparty is.
Fees
A small fee could be charged on successful settlement.
For example:
Private Trade fee: 0.05% – 0.10%
The exact economics would obviously need to be discussed.
The important part is that this could potentially become another protocol primitive without requiring a separate OTC network.
For SDK integrations, applications could potentially also build their own business model around the primitive.
MVP
I’d keep the first version very small.
Required
-
ERC20 → ERC20
-
fixed input amount
-
fixed output amount
-
expiration
-
shareable trade link
-
atomic P2P settlement
-
cancellation
-
optional counterparty address restriction
-
no solver competition
Later
-
native ETH
-
NFTs
-
game assets
-
partial fills
-
multiple assets
-
QR codes
-
SDK
-
embedded trade widgets
-
DAO integrations
I wouldn’t start with all of these.
The basic ERC20-for-ERC20 flow should be enough to validate the concept and the UX.
Open questions
There are still some implementation details I’d like to get feedback on:
-
How much of the existing CoW settlement infrastructure can be reused for a direct P2P trade?
-
What is the cleanest way to guarantee atomicity between the two parties?
-
Should funds be locked when creating the trade, or can existing permit/approval mechanisms be used?
-
How should cancellation work?
-
Should the open version be first-come-first-served?
-
Should a Private Trade always be fully filled?
-
How should protocol fees be handled?
-
What would the right SDK interface look like?
-
Are there privacy or MEV considerations for this type of settlement?
-
How could this work for assets that aren’t ERC20s, such as NFTs or game items?
Why I think this is worth exploring
I don’t see this as trying to compete with CoW’s normal trading flow.
It’s for a different situation.
Sometimes the two parties have already done the hard part themselves:
They agreed on the trade.
What they need is a reliable way to settle it without trusting the other party.
The basic UX is:
Create → Share → Accept → Settle
No order book.
No solver competition.
No price discovery.
Just a bilateral trade between two parties with atomic settlement.
But the interesting part is that the same primitive could potentially be used outside of the CoW frontend.
If exposed through an SDK, it could become a general-purpose building block for P2P marketplaces and applications — from crypto OTC trades to DAO deals to game-item marketplaces.
In that sense, the opportunity isn’t necessarily to build another trading interface.
It is to make CoW a trustless P2P settlement layer that other applications can build on.
I’d be interested in hearing whether this fits within the current direction of CoW Protocol and what the simplest technically viable implementation would look like.