The Void: A Time-Weighted Survival Protocol for ETH-Denominated Yield and Stochastic Redistribution

1. Scope and Design Objective

THE VOID is an ETH-denominated vault protocol in which random epochs remove addresses rather than assets. ETH enters the vault, the vault internalises yield-bearing collateral, and the withdrawal boundary recycles fees into a buyback loop, a staking loop, an afterlife loop, and a treasury loop. The system is therefore neither a pure staking vault nor a pure lottery. It is a redistribution engine coupled to a productive collateral base.

The central design move is to separate hazard from capital weighting. Selection probability is address-based and tier-weighted. Share ownership, yield accrual, and redistribution uplift are capital-based. A player can therefore enlarge the size of the position at risk without creating an extra lottery ticket, because top-ups mint more shares to the same address instead of adding a new address to the tier arrays. This is not a side effect. It is the mechanism.

In scientific terms, THE VOID can be read as an applied experiment in endogenous redistribution under bounded stochastic hazard. It asks whether a productive collateral base and a shrinking claimant set can coexist in a stable regime without requiring perpetual external token inflation as the primary source of user return. The protocol therefore occupies an unusual position in the design space between yield vaults, elimination games, and reflexive token sinks.

2. State Model and Economic Mechanics

Let A_t denote the vault's internal asset balance at time t, measured in yield-token units, and let S_t denote total vVOID share supply. The implied asset claim per share is:

A depositor who holds s_i shares therefore controls an internal asset claim of a_i = s_i * q_t. External ETH value is obtained through the configured IYieldToken implementation, which exposes getETHValue() and getYieldTokenValue().

Risk enters through six tiers. If tier k contains n_k addresses and carries weight w_k, then the probability that the next epoch selects tier k is:

Selection within a chosen tier is uniform over addresses, not over balances. For an address i inside tier k:

Equation (3) makes the main game-theoretic point explicit: position size changes loss severity if selected, but it does not change the selection probability of the address itself. A Tier 1 address has ten times the per-epoch hazard of a Tier 6 address when all else is equal, because 60 / 6 = 10.

2.1 Experimental thesis

The protocol is built around a falsifiable economic thesis. New entrants should bear high hazard and high exit friction. Long-lived participants should gradually migrate toward lower hazard and lower exit cost. Survivors should inherit a growing claim on the collateral base as the claimant set contracts. Consumed participants should not disappear from the economy entirely; instead, they should transition into a second-order fee-claim class through the Soul NFT and consumed pool.

This implies a dual decomposition of expected outcome. A participant faces a hazard-weighted full-loss term because address selection burns the entire position if chosen, but simultaneously benefits from a survivor-weighted redistribution term when some other address is chosen. The protocol is therefore not reducible to a simple lottery with a house edge. It is a state-dependent stochastic game in which tenure, batch size, claimant count, and fee throughput jointly shape the return surface.

2.2 Deposit, shares, and age

Users enter only through depositETH(). The vault snapshots pre-deposit state, forwards ETH into the configured yield-token adapter, computes shares from the pre-deposit asset and share balances, then mints vVOID. Standard ERC-4626 asset entry functions are deliberately disabled so users never interact with the internal yield token directly.

A new address starts in Tier 1. A top-up does not reset the address age and does not create another selection ticket. The original depositTimestamp is preserved. During the genesis window, deposits are timestamped at genesisPeriodEnd so the first cohort begins on a common clock.

This share-issuance path matters analytically. Because the share quantity is computed against the pre-deposit state, the incoming deposit does not participate in its own pricing base. The contract therefore avoids self-referential dilution at the point of entry and keeps the share-mint equation aligned with the intended balance-sheet interpretation of q_t.

2.3 Manual tier ascent and hazard reduction

The vault stores both a deposit timestamp and an on-chain tier index. Time alone only creates eligibility for a better tier. The player must call upgradeTier() to move the address into the safer array. This is operationally important because VoidConsumer samples the stored tier arrays, not a virtual time-derived tier.

Withdrawal fees behave differently from consumption hazard. requestWithdrawETH() computes the fee from elapsed time since depositTimestamp, so an address that forgets to call upgradeTier() still benefits from time-decayed exit fees, but does not benefit from lower on-chain hazard until the upgrade transaction is sent.

This dual-state representation is intentional. It separates chronological age from operational state. Chronological age is continuous and monotone. On-chain tier membership is discrete and explicit. As a consequence, the protocol preserves a measurable gap between eligibility and realised migration, which is useful both analytically and behaviorally because it reveals whether participants actively manage their hazard or passively leave it unchanged.

