Deployments

NetworkCopy Anchor Link

What matters about Elysium when you build on it:

• Blocks follow transactions. Elysium makes a block only when there are transactions, so block numbers are not a clock. voidcash's contracts measure time with block.timestamp.
• Log queries are capped. eth_getLogs on the public endpoints accepts at most 10,000 blocks per call, and heavy ranges can fail before that. The SDK reads in ranges of 5,000 blocks and splits any range the RPC refuses.
• No websocket on the public RPC. Read logs with eth_getLogs, or use the indexer.
• Contract size limit. Elysium enforces the 24,576-byte limit on deployed code.

voidcash contractsCopy Anchor Link

The verifier links two external libraries. They were deployed with the first verifier, and the v2 verifier links the same two:

Every function, event and error is on Contracts.

Roles and parametersCopy Anchor Link

The vault has three roles and a token fee recipient. The fee collector has an owner and a team recipient. VOID's creator NFT on Volta decides who receives the creator's share of VOID's swap fee. One address holds all of them, 0xb06aBb2a232e6e7e91b37ADf79116c41AD4b879a:

What each role can and cannot reach is on Trust model.

Listed tokensCopy Anchor Link

The vault's admin lists tokens one at a time (listToken). A listed token is never removed, since its notes stay spendable; the guardian can close it to new deposits (setTokenEntriesPaused), and the vault's own entries pause closes HYPE and every token at once. Each token has two limits, in its own units: an exit paying out more than its large-exit threshold waits 24 hours, and so does an exit that would take the exits paid in the current 24-hour window above its window cap. The guardian can stop a waiting exit.

BLOB pays its holders dividends in HYPE, which each holder claims from the token; BLOB held in the vault earns none for its owners, since the dividends that accrue to the vault cannot be claimed.

A token's exit fee is 1% of what leaves, in the token, and goes to the token fee recipient, not to the fee collector: the VOID burn is fed by HYPE exit fees only. Gas for every private action is paid in HYPE, so a private token action also spends a private HYPE note. Read the live values with tokenConfig(token) (see below), or every listing and change from the vault's TokenListed and TokenLimitsSet events.

Unused contractCopy Anchor Link

LaunchBuyer (0x7534Ba20DC4bFAFAE4650B2Dc67A0d02EC1794A5) was deployed by the same deployer for a launch plan that was then dropped. It has no owner, holds nothing between calls, and nothing in voidcash uses it.

Volta and the VOID poolCopy Anchor Link

VOID launched on Volta, a launchpad on Elysium built on Flaunch's contracts. It trades on a Uniswap v4 pool against native HYPE from its first block; Volta has no bonding curve. VOID is Volta launch number 232. Its page on Volta is https://volta.family/token/ followed by VOID's address.

VOID's pool, as the fee collector checks it in its constructor:

Every swap pays a 1% fee, fixed for the life of the pool. Volta keeps 30% of it; of the rest, half goes to the creator NFT's holder and half to Volta's buyback, which buys VOID and burns it. See VOID.

Shared infrastructureCopy Anchor Link

Public servicesCopy Anchor Link

BundlerCopy Anchor Link

Private actions reach the chain as ERC-4337 UserOperations whose sender is the vault. No public bundler serves Elysium, so voidcash runs its own: Alto 0.0.21, Pimlico's open-source bundler, behind a gate.

The gate forwards only the request body, so no client header reaches Alto. One private action makes about 35 requests: a gas price, an estimate, the send, and receipt polls every 2 to 5 seconds. Any bundler that speaks Pimlico's RPC methods and supports EntryPoint v0.8 on Elysium can be used instead. See Gas.

IndexerCopy Anchor Link

The indexer serves the vault's events, the same for everyone, so wallets do not have to read the whole chain.

The API is described on Integrations.

Check it on-chainCopy Anchor Link

Everything above can be read with Foundry's cast and the public RPC. Set the addresses from the tables on this page:

export ETH_RPC_URL=https://rpc.volta.family
VAULT=0x…        # PrivateVault (proxy)
COLLECTOR=0x…    # FeeCollector
VOID=0x…         # VOID
ACCOUNT=0x…      # an address whose roles you want to check

The vault's code and wiring:

# The implementation the proxy runs now (ERC-1967 implementation slot)
cast storage $VAULT 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc

# Immutables of that implementation
cast call $VAULT "verifier()(address)"
cast call $VAULT "hasher()(address)"
cast call $VAULT "hasher4()(address)"
cast call $VAULT "entryPoint()(address)"

