08.24.2022|transmissions11FrankieDave White

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.

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

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.**Parameters**

$p_0$

- The price an NFT would sell for if sold perfectly on pace (the $k$

- $f(t)$

- The issuance schedule: maps 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}$

$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)$

.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)}$

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

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.

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}$

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.

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.

$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}$

.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}}$

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.

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*

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