EVault

EVault is a decentralized, blockchain-based “vault” system designed to enable secure, tamper-resistant storage, sharing, and access control of digital documents. It combines a smart-contract backend with a web frontend to let users upload, retrieve, and authorize document access in a trustless environment.

Key Features & Goals_

Immutable Storage & Verification Documents are hashed and managed via a smart contract (e.g. DocumentVault.sol) so that any tampering can be immediately detected.

Access Control & Authorization Only authorized users (owners or designated parties) can retrieve or view documents. Permissions are enforced on-chain by the contract logic.

Web Interface A browser UI (via JavaScript, HTML, CSS) allows users to interact with the system—upload files, fetch documents, check status, etc.

Transparent Audit Trail All interactions (uploads, permissions changes, fetches) are recorded on-chain, giving a full log of document history and usage.

Lightweight & Integratable The architecture is minimal so it can be integrated or extended into larger systems (e.g. legal document systems, regulatory compliance, enterprise record keeping).

Architecture & Tech Stack

Smart Contract Layer — DocumentVault.sol (Solidity) forms the core logic.

Frontend Layer — HTML, CSS, JavaScript (in files like app.js, style.css) drive user interactions.

Interaction — The frontend invokes contract methods via Web3 / JSON-RPC to upload hashes, request permission, fetch stored data.

Storage — Actual document content isn’t stored on-chain. Instead, documents are stored off-chain (e.g. IPFS or centralized storage) and their cryptographic hashes are stored on-chain to validate integrity.

Use Cases & Problem Addressed

In sectors where document authenticity and integrity matter (legal, healthcare, compliance, government), EVault helps to ensure no unauthorized changes occur.

It mitigates risks of centralized server hacks or insider manipulation because verification is built into the blockchain.

EVault can serve as a backbone for systems needing auditability and proof-of-integrity for documents (contracts, certificates, records).

EVault was built from the ground up as a decentralized application that blends Solidity smart contracts with a lightweight web frontend to create a secure electronic vault for digital documents.

Smart Contract Layer

At the core is a Solidity contract (DocumentVault.sol) deployed on Ethereum-compatible networks. This contract manages:

Document registration (via storing cryptographic hashes and metadata).

Ownership tracking.

Access control and permission granting.

On-chain audit logs of all actions.

We designed the contract to be minimal yet robust: instead of storing bulky files directly on-chain, EVault only records file hashes and references, ensuring low gas costs and high scalability while still guaranteeing tamper-evidence.

Frontend Layer

The user-facing component is a JavaScript-powered web app that interacts with the contract through Web3 calls. The frontend handles:

File uploads and SHA-256 hash computation in the browser before sending data to the blockchain.

Triggering contract functions for registering or fetching documents.

Rendering stored data (document hash, owner, permissions) in a clear, user-friendly format.

We used HTML + CSS + JS for simplicity, focusing on accessibility and fast prototyping.

Integration Details

Hashing is done client-side, so raw files are never exposed to the blockchain.

Off-chain storage (e.g. local machine, IPFS-ready integration) holds the actual file, while the contract enforces authenticity checks.

Events and logs emitted from the contract are captured by the frontend to display real-time feedback on actions like “Document Registered” or “Access Granted.”

Notable Hacks & Engineering Choices

Instead of storing documents directly, which is costly and inefficient, we built a hash-based referencing system—this was a crucial design decision to make EVault viable.

The access control system is fully enforced on-chain, which prevents backend tampering or centralized override.

To keep gas usage efficient, we used compact data structures and event-based logging rather than bloated storage patterns.

Why This Approach Works

By combining a trustless smart contract with a lightweight web frontend, EVault ensures that documents can be verified and shared securely without reliance on a single authority or server. The modular design also means it’s ready for enhancements like IPFS integration, role-based access models, or encryption layers.

Strengths & Differentiators_

Tamper-evident & trustless — you don’t need to trust a single server or party. Simplicity and clarity — the project’s architecture is clean and focused on the core use case. Auditability built-in — transparent logs allow any stakeholder to verify history.