# State of the proxy
cast call $VAULT "feeCollector()(address)"
cast call $VAULT "largeExitThreshold()(uint256)"
cast call $VAULT "paused()(bool)"
cast call $VAULT "entriesPaused()(bool)"
cast call $VAULT "eip712Domain()(bytes1,string,string,uint256,address,bytes32,uint256[])"

The listed tokens:

# listed, entriesPaused, largeExitThreshold, windowCap
cast call $VAULT "tokenConfig(address)(bool,bool,uint256,uint256)" $VOID
# backing, pendingExits, feesAccrued, windowStart, windowOut
cast call $VAULT "tokenBook(address)(uint256,uint256,uint256,uint64,uint256)" $VOID
cast call $VAULT "tokenFeeRecipient()(address)"
cast call $VAULT "TOKEN_WINDOW()(uint256)"   # 86400

# What the vault holds of the token: at least backing + pendingExits + feesAccrued
cast call $VOID "balanceOf(address)(uint256)" $VAULT

The vault's roles:

# DEFAULT_ADMIN_ROLE is 0x00…00
cast call $VAULT "hasRole(bytes32,address)(bool)" 0x0000000000000000000000000000000000000000000000000000000000000000 $ACCOUNT
cast call $VAULT "hasRole(bytes32,address)(bool)" $(cast keccak UPGRADER_ROLE) $ACCOUNT
cast call $VAULT "hasRole(bytes32,address)(bool)" $(cast keccak GUARDIAN_ROLE) $ACCOUNT

The roles use OpenZeppelin AccessControl, which does not list a role's members. To find every holder, read the vault's RoleGranted and RoleRevoked events from its deployment block, 454409, in ranges of at most 10,000 blocks. A change of implementation shows as an Upgraded event.

The fee collector and VOID:

cast call $COLLECTOR "owner()(address)"
cast call $COLLECTOR "teamRecipient()(address)"
cast call $COLLECTOR "token()(address)"
cast call $COLLECTOR "poolId()(bytes32)"
cast call $COLLECTOR "totalBurned()(uint256)"

cast call $VOID "name()(string)"        # "voidcash"
cast call $VOID "symbol()(string)"      # "VOID"
cast call $VOID "decimals()(uint8)"     # 18
cast call $VOID "totalSupply()(uint256)"

# VOID is a clone of Volta's token implementation: 44 bytes that delegate to it
cast code $VOID
# 0x3d3d3d3d363d3d37363d73541ef1674d3cc64d0ab1f14381ca5970fd10b5545af43d3d93803e602a57fd5bf3

# The launch and its creator NFT
NFT=0xac466Ee5CEdD012eB750DBDA0B935F8B997402c7
cast call $NFT "tokenId(address)(uint256)" $VOID    # 232
cast call $NFT "ownerOf(uint256)(address)" 232

The vault's own deposit on the EntryPoint. Every private operation adds its gas fee to it, the EntryPoint takes the gas used from it, and sweepFees sends what is left to the fee collector:

cast call 0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108 "balanceOf(address)(uint256)" $VAULT

How it was deployedCopy Anchor Link

The deploy scripts are in contracts/script, and their records in contracts/deployments: 99901.planned.json (addresses computed in advance), 99901.verifier.json, 99901.vault.json, 99901.upgrade-v2.json (the upgrade to v2) and 99901.json (every current address).

The first deployment, with vault v1 (HYPE only):

Build settings: Solidity 0.8.38 for the Cancun EVM, OpenZeppelin Contracts and Contracts Upgradeable 5.7.0. The vault is compiled at 200 optimizer runs to fit the contract size limit: the v2 implementation's deployed code is 23,413 bytes (cast codesize). The verifier and every other contract are compiled at 10,000.

After the deploy, the deployer deposited 0.001 HYPE for the vault on the EntryPoint (block 553934). A bundler's gas estimate is simulated at a tiny gas price and still needs a prefund from the account's deposit; this deposit lets it succeed. Every real operation still pays its own gas from the notes it spends. sweepFees() withdraws the whole deposit, so the keeper tops it up to 0.001 HYPE after every sweep.

The upgrade to v2Copy Anchor Link

On 2026-11-05 the vault was upgraded in place to v2, which adds listed ERC-20 tokens. The proxy, its address, the note tree and every HYPE note stayed as they were: HYPE notes keep their commitment, and v2 only appends storage. A proof made for the v1 circuit fails under v2, so the app, the SDK, the indexer and the keeper switched at the same time.

Every transaction came from the address that holds the admin and upgrader roles, 0xb06aBb2a232e6e7e91b37ADf79116c41AD4b879a, between 20:06 and 20:08 UTC:

The implementation before the upgrade was 0x942b5DF5f8D19Ea95b006F0e3AF947909453622b.