Velum | Devpost

Landing Page
Seeding Encryptic Key Generation - Inspo CloudFlare
Manual Creation Page
Attempting to copy and paste on new pdf
Minted Document after Encryption Process
Hierarchy of Cloud Service
Hierarchy of Cloud Service - Folder Inspection Syncing Documents Async
Workflow Setup

Inspiration

Centralized document security is only as trustworthy as the company holding the keys. We wanted to remove that single point of failure entirely. Inspired by Cloudflare’s lava lamp wall, we replaced physical entropy with live blockchain state as the source of randomness. It is public, immutable, and not controlled by any single entity.

Velum emerged from this idea as a platform where documents are cryptographically anchored to real-time Solana state, and financial workflows are executed using real banking infrastructure through Capital One’s Nessie API.

What it does

Velum is a decentralized document protection and financial workflow platform built on three core systems.

Entropy Engine:

Solana state + document IDs hashed via SHA3-256, committed on-chain via SPL Memo. Documents anchored to specific blockchain moments.

Document Hardening:

Multi-layer adversarial ML pipeline (rasterization, pixel noise, prompt injection overlays, gibberish copy layers, UAP perturbations, EXIF poisoning) that makes documents unreadable to AI while preserving human readability. Deterministic output seeded by blockchain entropy.

Workflow Engine:

Visual canvas with 4 block types, topological execution (Kahn's algorithm), Nessie banking integration for real deposits/withdrawals, atomic on-chain commitment alongside financial execution.

Under the hood, each workflow behaves like a deterministic smart contract. Inputs are validated against on-chain state, execution conditions are enforced programmatically, and outputs are committed atomically.

The Banking Event block integrates directly with Capital One’s Nessie API. It reads live account balances, transaction history, deposits, and withdrawals. When a workflow runs, Velum validates the document against its on-chain anchor, checks financial conditions against real account data, and if all conditions pass, executes a real deposit or withdrawal.

At the same time, a Solana transaction is submitted to finalize the document action on-chain. This creates a single execution flow where financial state changes and cryptographic commitments are tightly coupled and verifiable.

Velum also integrates with Google Drive to track file provenance. Any file movement or modification is included in the next entropy cycle.

A Next.js dashboard allows users to connect wallets, manage Nessie accounts, build workflows, and monitor activity with direct links to Solana Explorer.

How we built it

The entropy oracle runs as a TypeScript and Node.js service on a 5 second loop. It fetches document IDs from Supabase and blockchain state from Solana RPC, combines them into a deterministic hash, and commits the result on-chain. A retry system handles blockhash expiry, rate limits, and RPC failures using exponential backoff.

The workflow system is designed as a smart contract-like execution layer. Each workflow is parsed into a sequence of validated steps, where off-chain computation handles orchestration and on-chain transactions finalize state.

Users create bank profiles linked to Nessie customer IDs and configure events that define account, amount, and transaction type. When triggered, the backend validates conditions and executes requests to Nessie endpoints for deposits or withdrawals, while simultaneously committing results to Solana for verifiability.

The backend uses Express for API handling, Google OAuth for Drive integration, and Python for document hardening. The frontend is built with Next.js, Tailwind, and Solana wallet adapters for transaction signing.

Challenges

Ensuring deterministic entropy generation was critical. JavaScript object ordering is not guaranteed, so we implemented a recursive stable serialization method to ensure identical hashes across environments.

Designing workflows to behave like smart contracts required strict guarantees around execution order, idempotency, and atomicity between off-chain banking actions and on-chain commitments.

Coordinating real-time banking validation with on-chain execution required careful sequencing to avoid partial execution states.

Solana introduced constraints with short blockhash lifetimes and RPC rate limits. We tuned retry logic to maintain reliability without overwhelming the network.

Accomplishments

Velum executes real financial transactions as part of automated workflows that behave like programmable smart contracts.

Each workflow validates against live banking data, enforces execution conditions, and commits results on-chain in a single atomic flow.

The audit trail is fully verifiable. Each entropy commit includes the exact blockchain state used to generate it, allowing anyone to independently reproduce and verify the result.

This creates a system where both financial actions and document integrity are trustless, programmable, and provable.

What we learned

Trustless systems depend on precise implementation details. Deterministic serialization, idempotency, and consistent input handling are essential.

We also learned that combining off-chain systems like Nessie with on-chain guarantees requires designing around failure states and ensuring atomic-like behavior across both environments.