2.4 Epoch triggering and randomness

Epoch cadence is governed by VoidConsumer. The contract holds a descending list of player-count thresholds, a hibernation threshold, a last-epoch timestamp, and a pending-randomness flag. An epoch can trigger only when the vault is past genesis, at least two active players remain, the hibernation threshold is cleared, the current duration bucket has elapsed, and no prior VRF request is outstanding.

Anyone may call triggerConsumption(), and the contract also implements Chainlink Automation's check/perform interface. The actual victim is chosen only inside the VRF callback. Tier selection uses the VRF word directly modulo total weight. Intra-tier address selection derives a second random value by hashing the VRF word with a fixed label. This reduces unwanted coupling between tier selection and within-tier index selection.

The resulting stochastic process is neither memoryless nor fully deterministic. It is state dependent. Player count changes the epoch interval. Tier migration changes the weight vector. Full withdrawals and consumptions change both the numerator and denominator of the selection kernel. The hibernation threshold imposes a lower bound beneath which the elimination process pauses, preventing pathological behavior in degenerate low-population states.

2.5 Consumption, redistribution, and afterlife rights

Once an address is selected, the consumer calls VoidVault.consumePlayer(player, epoch). The vault snapshots the player's share balance and implied asset value before any burn. It then burns all shares, removes the address from the tier arrays, clears all player state, and emits PlayerConsumed. The consumed address is converted from survivor to soul.

Let gamma denote the configured fraction of the consumed asset value routed out of the vault into the consumed pool. The post-consumption share price is:

More generally, if address j is consumed and address i survives, the survivor's post-event asset claim becomes:

The current launch target is gamma = 0, meaning consumed principal remains entirely in the vault and survivor uplift is purely internal redistribution. The consumed player instead receives a newly minted vSOUL token and future access to the fee stream handled by VoidConsumedPool. Already-accrued VOID emissions are preserved across consumption because the vault checkpoints rewards before burning shares.

Equation (5) shows why the mechanism is experimentally interesting. Uplift is generated by denominator contraction even in the absence of any new external capital. When gamma = 0, the entire consumed position remains on the balance sheet while the corresponding share claim is deleted. When gamma > 0, uplift remains positive but is partially offset by the principal diverted toward the afterlife pool. The parameter therefore regulates the balance between survivor convexity and afterlife funding.

2.6 Full exit and fee routing

Exits are full only. There is no partial withdrawal path in the vault contract. requestWithdrawETH() burns the player's entire share balance, removes the address from the game state, computes a fee fraction from elapsed age, and creates an async withdrawal request against the yield-token adapter. Later, once the adapter marks the request as ready, the user finalises through claimWithdrawETH().

The final ETH payout is split into player proceeds and fee proceeds using the realised settlement amount, not a fixed ETH constant:

Fee ETH is then credited to four destinations through a pull-based escrow: buyback, staking, consumed pool, and treasury. The vault does not push arbitrary calls into those recipients during fee accounting; it records pending balances and each recipient claims separately.

The exit path is asynchronous by design. This architecture prevents the vault from entangling its accounting logic with a specific execution venue or immediate on-chain liquidity assumption. From a systems perspective, the withdrawal path is decomposed into request, settlement, and claim stages, allowing the protocol to maintain a stable internal accounting model even when the external ETH recovery path is delayed or venue-specific.

2.7 Soul afterlife economy

The Soul NFT is both memorial and accounting key. VoidSoulNFT stores the epoch number, timestamp, vault TVL snapshot, shares lost, and original player address. VoidConsumedPool then tracks a cumulative ETH amount per registered NFT using accETHPerNFT. The first soul has a special advantage: if fees arrived before any soul existed, they are held and assigned to that first NFT when it is registered.

At launch, the afterlife stream is therefore fee-based rather than principal-based. Souls earn because withdrawals continue to happen in the living vault, not because a portion of every future death is siphoned away from survivors.

This turns the consumed pool into a second-order participation layer. Survivor capital is exposed to hazard and redistribution. Soul capital is exposed to protocol throughput. The two states therefore earn from different stochastic drivers: survivors from claimant contraction and collateral growth, souls from fee generation and continued exit activity. The protocol's afterlife economy is thus not symbolic; it is a distinct economic regime.

