Overview

This paper introduces a novel token issuance mechanism. Variable Rate GDAs (VRGDAs), designed for Art Gobblers and used in 0xMonaco, let you sell tokens close to a custom schedule over time by raising prices when sales are ahead of schedule and lowering prices when sales are behind schedule — a generalization of the GDA mechanism.

We provide both an overview of the mechanism and a highly optimized, production-ready Solidity implementation of the core mechanism and several example schedules.

Motivation

Art Gobblers is a digital art experiment by Justin Roiland and Paradigm. An important objective of the project was to create a self-sustaining ecosystem that could thrive on its own without human intervention for years to come.

There are two core NFTs in this system, and we wanted anyone to be able to purchase either at any time.

We wanted to issue both relatively quickly at first. Over time, one tops out at a fixed supply, whereas the other is issued at a slow constant rate forever.

We sought to achieve these goals while maintaining a seamless user experience that would allow users to buy NFTs at any time, without having to, for example, wait for a scheduled auction.

Our solution was VRGDAs, a generalization of GDAs that allows for arbitrary scheduling of NFT issuance, as opposed to the uniform linear scheduling of standard GDAs.

Mechanism

Building Intuition

Imagine a simple schedule where we want to sell 10 NFTs per day. We set a starting price of 1 token for the first NFT.

Suppose it is currently day 5, so we should have sold 50 NFTs. However, demand has been high, and we have sold 70. We weren’t supposed to sell 70 NFTs until day 7, so we are two days ahead of schedule.

As a result, we want to charge a higher price going forward. We use an exponential curve to determine how much higher. This can vary based on parameters, but in this case, let’s say we use

2^\text{days ahead of schedule}

, so that we increase our price by a factor

2^2=4

, so since our initial price was 1 token, the new price will be 4 tokens, making it harder to buy more NFTs.

Ten days later, on day 15, we should have sold 150 NFTs, but users have only bought 120, the amount they should have bought by day 12, meaning we are three days behind schedule. We adjust the price to , making it easier for users to buy more NFTs.

Ten days later, on day 15, we should have sold 150 NFTs, but users have only bought 120, the amount they should have bought by day 12, meaning we are three days behind schedule. We adjust the price to

2^{-3}=0.125

, making it easier for users to buy more NFTs.

Construction

Parameters

p_0

- The price an NFT would sell for if sold perfectly on pace (the target price).

$k$
- The percentage an NFT’s price decreases in a unit of time with no purchases.

f(t)

- The issuance schedule: maps t to the number of NFTs to aim to sell by that time.

Objective

We want to issue NFTs on a particular schedule. The mechanism we will use to do this is to raise prices if NFTs are sold ahead of schedule and lower them if they are sold behind schedule. If sales are perfectly on schedule, the price to buy the next one will remain the same.

Definitions

Let’s say we want to sell NFTs at a schedule described by

f(t)

, which maps a point in time to the cumulative number of NFTs we want to have sold by that time. For example, if we want to sell one NFT every two days, we’d define

f(t)

like so:

f(t) = \frac{t}{2}

Let’s also say we want to sell our NFTs using a separate Dutch Auction per NFT. If we set each NFT’s starting price at 1, and let this price decay by a rate of per unit of time with no sales, its price if purchased at time

t

will be:

(1-k)^t

To give ourselves the flexibility we need to achieve our objective, we can shift the starting point of the auction in time by some

s_n

, which we will derive below, so that the price at time

t

is:

(1-k)^{t-s_n}

If we want our target price to be different than 1, we can multiply by a constant

p_0

. We call this adjusted price

\texttt{vrgda}_n(t)

:

\texttt{vrgda}_n(t) = p_0(1-k)^{t-s_n}

Determining
$s_n$

According to our issuance schedule

f

, we want to sell the

n

th NFT at time

t_n

. We can define

t_n

by inverting

f

to get a mapping from

n

to the time it should be sold:

t_n = f^{-1}(n)

A consequence of the VRGDA objective is that if the

n

th NFT is purchased exactly at the target time according to its issuance schedule, its price will be

p_0

. Expressed formally, this means that if we are selling at exactly the target rate, then at time

t_n

, the

n

th NFT will be priced such that:

p_0(1-k)^{t_n-s_n}=p_0

Simplifying by dividing out

p_0

, we know that the following should always hold true:

(1-k)^{t_n-s_n}=1

Which implies

t_n-s_n=0

or

s_n=t_n

. Using our definition of

t_n

from above, we know

s_n = f^{-1}(n)

.

Final Formula

By substituting this definition of

s_n

into

\texttt{vrgda}_n(t)

, we end up with the final formula:

