Homomorphic Encryption: Math on Locked Boxes

What Problem Does It Solve?

The Challenge:

Blockchain needs to:
  ✓ Verify transactions (amounts valid)
  ✓ Update balances (addition/subtraction)
  ✓ Ensure no double-spending
  
But WITHOUT revealing:
  ✗ Account balances
  ✗ Transaction amounts
  ✗ Any private information

The Solution: Homomorphic Encryption

• ✅ Math happens on encrypted data
• ✅ No decryption ever required
• ✅ Privacy never broken
• ✅ Blockchain can verify without seeing amounts

The Simple Analogy

You have $500 in a locked safe
Someone sends you $100

Normal way:
  1. Open safe (decrypt) → See $500
  2. Add $100 → Now $600
  3. Lock safe again (encrypt)
  
Problem: When safe is open, anyone can see $500
    Privacy: ❌ Broken

For DERO:

• Balance is always encrypted (safe always locked)
• Math happens on the encrypted number
• Safe never opens
• Blockchain never sees actual balance

How It Works

The Encryption Flow

The Setup:

Private key: x (your secret)
Public key:  P = x × G (everyone can see this)
Generator:   G (elliptic curve point - public constant)

Encrypting an Amount

From Source Code (cryptography/crypto/algebra_elgamal.go):

// Encrypt 100 DERO:
// 1. Pick random number 'r'
// 2. Calculate Left:  L = 100×G + r×P
// 3. Calculate Right: R = r×G
// 4. Ciphertext: E(100) = (L, R)
 
// Result: Looks like random elliptic curve points
// Network cannot determine the amount

The Magic: Homomorphic Operations

Addition & Subtraction on Encrypted Data:

The Math:

E(a) = (L₁, R₁)
E(b) = (L₂, R₂)

Addition:
  E(a) + E(b) = (L₁ + L₂, R₁ + R₂) = E(a + b)
  
Subtraction:
  E(a) - E(b) = (L₁ - L₂, R₁ - R₂) = E(a - b)

The encrypted result is STILL encrypted!
No decryption needed at any step!

Transaction Flow: Alice → Bob

Alice sends 100 DERO to Bob:

What Happens at Each Step

Alice's balance: E(500) = (L_a, R_a)
Bob's balance:   E(200) = (L_b, R_b)
Transfer amount: 100 DERO

Comparison: Traditional vs DERO

Balance Storage

The Difference:

• Bitcoin/Ethereum: Your balance is like your bank statement posted on a billboard
• DERO: Your balance is permanently locked in a safe only you can open

Blockchain Architecture Comparison

DERO = Ethereum's simplicity + Privacy coin encryption 🎯

Real-World Applications

1. Instant Balance Queries

Traditional Privacy Coin:

1. Download entire blockchain
2. Scan all transactions
3. Calculate balance from history
4. Wait minutes to hours

Result: Slow, requires full sync

DERO:

1. Query encrypted balance from node (66 bytes)
2. Decrypt with your private key
3. See balance instantly

Result: Instant, no chain scanning needed

2. Private Token Systems

How It Works:

Key Points:

From Source Code (dvm/dvm_functions.go:80):

// Issue tokens to user
Function IssueAsset() Uint64
    10 SEND_ASSET_TO_ADDRESS(SIGNER(), amount, SCID())  
       // Sends without knowing user's current balance - homomorphic!
End Function

// Result in user's wallet:
User's token balance: E(1000)  ← Encrypted, only user can decrypt
User's DERO balance:  E(500)   ← Also encrypted

Traditional tokens (ERC-20): Balances public in contract
DERO tokens: Balances encrypted in user wallets, transferable peer-to-peer

3. Private DeFi Operations

Swap Example:

Swap 100 DERO for 500 tokens:

  Your DERO:  E(balance_dero) - E(100)
  Your tokens: E(balance_tokens) + E(500)
  
Public sees:
  ✓ Swap contract called
  ✗ How much swapped
  ✗ Who swapped
  ✗ Resulting balances

Technical Implementation

The C and D Commitments

Every DERO transaction contains encrypted commitments:

C Commitment (Pedersen Commitment):

C = amount×G + blinding×H
 
Where:
  amount = Transfer amount (hidden)
  G, H = Generator points (public)
  blinding = Random factor (secret)
  
Properties:
  • Binding: Cannot change amount after creating C
  • Hiding: Cannot determine amount from C
  • Homomorphic: C₁ + C₂ = C(amount₁ + amount₂)

D Commitment (Randomness):

D = r×G
 
Purpose:
  • Provides randomness for ElGamal encryption
  • Prevents amount correlation attacks
  • Enables decryption for intended recipient

Together they enable:

• ✅ Encrypted amounts in transactions
• ✅ Verifiable without revealing amounts
• ✅ Homomorphic balance updates

Source: cryptography/crypto/algebra_elgamal.go - ElGamal encryption implementation

Technical Specifications

Key Takeaways

What Homomorphic Encryption Provides

What It Enables

• ✅ Private Smart Contracts - Impossible on other chains
• ✅ Instant Balance Lookup - No blockchain scanning
• ✅ Encrypted Token Systems - Private token transfers
• ✅ Private DeFi - Encrypted swap operations
• ✅ Account-Based Privacy - First blockchain to achieve this

Related Pages

Privacy Suite:

• Ring Signatures - Transaction anonymity
• Bulletproofs - Zero-knowledge range proofs
• Transaction Privacy - Complete privacy flow
• Payload Proofs - Prove transfers cryptographically

Technical Implementation:

• DERO Tokens - How tokens use homomorphic encryption
• Private Smart Contracts - Contract encrypted balances

Build with Privacy:

• Token Contract - Private token example
• Wallet RPC API - Send private transactions