2.8 VOID token, emissions, and staking

VoidToken is fixed supply. The token contract itself only mints once, to the deployer, at construction. Any vault emission program must therefore be funded by transferring some of that fixed supply into the vault and configuring voidRewardRate plus voidRewardEndTimestamp. Emissions are share-weighted, in contrast to the address-weighted selection process.

When a player claims emissions, the vault does not send liquid VOID to the wallet. It sends tokens directly into VoidStaking and calls stakeFor() with a 14-day lock. Manual stakes remain possible through stake(). Unstaking is two-step: the user requests an amount, waits through the cooldown, and then executes the release from unlocked batches.

Architecturally, the VOID layer introduces a secondary incentive axis without changing the ETH-only interaction surface of the vault. Depositors may become stakers through emissions, stakers may earn ETH from exit activity, and buybacks may reduce circulating supply through burns. The token therefore functions as a reflexive but bounded incentive instrument attached to the fee perimeter rather than as a continuously inflationary subsidy inside the core vault.

3. Contract Architecture

The architecture is expressed across ten named contract surfaces. The stack separates vault accounting, epoch selection, afterlife claims, token staking, buyback execution, yield conversion, and settlement routing into dedicated modules so that each mechanism can be analysed independently without collapsing the full protocol into a single contract.

This modularity is methodological rather than merely aesthetic. The vault never performs victim selection. The consumer never custodies the user's position. The soul registry never mutates vault balances. The buyback sink never prices its own execution path. The result is a factorised architecture in which each contract expresses one dominant transformation of state, making the system easier to reason about both formally and empirically.

3.1 Architectural invariants

Three invariants unify the stack. First, asset abstraction: participants interact in ETH, while yield-bearing collateral remains behind the IYieldToken boundary. Second, identity integrity: both vVOID and vSOUL are non-transferable, preventing secondary-market reshuffling of risk state and afterlife state. Third, role narrowness: cross-contract permissions are specialised and scoped to single transformations rather than broad asset control.

3.2 Asynchronous settlement methodology

The settlement layer is intentionally abstracted away from vault arithmetic. Yield conversion, withdrawal settlement, and buyback routing are each isolated behind explicit interfaces. This makes the core protocol portable across execution venues while preserving a coherent accounting model at the vault level. In effect, THE VOID treats execution routing as an adapter problem and redistribution as a core-mechanism problem, which is the correct separation for a protocol whose defining properties are economic rather than venue-specific.

user ETH
  |
  v
VoidVault --depositETH()--> IYieldToken boundary --> yield-bearing collateral
  |    |   \-> claimVoidRewards() -> VoidStaking -> ETH fee yield to stakers
  |
  +-> tier arrays + share ledger (vVOID)
  |
  +-> requestWithdrawETH() -> async adapter settlement -> claimWithdrawETH() -> user ETH
  |
  +-> fee escrow -> VoidBuyback / VoidStaking / VoidConsumedPool / Treasury
  |
  v
VoidConsumer --VRF--> select one address -> consumePlayer()
  |
  +-> VoidSoulNFT.mint()
  |
  +-> VoidConsumedPool.registerNFT()

4. Parameter Surface

Several parameters are core to the mechanism and already visible in the contract surface. Others, such as exact epoch thresholds or the final VOID emission schedule, are operational system inputs rather than immutable whitepaper constants. Only the parameters that are either encoded directly in the core contracts or structurally central to the mechanism are fixed below.

These parameters are not independent. Tier weights determine hazard dispersion. Tier boundaries determine the time required to acquire a lower-hazard state. Withdrawal fees determine the cost of abandoning the process early. Epoch thresholds determine how often the selection operator is applied. The fee split determines how much exit activity is transformed into burns, staking yield, soul yield, and treasury reserves. The parameter surface should therefore be interpreted as a coupled control system rather than as a collection of isolated knobs.

Vault share token

vVOID, non-transferable

Afterlife token

vSOUL, non-transferable

Total VOID supply

100,000,000 tokens, minted once at token deployment

Auto-stake lock for claimed VOID emissions

14 days

Consumed principal cut parameter

consumedPoolBps = 0

Withdrawal mode

Full exit only, async request plus later claim

Tier progression mode

Manual on-chain ascent through upgradeTier()

Pending-consumption timeout

1 hour

Epoch thresholds

Dynamic and owner-configured inside VoidConsumer; not hard-coded in the token or vault contracts

Yield boundary

