Blaut - Decentralized File Storage

Secure, blockchain-based file storage with emergency access controls and wallet-based encryption.

🚀 Live App: http://blaut.vercel.app/

📋 Smart Contract: 0x06cc01278b3e60fFAF4096ccd08e9Cc6D1D51722 (View on Explorer)

Demo Videos

Feature	Demo Link	Description
File Upload & Encryption	Watch Demo	See how files are encrypted and stored securely
File Sharing	Watch Demo	Learn to share files with wallet addresses
Emergency Access	Watch Demo	Emergency responder access for medical scenarios
Folder Organization	Watch Demo	Create and manage folder structures

How Blaut Works

3-Layer Security Architecture

Your Device     → Encrypt file with unique key
     ↓
Blockchain     → Record ownership & access permissions  
     ↓
Supabase      → Store encrypted file + encrypted keys

Upload Process

Select File → Choose file (max 50MB)
Generate Key → Create unique encryption key
Encrypt File → AES-256 encryption on your device
Sign Message → Wallet signs unique challenge for key derivation
Derive Encryption Key → SHA256 hash of signature creates encryption key
Upload → Store encrypted file in cloud
Blockchain Record → Record ownership on blockchain

Sharing Process

Select File → Choose file to share
Enter Address → Input recipient's wallet address
Owner Signs → Owner wallet signs to decrypt original key
Re-encrypt Key → Encrypt file key for recipient's wallet
Grant Access → Update blockchain permissions

Download Process

Verify Access → Check blockchain permissions
Get Encrypted Key → Retrieve your encrypted file key
Sign Challenge → Wallet signs verification message
Derive Decryption Key → Generate key from signature
Decrypt File Key → Use derived key to decrypt file key
Download & Decrypt → Get and decrypt original file

Wallet Signature-Based Encryption

How Signature-Based Key Derivation Works

Blaut uses a unique approach where each user's wallet signature generates deterministic encryption keys:

// 1. Create unique challenge message
const challenge = `Blaut File Key Encryption
Wallet: ${walletAddress.toLowerCase()}
Timestamp: ${Date.now()}`;

// 2. User signs the challenge with their private key
const signature = await signMessage({ message: challenge });

// 3. Derive encryption key from signature
const encryptionKey = SHA256(signature).toString();

// 4. Use key for AES encryption/decryption
const encrypted = AES.encrypt(fileKey, encryptionKey);

Why Signature-Based Encryption?

Unique Keys: Each signature produces a unique encryption key
Non-Deterministic: Same wallet can generate different keys each time
Wallet-Bound: Only the wallet owner can recreate the signature
Secure: Requires private key access to decrypt
Traceable: Each signature is linked to wallet address on blockchain

Signature Verification Flow

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   File Upload       │    │   Signature Process  │    │   Blockchain Link   │
│                 │    │                  │    │                 │
│ 1. Select File      │    │ 3. Create Challenge  │    │ 6. Record on Chain  │
│ 2. Generate File Key│    │ 4. Sign with Wallet  │    │ 7. Link Signature   │
│                 │    │ 5. Derive Enc Key    │    │ 8. Explorer Link    │
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │                        │                        │
         └────────────────────────┼────────────────────────┘
                                  │
                         ┌──────────────────┐
                         │   Key Storage        │
                         │                  │
                         │ • Encrypted Keys     │
                         │ • Challenge Data     │
                         │ • Wallet Mapping     │
                         └──────────────────┘

Transaction Explorer Integration

Every file operation creates a blockchain transaction that can be verified:

Contract Address: 0x9C87587f06B43dEF7e0b7FA0fB0F12fFB4337454
Network: Sepolia Testnet
Explorer: https://sepolia.etherscan.io/address/0x9C87587f06B43dEF7e0b7FA0fB0F12fFB4337454

Transaction Types:

uploadFile() - Records file ownership and initial access
grantAccess() - Adds new user to file access list
revokeAccess() - Removes user from file access list
addEmergencyResponder() - Authorizes emergency personnel
markFileAsEmergency() - Enables emergency access for file

Technical Implementation Details

Unique Key Generation System

Blaut implements a sophisticated signature-based encryption system that generates unique keys for each operation:

1. Challenge Generation

const generateChallenge = (walletAddress: string, operation: string) => {
  return `Blaut ${operation} Operation
Wallet: ${walletAddress.toLowerCase()}
Timestamp: ${Date.now()}
Nonce: ${crypto.getRandomValues(new Uint32Array(1))[0]}`;
};

2. Signature-Based Key Derivation

const deriveEncryptionKey = async (challenge: string, wallet: any) => {
  // User signs challenge with wallet private key
  const signature = await wallet.signMessage(challenge);
  
  // Create deterministic but unique encryption key
  const keyMaterial = `${signature}:${challenge}`;
  const encryptionKey = await crypto.subtle.digest('SHA-256', 
    new TextEncoder().encode(keyMaterial)
  );
  
  return Array.from(new Uint8Array(encryptionKey))
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
};

3. Unique Queue System

Each wallet generates a unique queue of encryption keys that are:

Non-reversible: Cannot derive private key from encryption key
Deterministic: Same signature always produces same encryption key
Unique per operation: Different challenges create different keys
Wallet-bound: Only the wallet owner can recreate signatures

interface EncryptionQueue {
  walletAddress: string;
  keyIndex: number;
  encryptedKeys: {
    fileId: string;
    encryptedKey: string;
    challenge: string;
    timestamp: number;
    signature: string;
  }[];
}

Blockchain Explorer Integration

Every file operation is recorded on the blockchain and can be verified through the explorer:

Network Details:

Network: Awakening Testnet
Chain ID: 1043
RPC URL: https://rpc.awakening.bdagscan.com
Currency: BDAG
Explorer: https://explorer.awakening.bdagscan.com

Contract Information:

Contract Address: 0x06cc01278b3e60fFAF4096ccd08e9Cc6D1D51722
Contract Name: FileStorageV3
Network: Ethereum Mainnet / Sepolia Testnet
Verification: View all transactions and contract interactions
Explorer: View Contract on Etherscan

Transaction Hash Lookup:

// Example transaction verification
const verifyTransaction = async (txHash: string) => {
  const explorerUrl = `https://explorer.awakening.bdagscan.com/tx/${txHash}`;
  // View transaction details, gas usage, and contract interactions
};

Key Transaction Events:

FileUploaded(address indexed owner, string fileId, string ipfsHash)
AccessGranted(string indexed fileId, address indexed user, address indexed grantedBy)
AccessRevoked(string indexed fileId, address indexed user, address indexed revokedBy)
EmergencyResponderAdded(address indexed user, address indexed responder, string nickname)
EmergencyFileAccessed(string indexed fileId, address indexed responder)

Blockchain Explorer View

The contract is live and all transactions can be verified on the blockchain explorer:

Contract Overview:

Address: 0x06cc01278b3e60fFAF4096ccd08e9Cc6D1D51722
Creator: 0x170F099B...A3E2bcd13
Total Transactions: 4 successful deployments
Latest Activity: Recent contract interactions visible
Gas Usage: Optimized for file operations

Recent Transactions:

Contract deployment and initialization
File upload operations with encrypted storage
Access permission grants and revokes
Emergency responder management
Ownership verification transactions

How to Verify Your Transactions:

Copy your transaction hash from the app
Visit the contract explorer page
Check the "Transactions" tab for your specific operation
Verify gas fees, block confirmation, and transaction status

Code Architecture

Frontend Architecture

