Crypto Basics

News

Governance

Guides

Product Info

George Hristov


The vast world of DeFi offers many kinds of tokens, with more being added every day. Decentralized aggregators like CoW Swap allow users to swap between practically any two ERC-20 tokens, but sometimes you need to manually add a custom token before you can trade it.

## Add Custom Tokens

In order to display user balances, CoW Swap queries the blockchain to see what tokens a wallet holds. To ensure a smooth user experience, this analysis is limited to tokens included on official token lists such as CoinGecko.

![1-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/1_add_custom_tokens_a00d95fa40.webp)

For this reason, your wallet may hold tokens that don’t show up in your balance on CoW Swap. This doesn’t mean you can’t trade them! The CoW Protocol network of  [solvers](https://docs.cow.fi/cow-protocol/concepts/introduction/solvers)  searches all available liquidity to bring you the best prices, even for tokens outside of the default lists.

To trade custom tokens, you simply need to add them to the UI. Here’s how:

## Step 1

Navigate to CoW Swap and click “Select a token.”

![2-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/2_add_custom_tokens_c80ddc6351.webp)

## Step 2

A token list will come up. Here you can either search the name of your token or enter the contract address in the search box.

![3-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/3_add_custom_tokens_f8dd21ae8e.webp)

## Step 3

For maximum security, you should always paste the official token contract address into the search box. This prevents any form of manipulation or phishing.

![4-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/4_add_custom_tokens_1ee5946e85.webp)

For ERC-20 tokens, the contract address starts with “0x” and is followed by 40 characters. You can usually find it by looking up the token you want to trade on reputable websites like  [CoinGecko](https://www.coingecko.com/).

_Note: While rare, it is possible for token lists to show the wrong contract address. Always check the official channels of the project you are trading for the most up-to-date information on token contract addresses._

## Step 4

Once you’ve found the token you’re looking for, click the “Import” button to add it to CoW Swap.

![5-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/5_add_custom_tokens_da75a6cce1.webp)

## Step 5

Ensure you’ve entered the correct token address and click “Import.”

![6-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/6_add_custom_tokens_160c90e632.webp)

## Step 6

Once imported, you will be able to trade the token on CoW Swap. Tokens only need to be imported once per browser.

![7-add-custom-tokens.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/7_add_custom_tokens_149eafcaa6.webp)

If you have any questions or need help importing tokens, feel free to reach out to us on  [Discord](https://discord.com/invite/cowprotocol)  or on  [X](https://twitter.com/CoWSwap). Happy swapping!

large_add-custom-tokens-cover-photo.webp

medium_add-custom-tokens-cover-photo.webp

small_add-custom-tokens-cover-photo.webp

thumbnail_add-custom-tokens-cover-photo.webp

add-custom-tokens-cover-photo.webp

How to Add Custom Tokens on CoW Swap

On CoW Protocol, rather than sending on-chain transactions with predefined swap instructions, users submit signed  [intent-to-trade messages](/learn/cow-protocol-glossary#:~:text=Intent%20to%20Trade). These messages contain some order details, like which assets to trade in which amounts, but leave other details to be optimized by  [solvers](https://docs.cow.fi/cow-protocol/tutorials/solvers).

One important parameter of these intents is min_out — the minimum amount of buy tokens a user is willing to receive for their sell tokens (or the buy amount, minus the maximum allowable slippage set by the user). Min_out works really well when a trade is intended for immediate or near-immediate execution, because it allows solvers to improve prices for users while protecting them from unfavorable price movements. However, when prices fluctuate a lot, min_out can be overly-restricting.

## **What is delayed execution trading?**

Simply put, delayed execution trades are trades intended to execute at some point far in the near future.

Many smart contract wallet users, such as DAOs, frequently need to create these types of orders. Take the following examples:

-   DAOs that need trades to execute after passing a governance process
-   Groups that need hours to collect signatures to execute trades from a multisig wallet
-   Applications that process automated swaps years in the future (e.g. for payroll or treasury management)

With extra time, prices can fluctuate wildly — and this creates a dilemma for traders:

If the buy token price falls and the min_out is too high, the order might not execute. But if the min_out is too low, the trader risks getting an unnecessarily poor execution price. (CoW Protocol solvers compete against each other to give users better prices, but placing such a high level of trust in solvers can be undesirable for very high-volume traders.)

![1-what-is-milkman.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/1_what_is_milkman_0518ebe1f4.webp)

If a user signs an intent to swap 1 ETH for a “min out” of 2000 USDC, there is no way for the trade to return any less than 2000 USDC

![2-what-is-milkman.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/2_what_is_milkman_08ab1cbaac.webp)

But setting a low “min out” risks leaving money on the table

## **What is Milkman?**

Milkman is a smart contract that solves the above dilemma for smart contract wallets.

It does this by allowing smart contracts to specify an on-chain data source (such as an oracle) to use as a reference for min_out — effectively turning min_out into a dynamic price backstop for their trade.

Let’s say you want to sell 1000 ETH for USDC, but you want to do it far in the future. To protect yourself from volatile price movements, you can supply Milkman to create the order based on with the Chainlink price feed for ETH/USDC, and Milkman at the time of order placement will dynamically adjust the minimum amount you’ll receive based on that price feed.

When the time comes to execute your trade, CoW Protocol will receive it with a min_out that accurately reflects prices at that point in time; and solvers will compete to improve the price on top of that, as they always do.

![3-what-is-milkman.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/3_what_is_milkman_7f4ab32979.webp)

## **Milkman for DAOs**

Milkman is particularly well-suited to many DAO-related use cases, because DAO governance processes often delay trades and because amounts traded by DAOs can be very large.

Several well-known DAOs, including  [Aave](/learn/aave-trade-breakdown)  and  [ENS](/learn/ens-trade-breakdown), have already used Milkman to trade over $20M worth of tokens. Beyond allowing these DAOs to count on reliable prices, Milkman lets them reduce their overall number of governance votes and gives them standard CoW Swap benefits like best price execution and  [best-in-class](https://eigenphi.substack.com/p/sandwich-mevs-impact-on-cow-swap)  MEV protection — critical for large trades.

Milkman is also natively integrated as a  [recipe on Tally](/learn/tally-recipe-for-cow-swaps), the widely-used DAO management platform — removing even more trading friction for DAOs.

## **Technical details**

Milkman follows a UniV2-style interface. To interact with Milkman, smart contracts need only to call the following function:

> _function requestSwapExactTokensForTokens(_
> 
> _uint256 amountIn,_
> 
> _IERC20 fromToken,_
> 
> _IERC20 toToken,_
> 
> _address to,_
> 
> _address priceChecker,_
> 
> _bytes calldata priceCheckerData_
> 
> _)_

The priceChecker is the data feed provider, and priceCheckerData is an array of arbitrary bytes that the function passes to the price checker (e.g. the desired slippage tolerance).

Price checkers have been deployed for Chainlink, Curve, SushiSwap, Uniswap V2, Uniswap V3, and combinations of these. The core Milkman code can be found  [here](https://github.com/cowdao-grants/milkman). Anyone can run a  Milkman bot, which simply functions as a hook that watches for new swap requests and surfaces them to CoW Protocol. Running a bot is fairly easy if you have a Kubernetes cluster; the instructions are in the repo.

Milkman was developed by  [Yearn Finance](https://yearn.fi/)  in partnership with CoW Protocol, through the  [CoW Grants Program](https://grants.cow.fi/).

Long live Milkman! And may you benefit from his commitment to bringing you favorable prices!

![4-what-is-milkman.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/4_what_is_milkman_185027226b.webp)


large_what-is-milkman-cover-photo.webp

medium_what-is-milkman-cover-photo.webp

small_what-is-milkman-cover-photo.webp

thumbnail_what-is-milkman-cover-photo.webp

what-is-milkman-cover-photo.webp

Milkman is a simple contract that lets DAOs and other smart contract wallet users set dynamic price backstops for orders that will execute in the future!


What is Milkman? CoW Swap’s Solution for Delayed Execution Trading

As a pioneer in the field of intents, CoW Swap has consistently brought faster, easier, and safer trading to DAOs and DeFi enthusiasts.

As DeFi grows and transactions become ever-more complex, the friction of having to sign and make orders manually becomes more pronounced. Traders looking to place recurring orders as a part of a complex trading strategy, DAO operators responsible for managing a treasury, and individuals tired of signing repetitive transactions could all benefit from a system that allows for automated order placement.

Today, CoW Protocol is proud to announce the release of two features that take the pain out of order placement and open up a wide range of possibilities for automation.

To start off, we’re introducing a new order primitive to the world of DeFi. We call it “Programmatic Orders”. Programmatic Orders are orders that create more orders. They require just one signature to create, then execute when on-chain conditions (prices, volumes, balances, times, etc.) are met. Programmatic Orders can execute indefinitely into the future, automating everything from complex trading strategies to advanced order types, portfolio management, DAO operations, and more.

Alongside Programmatic Orders, CoW Protocol is launching the Programmatic Order Framework. As the name implies, it’s a framework that allows for the easy creation of Programmatic Orders.

Below, we take a deeper look at Programmatic Orders, the Programmatic Order Framework, and the technical details necessary for implementation. We also call on the DeFi ecosystem to submit proposals for building applications on top of the Programmatic Order Framework through the  [CoW Grants Program](https://grants.cow.fi/).

## The current state of programmatic actions

The DeFi space currently supports very simple programmatic actions — for example, individual limit orders. Unfortunately, users have to trust a centralized operator to execute these actions correctly and fairly.

Despite the rise of autonomous agents in the wake of initiatives like ERC-1271, the vast majority of interactions are performed manually, which means there is a dependency on individuals, and a central point of failure.

Even when orders are executed properly, users still have to sign a transaction every time they want to place a new order. This may not be an issue for one-off transactions, but it starts to become a nuisance for frequent, recurring transactions.

The Programmatic Order Framework is built to address these problems.

## The Programmatic Order Framework: A decentralized solution for automated orders

At its core, the Programmatic Order Framework brings simplicity to order creation by automating the boilerplate code necessary for order placement. This allows DeFi users to programmatically create any set of orders and automatically approve them for execution with just a single signature.

Users can create advanced order types (such as Stop Loss and TWAP orders), automate DAO payrolls, and create or destroy multiple orders with just one on-chain transaction. Thanks to a “WatchTower” relayer, orders built with the Programmatic Order Framework execute automatically whenever certain on-chain conditions are met, eliminating the need for tedious and repetitive signatures for programmatic actions.

The framework is a plug-and-play system that takes in order logic and executes orders in perpetuity based on on-chain conditions. Creating orders only requires coding the order logic itself. The rest of the swap components like order creation, order validation, signature validation, API calls, order placement, and order settlement are provided by the framework itself.

![1-programmatic-order-framework.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/1_programmatic_order_framework_5ee644e722.webp)

The key unlock of the Programmatic Order Framework is the low cost of deploying, updating, and deleting orders in large quantities. Developers only need to write code specifying the particular type of order they’d like to execute and the framework takes care of everything else — storing the data, validating parameters, and placing orders.

The WatchTower relayer verifies that order conditions are met, validates the order signature, and places the order on behalf of the user’s smart contract. To make deploying Programmatic Orders easy, CoW Protocol runs a default WatchTower that users can route orders through. However, users can also run their own WatchTower instance for maximum privacy.

## The all-in-one order automation kit

With the Programmatic Order Framework, a single signature can create hundreds of Programmatic Orders. The WatchTower monitors on-chain order conditions continuously and places orders whenever these conditions are met.

For example, a DAO with a diverse treasury can set up conditional orders for each token within its treasury. Based on these conditions, the framework may initiate a swap to rotate into stables when the treasury value rises above a certain threshold, or it may initiate a payout for DAO contractors on a given day of the month.

As the treasury receives various tokens, the framework executes trades accordingly, making DAO financial operations simple and automatic.

## Benefits of the Programmatic Order Framework

The Programmatic Order Framework unlocks a world of convenience for individuals and on-chain organizations:

-   **Leverage on-chain conditions**: Build highly complex use-cases that rely on custom conditional order logic through the Programmatic Order Framework. Create orders that get picked up by the WatchTower on a certain date, once the balance of your contract or wallet is above a defined threshold, or based on other on-chain conditions
-   **Deploy orders en masse**: Create hundreds or even thousands of orders with a single on-chain transaction. Developers can also mass-update orders all at once with a single gas payment by simply updating the Merkle root with another transaction
-   **Execute many orders in parallel**: In a traditional smart contract wallet, orders execute sequentially. With the Programmatic Order Framework, the WatchTower monitors your orders and executes them as soon as the on-chain conditions are met, meaning you can execute many orders simultaneously

Most importantly, the framework is  **fully decentralized**, providing 100% trustless execution with no intermediate contracts or centralized parties.

## Examples & use-cases

With the Programmatic Order Framework, you can program a limitless number of use-cases:

-   **Special order types**: Gone are the days of centralized exchanges offering order types you can’t get in DeFi. Program intricate order types like stop-loss, good-after-time, and take-profit orders — plus many more. CoW Swap’s very own  [TWAP feature](https://blog.cow.fi/why-twap-25d9a0f690f4)  is built using the Programmatic Order Framework
-   **Automated DAO operations**: Blockchain-native organizations like DAOs process hundreds or even thousands of transactions every month. Thanks to the Programmatic Order Framework, your DAO can automate payroll, treasury diversification, fee collection, or any other type of repetitive transaction
-   **Portfolio rebalancing**: Set up order logic to programmatically rebalance assets based on a portfolio value. Automatically diversify based on market conditions or use custom logic to manage loan risk, farm yield, or hedge positions
-   **Private conditional orders**:  Thanks to the framework’s support for private WatchTower configurations, traders can place highly complex conditional orders while simultaneously keeping them private. Buy and sell tokens through a recurring strategy while keeping your parameters hidden
-   **Protocol integrations**: The Programmatic Order Framework isn’t  _just_  for Safe! DeFi protocols can leverage its power to assist with recurring protocol-level transactions like loan liquidations
-   **Easy transaction modules**: Program custom functionality into any order type. Companies can build DAO tooling with a fraction of the complexity. Focus on building adoption rather than fiddling with backend tech

With just a few lines of code, the Programmatic Order Framework brings convenience and predictability to all types of DeFi actions.

## What will you build, anon?

CoW Protocol is bringing Programmatic Orders to Ethereum through the Programmatic Order Framework. Create any order type you can imagine and deploy it instantly — all within the security of your own smart contract wallet.

The  [CoW Grants Program](https://grants.cow.fi/)  is also putting out a request for proposals relating to the Programmatic Order Framework. Have an idea for a solution built on top of the framework (especially one that includes a UI)? Submit a grant proposal!

The Programmatic Order Framework is now live. Read the documentation  [here](https://hackmd.io/pmZX_qT2Q1yw59KiiT6TPQ)  to get started.

Have questions? The CoW Protocol team is here to help: join us on  [Discord](https://discord.com/invite/cowprotocol)  or send us a  [Twitter DM](https://twitter.com/CoWSwap).

## About CoW DAO

CoW DAO is an open organization of developers, traders, market makers and many more community members aligned with its vision. CoW DAO is focused on fair and decentralized trading systems — in particular, building, maintaining and advancing the CoW Protocol. CoW Protocol technology powers a network of traders and solvers, enabling trustless and efficient peer-to-peer trading. Leveraging batch auctions as a key concept uniquely positions CoW Protocol as native trading infrastructure for discrete-time settlement layers like Ethereum and enables fair and accessible trading to its users.

🐦 [Twitter](https://twitter.com/CoWSwap)| 📒 [Documentation](https://docs.cow.fi/)| 💬  [Forum](https://forum.cow.fi/)  | 📊  [Analytics](https://dune.com/cowprotocol)  | 📸 [Snapshot](https://snapshot.org/#/cow.eth)

large_introducing-the-programmatic-order-framework-from-cow-protocol-cover-photo.webp

medium_introducing-the-programmatic-order-framework-from-cow-protocol-cover-photo.webp

small_introducing-the-programmatic-order-framework-from-cow-protocol-cover-photo.webp

thumbnail_introducing-the-programmatic-order-framework-from-cow-protocol-cover-photo.webp

introducing-the-programmatic-order-framework-from-cow-protocol-cover-photo.webp

Programmatic Orders enable a world of possibilities in DeFi; they’re now easier to create than ever thanks to CoW Protocol’s Programmatic Order Framework

Introducing the Programmatic Order Framework, from CoW Protocol

Don’t worry, trade happy! CoW Swap has been busy cooking up Conditional Orders, an architecture that allows developers (and their users) to create sophisticated orders of all kinds. At the core of this system is a flexible smart contract wallet that allows the protocol to implement its unique logic. What’s better than standing on the shoulders of giants in the ecosystem and within the Gnosis family  [Safe](https://safe.global/)?

Wait? Smart contract wallet?

That’s right: CoW Swap pioneered intents across the Ethereum space for EOAs (think MetaMask, Trezor, Trust Wallet, etc.), but what’s less well-known is that the protocol can actually work in a similar way for smart contracts by relying on a flexible intents system with the ERC-1271 integration. It sounds technical, but this standard is basically designed to allow smart contracts to “Sign” a message like any other EOAs. This is a familiar procedure for the seasoned CoWmunity, but Conditional Orders now allow anyone to define a set of conditions and have the smart contract wallet do the clicking for you.

Incubated through the  [CoW Grants Program](https://grants.cow.fi/), and supported by the Safe team throughout the testing/auditing process, the ExtensibleFallbackHandler is now live. Sounds complicated, we know! Put simply, this is a way to add extra powers to your Safe, while preserving the strong security guarantees that the Safe is well known for.

Upgrading your Safe’s fallback handler is a secure process, all you have to do is tick a box when placing an order, and your Safe upgrade will be batched with your order, making for a single-transaction order placement and upgrade. The contracts that implement this system have been audited both by an independent auditor, and an external auditor from Ackee Blockchain (You can read the final audit reports  [here](https://github.com/cowprotocol/composable-cow/tree/ab3addad9bc05acdbf5fb040eb5c336209b58e31/audits)).

The owl-eyed among you would be aware that smart contracts have always been able to use CoW Protocol, though this required both a transaction on chain to signal your intent, and that the orders be fixed (not conditional). Wave goodbye to these limitations!

With an ExtensibleFallbackHandler+ComposableCoW-enabled Safe you now benefit from all the CoW Swap features directly from your smart contract wallet: MEV protection, no failed swap transactions, at-execution path discovery, conditional orders, and batching if you need to do pesky things like approve or wrap ETH.

If you’re technically inclined, check out how you can  [start building with conditional orders using ComposableCoW](https://hackmd.io/@mfw78/HyuvoGt9h#), or drop into  [#tech-talk on our discord](https://discord.gg/cowprotocol)! While you’re busy reading up on how to write the latest and greatest conditional order, you could also be gradually buying up more of your favorite token using TWAP!

## What is a Safe fallback handler?

Long story short, Safe is designed to have strong security guarantees over basic operations (think executing transactions, spending your precious tokens, etc.), but there’s not enough time to program all functionality that a user may require. Therefore, the Safe can “forward” all function requests that it doesn’t recognize to another contract (the fallback handler).

**CRITICALLY**: Fallback handlers do  **NOT**  have the same authority as the Safe from which they were called. Due to the security architecture of Safe, it is not possible for the fallback handler to execute transactions on behalf of the Safe.

OK, the fallback handler can’t execute a transaction for you, so why should you care? Safe doesn’t by default (without a fallback handler) support ERC-1271 signatures. The standard deployment of a Safe deploys with CompatibilityFallbackHandler as the fallback handler, which has limited ERC-1271 support (meaning: it cannot read and thus, cannot be automated). CoW Swap intents super-charge this by allowing a Safe to also specify a smart contract that can sign messages for a particular application on its behalf.

This is where ComposableCoW takes over! 🐮🎶 You can think of ComposableCoW as an autonomous agent, signing orders that meet whatever conditions you have specified. After you create your first conditional order, the second transaction you see in the batch will enable ComposableCoW, which tells your Safe “I want ComposableCoW to be able to sign orders from CoW Protocol”. TWAP is just a conditional order type that works with ComposableCoW.

**CRITICALLY**: Due to the design of ERC-1271, all signature verification is  **read-only**  which means it is  **impossible**  for a ComposableCoW or any conditional order to directly access user funds (the movement of funds during a swap is initiated by the settlement contract  **ONLY**).

In summary, to make CoW Swap’s new TWAP order feature work:

-   Safe users need to upgrade their fallback handler(enables conditional signing)
-   Conditional orders are automatically placed in the CoW Protocol order book (now signed with the new handler)
-   Automated signing of orders means you may hear less of CoW’s trademark moo. Feel free to set  [this](https://github.com/cowprotocol/cowswap/blob/develop/apps/cowswap-frontend/public/audio/success.mp3)  as your phone’s notification tone if suffering withdrawal symptoms 🐄

CoW Swap takes security very seriously. The underlying Safe fallback handler code has been fully audited by both the Safe and CoW teams as well as by two independent external auditors, G0 and Ackee Blockchain. You can find all the audit final reports  [here](https://github.com/cowprotocol/composable-cow/tree/ab3addad9bc05acdbf5fb040eb5c336209b58e31/audits).

The solution presented follows Safe’s high security standards. What’s more, the fallback handler isn’t just about placing orders. It allows limitless and, as of yet, unknown functionality. Maybe you want to:

-   Define a custom method handler for any non-standard method (if you really want you can turn your Safe into an ERC-20 token)
-   Define a custom EIP-712 domain verifier, whereby a contract implementing ISafeSignatureVerifier can do your menial signing automatically (it is this interface that ComposableCoW implements to power the shiny new TWAP orders)
-   Define a set of methods (interfaceId) that your Safe supports, and report such using ERC-165

The architecture for the ExtensibleFallbackHandler can be viewed  [here](https://hackmd.io/@mfw78/HyuvoGt9h).

**NOTE**: Audits are not a guarantee that code is free from error. Use with caution.

We wish you much surplus and happy  [TWAP order trading](https://swap.cow.fi/swap?utm_source=medium&utm_campaign=fallback-handler)! Give  [TWAP orders a try](https://swap.cow.fi/swap?utm_source=medium&utm_campaign=fallback-handler)  today and let us know what you think by reaching out on  [Twitter](https://twitter.com/CoWSwap)  or  [Discord](https://discord.com/invite/cowprotocol)!

## About CoW DAO

CoW DAO is an open organization of developers, traders, market makers and many more community members aligned with its vision. CoW DAO is focused on fair and decentralized trading systems — in particular, building, maintaining and advancing the CoW Protocol. CoW Protocol technology powers a network of traders and solvers, enabling trustless and efficient peer-to-peer trading. Leveraging batch auctions as a key concept uniquely positions CoW Protocol as native trading infrastructure for discrete-time settlement layers like Ethereum and enables fair and accessible trading to its users.

🐦 [Twitter](https://twitter.com/CoWSwap)| 📒 [Documentation](https://docs.cow.fi/)| 💬  [Forum](https://forum.cow.fi/)  | 📊  [Analytics](https://dune.com/cowprotocol)  | 📸 [Snapshot](https://snapshot.org/#/cow.eth)

large_all-you-need-to-know-about-cow-swap-new-safe-fallback-handler-cover-photo.webp

medium_all-you-need-to-know-about-cow-swap-new-safe-fallback-handler-cover-photo.webp

small_all-you-need-to-know-about-cow-swap-new-safe-fallback-handler-cover-photo.webp

thumbnail_all-you-need-to-know-about-cow-swap-new-safe-fallback-handler-cover-photo.webp

all-you-need-to-know-about-cow-swap-new-safe-fallback-handler-cover-photo.webp

Don’t worry, trade happy! Upgrading your Safe fallback handler is a secure process. This Safe fallback handler extension has been developed by the CoW Swap team in collaboration with the Safe team, and has undergone a successful audit.

All you need to know about CoW Swap’s new Safe fallback handler

> _Note: TWAP orders are most useful for big trades! So, when trading on Mainnet, the minimum TWAP order size is $5k. This minimum ensures that your savings from reduced price impact are not lost on execution fees (AKA gas fees). If you want to trade smaller amounts, head over to Gnosis Chain, where the TWAP order minimum is only $5 (and the gas fees are much cheaper!)_

TWAP orders are now available in the  [CoW Swap order interface](https://swap.cow.fi/#/1/advanced)  under the “Advanced” tab.

**Have a Safe?**  Awesome! You can try out TWAP  [here](https://swap.cow.fi/#/swap?utm_source=medium&utm_campaign=TWAP-guide).

**Don’t have a Safe?**  Not a problem! Create one  [here](https://app.safe.global/share/safe-app?appUrl=https%3A%2F%2Fswap.cow.fi&chain=eth).

For the below guide, we already have a Safe created. To get started, navigate to  [CoW Swap](https://swap.cow.fi/#/swap?utm_source=medium&utm_campaign=TWAP-guide)  and connect your Safe wallet via Wallet Connect, or directly using the CoW Swap Safe native app.

Once your wallet is connected, there are two ways to access TWAP orders:

-   Next to “Limit” in the center module, there is a tab that says “Advanced Orders” → clicking this opens the TWAP orders interface
-   On the top-left corner of the page, next to the CoW Swap logo, it says “Trade” → clicking this opens a drop-down menu that lets you choose between “Swap,” “Limit orders,” and “Advanced orders”

Once you have selected the “Advanced” tab, you will see the following screen:
![1-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/1_twap_how_to_6290090db4.webp)

After you click “Unlock TWAP orders (BETA)”, you will be taken to the TWAP orders interface.


![2-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/2_twap_how_to_0171b4ab6d.webp)

On the left side of this screen, you can see the order box where you input your TWAP order parameters. On the right, there is a panel that shows your open orders and order history.

In order to place a TWAP trade, you need to input your tokens and amounts, indicate how many parts you would like to split your order into, and select the time duration of your order.


![3-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/3_twap_how_to_c1d0d380d2.webp)

To get started, select the tokens you would like to swap from the token list.


![4-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/4_twap_how_to_961f05a961.webp)

Once you’ve chosen your tokens, you need to select the numbers of parts your TWAP order will be split into, as well as the duration of the TWAP order as a whole.


![5-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/5_twap_how_to_577542d502.webp)

As an added bonus, trading via a smart contract wallet like Safe automatically bundles your approval transaction and your trade together to save you time and gas.


![6-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/6_twap_how_to_bcfd7564ec.webp)

Below the Safe bundling banner, you will see a yellow notice. This notice is not related to your TWAP order itself, but to your wallet. TWAP orders are based on the “Composable CoW” conditional order framework which uses Safe fallback handlers to enhance the functionality of your smart contract wallet.


![7-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/7_twap_how_to_5563d17bc7.webp)

In order to use TWAP orders, you will need to upgrade your Safe fallback handler. This is a secure process; the code was co-developed by CoW Swap and the Safe team and it has undergone two external audits (you can find the final results of the audits  [here](https://github.com/cowprotocol/composable-cow/tree/ab3addad9bc05acdbf5fb040eb5c336209b58e31/audits)).

_Note: if you are interested in learning more about the fallback handler upgrade process, please refer to this_ [_article_](https://blog.cow.fi/all-you-need-to-know-about-cow-swaps-new-safe-fallback-handler-8ef0439925d1)_. If the fallback handler is new to you, please refer to this Safe_ [_article_](https://help.safe.global/en/articles/40838-what-is-a-fallback-handler-and-how-does-it-relate-to-safe) _for a full introduction to the concept._

Once you understand how the fallback handler interacts with your Safe wallet, you can check the “Modify Safe’s fallback handler when placing order” box in order to upgrade your wallet. This upgrade will take place alongside your trade and bundle any token approvals as a single transaction.


![8-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/8_twap_how_to_6aab5754fc.webp)

After you click “Approve”, you will be prompted to review your order one last time. Review all of your order details including the price protection, limit price, the minimum tokens you’re set to receive, and all your TWAP properties and ensure everything looks good.


![9-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/9_twap_how_to_39ea16bee1.webp)

To actually place your TWAP order, click “Place TWAP order” and review & sign your transaction from your Safe interface.


![10-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/10_twap_how_to_6a196bdf6b.webp)



![11-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/11_twap_how_to_e39305a40f.webp)

After you sign your order, you will see an “Order submitted” pop-up and your order will appear in the order panel on the side.


![12-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/12_twap_how_to_71bea598ed.webp)

In the order panel, you will notice that the order status is not “open,” but rather indicates that your order is still in the “signing” stage. The wallet used in this example requires 2 out of 3 signers to execute a transaction. By creating the transaction, we have performed one of the signatures, and to reach the threshold we need one more signer. To sign, the second signer would need to connect to the Safe wallet and navigate to the “Transactions” queue.


![14-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/14_twap_how_to_a703daa281.webp)

In the queue, we can see our pending transaction and confirm it with the last signature required.


![15-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/15_twap_how_to_f995c65744.webp)



![16-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/16_twap_how_to_43c9f04edd.webp)



![17-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/17_twap_how_to_21dd244dc5.webp)

After the last confirmation for the order is done, the order is placed and it will appear in the “Your Orders” UI.

The interface includes several ways to view your orders. You can get a high-level overview at a glance, expand to see the different parts of your TWAP order (in this example the first part executed immediately, which is why only 3 parts are shown), or click into the order to view a full list of details.


![18-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/18_twap_how_to_58564c545d.webp)



![19-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/19_twap_how_to_c6eab87d53.webp)



![20-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/20_twap_how_to_41156cc84e.webp)

Now that your TWAP order is placed, you can sit back, relax, and watch it get filled with CoW Swap’s signature MEV protection and best prices.


![21-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/21_twap_how_to_935598c651.webp)

We wish you much surplus and happy  [TWAP order trading](https://swap.cow.fi/#/swap?utm_source=medium&utm_campaign=TWAP-guide)! Give  [TWAP orders a try](https://swap.cow.fi/#/swap?utm_source=medium&utm_campaign=TWAP-guide)  today and let us know what you think by reaching out on  [Twitter](https://twitter.com/CoWSwap)  or  [Discord](https://discord.com/invite/cowprotocol)!


![22-twap-how-to.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/22_twap_how_to_07e8708fcb.webp)

## About CoW DAO

CoW DAO is an open organization of developers, traders, market makers and many more community members aligned with its vision. CoW DAO is focused on fair and decentralized trading systems — in particular, building, maintaining and advancing the CoW Protocol. CoW Protocol technology powers a network of traders and solvers, enabling trustless and efficient peer-to-peer trading. Leveraging batch auctions as a key concept uniquely positions CoW Protocol as native trading infrastructure for discrete-time settlement layers like Ethereum and enables fair and accessible trading to its users.

🐦 [Twitter](https://twitter.com/CoWSwap)| 📒 [Documentation](https://docs.cow.fi/)| 💬  [Forum](https://forum.cow.fi/)  | 📊  [Analytics](https://dune.com/cowprotocol)  | 📸 [Snapshot](https://snapshot.org/#/cow.eth)


large_how-to-use-cow-swap-twap-orders-via-safe-wallet-cover-photo.webp

medium_how-to-use-cow-swap-twap-orders-via-safe-wallet-cover-photo.webp

small_how-to-use-cow-swap-twap-orders-via-safe-wallet-cover-photo.webp

thumbnail_how-to-use-cow-swap-twap-orders-via-safe-wallet-cover-photo.webp

how-to-use-cow-swap-twap-orders-via-safe-wallet-cover-photo.webp

How to use CoW Swap’s TWAP orders via Safe Wallet, step by step guide


How to use CoW Swap’s TWAP orders via Safe Wallet

CoW Protocol’s native order types are limited to  _partially-fillable limit buy_  and  _limit sell_  orders. While this expression language covers most retail use cases, it misses some more-powerful advanced order types such as:

-   Good after time orders
-   Stop loss orders
-   Automated rebalancing portfolio orders

… to just name a few.

Adding new native order types to CoW Protocol would involve changing and redeploying the smart contract logic of the core protocol, and is therefore something we want to avoid for the time being.

While the above-mentioned order semantics could be communicated to the protocol/solvers without a smart contract change (e.g. by using additional fields in the  **app_data**), they couldn’t be enforced by the settlement logic and would therefore be subject to “off-chain consensus” (misbehavior would result in slashing by the DAO). This limits the amount of value that can be exchanged using these order types and puts more risk and trust on the solvers.

Smart orders are a clever way of achieving the above-mentioned semantics in a completely trust-less way without requiring a protocol change. Smart orders are based on  [ERC1271](https://eips.ethereum.org/EIPS/eip-1271)’s contract signature scheme and allow smart contracts to decide  **at settlement time**  if an order that is placed in their name is satisfying their trade preference or not.

While regular orders are signed by their owner ahead of time and statically verified using  [**ecrecover**](https://soliditydeveloper.com/ecrecover), smart contract orders implement interactive signature verification by asking the author at settlement time if they are okay with the proposed trade. This verification allows the author to decide just-in-time if they are happy with the proposed trade, so that their approval can be conditioned on any on-chain information (e.g. block time, oracle prices, current balance, etc.).

**In essence, this allows developers to create smart autonomous agents that trade according to predefined rules and strategies, entirely on-chain.**

For example, an automated rebalancing portfolio order (a smart contract that aims to have equal $ value of all its tokens) could perform the following check:

    def checkSignature(order): 
	    buyBalanceAfterTrade = order.buyToken.balanceOf(self) + order.buyAmount
	    sellBalanceAfterTrade = order.sellToken.balanceOf(self) + order.sellAmount
		
		buyBalanceValue = oracle.value(order.buyToken, buyBalanceAfterTrade)
		sellBalanceValue = self.oracle.value(order.sellToken, sellBalanceAfterTrade)

		# Check we only trade portfolio tokens
		assert(order.sellToken in portfolio and order.buyToken in portfolio)
		# Check we don't over-balance
		assert(sellBalanceValue >= buyBalanceValue)
		return  True

Note that the concrete CoW Protocol order that is verified by the smart order contract conforms to the native CoW Protocol order type (i.e. it is a partially-fillable limit order).

However, by incorporating additional information into the interactive verification step (e.g. check the oracle price and only accept if ETH trades below X), the smart order can add additional conditions to the trade.

In fact, the “tricky” part is finding the correct native CoW Protocol order parameter for which the smart contract’s signature verification passes. For this, order placement can happen either:

-   By solvers that are aware of smart orders in the form of just-in-time liquidity (orders that are not part of the official auction set and therefore don’t contribute to the object value)
-   Permissionlessly via the public CoW Protocol API (since ERC1271 doesn’t require a private key signature, anyone can place orders on behalf of a smart contract)

The former option is better suited for very complex order types where the correct order parameters may depend on the outcome of the optimization problem itself. Solvers are incentivised to include these orders since they might allow them to generate more surplus for public user orders.

However, aside from reaching out to solvers directly, there isn’t a great way to inform solvers about this type of custom liquidity today. Therefore, for the purpose of this tutorial, we will focus on the simpler type of order placement: smart orders that are included via CoW Protocol’s public API and available to all solvers by default.

## How do you build a smart order?

We developed an experimental framework for creating smart orders, which proposes a standard interface for conditional smart orders. Orders that implement this interface can be automatically picked up by our supporting infrastructure to place orders without the need for individual operational maintenance:  [https://github.com/cowprotocol/conditional-smart-orders](https://github.com/cowprotocol/conditional-smart-orders)

The core idea is that the smart order contract not only verifies if it is happy to trade a given order. It also proposes (via a separate view method) a concrete CoW Protocol order that it would be willing to accept.

Upon instantiation, the smart order triggers an event. This event is indexed and adds this contract to a registry that an external  _watchtower_  is constantly monitoring by querying the implemented view method. Upon seeing an order candidate, the  _watchtower_  places this order into the CoW Protocol API.

From a developer perspective, all you need to do is implement a single method (**getTradableOrder**), which provides logic for what order parameters your contract would accept given the current state of the chain. The default implementation of the signature verification logic would be as simple as checking that the given order is indeed the one returned by  **getTradableOrder**  (less strict checks are of course also possible in case it’s hard to reliably reproduce the exact order params in between calls).

As soon as  **getTradableOrder**  returns an order, our  _watchtower_  will forward it to the CoW Protocol API, a solver will pick it up and, via the settlement logic, ask your contract to verify it as part of the settlement transaction.

We implemented the registry indexing and  _watchtower_  logic using two [Tenderly Web3 Actions](https://docs.tenderly.co/web3-actions/intro-to-web3-actions):

1.  One to index order creation events and add contracts to the watch registry
2.  Another one to periodically check contracts in the registry if they are willing to trade at the current block

There are other ways to run this off-chain infrastructure, but we found Tenderly’s framework the most convenient without the need for our own cloud setup.

The repository also comes with a few suggested order types (use at your own risk). We would highly appreciate contributions to this repository (you can also apply for  [Grants](https://grants.cow.fi/)  for specific order types).

## How do you deploy a smart order with your Safe?

While the conditional-order framework makes it quite easy to implement custom verification logic, there is usually some amount of custody overhead logic involved that needs to be implemented in such a contract (e.g. how do I get my funds back when I want to exit the strategy). This logic can be complex, expensive to audit and prone to errors. Thankfully, there is a proven smart account abstraction standard out there ([Safe](https://safe.global/)) that allows for a very flexible custody solution and that is already securing many billions of dollars in funds.

In this tutorial we will therefore use a Safe as our main “smart agent” contract and delegate to the conditional smart order logic only for signature verification.

Safe supports ERC1271 signatures out of the box, but also allows the owner to set a custom ERC1271 implementation (e.g. the one your smart order implements). Safes implement ERC1271 via a so-called “fallback handler”, a component that is called whenever the Safe is invoked on a method it doesn’t implement directly (e.g.  **isValidSignature**). Therefore, by setting our smart order implementation as the Safe’s custom fallback handler we replace the default ERC1271 implementation with our own and make our agent trade according to our custom rules. Note that a Safe with such a fallback handler will only be able to ERC1271 sign off on CoW Protocol orders (no other 3rd party dApp related signatures will be valid). Normal Safe transactions with owner signatures will continue to work as usual.

So let’s get started! Most smart orders in our conditional smart order framework come with a  [factory](https://soliditydeveloper.com/clonefactory)  that allows instantiating new instances directly from the Safe UI. The plan of attack is therefore to:

1.  Create a new Safe
2.  Approve the tokens in the CoW Swap app
3.  Create a new smart order instance (targeted at this Safe specifically)
4.  Set the smart order’s address from the previous step as the Safe’s fallback handler
5.  Fund it with the token(s) to be traded. Wait and see the Safe trade automatically

## Step-by-step guide

### 1. Create a new Safe

Head over to [https://app.safe.global/welcome](https://app.safe.global/welcome)  and follow the prompts for “Create new Safe”. Feel free to leave the owner structure simple, e.g. 1/1 signer.

![1-create-new-safe.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/1_create_new_safe_11947cfc37.webp)

### 2. Approve the tokens in the CoW Swap App

Inside your Safe, head over to Apps →  [CoW Swap](https://swap.cow.fi/#/1/swap/WETH?utm_source=docs.cow.fi&utm_medium=web&utm_content=header-nav-link). At the top-left of the app, click on Account → Tokens and select the token that needs to be enabled.  [Swap](https://swap.cow.fi/#/1/swap/WETH?utm_source=docs.cow.fi&utm_medium=web&utm_content=header-nav-link)  for any other token and approve the token(s) you intend to trade with this contract.

In this example we are going to trade Wrapped XDAI:

![2-approve-tokens-in-cow-swap-app.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/2_approve_tokens_in_cow_swap_app_5364f18433.webp)

### 3. Create a new smart order instance

For this example we will deploy a TradeAboveThreshold order, which will automatically sell whenever the holds more than X of some token.

The factory for this contract on Gnosis Chain is located at [0xd20a99e3c6c103108d74e241908e00ef4db447fb](https://gnosisscan.io/address/0xd20a99e3c6c103108d74e241908e00ef4db447fb)  (if you can’t find the factory, you can deploy a new factory using foundry). To create a new instance, head to your Safe and create a  _New Transaction_  →  _Contract Interaction_  and load the contract ABI from the factory address.

We want to call create. Fill out the required parameters (with the target being your current Safe). In this example we are selling wxDAI for USDC whenever the contract holds $1 or more:

![3-create-a-new-smart-order-instance.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/3_create_a_new_smart_order_instance_a65941db91.webp)

Add transaction, create batch, and execute. After the transaction has been executed, open the transaction hash in a block explorer to find the address of the smart order instance that the factory has created (e.g. from looking at the internal txs).

![3-1-create-a-new-smart-order-instance.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/3_1_create_a_new_smart_order_instance_214ed8ac83.webp)

Here we created [https://gnosisscan.io/address/0xdf724fdbaef2419f1af895f494bd8969ec433d01](https://gnosisscan.io/address/0xdf724fdbaef2419f1af895f494bd8969ec433d01).

### 4. Set Custom Fallback handler

Head back to the Safe to create a  _New Transaction_  →  _Contract Interaction_, this time on the Safe itself (enter the address of the Safe).

When prompted choose  _Use Implementation ABI_.

![4-set-custom-fallback-handler.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/4_set_custom_fallback_handler_ae00dddb6b.webp)

The contract method selector we want to invoke is setFallbackHandler and the address should be the contract that has been created in the previous step:

![4-1-set-custom-fallback-handler.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/4_1_set_custom_fallback_handler_12a2a422f0.webp)

After adding and executing this transaction, you will have set the smart order as your Safe’s ERC1271 implementation.

### 5. Fund the Safe

Now, when the Safe receives 1 wxDAI, it should automatically place an order to sell it for USDC. Let’s try:

![5-fund-the-safe.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/5_fund_the_safe_998c182c18.webp)

Shortly after the transfer is mined, if we check [https://explorer.cow.fi/](https://explorer.cow.fi/)  for our Safe address, we should see a pending order trying to sell the wxDAI for USDC

![5-1-fund-the-safe.webp](https://celebrated-gift-f83e5c9419.media.strapiapp.com/5_1_fund_the_safe_141edf754d.webp)

And, after a short amount of time the order should be filled.

You can repeat this process as often as you want by just sending some more funds to this Safe. In order to withdraw the proceeds you can use the standard Safe functionality.

## Conclusion

In this tutorial we described and hinted at the power that smart orders can have in the context of smart contracts becoming autonomous trading agents, talked about how a simple “conditional order” type can be created with a few lines of solidity and walked through a step-by-step example of how we can deploy a smart order using Safe as a custody solution.

We hope this article inspired you to try out smart orders, or even build your own on top of CoW Protocol. Please get in touch with suggestions and ideas. We are looking forward to seeing what type of orders can be built with this paradigm.

Give  [ERC1271 orders a try](https://swap.cow.fi/#/1/swap/WETH?utm_source=docs.cow.fi&utm_medium=web&utm_content=header-nav-link)  today and let us know what you think by reaching out on  [Twitter](https://twitter.com/CoWSwap)  or  [Discord](https://discord.com/invite/cowprotocol)!

## About CoW DAO

CoW DAO is an open organization of developers, traders, market makers and many more community members aligned with its vision. CoW DAO is focused on fair and decentralized trading systems — in particular, building, maintaining and advancing the CoW Protocol. CoW Protocol technology powers a network of traders and solvers, enabling trustless and efficient peer-to-peer trading. Leveraging batch auctions as a key concept uniquely positions CoW Protocol as native trading infrastructure for discrete-time settlement layers like Ethereum and enables fair and accessible trading to its users.

🐦  [Twitter](https://twitter.com/CoWSwap)| 📒  [Documentation](https://docs.cow.fi/)| 💬  [Forum](https://forum.cow.fi/)  | 📊  [Analytics](https://dune.com/cowprotocol)  | 📸  [Snapshot](https://snapshot.org/#/cow.eth)

large_smart-order-tutorial-cover.webp

medium_smart-order-tutorial-cover.webp

small_smart-order-tutorial-cover.webp

thumbnail_smart-order-tutorial-cover.webp

smart-order-tutorial-cover.webp

This tutorial provides an introduction and a step-by-step description of how to create “smart orders” on CoW Protocol. The order that we create will facilitate custom trading logic and use Safe (formerly known as Gnosis Safe) as a backbone.