wstETH-backed IYieldToken implementation

Settlement routing

Dedicated withdrawal and buyback settlement adapters

5. Operational Surfaces

From an architectural perspective, THE VOID exposes two distinct external surfaces. One surface mutates bounded parameters and cross-contract permissions. The other surface emits the event trail by which deposits, epochs, consumptions, fee flows, claims, and buybacks can be reconstructed off chain.

This separation is especially important for an experimental protocol. Control functions define the admissible intervention set. Events define the empirical record. Because the most meaningful protocol transitions are event-native, the full life cycle of the system can be indexed as a sequence of deposits, ascents, exits, consumptions, soul registrations, fee accruals, and staking claims without needing to infer hidden accounting state.

5.1 Parameter and role surface

1. VoidVault exposes the primary parameter surface: tier weights, tier boundaries, withdrawal fees, deposit cap, fee split, fee-recipient addresses, consumedPoolBps, VOID reward rate, VOID token address, VOID staking address, and reward end timestamp.
2. VoidConsumer controls epoch thresholds, hibernation threshold, VRF subscription parameters, callback gas, and timeout recovery for pending consumption.
3. VoidStaking exposes cooldownDuration, while VoidBuyback exposes swapRouter, minSwapAmount, and maxSlippageBps.
4. WstETHAdapter binds the vault and liquidator addresses and uses a dedicated settlement-manager role for the async withdrawal pipeline.
5. Cross-contract permissions are narrow by construction: the consumer may consume players, mint souls, and register souls; the vault may auto-stake emissions; and parameter roles remain isolated to their own modules.

5.2 Observable event surface

1. VoidVault emits Deposited, WithdrawalRequested, WithdrawalClaimed, TierUpgraded, PlayerConsumed, FeesCredited, and FeesClaimed for the core accounting path.
2. VoidConsumer emits ConsumptionTriggered, Consumption, EpochSkipped, and ConsumptionReset for epoch timing and random selection observability.
3. VoidSoulNFT emits SoulMinted, while VoidConsumedPool emits NFTRegistered, FeesReceived, and Claimed for the afterlife side of the system.
4. VoidStaking emits Staked, StakedFor, UnstakeRequested, Unstaked, ETHReceived, and ETHClaimed for the VOID staking surface.
5. VoidBuyback emits BuybackAndBurn, exposing the conversion of fee ETH into burned VOID.

6. Experimental Character

THE VOID is experimental in a precise sense. It does not merely use randomness as ornamentation, nor does it merely add a token to an otherwise standard vault. Instead, it reorganises the causal structure of a yield protocol by making claimant contraction a first-class source of return. The protocol therefore studies whether a time-weighted, address-based hazard schedule can coexist with productive collateral growth and still produce coherent long-run participant behavior.

Several measurable hypotheses follow. If the mechanism functions as intended, one should observe migration toward lower-hazard tiers among committed participants, elevated early attrition among short-duration entrants, survivor concentration in progressively older cohorts, and a distinct separation between the economics of living positions and the economics of souls. One should also observe that the fee perimeter generates secondary feedback into staking yield and token supply through buybacks and burns.

The architecture is designed so that these hypotheses can be evaluated from the event stream itself. Survival distributions can be estimated from deposit and consumption events. Exit behavior can be inferred from withdrawal requests and claims. Afterlife throughput can be measured from pool funding and soul claims. Token reflexivity can be tracked through buyback and staking emissions. In this respect, THE VOID is not only a protocol but also a live, observable economic experiment in state-dependent redistribution.

7. Conclusion

THE VOID is best understood as a controlled destruction mechanism over addresses embedded inside an ETH-denominated yield vault. Shares capture upside. Tiers shape hazard. Randomness selects a player, not a balance. When that player is consumed, the address exits the living vault and enters the afterlife ledger without extracting principal from the system at launch.

The resulting economy has three simultaneous flows: passive growth from the yield-bearing collateral, convex survivor uplift from a shrinking share supply, and fee recycling through buybacks, staking, and souls. The contract stack keeps these flows separated across explicit modules so that vault accounting, epoch selection, afterlife rights, and settlement routing can each be reasoned about on their own terms.

In formal terms, the protocol transforms time into a state variable, risk into an address-level function, and survival into a balance-sheet amplifier. That combination is what gives THE VOID its distinctive experimental identity. It is a protocol for studying how productive collateral, stochastic elimination, and event-native redistribution behave when joined into one coherent economic machine.