src/
├── components/           # React UI components
│   ├── DashboardUI.tsx   # Main dashboard interface
│   ├── VaultUI.tsx       # File management interface
│   ├── EmergencyAccess.tsx # Emergency access portal
│   ├── Header.tsx        # Navigation header
│   ├── Sidebar.tsx       # Navigation sidebar
│   └── modals/           # Modal dialogs
│       ├── ShareModal.tsx
│       ├── RenameModal.tsx
│       └── FileActionsModal.tsx
├── lib/
│   ├── crypto.ts         # Encryption/decryption utilities
│   ├── supabase.ts       # Database client configuration
│   └── hooks/            # Custom React hooks
│       ├── useFileManager.ts     # File CRUD operations
│       ├── useFileUpload.ts      # File upload logic
│       ├── useFileSharing.ts     # File sharing logic
│       ├── useFolderManager.ts   # Folder operations
│       └── useEmergencyAccess.ts # Emergency access hooks
├── utils/
│   ├── file.ts           # File utility functions
│   ├── folder.ts         # Folder utility functions
│   └── emergencyAccess.ts # Emergency access utilities
├── constant/
│   ├── abi.ts            # Smart contract ABI
│   ├── contract.ts       # Contract address configuration
│   └── index.ts          # Application constants
├── pages/
│   ├── DashboardPage.tsx # Main dashboard page
│   ├── VaultPage.tsx     # File vault page
│   └── EmergencyAccessLearnPage.tsx # Emergency access info
└── wagmi.ts              # Web3 configuration

Data Flow Architecture

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   User Interface   │    │   Business Logic     │    │   Data Layer        │
│                 │    │                  │    │                 │
│ • React Components │    │ • Custom Hooks      │    │ • Supabase DB       │
│ • Modal Dialogs    │    │ • Crypto Functions   │    │ • Supabase Storage  │
│ • Form Validation  │    │ • File Operations    │    │ • Smart Contract    │
│ • State Management │    │ • Access Control     │    │ • IPFS (Future)     │
└─────────────────┘    └──────────────────┘    └─────────────────┘
         │                        │                        │
         └────────────────────────┼────────────────────────┘
                                  │
                         ┌──────────────────┐
                         │   External APIs      │
                         │                  │
                         │ • Wallet Providers   │
                         │ • RPC Endpoints      │
                         │ • Block Explorers    │
                         └──────────────────┘

Security Architecture

┌─────────────────────────────────────────────────────────────┐
│                    Client-Side Security                     │
├─────────────────────────────────────────────────────────────┤
│ • File Encryption (AES-256)                                │
│ • Key Generation (Crypto-secure random)                    │
│ • Wallet Signature Verification                            │
│ • Zero-Knowledge File Processing                           │
└─────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────┐
│                   Blockchain Layer                         │
├─────────────────────────────────────────────────────────────┤
│ • Access Control Lists                                     │
│ • Ownership Verification                                   │
│ • Emergency Responder Registry                             │
│ • Immutable Audit Logs                                     │
└─────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────┐
│                    Storage Layer                           │
├─────────────────────────────────────────────────────────────┤
│ • Encrypted File Storage                                   │
│ • Encrypted Key Storage                                    │
│ • Metadata Storage                                         │
│ • Row-Level Security                                       │
└─────────────────────────────────────────────────────────────┘

Quick Setup

Option 1: Use Live App (Recommended)

Visit the deployed application: http://blaut.vercel.app/

Connect your wallet (MetaMask recommended)
Ensure you're on the correct network
Start uploading and managing files immediately

Option 2: Local Development

1. Prerequisites

Node.js 18+
MetaMask wallet
Sepolia ETH for gas fees

2. Installation

git clone https://github.com/canhamzacode/blaut.git
cd blaut
npm install

3. Environment Setup

cp .env.example .env

Required Environment Variables:

VITE_PUBLIC_SUPABASE_URL=your_supabase_url
VITE_PUBLIC_SUPABASE_ANON_KEY=your_supabase_key
VITE_WALLET_CONNECT_ID=your_walletconnect_id

