Dynamically priced JAMKB via decaying deposits
by Jonas Gehrlein (@jonas) and Kremena Valkanova (@kremena)
Disclaimer: This is posted as a contribution to community discussion. It is a proposal only: nothing here is a commitment, no token is being offered or sold, and any decision to implement rests solely with DOT DAO. The design is exploratory and likely to change.
Abstract
This is a proposal for how $JAMKB, a token mapping at a fixed rate to state-footprint usage on Polkadot JAM, could be priced, distributed, and reclaimed over time, following its initial issuance on Polkadot Asset Hub.
It builds directly on Gavin’s recent note on the case for a dedicated state-footprint resource-access token. That note argues why JAM needs a specialized, inelastic-supply token distinct from DOT, and concludes that price-finding and rental arrangements should live above the base-layer protocol (JAM) rather than inside it. It deliberately stops short of specifying those mechanisms. This proposal takes up that open question.
We also address how the $JAMKB that the DOT DAO retains can drive value back to $DOT, treating it as an additional revenue source for Polkadot. A separate question, which we leave open for community discourse, is how much of the initially minted supply should eventually pass into private ownership; that portion falls outside this mechanism (and potentially under a different one), which governs only the retained, DAO-controlled supply.
Interestingly, we initially devised this mechanism to replace Polkadot’s state storage system, then realized it solves the problem above just as elegantly.
Motivation
Gavin’s note makes a strong case for representing JAM’s coherent state footprint with a fixed-supply, single-purpose resource-access token called JAMKB at a 1:1 mapping to bytes, initially held entirely by the DOT DAO. The fixed supply gives the protocol a clean soundness guarantee: footprint can never exceed what validators can hold in RAM, because the tokens needed to occupy it simply do not exist beyond genesis.
What the note leaves open is the economics on top of the token: how a service acquires JAMKB from the DAO, at what price, how that price should behave as state fills, what keeps no-longer-useful state from sitting idle indefinitely, and how a full system frees space when it must. The note gestures at distribution — for example, drip-feeding tokens into an on-chain exchange — but does not specify a pricing or carrying-cost mechanism. This proposal is an attempt to fill exactly that gap.
A key principle underlies the whole design. JAMKB is not a cryptocurrency; it is an access right to a finite, real resource, footprint that every validator must hold in RAM. This inverts the usual token-economic logic. In an ordinary token economy, supply that is lost or locked away is, if anything, a benefit to remaining holders, since their share of a fixed pie grows. Here the opposite is true: every unit of JAMKB that drifts out of productive use is footprint capacity sitting idle, deadweight that no one can build on and the protocol gains nothing from. What keeps this from happening for JAMKB subject to our pricing mechanism is that every bonded unit retains a permanent link back to the protocol: it can always eventually be reclaimed and re-allocated to a service that will actually use it. No unit is ever permanently stranded.
Three requirements shape the design:
- The price of acquiring footprint should reflect scarcity. Cheap and near-frictionless when state is abundant; rising, and rising faster, as capacity tightens.
- Holding footprint should carry an ongoing cost, not a one-time one. Otherwise a holder who no longer needs their state has no reason to release it, and the soundness cap is reached by accumulation of dead weight rather than live use.
- Footprint should not become a speculative asset. A fixed-supply right that users hold and trade can be hoarded or cornered: bought cheap when state is abundant, withdrawn from genuine users, and sold into scarcity. Access to footprint should track use, not the expectation of resale.
The mechanism below — dynamically priced JAMKB via decaying deposits and scarcity-triggered reclaim — is our attempt to meet all three while leaving Gavin’s fixed-supply soundness guarantee fully intact.
Overview
We add three components on top of the fixed-supply JAMKB token:
- A posted acquisition price that responds both to how full state is and to how fast it is filling.
- A decaying carrying cost on held footprint, applied continuously and computationally cheaply, that returns value to the DAO rather than destroying any tokens.
- A scarcity-triggered reclaim that frees space when the system approaches saturation.
One structural choice underpins all three. For carrying cost and reclaim to be enforceable in an ownerless system, occupying state must bond JAMKB to the slot under protocol-controlled terms, rather than merely checking that the holder happens to hold enough in a free balance. Thus, JAMKB is essentially a footprint right: exactly one is bonded per KB and is held by the protocol on the user’s behalf and it returns to the DAO in full on release. What the user actually pays is a separate deposit, in some other unit, and it is this deposit that decays as a carrying cost and is partially refundable.
The pricing and decay mechanism below is described in abstract price units. The settlement asset (dotUSD or DOT) and how it ties value back to DOT are addressed at the end.
Pricing
Let occupancy be ut = Ut / C, where Ut is occupied footprint and C is the soundness-capped maximum. The posted price to acquire one unit of footprint at time t is a product of two factors:
P
t = F(gt) · P(ut + Δu)
where P(·) is a structural curve responding to the level of occupancy and F(gt) responds to the flow — how fast occupancy is changing. The level factor is evaluated at ut + Δu, the occupancy the allocation results in, where ut is current occupancy and Δu the size of the allocation being priced. Both factors are needed because occupancy alone is a lagging indicator: if state is filling rapidly the system is heading toward scarcity well before ut reflects it, and the posted price should react sooner.
Structural curve P(ut)
The level-based factor is a static convex curve in occupancy:
P(u) = P
min / (1 − u)k
with Pmin the floor price at zero occupancy and k controlling how steeply the price rises as capacity tightens. For example, with k = 3, P(0.5) = 8 Pmin, P(0.8) = 125 Pmin, P(0.9) = 1000 Pmin — making the price cheap across most of the occupancy range and escalating sharply only when footprint is genuinely scarce.
Flow factor F(gt)
The flow-based factor is a stateless function of current flow conditions:
F(g
t) = min( exp(β · gt), Fmax )
The signal gt is a smoothed measure of recent net allocation activity, normalised by remaining headroom:
g
t = α · [ ΔUt / (C − Ut) ] + (1 − α) · gt−1 − δ
where ΔUt is allocations minus releases over a short window. The headroom normalisation gives gt a direct reading: at a sustained rate, gt ≈ 1/N means remaining capacity will be consumed in N periods. The EMA, parameterised via a half-life of a few days, smooths noise so the price tracks sustained trends rather than single-block bursts. When gt > 0 the flow factor amplifies the structural price; when gt < 0 (sustained net releases) it dips below 1, easing prices during slack. In prolonged periods with no allocations, suggesting that storage is overpriced relative to current demand, a small downward drift δ gradually reduces the price (similarly to a Dutch auction) until demand returns. The cap Fmax prevents the exponential from exploding during anomalous periods, above which the structural curve carries the escalation.
These magnitudes are illustrative. Realistic values of gt depend on usage patterns, so the calibration is a default for governance and simulation to refine, not a claimed optimum.
On choosing a price curve rather than an auction
An auction is a natural alternative for the acquisition price, as coretime shows. For footprint, the clean design would be to discretize time into epochs and auction available footprint at each epoch boundary, while retaining the decaying deposit as the carrying cost and aligning unbonding to the epoch. The periodic structure provides the defined bidder set and clearing event that a continuous allocation process otherwise lacks.
An auction’s information-revealing benefit, though, is most pronounced under sustained excess demand. Absent that competition an auction simply clears at its pre-set reserve price, effectively replicating a pricing curve, but with added periodicity and friction. Besides being much simpler to operate, a curve prices both abundant and scarce conditions continuously, rising automatically as utilization increases. Builders making multi-year infrastructure commitments benefit from a smooth, predictable cost path rather than periodically resetting clearing prices. For these reasons, we use a pricing curve throughout. The only plausible exception is genuinely contested reclaimed slots during periods of scarcity, where an auction-like mechanism may be appropriate (see reclaim stage).
Carrying cost via decaying deposits
Recall that decay acts on the deposit — the asset the user pays at allocation — and never on the bonded JAMKB, which stays fixed at one per KB throughout and returns to the DAO in full on release. Everything in this section concerns the deposit.
Holding footprint should cost something continuously. Rather than collecting a recurring fee — which would require per-account billing and balance monitoring — we let the recoverable portion of the escrowed deposit decay over time, at a rate that shares its shape with the posted price:
c(u
t, gt) = (cmin / Pmin) · Pt = cmin · (1 − ut)−k · min( exp(β gt), Fmax )
Here cmin sets the decay rate at zero occupancy and zero flow. Reusing the same (ut, gt) response for decay as for pricing is deliberate: the cost of acquiring new footprint and the cost of continuing to hold existing footprint express the same scarcity signal, one as an entry price and one as a continuous carrying cost. Any asymmetry would create strategic incentives — softer decay lets holders sit on stale state while the price moves without them; harsher decay pushes holders out faster than the price warrants. Governance may optionally decouple the two, giving decay its own gentler exponent and flow gain for a flatter carrying-cost profile, at the cost of reintroducing that asymmetry.
A global decay accumulator
The recoverable balance depends on the integral of a time-varying rate over the whole holding period. Storing per-deposit history, or touching every bond each block, would be infeasible at the scale of millions of allocations. Instead the protocol maintains one global running sum:
A(t) = A(t−1) + c(u
t, gt)
incremented once per block in constant time regardless of how many bonds exist, since c(ut, gt) depends only on current network conditions and is identical for every bond at a given block. Each bond stores just two values — its original bonded quantity and the accumulator value at creation. Accumulated decay for any bond is then A(t) − A(t0), reconstructed on access with no per-item updates. The recoverable fraction is
R(t) = D
0 · ( 0.1 + 0.9 · exp( −(A(t) − A(t0)) ) )
which is monotonically decreasing, can never exceed the original bonded amount (so the protocol never owes more than it holds and never mints), and asymptotes to a structural 10% floor.
Reclaim under supply shortage
Decay applies continuous pressure, but as the system approaches saturation, decay alone may not free space fast enough. At that point the protocol activates reclaim. Critically, reclaim is automatic and rule-bound: it triggers when occupancy crosses governance-defined thresholds, and it never involves a discretionary judgment about whose state is worth keeping.
Reclaim activates gradually. At a first, high occupancy threshold only the most-decayed bonds become eligible; at progressively higher thresholds the eligibility bar relaxes so more bonds come into scope. Bonds are prioritised by accumulated decay A(t) − A(t0): a larger value means the bond has been held longer and more cheaply relative to current conditions, and has the weakest residual claim.
When a bond becomes reclaim-eligible the protocol emits an on-chain event and opens a grace period whose length shortens as occupancy rises. During the grace period the holder may restore the slot by topping up to the current posted price Pt. Ownership is never lost during this window and restoration is a top-up, not a repurchase. If the holder does not restore, they receive their current decayed balance, the bond’s JAMKB returns to the DAO, the slot is freed and re-allocated at the posted price like any other. When multiple parties would pay Pt for the same freed slot, a community could alternatively allocate reclaimed slots through a one-shot sealed bid instead of first-come allocation.
Value capture for Polkadot
The price and deposit for JAMKB allocated by the Polkadot protocol should be denominated either in DOT or (if available at the time) in dotUSD (working term for any DOT-backed stablecoin). Either way, a user only ever pays a deposit and is refunded in that asset and never holds JAMKB itself; the protocol bonds it on their behalf. JAMKB therefore remains a footprint right rather than a tradable asset, which also significantly improves the UX of interacting with the system. Further, it reduces the speculative aspect and makes sure the footprint pricing is not biased by speculation. The value capture for Polkadot comes from the portion of each deposit that decays away: this is protocol revenue, which the DOT DAO can route into activities that increase protocol value, such as buybacks, treasury accumulation, and other activities.
Conclusion & future direction
This proposal offers a dynamic pricing mechanism that uses decaying deposits to price the portion of JAMKB that remains under the control of the DOT DAO and thereby can be used to capture value for Polkadot. Our goal at this stage is to gauge community sentiment on the approach. If it is generally well received, further steps could include simulating the mechanism across a range of parameters and demand schedules, to better understand how such a system would behave under different regimes.