Sovseal(Lockdrop)

Send media messages to the future, guaranteed by math, not corporations.

Comment

Inspiration

Imagine recording a message for your child to receive on their 18th birthday. Or leaving final words for loved ones. Or preserving family stories for future generations. These are the most intimate, precious moments of our lives.

Now imagine that message being:

  • Sold to AI training companies without your consent
  • Analyzed by algorithms to build psychological profiles
  • Accessed by corporations for targeted advertising
  • Seized by governments through legal orders
  • Lost forever when the company shuts down

This is the reality of centralized digital storage in the age of AI.

We're living through a gold rush where our most personal data - our voices, our faces, our stories - is being harvested to train AI models worth billions. Companies promise privacy, but their terms of service tell a different story. Your "private" messages become training data. Your memories become commodities.

I asked myself: What if we could send messages to the future where even I, the developer, cannot access them? Where no company can sell them? Where no AI can train on them?

This question led me down a rabbit hole of cryptography, blockchain consensus, and decentralized storage. The answer became Lockdrop - where your privacy is guaranteed by mathematics, not corporate policies.

The Math is Simple:

  • Want to decrypt early? Break AES-256 encryption (computationally impossible - would take 3.67 × 10^51 years)
  • Want to change the unlock time? Control 51% of Polkadot's validator stake (economically impossible)
  • Want to delete the message? Rewrite blockchain history (consensus makes this infeasible)

The Vision is Profound: In a world where AI companies scrape everything, where privacy is a marketing term, where your data is the product - Lockdrop offers something radical: true digital sovereignty. Your messages. Your timeline. Your control. Guaranteed by mathematics, not corporate promises.

The tagline "Guaranteed by math, not corporations" isn't just clever - it's a manifesto for the future of private communication.

What it does

Lockdrop lets you create time-locked audio/video messages with mathematical privacy guarantees.

The Flow:

  1. Record or upload a video message
  2. Set an unlock date (could be years in the future)
  3. Specify a recipient's wallet address
  4. Hit send

What happens behind the scenes:

  • Your browser generates a unique AES-256 key
  • The media is encrypted entirely client-side (never leaves your device as plaintext)
  • Encrypted content goes to IPFS via Storacha Network
  • The encryption key is encrypted with the recipient's public key
  • Metadata (IPFS CIDs, unlock timestamp) is stored on Passet Hub blockchain
  • The blockchain enforces the time-lock through consensus

Privacy Architecture:

Component What It Sees Can It Decrypt?
Your Browser Plaintext (temporarily) ✅ Yes (during creation)
IPFS Nodes Encrypted blob ❌ No (no key)
Blockchain Metadata only ❌ No (no content or keys)
My Servers Nothing ❌ No (I have no servers!)
Recipient Encrypted data ✅ Yes (after unlock time)

Bonus Feature: Recipients without wallets can claim messages using passphrase-protected "redeem packages" - perfect for sending to non-crypto users.

How we built it

Tech Stack:

  • Frontend: Next.js 14 + TypeScript (strict mode) + Tailwind CSS
  • Blockchain: Solidity 0.8.20 on Passet Hub testnet via pallet-revive (PolkaVM)
  • Contract Address: 0xeD0fDD2be363590800F86ec8562Dde951654668F (Passet Hub Testnet)
  • RPC: ethers.js v6 for Ethereum-compatible JSON-RPC
  • Storage: Storacha Network (IPFS with email-based UCAN auth)
  • Crypto: Web Crypto API (AES-256-GCM, RSA-OAEP)
  • Wallets: Talisman & MetaMask via EIP-1193

Key Implementation - Encryption Service:

// lib/crypto/CryptoService.ts
export class CryptoService {
  static async encryptBlob(blob: Blob, key: CryptoKey): Promise<EncryptedData> {
    // Generate random IV (never reused!)
    const iv = crypto.getRandomValues(new Uint8Array(12));

    const plaintext = await blob.arrayBuffer();

    // AES-256-GCM with 128-bit auth tag
    const ciphertext = await crypto.subtle.encrypt(
      { name: 'AES-GCM', iv, tagLength: 128 },
      key,
      plaintext
    );

    return { ciphertext, iv, algorithm: 'AES-GCM', keyLength: 256 };
  }

