Data Encoding

📦 Data Encoding in Blockchain: Packing Your Digital Suitcase

Imagine you’re packing a suitcase for a trip. You need to fit toys, clothes, and snacks in a way that everything stays safe and you can find things easily. That’s exactly what data encoding does for blockchain!

🧳 The Story: Why Do We Need Encoding?

Picture this: You and your friend live in different countries. You want to send a LEGO castle you built. But you can’t send the whole castle—it might break! So you:

1. Take it apart piece by piece
2. Write instructions on how to rebuild it
3. Pack it carefully in a box
4. Your friend follows the instructions to rebuild it perfectly!

That’s encoding! We turn complex data into a simple format that can travel safely across the blockchain network.

🔑 The Five Heroes of Blockchain Encoding

graph TD
    A["📦 Data Encoding"] --> B["🔴 RLP"]
    A --> C["🔵 SSZ"]
    A --> D["🟢 ABI"]
    A --> E["🟡 Recursive"]
    A --> F["🟣 Serialization"]

    B --> B1["Ethereum Classic"]
    C --> C1["Ethereum 2.0"]
    D --> D1["Smart Contracts"]
    E --> E1["Nested Data"]
    F --> F1["Storage/Transfer"]

🔴 RLP Encoding (Recursive Length Prefix)

What Is It?

RLP is like a Russian nesting doll 🪆. It wraps data inside data inside data!

The Magic Rule

RLP only knows TWO things:

• Strings (like words: “hello”)
• Lists (like a shopping list: [apple, banana, cherry])

How Does It Work?

Step 1: Single Small Item (0-55 bytes)

"dog" → [0x83, 'd', 'o', 'g']
         ↑
    0x80 + length(3) = 0x83

Step 2: Longer Items (>55 bytes)

First byte tells us HOW MANY bytes
describe the length!

Step 3: Lists

["cat", "dog"] →
[0xc8, 0x83, 'c','a','t', 0x83, 'd','o','g']
 ↑
 0xc0 + total length

Real Example: Encoding a Transaction

Transaction = [nonce, gasPrice, gasLimit, to, value, data]

Let's encode nonce = 1:
→ Single byte: 0x01

Whole transaction gets wrapped in a list!

💡 Why Use RLP?

🔵 SSZ Encoding (Simple Serialize)

What Is It?

SSZ is like organizing your toy drawer with labels! Everything has a fixed spot.

The Big Difference from RLP

• RLP: Variable size (like a stretchy bag)
• SSZ: Fixed size (like boxes that stack perfectly)

Two Types of Data

1. Basic Types (Fixed Size)

uint8   → 1 byte   (0-255)
uint16  → 2 bytes  (0-65,535)
uint64  → 8 bytes  (huge numbers!)
bool    → 1 byte   (true/false)

2. Container Types (Collections)

Vector  → Fixed-length list [🍎🍎🍎🍎🍎]
List    → Variable-length   [🍎🍎🍎...]
Container → Struct with named fields

How SSZ Packs Data

Container: Validator
├── pubkey: bytes48
├── balance: uint64
└── active: bool

Packed as:
[48 bytes][8 bytes][1 byte] = 57 bytes total

Merkle Trees in SSZ

graph TD
    R["🌳 Root Hash"] --> A["Hash A+B"]
    R --> B["Hash C+D"]
    A --> C["Chunk 1"]
    A --> D["Chunk 2"]
    B --> E["Chunk 3"]
    B --> F["Chunk 4"]

SSZ creates Merkle proofs so you can verify parts without the whole thing!

💡 Why Use SSZ?

🟢 ABI Encoding (Application Binary Interface)

What Is It?

ABI is like a menu at a restaurant 🍽️. It tells smart contracts what you want to order!

The Structure

Function Call = Selector + Arguments

transfer(address to, uint256 amount)
    ↓
[4 bytes selector][32 bytes to][32 bytes amount]

Function Selector