4. Database Setup

Open Supabase SQL Editor
Run supabase-complete-schema.sql
Creates all tables, functions, and storage buckets

5. Start Application

npm run dev

Tech Stack

Frontend: React 18 + TypeScript + Vite
Web3: Wagmi + RainbowKit
Blockchain: Ethereum Sepolia Testnet
Storage: Supabase Storage + Database
Encryption: AES-256 (CryptoJS)
Styling: Tailwind CSS

Key Configuration Files

File	Purpose	Location
Contract Address	Smart contract: `0x06cc01278b3e60fFAF4096ccd08e9Cc6D1D51722`	`src/constant/contract.ts`
Contract ABI	Interface for blockchain calls	`src/constant/abi.ts`
Network Config	Wallet & chain setup	`src/wagmi.ts`
Database Schema	Supabase tables & functions	`supabase-complete-schema.sql`

Current Contract: 0x9C87587f06B43dEF7e0b7FA0fB0F12fFB4337454 (Sepolia)

Core Features

File Operations

Upload: Drag-and-drop with client-side encryption
Download: Automatic decryption with wallet verification
Share: Grant access to any wallet address
Delete/Rename: Full file lifecycle management

Organization

Folders: Create hierarchical folder structures
Navigation: Breadcrumb paths and folder browsing
Permissions: Folder-level sharing with role controls

Emergency Access

Medical Scenarios: Emergency responder access to critical files
Blockchain Verification: Verified emergency personnel only
Audit Trail: Complete logging of emergency access events
Time-Limited: Automatic access expiration

User Experience

Multiple Views: Grid and list display modes
Real-time Updates: Live file and folder synchronization
Responsive Design: Mobile-friendly interface
Progress Tracking: Upload/download progress indicators

Security Features

End-to-End Encryption: Files encrypted before upload
Zero-Knowledge Storage: Cloud providers can't read files
Blockchain Access Control: Immutable permission records
Wallet-Based Security: Your keys, your files
Emergency Protocols: Secure emergency access with full audit trails

API Reference

Core Hooks

useFileManager

const {
  files,              // Array of accessible files
  isLoading,          // Loading state
  downloadFile,       // Download and decrypt file
  deleteFile,         // Delete file
  renameFile,         // Rename file
  refreshFiles        // Refresh file list
} = useFileManager();

useFileUpload

const {
  uploadFile,         // Upload and encrypt file
  uploadState,        // Upload progress state
  resetUpload         // Reset upload state
} = useFileUpload();

useFileSharing

const {
  shareFile,          // Share file with address
  sharingState,       // Sharing progress state
  resetSharingState   // Reset sharing state
} = useFileSharing();

Utility Functions

Encryption

// Encrypt file with generated key
encryptFileWithKey(file: File, key: string): Promise<EncryptedFileData>

// Decrypt file with key
decryptFileWithKey(encryptedData: string, key: string, metadata: FileMetadata): Blob

// Encrypt key for wallet
encryptKeyForWallet(key: string, walletAddress: string, signMessage: Function): Promise<string>

// Decrypt key with wallet
decryptKeyForWallet(encryptedKey: string, walletAddress: string, signMessage: Function): Promise<string>

File Operations

// Upload encrypted file to storage
uploadEncryptedFileToStorage(encryptedData: EncryptedFileData): Promise<string>

// Download encrypted file from storage
downloadEncryptedFile(filePath: string): Promise<string>

// Get files accessible to user
getAccessibleFiles(walletAddress: string): Promise<FileWithAccess[]>

// Grant file access to user
grantFileAccess(fileId: string, walletAddress: string, encryptedKey: string, grantedBy: string): Promise<void>

Contact & Support

Developer: Hamza Abdul-Muizz
Repository: github.com/canhamzacode/blaut
Issues: Use GitHub Issues for bug reports
Demo: Live Demo (Coming Soon)

