VOID and Volta

VOID is an ordinary ERC-20 token, launched on Volta (https://volta.family), a launchpad on Elysium built on Flaunch's contracts. It trades on a Uniswap v4 pool against native HYPE. VOID gives no claim on the vault's HYPE and is not needed to use voidcash: gas is always paid in HYPE.

VOID meets voidcash in two places:

• The burn. Half of the HYPE that reaches the fee collector (HYPE exit fees and gas that operations overpaid) buys VOID on its pool and burns it. Volta's own buyback burns VOID too, out of VOID's swap fee.
• The vault. VOID is the vault's first listed token: it can be shielded, sent privately and unshielded like HYPE. See VOID in the vault. The app moves VOID but does not trade it; buying and selling happen on Volta.

AddressesCopy Anchor Link

VOID's page on Volta is https://volta.family/token/ followed by VOID's address.

The launchCopy Anchor Link

VOID was launched with Volta's PositionManager.flaunch, from contracts/script/Deploy.s.sol, with these parameters:

VOID is a 44-byte clone of Volta's token implementation, so its code cannot change. The deploy refuses to launch if the code of Volta's PositionManager, creator NFT contract, fee escrow or token implementation, or of the PoolManager, differs from the code the fork tests ran against (contracts/test/VoltaFork.t.sol), if those contracts point at each other differently, if Volta's share of the fee is above 30%, or if a 1% fee is outside Volta's range. Its check step then verifies the clone, the creator NFT, the pool key, the fee and its split, and that no anti-snipe fee is set.

The poolCopy Anchor Link

Volta has no bonding curve: VOID trades on its Uniswap v4 pool from its first block.

PoolKey({
    currency0: Currency.wrap(address(0)),   // native HYPE
    currency1: Currency.wrap(VOID),
    fee: 0,                                 // the hook takes the swap fee instead
    tickSpacing: 60,
    hooks: IHooks(PositionManager)          // Volta's
})
// poolId = keccak256(abi.encode(key))

The whole supply, 10⁹ VOID, is minted at launch (block 520921) and goes into the pool as a single position running from a market cap of 40 HYPE to the top of Uniswap's price range, except 1 VOID that the same transaction sends to the launching wallet. Until the first buy the pool has no active liquidity.

Volta's swap feeCopy Anchor Link

Every swap on the pool, buy or sale, pays the pool's swap fee of 1%:

• On a sale the fee is taken in HYPE.
• On a buy the fee is taken in VOID. The PositionManager keeps that VOID and sells it to later buyers, before their swaps reach the pool, for HYPE. That HYPE is then split like any other fee.

Each fee is split three ways:

The creator's share moves with the NFT: transferring it sends every later fee to the new holder, and what was owed before stays with the previous one. Only the holder can withdraw its own balance (withdrawFees([address(0)], recipient, false)).

Volta's buybackCopy Anchor Link

The buyback share waits in the FeeVault, readable as balanceOf(poolId, 0). Volta's FeeExecutor spends it on VOID and destroys what it buys, which lowers VOID's totalSupply; nothing is sent to 0x…dEaD. Only Volta's operators can run the executor. Volta's documentation says it runs once a pool has collected 0.01 HYPE, and at most every 10 minutes. voidcash's keeper does not run it and cannot.

The fee collectorCopy Anchor Link

FeeCollector (0x145618DF0662dCd38a2Cf2AC4d24Dfe1FC8A4991) receives HYPE from the vault's sweepFees: the HYPE exit fees and what private operations overpaid for gas. Anyone may call collect(), which splits what has arrived, pays the team, and buys and burns VOID within the limits below.

function collect() external returns (uint256 tokensBurned);
function payTeam() external;

The splitCopy Anchor Link

arrived   = balance(collector) - teamOwed - toBurn      HYPE that came in since the last split
teamOwed += arrived * 5_000 / 10_000                    TEAM_SHARE_BPS
toBurn   += the rest

Every collect and payTeam splits first and emits Collected(amount, teamShare, burnShare). The team's half is paid to teamRecipient at the end of the call (TeamPaid); if the recipient is zero or refuses the HYPE, it stays in teamOwed and is paid later. It is never spent on VOID. toBurn is never paid out: the only HYPE that leaves it buys VOID or refunds the caller of a buy. An exit of u HYPE therefore sets aside 0.5% × u for the burn.

The buysCopy Anchor Link

hype = toBurn * (10_000 - 50) / 10_000                 0.5% held back for the caller's refund
if hype != 0 and block.timestamp >= lastBuyAt + 12 s:
    spot   = VOID per HYPE at the pool's current price
    X      = liquidity * 2^96 / sqrtPriceX96           the HYPE side of the pool's active liquidity
    spend  = min(hype, X * 50 / 20_000)                moves the price by about 0.5%
    feeBps = hook.poolFees(poolId).swapFee
    repeat up to 8 times:
        minOut = spend * spot * (10_000 - feeBps) / (1e18 * 10_000) * (10_000 - 25) / 10_000
        if quote(spend) >= minOut:
            buy spend with minOut; send the VOID to 0x…dEaD
            lastBuyAt = block.timestamp; toBurn -= spend; totalBurned += VOID bought
            stop
        spend /= 2

Each buy is a swap on the PoolManager directly (unlock, swap, settle, take), not through a router. The quote is the same swap, run and undone in the same call, so it includes the 1% fee and any part of the buy Volta fills from the VOID it holds. What does not fit waits in toBurn for the next call. Each buy emits Burned(hypeSpent, tokensBurned).

The collector's constructor accepts a pool only if Volta's PositionManager names this PoolManager, its creator NFT contract names the PositionManager back, the token is a launch that contract created, and the key above hashes to the pool the PositionManager records for the token. A decoy token or pool never enters its pricing or trading.

The caller's refundCopy Anchor Link

The caller is refunded only the gas of a call that bought and burned:

price  = min(tx.gasprice, 2 * block.basefee)
refund = (gas the call measured + 25_000) * price      GAS_OVERHEAD = 25,000
refund = min(refund, spent * 50 / 9_950, toBurn)       CALLER_TIP_BPS = 50: about 0.5% of what it spent

A call that does not buy earns nothing, so calling collect in a loop pays nobody. The refund emits CallerTipped.

Why the buys are smallCopy Anchor Link

A buy that small is not worth sandwiching. With the swap fee τ = 1% and the impact cap δ = 0.5%, the whitepaper shows that an attacker who buys just before one of the collector's buys and sells right after loses at least 0.75% of the capital used, at any size, and 1.5% when the front-run is small next to the pool. A single buy would break even for the attacker only at an impact of about 2.02%, four times the cap.

The cap limits the pace of buying, not the total. The backlog is public and anyone can trigger each buy, so an attacker who buys first and holds through several buys can come out ahead: from the fifth buy, about 48 seconds after the first, once the backlog exceeds about 1% of X. Volta's buyback is exposed the same way whenever one buyback spends more than about 1% of X. These are mechanics; they say nothing about VOID's price.

OwnerCopy Anchor Link

The owner can do nothing else. Nobody can take the HYPE set aside for burning. At deployment the same key owns the collector and receives the team's half.

VOID in the vaultCopy Anchor Link

Since the vault's v2 upgrade on 5 November 2026, VOID is the first token the vault lists (VOLTA, Volta's own token, followed on 6 November 2026, BLOB on 7 November and YIELDEX on 8 November). It was listed by the same script that upgraded the vault, with these terms:

