The Vault

What Is a Vault?#

When you register with AeternumVault, the contract creates a private record in your name — a vault. Think of it like a safety deposit box that only you can open. Your ETH sits inside, and no one else can access it under normal conditions.

Technically, a vault is a struct stored in a mapping keyed by your wallet address:

// Simplified — the actual struct lives in IAeternumVault.sol
struct RecoveryConfig {
    address backupAddress;       // where ETH goes if recovery triggers
    uint256 inactivityPeriod;    // how long silence is allowed (seconds)
    uint256 lastActivity;        // timestamp of your last on-chain interaction
    uint256 balance;             // your ETH balance, in wei
    bool    isActive;            // true when your vault is live and monitored
    uint8   failedRecoveryAttempts; // retry counter (max 3 before abandonment)
    bool    isAbandoned;         // true if recovery failed 3 times
}
 
mapping(address => RecoveryConfig) private s_configs;

Every field is per-wallet. There is no shared pool, no commingling, and no way for one user's vault state to affect another's.

Vault Isolation#

Each vault is completely isolated. Your ETH balance is tracked separately from every other user. If something goes wrong with another user's vault configuration (for example, their backup address is a broken contract), it has zero effect on your vault or your funds.

This is a deliberate design choice. The s_configs mapping gives each wallet its own private namespace within the contract. The contract enforces this at the code level — your address is the key, and only transactions from your address can modify your config or move your funds.

What You Can Do With Your Vault#

Your vault supports the full set of operations you would expect from a standard Ethereum wallet, plus the recovery-specific functions:

Every function that touches the contract resets your inactivity timer — because any on-chain interaction is proof that you are alive and in control of your wallet. The only exception is cancelRecovery(), which closes your vault entirely.

Sending ETH From Your Vault#

The send() function lets your vault behave like a normal wallet. You can pay anyone directly from your vault balance without withdrawing first:

// Send 0.1 ETH to a recipient address
// msg.sender must have a registered, active vault
function send(address to, uint256 amount) external onlyRegistered nonReentrant {
    // Checks
    if (amount > config.balance) revert AeternumVault__InsufficientBalance();
 
    // Effects (balance zeroed before the external call — CEI pattern)
    config.balance -= amount;
    config.lastActivity = block.timestamp;
 
    // Interaction
    (bool success,) = to.call{value: amount}("");
    if (!success) revert AeternumVault__TransferFailed();
}

The balance reduction and timer reset happen before the ETH transfer. This follows the Checks-Effects-Interactions pattern, which protects against reentrancy attacks. See the Security Design page for a full explanation.

Withdrawing and Cancelling#

withdrawAll() and cancelRecovery() are two different exit paths:

withdrawAll() pulls your entire balance back to your wallet but leaves your vault active. Your recovery config stays in place. You can deposit again whenever you want. Your timer resets, so you are not at risk of an immediate recovery trigger.

cancelRecovery() does two things in one transaction: it withdraws any remaining balance AND permanently removes your vault from the monitoring system. You are deregistered. You can re-register later with a clean slate.

Version 1 is free#

AeternumVault v1 has no subscription fees, no tiers, and no protocol-level charges. The only costs are standard Ethereum gas fees for the transactions you initiate (register, deposit, send, etc.). The Aeternum keeper bot — the service that watches your vault and calls triggerRecovery() when it's due — runs as a public good, with Aeternum Labs absorbing its gas costs as an operating expense rather than passing them on to individual users. Because triggerRecovery() is permissionless, this isn't a service you depend on paying for either — anyone, including you or your backup address, could call it directly at no cost beyond gas.

This is intentional. Foundational wallet safety should not be gated behind a paywall.