  // Secure cleanup - overwrite sensitive data
  static secureCleanup(...buffers: (ArrayBuffer | Uint8Array)[]) {
    for (const buffer of buffers) {
      if (!buffer) continue;
      const view = new Uint8Array(buffer);

      // Different strategies for different sizes
      if (view.length > 65536) {
        view.fill(0); // Fast for large files
      } else {
        const random = new Uint8Array(view.length);
        crypto.getRandomValues(random);
        view.set(random); // Secure overwrite for keys
        view.fill(0);
      }
    }
  }
}

Smart Contract on Passet Hub:

// contract/contracts/Lockdrop.sol
function getMessage(uint256 messageId) public view returns (Message memory) {
    require(messageId < messages.length, "Message does not exist");
    Message memory message = messages[messageId];

    // Time-lock enforced by blockchain!
    require(
        block.timestamp >= message.unlockTimestamp,
        "Message is still locked"
    );

    return message;
}

Challenges we ran into

Challenge 1: The RPC Endpoint Mystery

The Problem: Passet Hub has TWO different RPC endpoints and the documentation wasn't clear which to use:

  • wss://testnet-passet-hub.polkadot.io (Substrate RPC)
  • https://testnet-passet-hub-eth-rpc.polkadot.io (Ethereum RPC)

I spent hours trying to deploy with Foundry using the Substrate endpoint:

# This FAILED with "Method not found (-32601)"
forge create --resolc \
  --rpc-url wss://testnet-passet-hub.polkadot.io \
  contracts/Lockdrop.sol:Lockdrop

The Solution: pallet-revive exposes an Ethereum-compatible RPC specifically for Solidity contracts. Once I switched:

# This WORKED!
forge create --resolc \
  --rpc-url https://testnet-passet-hub-eth-rpc.polkadot.io \
  contracts/Lockdrop.sol:Lockdrop

I documented this extensively in docs/RPC_ENDPOINTS.md to save others the pain.

Challenge 2: Address Format Hell

The Problem: Talisman wallet was returning Substrate addresses (starting with 5...) but pallet-revive needs Ethereum addresses (starting with 0x...). This caused:

// Error: address.toLowerCase is not a function
const result = await contract.storeMessage(params, account);
// account was an object, not a string!

The Solution: Complete migration from Polkadot extension API to EIP-1193:

// BEFORE - Returns Substrate addresses
import { web3Accounts } from '@polkadot/extension-dapp';
const accounts = await web3Accounts(); // [{ address: "5Grw..." }]

// AFTER - Returns Ethereum addresses
const addresses = await window.ethereum.request({ 
  method: 'eth_requestAccounts' 
}); // ["0x742d...", "0x8f3a..."]

This broke my entire wallet integration, but the fix made everything simpler and more standard.

Challenge 3: ENS Resolution Nightmare

The Problem: In production (Vercel), I got this error:

Error: network does not support ENS
    at ContractService.getSentMessages

Even though I was passing valid 0x... addresses, ethers.js was trying to resolve them through ENS (Ethereum Name Service), which Passet Hub doesn't support.

The Solution: Two-pronged approach:

// 1. Use staticCall for all read operations
const messages = await contract.getSentMessages.staticCall(address);

// 2. Aggressively remove ENS plugins
const network = new ethers.Network('passet-hub', 420420422);
network.plugins.forEach(plugin => {
  if (plugin.name === 'org.ethers.plugins.network.Ens') {
    network._plugins.delete(plugin.name);
  }
});

const provider = new ethers.JsonRpcProvider(rpcUrl, network, {
  staticNetwork: network
});

This took me 3 deployment cycles to get right!

Challenge 4: Encrypting 100MB Videos in Browser

The Problem: Users want to send video messages, but encrypting large files in-browser is tricky:

  • Memory constraints
  • UI freezing
  • Secure cleanup of sensitive data

The Solution: Chunked cleanup strategy based on buffer size:

static secureCleanup(...buffers) {
  const MAX_RANDOM_BYTES = 65536; // crypto.getRandomValues() limit

  for (const buffer of buffers) {
    const view = new Uint8Array(buffer);

    if (view.length > MAX_RANDOM_BYTES) {
      // Large buffers (videos): fast zero-out
      view.fill(0);
    } else {
      // Small buffers (keys, IVs): secure random overwrite
      crypto.getRandomValues(randomBytes);
      view.set(randomBytes);
      view.fill(0);
    }
  }
}

This balances security (for keys) with performance (for large files).

Challenge 5: Production Error Handling

The Problem: Blockchain and IPFS operations fail in unpredictable ways:

  • Network timeouts
  • RPC endpoint unavailability
  • Transaction failures

The Solution: Exponential backoff with jitter:

