Future Protocol

Future-Protocol (Dvaut / TimeCapsule) is a trustless, cryptographically enforced digital vault that ensures sensitive data, assets, or documents are only accessible at the right time, by the right person, and with a fail-safe backup.

The system combines multiple Web3 layers:

BlockLock + zkTLS → enforce provable time-lock encryption and guarantee no early leaks.

Filecoin + Lighthouse → provide decentralized, permanent, programmable storage with auditable metadata.

Self Protocol + DID identity → authenticate recipients via QR scans, Aadhaar/DID, or family hierarchy proofs.

Emergency Recovery (Nullifier Verification) → ensures assets or capsules can still be transferred to trusted wallets if the original sender passes away or cannot unlock.

Use Cases: Exam papers (no leaks before exam), enterprise embargo documents (unlock only at release time), governance contracts (restricted tender access), and digital wills/legacy transfers (unlock only by rightful heir).

In short, Future-Protocol provides “When + Who + What If” guarantees through blockchain, ZKPs, and decentralized identity — creating a provable, secure, and future-proof way to share or inherit data and assets

Future-Protocol (Dvaut / TimeCapsule) is built as a layered Web3 protocol, where each component enforces either time, identity, or continuity.

Core Stack & Flow:

Frontend (Next.js + Self SDK) → Wallet connection (MetaMask, Self Wallet), capsule creation UI, QR flows.

Encryption Layer (BlockLock Engine) → AES/RSA hybrid encryption with a zkTLS-bound timer to ensure capsules cannot be decrypted before the set unlock time.

Storage Layer (Lighthouse + Filecoin FEVM) → Encrypted capsule is pinned on Lighthouse (IPFS gateway) and anchored on Filecoin FEVM for permanence and programmable storage policies.

Authentication Layer (Self Protocol DID + Aadhaar integration) → Recipients must scan a QR via Self App; generates a verifiable DID proof/nullifier that ties identity to unlock requests.

Validation Layer (zkTLS + ZK Proofs) → Time-lock and non-leak proofs are generated off-chain and verified before BlockLock releases keys.

Decryption Layer → Only after zkTLS (time) + Self QR proof (identity) are satisfied, the decryption key is released locally to the rightful recipient.

Emergency Recovery Mechanism:

We built a landing page fail-safe: user can pre-assign a trusted wallet.

If the original sender cannot unlock (death/accident), the trusted party scans a QR via Self App, generating a Self Nullifier.

The nullifier proof is verified onchain, triggering secure asset transfer from the dead-locked wallet.

Partner Tech Benefits:

Filecoin + Lighthouse → gave us decentralized permanence + programmable storage without relying on centralized servers.

Self Protocol → handled identity elegantly, replacing manual KYC with DID & QR-based proofs.

zkTLS + BlockLock → added a provable “no-early-access” guarantee, which is critical for exam papers and embargoed contracts.

Hacky/Notable Bits:

Implemented a QR-based nullifier recovery flow on top of Self Protocol that isn’t a default feature — we extended it for inheritance/emergency transfers.

Built a hybrid off-chain/on-chain proof flow (zkTLS validation off-chain, storage + nullifier proofs on-chain) to keep it gas-efficient while still fully trustless.