Rollups (Optimistic vs ZK) in Blockchain / Solidity

Introduction

Rollups help blockchains handle more transactions quickly and cheaply by doing work outside the main chain. They keep the main chain safe while making things faster.

When you want to make blockchain transactions faster and cheaper.

When you need to keep blockchain data secure but reduce the load on the main chain.

When building apps that need quick confirmation but still trust the main blockchain.

When you want to save money on transaction fees but keep security.

When scaling blockchain games or finance apps that need many transactions.

Syntax

Blockchain / Solidity

Optimistic Rollup:
- Assumes transactions are correct.
- Waits for a challenge period to check for fraud.

ZK Rollup:
- Uses math proofs (zero-knowledge proofs) to prove transactions are correct immediately.
- No waiting period needed.

Optimistic rollups trust transactions first, then check later.

ZK rollups prove correctness upfront using special math.

Examples

This shows how optimistic rollups wait before finalizing to catch fraud.

Blockchain / Solidity

Optimistic Rollup Example:
User sends transaction -> Rollup batches it -> Posts batch to main chain -> Waits 1 week for challenges -> If no fraud, batch final.

ZK rollups use proofs to finalize transactions right away.

Blockchain / Solidity

ZK Rollup Example:
User sends transaction -> Rollup batches it -> Generates zero-knowledge proof -> Posts proof and batch to main chain -> Final immediately.

Sample Program

This simple program shows how optimistic rollups wait before finalizing, while ZK rollups finalize immediately using proofs.

Blockchain / Solidity

class Rollup:
    def __init__(self, type):
        self.type = type

    def process_batch(self, batch):
        if self.type == 'optimistic':
            return self.optimistic_process(batch)
        elif self.type == 'zk':
            return self.zk_process(batch)

    def optimistic_process(self, batch):
        # Assume batch is correct
        print(f"Batch posted: {batch}")
        print("Waiting for challenge period...")
        # Simulate no fraud found
        print("No fraud found. Batch finalized.")

    def zk_process(self, batch):
        print(f"Batch posted: {batch}")
        print("Generating zero-knowledge proof...")
        print("Proof verified. Batch finalized immediately.")

# Example usage
optimistic = Rollup('optimistic')
zk = Rollup('zk')

print("Optimistic Rollup:")
optimistic.process_batch('TxBatch1')

print("\nZK Rollup:")
zk.process_batch('TxBatch2')

Important Notes

Optimistic rollups have a delay to catch fraud but can handle complex transactions easily.

ZK rollups finalize fast but creating proofs can be complex and costly for some transactions.

Both help blockchains scale but choose based on your app's needs for speed, cost, and complexity.

Summary

Rollups move work off the main blockchain to make it faster and cheaper.

Optimistic rollups trust first, check later with a waiting period.

ZK rollups prove correctness immediately using zero-knowledge proofs.