// utils/retry.ts
for (let attempt = 1; attempt <= 3; attempt++) {
  try {
    return await operation();
  } catch (error) {
    if (attempt < 3) {
      const baseDelay = 1000 * Math.pow(2, attempt - 1); // 1s, 2s, 4s
      const jitter = Math.random() * 0.3 * baseDelay; // ±30%
      await sleep(baseDelay + jitter);
    }
  }
}

Plus timeout protection on every operation:

await withTimeout(
  provider.getBlockNumber(),
  10000, // 10 second timeout
  'RPC connection'
);

Accomplishments that we're proud of

1. True Zero-Knowledge Architecture

No plaintext ever leaves the user's device. The application literally cannot access user content even if we wanted to. The math protects them, not our promises.

Technical Implementation:

  • All encryption/decryption happens client-side using Web Crypto API
  • AES-256-GCM with unique 96-bit IV per message
  • 128-bit authentication tags prevent tampering
  • IPFS stores only encrypted blobs (meaningless without keys)
  • Smart contract stores only metadata (CIDs, timestamps, addresses)
  • Secure memory cleanup overwrites sensitive data after use

Privacy Guarantees:

// Encryption happens entirely in browser
const key = await CryptoService.generateAESKey();
const encrypted = await CryptoService.encryptBlob(mediaBlob, key);
// Only encrypted data leaves the device
await IPFSService.uploadBlob(encrypted);

2. Production-Ready dApp with Comprehensive Testing

Built with production quality from day one, not as an afterthought.

Test Coverage:

  • 102 automated tests across 6 test suites
  • 68 unit tests covering core cryptographic operations
  • 34 integration tests validating complete workflows
  • Comprehensive manual testing guide for QA
  • All tests passing with 100% success rate

Robust Error Handling:

  • Exponential backoff retry logic (1s → 2s → 4s with ±30% jitter)
  • Timeout protection on all network operations (10s default)
  • User-friendly error messages with recovery suggestions
  • Network resilience with automatic reconnection
  • Graceful degradation when services are unavailable

Code Quality:

// Example: Retry logic with exponential backoff
for (let attempt = 1; attempt <= 3; attempt++) {
  try {
    return await operation();
  } catch (error) {
    if (attempt < 3) {
      const baseDelay = 1000 * Math.pow(2, attempt - 1);
      const jitter = Math.random() * 0.3 * baseDelay;
      await sleep(baseDelay + jitter);
    }
  }
}

3. Solidity on Polkadot via pallet-revive

Successfully deployed Ethereum-compatible Solidity contracts to Polkadot's Passet Hub testnet using pallet-revive (PolkaVM).

Technical Achievement:

  • Solidity 0.8.20 contract compiled to PolkaVM bytecode
  • Ethereum JSON-RPC endpoint for contract interaction
  • Gas-optimized storage with custom errors
  • Event-based indexing for efficient queries

Smart Contract Features:

// Gas-efficient custom errors
error InvalidTimestamp();
error MessageNotFound();

// Indexed events for fast queries
event MessageStored(
    uint64 indexed messageId,
    address indexed sender,
    address indexed recipient,
    uint64 unlockTimestamp
);

Developer Experience:

  • Same deployment commands as Ethereum
  • No need to learn Substrate or Rust
  • Standard ethers.js integration
  • Opens Polkadot to entire Ethereum developer ecosystem

4. Innovative Recipient-Without-Wallet Flow

Solved the cold-start problem: how do you send encrypted messages to people who don't have crypto wallets yet?

Solution: Passphrase-Protected Redeem Packages

// Create package with PBKDF2 (100k iterations)
const redeemPackage = RedeemPackageService.createRedeemPackage(
  encryptedKeyCID,
  encryptedMessageCID,
  messageHash,
  unlockTimestamp,
  senderAddress
);

// Encrypt with passphrase
const encrypted = await RedeemPackageService.encryptRedeemPackage(
  redeemPackage,
  passphrase
);

// Upload to IPFS and generate claim link
const packageCID = await IPFSService.uploadBlob(encrypted);
const claimLink = `${origin}/claim/${packageCID}`;
// Send link + passphrase separately for security

User Experience:

  1. Sender creates message and redeem package
  2. Sender shares claim link via one channel (email/SMS)
  3. Sender shares passphrase via different channel (phone call/Signal)
  4. Recipient visits link, enters passphrase
  5. Recipient sets up wallet when ready
  6. Message automatically appears in their dashboard

Security:

  • PBKDF2 with 100,000 iterations (OWASP recommended)
  • Salt prevents rainbow table attacks
  • Two-factor delivery (link + passphrase)
  • 30-day expiration reduces exposure window

