This paper introduces the Gradual Dutch Auction, 1 or GDA, a mechanism that enables efficient sales of assets that do not have liquid markets.
GDAs solve a similar problem to TWAMM, but do not rely on the existence of liquidity providers willing to make markets on pairs of assets.
GDAs work by breaking up a sale into a sequence of Dutch auctions—a type of auction that start with a high asking price that is gradually lowered until a buyer makes a bid. GDAs allow you to purchase multiple of these auctions at once in a gas-efficient manner.
We provide an outline for both discrete GDAs, which are useful for selling NFTs, and continuous GDAs, which are useful for selling fungible tokens. We also include a Python notebook modeling the mechanism’s behavior, as well as a reference Solidity implementation.
Imagine Alice would like to sell a collection of 10,000 NFTs. She is unsure what a fair price for her art pieces would be, so she does not want to sell them at a fixed price.
Instead, she might choose to sell them all in a single Dutch auction—starting with a high asking price, and gradually lowering it until all the NFTs are sold. However, such an auction can be suboptimal: there may not be enough interest from buyers to purchase all pieces at the same time.
Instead, Alice could auction off one NFT at a time. For example, she might start a new Dutch auction every minute for a new piece in her collection. This will give the market more time to find a fair price for her art.
Discrete GDAs are an extension of this idea, but support gas-efficient bulk purchases of multiple sub-auctions thanks to their mathematical properties.
Discrete GDAs are suitable for selling NFTs, because these have to be sold in integer quantities. They work by holding a virtual Dutch auction for each token being sold. These behave just like regular dutch auctions, with the ability for batches of auctions to be cleared efficiently.
In a discrete GDA, every auction starts at the same time, with each successive auction having a higher starting price. The price of each auction is given by some price function, , where is index of the auction, and is the time since its start.
Various price functions can be used with GDAs. One particular well-behaved formulation is given by:
Here, the price for every auction decays exponentially according to some decay constant . The starting price of each auction increases by some fixed scale factor . And the starting price of the first auction is given by some initial price .
Given the above price function, we can efficiently compute the cost of purchasing a batch of auctions.
Imagine that Bob wanted to purchase some quantity of tokens. To do this, he would purchase the cheapest auctions. If seconds have passed since the auctions began, and total NFTs have been sold so far, the total price of purchasing tokens is given by:
For the case of the above price function, can be computed efficiently. As shown in the appendix, the formula for is: