L1 Architecture

Movement L1 is designed as a high-performance, native Move blockchain with a modular architecture that separates concerns while maintaining tight integration for optimal performance. This document covers the high-level system architecture, while detailed implementation of individual node components is covered in the Node-Level Architecture.

Core Layers

The Movement L1 architecture is organized into five core layers, each handling specific aspects of the blockchain system while working together to provide a complete, high-performance platform. This high-level architecture is implemented through individual nodes that follow the same five-layer structure, as detailed in the node-level architecture documentation.

┌─────────────────────────────────────────────────────────────────┐
│                        Movement L1 Network                      │
├─────────────────────────────────────────────────────────────────┤
│  Application Layer                                              │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐                │
│  │    DeFi     │ │    NFTs     │ │ Enterprise  │                │
│  │    DApps    │ │   Games     │ │   Apps      │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
├─────────────────────────────────────────────────────────────────┤
│  1. API Layer                                                   │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐                │
│  │  REST API   │ │ WebSocket   │ │   GraphQL   │                │
│  │  Endpoints  │ │   Events    │ │   Queries   │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
├─────────────────────────────────────────────────────────────────┤
│  2. Execution Layer                                             │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐                │
│  │   MoveVM    │ │ Transaction │ │   State     │                │
│  │  Runtime    │ │  Pipeline   │ │ Management  │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
├─────────────────────────────────────────────────────────────────┤
│  3. Storage Layer                                               │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐                │
│  │   Merkle    │ │   Account   │ │  Transaction│                │
│  │    Trees    │ │    Store    │ │   History   │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
├─────────────────────────────────────────────────────────────────┤
│  4. Consensus Layer                                             │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐                │
│  │   Leader    │ │  Validator  │ │    BFT      │                │
│  │  Selection  │ │   Network   │ │  Consensus  │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
├─────────────────────────────────────────────────────────────────┤
│  5. Network Layer                                               │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐                │
│  │   P2P       │ │  Mempool    │ │  Message    │                │
│  │  Protocol   │ │  Management │ │  Routing    │                │
│  └─────────────┘ └─────────────┘ └─────────────┘                │
└─────────────────────────────────────────────────────────────────┘

1. API Layer

REST API

The REST API provides standard endpoints for common blockchain operations, enabling direct resource queries to Move resources and secure transaction submission for broadcasting. The API supports real-time state inspection and querying capabilities.

WebSocket Events

WebSocket events deliver real-time updates through live transaction and block notifications, featuring selective event filtering for subscription and low latency with minimal delay for event delivery. The system ensures reliable delivery with guaranteed event ordering.

GraphQL Interface

The GraphQL interface enables flexible queries for complex multi-resource operations, providing type-safe query construction through schema definition and supporting efficient data aggregation and computation. The system includes query result caching for performance optimization.

2. Execution Layer

Move Virtual Machine (MoveVM)

The MoveVM provides native execution of Move bytecode, featuring precise gas metering that accounts for instruction, storage, and payload costs. It enforces type safety through Move's static and dynamic safety checks, including resource ownership rules, and ensures sandboxing by isolating transaction execution within the VM environment.

Transaction Pipeline

The transaction pipeline enables parallel processing through Block-STM, which applies dynamic dependency resolution to detect read/write conflicts and order transactions consistently. The system supports speculative execution with optimistic parallel execution, where transactions may be aborted and re-executed as needed, and Block-STM guarantees that transactions are only committed in deterministic order once all prior dependencies are finalized.

State Management

State management maintains a consistent global state view of all account and resource data. It integrates with Block-STM to provide deterministic commit ordering of state changes. For performance, it uses in-memory buffering and caching during execution. Finalized state updates are written through efficient serialization and stored in authenticated data structures, ensuring both persistence and verifiability.

3. Storage Layer

Account Store

The account store implements address-based direct mapping from addresses to account data, providing native storage of Move resources with optimized access patterns for common operations. The system includes state data compression for storage efficiency.

Merkle Trees

Merkle trees provide a cryptographic state root commitment to global state, enabling efficient proof generation for state verification and supporting incremental updates with minimal computation for state changes. The system ensures fast verification of state transitions.

Transaction History

Transaction history maintains a complete ledger with full history of all transactions, featuring efficient indexing for querying by various criteria and optional pruning of historical data for storage optimization. The system provides an immutable audit trail of all state changes.

4. Consensus Layer

Byzantine Fault Tolerant (BFT) Consensus

The BFT consensus mechanism uses a modified HotStuff-based algorithm designed for high throughput, providing safety guarantees that ensure consistency even with up to 1/3 malicious validators. The system maintains liveness by ensuring progress under network asynchrony, while delivering single-slot finality for fast transaction confirmation.

Validator Network

The validator network operates on a proof-of-stake model that enables energy-efficient validation through token staking, featuring a dynamic set where validators can join or leave based on their stake and performance. The system implements regular leader rotation for decentralization and includes slashing mechanisms that impose penalties for malicious or negligent behavior.

Leader Selection

Leader selection employs a deterministic approach with cryptographically verifiable selection that is weighted based on validator stake, ensuring fair distribution and preventing leader monopolization while maintaining efficient operation with minimal computational overhead.

5. Network Layer

Peer-to-Peer Protocol

The peer-to-peer protocol implements a gossip network for efficient information dissemination, featuring automatic peer discovery of network participants and robust connection management with handling and recovery capabilities. The system includes cryptographic message authentication for verification.

Mempool

The mempool manages pending transactions in a transaction pool, implementing priority-based ordering for transaction selection and providing spam protection against malicious transactions. The system includes broadcast optimization for efficient transaction propagation.

Security Architecture

Cryptographic Primitives

The system employs Ed25519 digital signatures for transaction authentication, SHA-3 hash functions for data integrity and commitments, and efficient Merkle proofs for state and transaction verification. The architecture includes verifiable random beacons for leader selection.

Access Control

Access control implements an address-based account model with Move's resource ownership model for asset safety, featuring fine-grained permission systems for management and multi-signature support for transaction authorization.

Network Security

Network security provides DDoS protection against network attacks, implements rate limiting to prevent resource exhaustion, and ensures cryptographic validator authentication for identity verification. The system includes slashing conditions that create economic incentives for honest behavior.

Performance Characteristics

Throughput

The system targets 10,000+ transactions per second with burst capacity for higher throughput during brief periods. Future development includes horizontal scaling through sharding and continuous performance optimization for sustained improvements.

Latency

The system achieves 1-2 second block production with single-block finality and sub-second transaction confirmation. The architecture minimizes network propagation delay for optimal performance.

Storage

Storage management implements bounded state growth through pruning mechanisms, configurable history retention for transaction data, and efficient data compression techniques. The system includes long-term archival solutions for data preservation.

Governance and Upgrades

On-Chain Governance

On-chain governance implements a structured proposal system for governance mechanisms, featuring token-weighted voting on protocol changes and automatic execution of approved proposals. The system includes emergency procedures with fast-track processes for critical issues.

Protocol Upgrades

Protocol upgrades feature coordinated version management for updates, maintaining backward compatibility where possible and providing automated migration tools for existing state. The process includes comprehensive testing before mainnet deployment.