Buy Volt tokens now before the Ethereum bridge launches on May 26.

Buy tokens
Last Updated: MAY 20, 2025

Volt: A Chainless, Feeless, Privacy‑Preserving Token Network

Abstract

We introduce Volt, a novel peer‑to‑peer token transfer network that eliminates traditional blockchain overhead—no global ledger, no fees, and instant finality—while preserving security and privacy. Volt achieves this through a combination of a single root sparse Merkle tree (SMT) for global state representation, a Distributed Hash Table (DHT) for on‑demand proof storage, and an efficient gossip protocol for transaction dissemination. Volt also features a lightweight bridge to Ethereum and other major networks, enabling cross‑chain asset interoperability without sacrificing its core advantages.

1. Introduction

Digital asset transfers have relied predominantly on blockchains, which require every full node to store and process the entire transaction history. While blockchains like Ethereum provide strong security guarantees, they suffer from high transaction fees, slow confirmation times, and publicly exposable transaction graphs. Volt rethinks this paradigm: we maintain only a single 32‑byte root hash on each node, deferring per‑account state to a DHT. This approach yields instant, feeless transactions and minimizes storage and bandwidth requirements, while still enabling provable balance integrity and unlinkability.

1.1 Motivation

  • Fees and Latency: On‑chain transactions incur gas fees and wait for block confirmations.
  • Scalability: Global state replication and transaction throughput are limited by consensus bottlenecks.
  • Privacy: Public ledgers expose transaction flows and address balances.

Volt addresses these issues by:

  1. Feeless Transfers: No miners or gas; transactions propagate via gossip.
  2. Instant Finality: New state roots are adopted as soon as messages traverse the network.
  3. Minimal State: Nodes store only the current root and proofs for accounts they care about.
  4. Selective Privacy: Only proven accounts are revealed; unused addresses remain hidden.

2. System Architecture

Volt consists of four primary layers:

2.1 Core Layer (SMT & Cryptography)

  • State represented as a Sparse Merkle Tree over (address ⇒ (balance, nonce)).
  • Ed25519 signatures for transaction authenticity.
  • SHA‑256 for hashing.

2.2 Network Layer (P2P & DHT)

  • Libp2p Kademlia for proof storage and retrieval.
  • RocksDB for local proof caching.
  • Gossipsub for broadcasting updates.

2.3 Node Daemon

  • Tokio‑based main loop handling network events, proof fetches, state updates, metrics, and JSON‑RPC endpoints.

2.4 Client Interfaces

  • CLI wallet for key management and transaction submission.
  • JavaScript/Python SDKs for web integration (under development)
  • Ethereum bridge contract for cross‑chain mint/burn (under development)

3. Sparse Merkle Tree State

3.1 SMT Overview

A Sparse Merkle Tree (SMT) compactly represents a large key space with default (zero) leaves. Volt's SMT covers 2^256 possible addresses but stores only non‑zero leaves. Each node maintains only the 32‑byte root.

3.2 Operations

  • new_zero(): Initialize an empty tree with a known zero‑root.
  • update(address, new_leaf): Compute a new root for a single leaf update.
  • batch_update(updates[]) (future): Apply multiple updates in a single tree traversal for efficiency.
  • gen_proof(address): Generate an inclusion/exclusion proof for a leaf.
  • verify_proof(root, address, proof): Recover leaf data or assert zero.

3.3 Cryptography

  • Leaf hash: H(0x00 || address || balance || nonce)
  • Internal hash: H(0x01 || left_child || right_child)
  • Hash function: SHA‑256

4. DHT & Proof Storage

Each node runs a Kademlia DHT, storing key = (address, root) ⇒ value = proof. Proof entries are propagated when accounts are first used or when roots change. RocksDB caches recent proofs for speed. Lookup flow:

  1. Node needs proof for address@root.
  2. Check local RocksDB cache.
  3. If missing or stale, issue DHT ProofRequest.
  4. Peers respond with ProofResponse containing the proof.
  5. Node verifies and stores it locally.

5. Gossip Protocol

Volt uses Libp2p Gossipsub:

  • Topic: volt-updates
  • Mesh parameters: Tuned to maintain connectivity while minimizing redundant messages
  • Message: UpdateMsg{ from, to, amount, nonce, signature, old_root, new_root_proof }

Upon receiving an UpdateMsg:

  1. Verify signature with ed25519
  2. Verify old_root == node's current root
  3. Verify inclusion proofs for from/to
  4. Apply SMT::update() to produce new_root
  5. Store new proof and broadcast the updated new_root message

6. Security Analysis

  • Authenticity: Ed25519 signatures ensure only keyholders can spend.
  • Integrity: SMT proofs guarantee single‑use nonces and immutable state transitions.
  • Privacy: Only addresses queried reveal their proofs; rest remain default zeros.
  • Sybil Resistance: DHT uses peer scoring; future work adds stake or resource‑based gating.
  • Replay Protection: Nonces bound to account state prevent double‑spends.

7. Ethereum Bridge

A minimal Solidity contract ETHBridge enables locked minting:

contract ETHBridge {
    mapping(bytes32 > bool) public redeemed;
    function lock() external payable { /* lock ETH & emit event */ }
    function unlock(bytes calldata proof, bytes32 root, address to) external {
        require(!redeemed[root], "Already redeemed");
        // Verify Merkle proof on‐chain
        redeemed[root] = true;
        payable(to).transfer(msg.value);
    }
}

Off‑chain relayers watch lock events, mint corresponding Volt tokens, and accept proofs to release ETH back when users redeem.

8. Token Economics

  • Total Supply Cap: Immutable after launch phase (no further mint/burn).
  • Initial Pricing: $0.021 USDC until bridge launch.
  • Use of Funds: 10% R&D; 90% cross‑chain liquidity provisioning.
  • Team Reserve: 200,000 VOLT split equally among core devs.

9. Conclusion

Volt redefines token transfer networks by removing the need for full chain replication and fees, while preserving security and enabling privacy. Its modular design allows lightweight clients, rapid adoption, and seamless cross‑chain interoperability. We invite developers, institutions, and end users to participate in the Volt ecosystem and shape the future of digital value exchange.

This whitepaper is provided under the MIT License.