Sydra High-Level Architecture

Abstract

This paper presents Nezo Sydra, a novel Layer 2 scaling solution for Ethereum that combines zkEVM technology with a Delegated Proof of Stake (DPoS) consensus mechanism. We introduce a multi-tiered node architecture secured by NFT licensing and token staking, enabling high throughput while maintaining security and decentralization. Our implementation achieves high transaction speeds while preserving Ethereum's security guarantees through zero-knowledge proofs. The system's unique delegation mechanism and economic model promote community participation while ensuring network stability and security.

Introduction

Ethereum's scalability challenges have led to the development of various Layer 2 solutions. While existing solutions address throughput limitations, they often sacrifice decentralization or introduce complex trust assumptions. Nezo Sydra addresses these challenges through a novel combination of zkEVM technology and DPoS consensus, enhanced by a tiered node architecture and delegation system.

Background

Layer 2 scaling solutions have emerged as a primary approach to addressing blockchain scalability limitations. Zero-knowledge proofs, particularly in zkEVM implementations, have shown promise in maintaining security while improving throughput. However, existing solutions often face challenges in balancing decentralization with performance.

System Architecture

A. Node Hierarchy

The system implements a three-tiered node architecture:

1. Light Node Validators

   • Minimum self-stake: 2,000 NEZO

   • Maximum delegation cap: 100,000 NEZO

   • Primary responsibilities: Transaction propagation and network monitoring

2. Full Node Validators

   • Minimum self-stake: 5,000 NEZO

   • Maximum delegation cap: 250,000 NEZO

   • Primary responsibilities: Data availability and state verification

3. Sequencer Validators

   • Minimum self-stake: 20,000 NEZO

   • Maximum delegation cap: 500,000 NEZO

   • Primary responsibilities: Block production and proof generation

Overview

Key Components

• Sequencers: Responsible for ordering transactions, updating the L2 state, generating zk-proofs, and submitting proofs to Ethereum Layer 1 (L1).

• Light Nodes: Handle transaction propagation, initial validation, network monitoring, and provide JSON-RPC endpoints.

• Full Nodes: Perform all functions of Light Nodes and additionally handle full data availability by storing the entire blockchain data.

• Bridges: Facilitate asset transfers between L2 and L1.

• Node Licenses (NFTs): Digital licenses required to operate a node, available in tiered levels.

• Staking Mechanism: Operators must stake Nezo Tokens to run a node, aligning incentives and securing the network.

Node Types

• Light Nodes: Low-resource nodes focused on network participation and basic functionalities.

• Full Nodes: High-resource nodes storing full blockchain data, ensuring data availability and integrity.

Tiered Node Licenses and Staking

Node License (NFT):

• Purpose: Grants the holder the right to operate a node.

• Tiers: Ranging from Tier 1 to Tier 5, with varying levels of privileges and rewards.

• Acquisition: Purchased from the network foundation or authorized marketplaces.

Staking Requirements:

• Minimum Stake: 2,000 Nezo Tokens per node.

• Lock-up Period: Tokens must be staked for at least 1 month.

• Community Staking Pools: Nodes can accept delegation staking from other community members.

• Operators Incentives: Operators earn rewards proportional to their stake and node performance.

Nodes Structure

Light Nodes

Responsibilities:

• Transaction Propagation and Mempool Management

• • Receive transactions from users via JSON-RPC endpoints.

  • Validate and propagate transactions to peers and sequencers.

• Initial Transaction Validation

• • Verify signatures, nonces, and balances.

• Network Monitoring and Censorship Resistance

• • Detect and report anomalies or malicious activities.

• Provide JSON-RPC Endpoints

• • Offer standard Ethereum JSON-RPC methods for wallet and DApp interaction.

Features:

• Low Hardware Requirements

• Easy to Set Up and Operate

• Requires Tiered Node License (NFT) and Staking

Full Nodes

Responsibilities:

• All Light Node Functions

• Data Availability (DA)

• • Store and maintain the entire blockchain data.

  • Ensure full data availability for state reconstruction and verification.

• Enhanced Network Security

• • Provide redundancy and prevent data withholding attacks.

Features:

• Higher Hardware Requirements

• Increased Rewards for Operators

• Requires Higher-Tier Node License (NFT) and Staking

Sequencers

Responsibilities:

• Transaction Ordering

• • Collect and order transactions from the mempool.

• State Updates

• • Execute transactions and update the L2 state.

• zk-Proof Generation

• • Generate zk-proofs for state transitions.

• Submit Proofs to L1

• • Post zk-proofs and state commitments to Ethereum L1 for verification.

Features:

• High-Performance Hardware

• Operated by the Foundation or Trusted Entities

• Subject to Separate Licensing and Staking Agreements

Technical Implementation Overview

Transaction Flow

Step-by-Step Process

1. Transaction Creation in Wallet

2. • User Input: The user initiates a transaction via a wallet or DApp.

   • Signing: The transaction is signed with the user's private key.

3. Transaction Submission

4. • JSON-RPC Call: The wallet sends the signed transaction to a Light Node's JSON-RPC endpoint using eth_sendRawTransaction.

   • Endpoint Connection: The wallet is configured to connect to the Light Node's endpoint.

5. Light Node Processing

6. • Transaction Reception: The Light Node receives the transaction.

   • Validation:

   • • Syntax Check: Ensures the transaction is correctly formatted.

     • Signature Verification: Validates the transaction signature using ECDSA.

     • Nonce Verification: Checks that the nonce is correct to prevent replay attacks.

     • Balance Verification: Confirms the sender has sufficient balance.

   • Mempool Addition: Adds the valid transaction to its local mempool.

   • Propagation: Broadcasts the transaction to peers and Sequencers via the P2P network.