5. Mathematical Security Guarantees

Privacy and unlock conditions enforced by cryptography and blockchain consensus, not corporate policies.

Cryptographic Security:

  • AES-256 brute force time: 2^256 / 10^18 operations/sec ≈ 3.67 × 10^51 years
  • Key space: 115,792,089,237,316,195,423,570,985,008,687,907,853,269,984,665,640,564,039,457,584,007,913,129,639,936 possible keys
  • Authentication: GCM mode provides both confidentiality and integrity
  • IV uniqueness: 96-bit random IV per message (collision probability: 2^-96)

Blockchain Security:

  • Attack cost: >$1 billion to control 51% of Polkadot validator stake
  • Consensus: Unlock times enforced by distributed validators
  • Immutability: Message metadata cannot be altered after submission
  • Transparency: All operations verifiable on-chain

Storage Redundancy:

  • IPFS availability: 99.9999% with 3 replicas (six nines)
  • Calculation: 1 - (1 - 0.99)^3 = 0.999999
  • Decentralization: Content distributed across multiple nodes
  • Content addressing: CIDs ensure data integrity

Real-World Impact:

Time to break AES-256 = 2^256 / (10^18 ops/sec × 31,536,000 sec/year)
                      = 3.67 × 10^51 years
                      = 2.67 × 10^41 times the age of the universe

Your messages are protected by mathematics that will outlast civilizations.

What we learned

1. pallet-revive is a Game-Changer I deployed Solidity to Polkadot using the exact same Foundry commands I'd use for Ethereum. No Substrate. No Rust. Just forge create and it works. This opens Polkadot to the entire Ethereum developer ecosystem.

2. Client-Side Crypto is Hard But Worth It Challenges:

  • Memory management for large files
  • Secure cleanup without performance impact
  • Browser API limitations (65KB limit for crypto.getRandomValues())

Rewards:

  • True privacy (math, not promises)
  • No server-side attack surface
  • Users control their own keys

3. Documentation is Force Multiplication I spent 20+ hours writing docs. That will save the community 100s of hours. Every edge case I hit, I documented. Every error message I deciphered, I explained. This is how we build better ecosystems.

4. Storacha Network is Production-Ready

  • Email-based auth = no API key management nightmare
  • 99.9% availability in my testing
  • 2-3 second uploads for 10MB files
  • CDN-level speeds

5. TypeScript Strict Mode Saves Lives 200+ type errors caught at compile time. ~50 runtime errors prevented. When I refactored the wallet integration, TypeScript caught every single place I needed to update. Worth every extra type annotation.

What's next for Lockdrop

Immediate (December 2025):

  • Production Launch on Polkadot Asset Hub - Deploy to mainnet when REVM goes live (mid-December 2025)
  • Fix remaining ENS issues in edge cases
  • Add WalletConnect for mobile wallets

Short Term (Q1 2026):

  • Leverage Polkadot 2.0 features:
    • 6-second block times for faster message creation
    • Elastic Scaling for handling high transaction volumes
    • XCM integration for cross-parachain messaging
  • Batch message operations
  • Message templates (birthday, anniversary, etc.)
  • CSV import for multiple recipients

Medium Term (Q2 2026):

  • Multi-chain deployment:
    • Ethereum mainnet for maximum reach
    • Moonbeam for immediate Polkadot ecosystem presence
    • Other EVM-compatible parachains (Astar, etc.)
  • Group messages (multiple recipients)
  • Recurring messages (annual, monthly)
  • Arweave integration for permanent storage

Long Term (Q3-Q4 2026):

  • Native iOS/Android apps
  • Enterprise features (team accounts, audit logs)
  • Advanced cryptography (threshold encryption, ZK proofs)
  • Cross-chain messaging protocols via XCM
  • Integration with Polkadot's unified address format

The Vision: Make Lockdrop the standard for digital legacy and time-locked communication. Every important message - wills, family histories, future advice to children - should be protected by mathematics, not corporate promises. In an age where AI companies commodify our most intimate moments, Lockdrop offers a different path: true digital sovereignty where your memories remain yours, forever.

Guaranteed by math, not corporations.

Built With

  • ether-js
  • foundry
  • ipfs
  • metamask
  • next-js
  • pallet-revive
  • passet-hub
  • polkadot
  • react
  • solidity
  • storacha
  • tailwindcss
  • talisman
  • typescript
  • web-crypto-api
Share this project:

Updates