Deployment

Frontend Deployment

npm run build
# Deploy to Vercel, Netlify, or preferred hosting

Smart Contract Deployment

Contract source: FileStorageV2.sol
Deploy to desired network
Update src/constant/contract.ts with new address

Important Notes

Wallet Security: Your wallet private key = master key to all files
Key Loss Warning: Lost wallet = lost file access (by design)
Network Fees: Blockchain transactions require gas fees
File Limits: 50MB maximum file size
Testnet Only: Currently on Sepolia testnet

License

MIT License - See LICENSE file for details

Built for secure, decentralized file storage

About 30% of emergency cases in developing nations fail because crucial records can’t be accessed quickly.
In Nigeria alone, thousands lose lives or assets yearly due to missing identity or medical details.

Blault was built to change that — ensuring that life-saving data is never locked away when it’s needed most.

💡 The Solution — BLAULT

Blault blends encryption, blockchain, and smart access control to keep your data safe yet instantly accessible to trusted people.

With Blault, you can:

✅ Upload and encrypt files directly from your wallet. 🔐 Grant access to trusted contacts like doctors or family. 🚨 Assign emergency responders who can view your files only in crisis. 📜 Track all file activities transparently on-chain.

No central servers, no leaks — only full control and privacy.

⚙️ How It Works

File Upload
- Files are encrypted locally using your wallet’s unique signature.
- Encrypted content is stored in Supabase.
- File metadata and permissions are stored on the BlockDAG chain.
Access Management
- You can add or remove wallet addresses for file access.
- Authorized users receive their own encrypted decryption keys.
Emergency Mode
- You can mark files as “emergency accessible.”
- Assigned responders (e.g. hospital, next of kin) can access them in verified emergencies.
Transparency
- Every access event is logged immutably on-chain — no disputes, no hidden edits.

🧱 System Overview

Component	Description
Smart Contract (FileStorageV3.sol)	Stores file ownership, access control, and emergency logic.
Supabase	Handles encrypted file storage & metadata.
Supabase Schema (supabase_schema.sql)	Predefined structure for replicating the same backend instantly.
Encryption Layer	Uses AES + wallet signature for encryption/decryption.
Frontend (Vite + React)	User dashboard for file upload and management.
WalletConnect	For authentication and signing transactions.

📂 Project Structure

root/
│
├── src/
│   ├── components/      # Reusable UI components
│   ├── pages/           # App screens
│   ├── utils/           # Encryption & wagmi config
│
├── FileStorageV3.sol     # Smart contract file
├── supabase_schema.sql   # Database schema for easy setup
├── .env.example
├── vite.config.ts
├── wagmi.ts              # Blockchain setup
└── README.md

🔐 Environment Setup

1️⃣ Duplicate .env.example and rename it .env. 2️⃣ Fill in your Supabase and WalletConnect details.

# Supabase
VITE_PUBLIC_SUPABASE_URL=https://your-project.supabase.co
VITE_PUBLIC_SUPABASE_ANON_KEY=your_supabase_anon_key

# WalletConnect
VITE_WALLET_CONNECT_ID=your_wallet_connect_project_id

Example:

VITE_PUBLIC_SUPABASE_URL=https://abcd1234.supabase.co
VITE_PUBLIC_SUPABASE_ANON_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...
VITE_WALLET_CONNECT_ID=abcd1234567890abcd1234567890abcd

⚡ Supabase Setup

To create your own database structure:

Log in to your Supabase Dashboard.
Create a new project.
Navigate to SQL Editor.
Copy all content from supabase_schema.sql (found in the root folder).
Paste and run it.

✅ This will automatically generate all tables and relationships needed for Blault to work.

⚡ Smart Contract

File: FileStorageV3.sol Network: BlockDAG Sepolia Testnet Compiler: Solidity ^0.8.0 Address: 0x06cc01278b3e60fFAF4096ccd08e9Cc6D1D51722