7. Sequencer Processing

8. • Transaction Collection: Sequencers collect transactions from their mempools.

   • Ordering and Execution:

   • • Transaction Ordering: Determines the sequence in which transactions will be processed.

     • State Transition Execution: Applies transactions to the current state to produce a new state.

   • zk-Proof Generation:

   • • Proof Computation: Generates zk-proofs attesting to the validity of the state transitions.

     • Computational Complexity: Requires significant resources, often utilizing GPUs or specialized hardware.

9. State Commitment to L1

10. • Proof Submission: Sequencers submit zk-proofs and state commitments to Ethereum L1 via a smart contract.

    • Verification:

    • • L1 Contract Interaction: The L1 contract verifies the zk-proof.

      • State Update on L1: Updates the canonical chain with the new state commitment.

11. Block Dissemination

12. • Block Propagation: Sequencers propagate the new blocks and proofs back to Light and Full Nodes.

    • State Update: Nodes update their local state based on the new blocks.

13. Confirmation to User

14. • Transaction Receipt: The user's wallet queries the transaction status using eth_getTransactionReceipt.

    • State Query: Wallet updates balances and state via JSON-RPC methods.

Running a Node Flow

Prerequisites for Both Node Types

1. Obtain Node License (NFT)

• Purchase: Acquire the appropriate tiered node license (NFT) from the foundation.

• Registration: Register the NFT with the network to activate node operation rights.

1. Stake Nezo Tokens

• Minimum Stake: Lock up at least 2,000 Nezo Tokens in the staking smart contract.

• Lock-up Period: Agree to the 1-month staking period.

• Community Staking (Optional): Accept additional stakes from other community members to increase rewards.

Light Node Setup

1. Installation

• Download Software: Obtain the Light Node software from the official repository.

• Installation Wizard: Use the installer to set up the node on the desired platform.

1. Configuration

• Network Settings: Configure network parameters, such as P2P ports and JSON-RPC endpoints.

• License Activation: Input the node license NFT details.

• Staking Confirmation: Verify that the staking requirements are met.

1. Synchronization

• Connect to Peers: Establish connections with other nodes in the network.

• Initial Sync: Download necessary state data to begin operation.

1. Operation

• Start Node: Run the node software.

• Monitoring: Use provided dashboards or CLI tools to monitor node status.

• Earning Rewards: Begin earning rewards proportional to stake and node performance.

Full Node Setup

1. Installation

• Download Software: Obtain the Full Node software.

• Hardware Preparation: Ensure hardware meets the higher requirements (storage, CPU, RAM).

1. Configuration

• Data Storage Settings: Configure storage paths and data retention policies.

• License Activation: Input the higher-tier node license NFT details.

• Staking Confirmation: Verify that the staking requirements are met.

1. Synchronization

• Full Data Download: Begin downloading the entire blockchain data.

• Data Verification: Validate data integrity during synchronization.

1. Operation

• Start Node: Run the node software.

• Data Availability Contribution: Store and serve full blockchain data to the network.

• Monitoring: Use tools to track node performance and data storage status.

• Earning Rewards: Earn higher rewards due to additional responsibilities.

Bridging Flow Between L2 and L1

L2 to L1 (Withdrawal)

1. Initiate Withdrawal

2. • User Action: The user requests to withdraw assets from L2 to L1 via a wallet or DApp.

   • Transaction Creation: A withdrawal transaction is created on L2.

3. Transaction Processing

4. • L2 Execution:

   • • State Update: The user's balance on L2 is debited.

     • Withdrawal Commitment: The withdrawal request is included in the state commitment.

   • zk-Proof Generation: A zk-proof including the withdrawal is generated by the Sequencer.

5. Proof Submission to L1

6. • L1 Contract Interaction: The Sequencer submits the zk-proof to the L1 bridge contract.

   • Verification:

   • • Proof Verification: L1 verifies the zk-proof using the on-chain verifier.

     • Withdrawal Queue Update: The withdrawal is added to the queue for processing.

7. Challenge Period (If Applicable)

8. • Security Mechanism: A period during which challenges to the proof can be made.

   • Resolution: If no challenges or all challenges are resolved, proceed to asset release.

9. Asset Release on L1

10. • L1 State Update: The L1 bridge contract releases the assets to the user's L1 address.

    • Event Emission: An event is emitted indicating successful withdrawal.

L1 to L2 (Deposit)

1. Initiate Deposit

2. • User Action: The user sends assets to the L1 bridge contract with the intention to deposit to L2.

   • Transaction Submission: The deposit transaction is sent on L1.

3. L1 Contract Processing

4. • Event Emission: The L1 bridge contract emits an event indicating a deposit, including details like amount and recipient.

5. L2 Acknowledgment

6. • Event Listening: The Sequencer monitors L1 for deposit events.

   • Inclusion in L2 Block:

   • • Transaction Creation: A corresponding deposit transaction is created on L2.

     • State Update: The user's balance on L2 is credited.

7. zk-Proof Generation

8. • Proof Computation: The state change is included in the next zk-proof.

   • Submission to L1: The proof is submitted to confirm the inclusion.

9. Confirmation to User

10. • Wallet Update: The user's wallet reflects the updated balance on L2.

Transaction Receipt: The user can verify the deposit via transaction receipts.

Stay tuned for further updates and insights from our ongoing work. Follow us