A VOID note is hashed as H(3, stub, amount, uint160(VOID)), apart from HYPE notes but in the same tree, so VOID notes and HYPE notes share one privacy set. See Notes and The vault.

The burned totalCopy Anchor Link

VOID is burned two ways, and each leaves a different mark:

• The fee collector sends what it buys to 0x000000000000000000000000000000000000dEaD, where nobody can spend it. FeeCollector.totalBurned counts it.
• Volta's buyback destroys what it buys, which lowers totalSupply.

So the total burned by every route is:

burned = (10^9 VOID - VOID.totalSupply()) + VOID.balanceOf(0x…dEaD)

The app's analytics page computes it this way (packages/sdk/src/analytics.ts), and shows the collector's part (totalBurned), the rest (Volta's buyback, and anyone else's burns), the HYPE waiting in the collector (toBurn) and the buyback share waiting in Volta's FeeVault.

The keeperCopy Anchor Link

Every call that moves fees and burns VOID is permissionless. voidcash runs a keeper (services/keeper) so that they happen on time, and so that someone hears at once about an exit that could hurt the pool.

The keeper checks for exits every 5 seconds and runs its fee tick every 30 seconds. It does not run Volta's buyback: only Volta's operators can. Anyone else can make the same calls.

TrustCopy Anchor Link

• The vault does not depend on Volta. Shielding, private sends and exits work whatever happens to VOID's market. If Volta's contracts stopped working, only the collector's buys and Volta's buyback would stop, and the HYPE meant for burning would wait in the collector. VOID notes in the vault depend on VOID's own token contract, a clone whose code cannot change.
• Volta does not publish its Solidity source. What these pages say about it comes from the ABI its site ships, its documentation, its bytecode and the fork tests. None of its contracts is a proxy.
• Volta's owner is a single externally owned account. It can name a keeper of the FeeVault, and a keeper can withdraw VOID's pending buyback share to any address, so that share is in Volta's hands until its executor spends it. The owner also names the executor's operators and can repoint the contracts that new launches use. It cannot reach the creator's share in the FeeEscrow or anything held by voidcash's contracts.
• Two public functions of Volta's PositionManager could not be identified.
• The PoolManager runs Uniswap v4's code. Its owner can name a protocol fee controller, which could add up to 0.1% to each swap; the collector's quotes come from the swap itself, so it would pay that fee and lose nothing beyond it.

See the trust model for the rest.