Features:

Upload & encrypt file metadata
Grant/revoke access
Manage emergency responders
Mark and auto-enable emergency access
View immutable access logs

💻 Local Setup

# Clone repo
git clone https://github.com/canhamzacode/blault
cd blault

# Install dependencies
npm install

# Run locally
npm run dev

Visit → http://localhost:5173

🧩 Encryption Process

User signs a message → generates AES key.
File is encrypted client-side with that key.
Encrypted file uploaded to Supabase.
File hash & access metadata stored on BlockDAG.
Only authorized wallets can decrypt using their keys.

🛡️ No one, not even Blault’s team, can read your files.

💬 FAQ

Q1: What if I lose access to my wallet? 🟢 Your trusted emergency contacts can access your marked files.

Q2: Are my files stored on-chain? 🟢 No, only file hashes and permissions. The encrypted file itself lives securely in Supabase.

Q3: Why BlockDAG? 🟢 BlockDAG offers faster confirmation times and low gas fees — ideal for real-time access control.

Q4: Can I revoke someone’s access? 🟢 Yes, instantly on-chain. Their keys are invalidated immediately.

🎥 Walkthrough Demo

🔗 Watch Demo: Loom — Blault Secure File & Emergency System

🧭 Pitch Deck

📑 View the full Blault Pitch Deck: 👉 https://www.figma.com/deck/kO73drXWEKgr9j6YE1K440/Blault-Presentation?node-id=49-133&t=LpFXpHVHn0ccYScE-0&scaling=min-zoom&content-scaling=fixed&page-id=0%3A1

Name		Name	Last commit message	Last commit date
Latest commit History 20 Commits
public		public
src		src
.env.example		.env.example
.gitignore		.gitignore
.npmrc		.npmrc
.prettierrc		.prettierrc
FileStorageV2.sol		FileStorageV2.sol
README.md		README.md
SUPABASE_SETUP_GUIDE.md		SUPABASE_SETUP_GUIDE.md
components.json		components.json
index.html		index.html
package-lock.json		package-lock.json
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
supabase-complete-schema.sql		supabase-complete-schema.sql
tsconfig.json		tsconfig.json
tsconfig.node.json		tsconfig.node.json
vercel.json		vercel.json
vite.config.ts		vite.config.ts

buildwithhamzat/blaut

Folders and files

Latest commit

History

Repository files navigation

Blaut - Decentralized File Storage

Demo Videos

How Blaut Works

3-Layer Security Architecture

Upload Process

Sharing Process

Download Process

Wallet Signature-Based Encryption

How Signature-Based Key Derivation Works

Why Signature-Based Encryption?

Signature Verification Flow

Transaction Explorer Integration

Technical Implementation Details

Unique Key Generation System

1. Challenge Generation

2. Signature-Based Key Derivation

3. Unique Queue System

Blockchain Explorer Integration

Blockchain Explorer View

Code Architecture

Frontend Architecture

Data Flow Architecture

Security Architecture

Quick Setup

Option 1: Use Live App (Recommended)

Option 2: Local Development

1. Prerequisites

2. Installation

3. Environment Setup

4. Database Setup

5. Start Application

Tech Stack

Key Configuration Files

Core Features

File Operations

Organization

Emergency Access

User Experience

Security Features

API Reference

Core Hooks

useFileManager

useFileUpload

useFileSharing

Utility Functions

Encryption

File Operations

Contact & Support

Deployment

Frontend Deployment

Smart Contract Deployment

Important Notes

License

💡 The Solution — BLAULT

⚙️ How It Works

🧱 System Overview

📂 Project Structure

🔐 Environment Setup

⚡ Supabase Setup

⚡ Smart Contract

Features:

💻 Local Setup

🧩 Encryption Process

💬 FAQ

🎥 Walkthrough Demo

🧭 Pitch Deck

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Contributors 2

Packages