\texttt{vrgda}_n(t) = p_0(1-k)^{t-f^{-1}(n)}

Simple Issuance Schedules

Below we demonstrate deriving some simple issuance schedules to use with the VRGDA formula.

Linear

Let’s say we want to sell

r

NFTs per day. Then

f(t) = rt

, so

f^{-1}(t) = \frac{t}{r}

After plugging this

f^{-1}(t)

into the VRGDA pricing formula, we end up with the following:

\texttt{linear\_vrgda}_n(t) = p_0(1-k)^{t-\frac{n}{r}}

Note this is isomorphic to a GDA, which is why we call VRGDA a generalization of GDA.

Square Root

Let’s say that we want to issue NFTs at a rate proportional to the square root of time — for example, to issue NFTs more quickly at first, and then more slowly over time, but without ever stopping.

We can then set

f(t) = \sqrt{t}

, so that on day 1 we have sold 1 NFT, on day 4 we have sold 2, on day 9 we have sold 3, and so on.

In this case,

f^{-1}(n) = n^2

. Now we simply plug into the VRGDA pricing formula to get:

\texttt{sqrt\_vrgda}_n(t) = p_0(1-k)^{t-n^2}

Logistic Issuance Schedule

The logistic issuance schedule is somewhat complex compared to the examples above. However, we have chosen to cover it in detail nonetheless as it provides a way to bootstrap initial growth without enforcing an infinite inflation regime.

Motivation

Let’s say we want to issue NFTs quickly at first, but then slow down until eventually some maximum number have been issued, as is the case in Art Gobblers.

One clean way to model this is using the logistic function with positive domain.

Deriving
$f$

The logistic function is an S-shaped curve. We’ll simplify it slightly and define it as:

l(t) =\frac{1}{1 + e^{-t}}

This curve approaches 0 as

t

approaches negative infinity, and 1 as

t

approaches infinity.

For our particular application, we don’t want to use the full S curve (although it’s also possible to have a full logistic VRGDA that would start slow, speed up, and then slow down again). Instead, we want to use only the part of the curve where

t

is positive.

Because

l(0)=0.5

, but we want our schedule to indicate selling 0 NFTs at time 0, we need to shift this function down by subtracting 0.5. This new curve will go from 0 to 0.5:

h(t)=\frac{1}{1 + e^{-t}}-0.5

We want to issue

L-1

NFTs (we choose this for notational convenience since the function will asymptote out before it hits

L

), so we will need to scale this function by a factor of

2L

.

We can also introduce a time-scaling parameter

s

to adjust the speed at which to issue the NFTs:

f(t)=\frac{2L}{1 + e^{-st}}-L

To pick

s

, observe that:

\frac{f(t)}{L}=\frac{2}{1 + e^{-st}}-1

Furthermore:

\frac{f(\frac{1}{s})}{L}=\frac{2}{1 + e^{-1}}-1\approx0.46

This means we can pick

s

by picking the time by which we want about 46% of the NFTs to be issued. For example, if we want 46% of the NFTs to be issued after 100 time units, that means

\frac{1}{s}=100

, so that

s=\frac{1}{100}

.

Formula

Taking the inverse of

f(t)

from above yields:

f^{-1}(n) = - \frac{\text{ln}\left(\frac{2L}{L+ n} - 1\right)}{s}

Putting this all together, we end up with the following formula:

\texttt{logistic\_vrgda}_n(t) = p_0(1-k)^{t+ \frac{\text{ln}\left(\frac{2L}{L+ n} - 1\right)}{s}}

Implementation

A highly optimized, production ready, and permissively licensed (MIT) implementation of VRGDAs and an assortment of issuance schedules can be found at transmission11/VRGDAs. Pull requests with improvements are welcome.

Conclusion

VRGDAs provide a way to issue NFTs using nearly any schedule you would like while still allowing users to seamlessly buy them at any time.

In the case of Art Gobblers, they allowed us to customize our community growth and UGC dynamics. In the case of 0xMonaco, it created a challenging and highly competitive game loop.

We believe there many other potential applications across NFTs, on-chain gaming, DeFi, and beyond. If you’d like to explore them, we’d love to hear from you. You can reach us on Twitter at @transmissions11, @FrankieIsLost and @_Dave__White_.

We can’t wait to see what you build.

Acknowledgments: Dan Robinson, samczsun, Riley Holterhus, NN Blossoms, dcfpascal, kootsZhin, Grug, Ben Leimberger, Kiran Cherukuri, Aaru, eva

Graphics By: Achal Srinivasan

Variable Rate GDAs

Overview

Motivation

Mechanism

Building Intuition