04.04.2022|FrankieDan RobinsonDave WhiteAndy8052

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*,

$p_n(t)$

, where $n$

is index of the auction, and $t$

is the time since its start.Various price functions can be used with GDAs. One particular well-behaved formulation is given by:

$p_n(t) = k \cdot \alpha^ne^{- \lambda t}$

Here, the price for every auction decays exponentially according to some *decay constant *

$\alpha$

$k$

.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

$q$

of tokens. To do this, he would purchase the $q$

cheapest auctions. If $T$

seconds have passed since the auctions began, and $m$

total NFTs have been sold so far, the total price $P$

of purchasing $q$

tokens is given by:$P(q) = \sum_{n=m}^{m + q - 1} p_n(T)$

For the case of the above price function,

$P(q)$

can be computed efficiently. As shown in the appendix, the formula for $P(q)$

is:$P(q) = \frac{k \alpha^m(\alpha^{q} - 1)}{e^{\lambda T}(\alpha -1)}$

We can plot the quantity of tokens being purchased in a single order against their cumulative price to obtain the following figure:

Having sold her NFTs, Alice now might want to sell some fungible tokens. One option would be for her to use the discrete GDA mechanism described above, to sell her tokens in fixed-sized lots.

However, Alice might not want to make all her tokens available for sale immediately, as is the case with discrete GDAs. For example, she might be running a protocol that sells emissions at some constant rate, say, 360 tokens per day.

Instead of using a discrete GDA, she could instead choose to sell her tokens in a series of standard dutch auctions. She could run one 360-token auction per day, one 15-token auctions per hour, or one 0.25-token auctions per minute. Again, there is a trade-off between price impact and gas efficiency, based on the number of auctions she holds.

Continuous GDAs work by taking this process to the limit, where the time interval between auctions approaches 0. This means that sales are split into an infinite sequence of auctions, each selling an infinitesimal amount of the token.

As it turns out, we can still compute the purchase price for any quantity of tokens in a gas-efficient manner.

Continuous GDAs work by incrementally making more of an asset available for sale, at a constant *emission rate, *

Emissions are broken up over an infinite series of *virtual* auctions. These auctions are started at an even rate over time, with each auction begining at the same price.

The price of each auction is given by some *price function*,

$p(t)$

, where $t$

is the time since its start. Just like in discrete GDAs, many different price functions can work. One such function is:$p(t) = k \cdot e^{- \lambda t}$

Like the previous example, price decays exponentially according to some *decay constant *

$k$

Say that Bob wanted to purchase some quantity

$q$

of the token being sold by Alice. In order to buy that many tokens, he needs to purchase every auction started over a period of $\frac{q}{r}$

seconds. Since prices decrease over time, he bids on the oldest available auctions.If the oldest available auction is

$T$

seconds old, the total price $P$

of purchasing $q$

tokens is given by:$P(q) = \int^{T}_{T-\frac{q}{r}} p(t)dt$

This means that we can compute the total purchase price in a gas-efficient manner as long as computing the integral of the *price function* is cheap.

The total price of purchasing

$q$

tokens using the above price function can be calculated efficiently on chain. As shown in the appendix, this price is given by:$P(q) =\frac{k}{\lambda} \cdot \frac{e^{\frac{\lambda q}{r}}-1}{e^{\lambda T}}$

From which we obtain the following price curve:

We’ve included a Python notebook modeling GDAs and a reference Solidity implementation.

GDAs are a useful mechanism for selling both fungible and non-fungible tokens that do not have liquid markets. While this paper derives a few useful price functions, we believe many more could be used in different contexts. We hope GDA will be useful in a variety of applications beyond those described in this paper.

If you’re a builder interested in implementing some of these concepts, please reach out to us at @FrankieIsLost, @danrobinson, @_Dave__White_ @andy8052 on Twitter. We’d be thrilled to hear from you.

$P(q) = \sum_{n=m}^{m + q -1} p_n(T)$

$P(q) \sum_{n=m}^{m + q -1} k \cdot \alpha^ne^{- \lambda t}$

$P(q) ke^{-\lambda T}\sum_{n=m}^{m + q -1} \alpha^n$

$P(q) \frac{k \alpha^m(\alpha^{q} - 1)}{e^{\lambda T}(\alpha -1)}$

$P(q) \int^{T}_{T-\frac{q}{r}} p(t)dt$

$P(q) \int^{T}_{T-\frac{q}{r}} k \cdot e^{-\lambda t}dt$

$P(q) \frac{k}{\lambda}\cdot \left( e^{-\lambda(T - \frac{q}{r})} - e^{-\lambda T} \right)$

$P(q) \frac{k}{\lambda} \cdot \frac{e^{\frac{\lambda q}{r}}-1}{e^{\lambda T}}$

- Also known as Australian Auctions. ↩

Copyright © 2024 Paradigm Operations LP All rights reserved. “Paradigm” is a trademark, and the triangular mobius symbol is a registered trademark of Paradigm Operations LP