selector = first 4 bytes of keccak256("transfer(address,uint256)")
         = 0xa9059cbb

Encoding Rules

Everything gets padded to 32 bytes!

Encoding uint256 value = 100:
0x0000000000000000000000000000000000000000000000000000000000000064
                                                               ↑
                                                      100 in hex = 64

Static vs Dynamic Types

Static (fixed size):

• uint256, address, bool, bytes32

Dynamic (variable size):

• string, bytes, arrays

Dynamic encoding uses OFFSETS:
[offset to data][...other args...][actual data]

Real Example: Calling transfer()

transfer(0x123...abc, 1000)

Encoded:
0xa9059cbb                               // selector
0000000000000000000000000123...abc       // address (32 bytes)
00000000000000000000000000000000...3e8   // 1000 (32 bytes)

💡 Why Use ABI?

🟡 Recursive Encoding

What Is It?

Recursive encoding is like folders inside folders 📁. You can nest things infinitely!

The Concept

graph TD
    A["📦 Main Box"] --> B["📦 Box 1"]
    A --> C["📦 Box 2"]
    B --> D["🎁 Item"]
    B --> E["📦 Tiny Box"]
    E --> F["🎁 Secret Item"]

How It Works

encode(data):
    if data is simple:
        return pack(data)
    if data is list:
        return pack_list([encode(item) for item in data])

Example: Nested Transaction

Transaction {
    inputs: [
        { txid: "abc...", vout: 0 },
        { txid: "def...", vout: 1 }
    ],
    outputs: [
        { address: "0x123", value: 100 }
    ]
}

// Each level gets encoded, then wrapped!

The Power of Recursion

Data: [[1, 2], [3, [4, 5]]]

Encoding Process:
1. Encode [4, 5] → bytes_45
2. Encode [3, bytes_45] → bytes_345
3. Encode [1, 2] → bytes_12
4. Encode [bytes_12, bytes_345] → final_bytes

💡 Why Use Recursive Encoding?

🟣 Serialization Formats

What Is It?

Serialization is turning your 3D LEGO castle into a flat instruction book 📖 that can be stored or sent!

Popular Formats in Blockchain

1. JSON (Human Readable)

{
  "from": "0x123",
  "to": "0x456",
  "value": 100
}

• ✅ Easy to read
• ❌ Large size

2. Protocol Buffers (Protobuf)

message Transaction {
  bytes from = 1;
  bytes to = 2;
  uint64 value = 3;
}

• ✅ Very compact
• ✅ Fast parsing
• ❌ Needs schema

3. MessagePack (Binary JSON)

Compact binary version of JSON
~30% smaller than JSON

4. CBOR (Concise Binary Object)

Like JSON but binary
Self-describing format
Used in many blockchains

Size Comparison

Same data in different formats:

JSON:        {"name":"Alice","age":25}  → 24 bytes
MessagePack: 82 a4 6e 61 6d 65...       → 16 bytes
Protobuf:    0a 05 41 6c 69 63 65...    → 12 bytes

graph LR
    A["Original Data"] --> B{Serialize}
    B --> C["JSON: 24 bytes"]
    B --> D["MsgPack: 16 bytes"]
    B --> E["Protobuf: 12 bytes"]

💡 Why Serialization Matters

🎯 Comparing All Five Methods

🏆 Key Takeaways

1. RLP = Simple packing for Ethereum
2. SSZ = Modern, efficient, with proofs
3. ABI = How we talk to contracts
4. Recursive = Handles nested complexity
5. Serialization = Converting data for storage/transfer

🌟 Remember This!

Encoding is like learning different languages for your data. Each format has its superpower—RLP is simple, SSZ is efficient, ABI is standard, recursive handles complexity, and serialization formats give you choices!

The blockchain doesn’t care about your fancy objects—it only understands bytes. Encoding is the translator! 🎉

Next up: Try the Interactive Lab to see encoding in action! 🚀