MIP-92: Move Stack

  • Description: This document defines the Move Stack and its components such as the Movement SDK.
  • Authors: Andreas Penzkofer
  • Desiderata: MD-91

Abstract

The Move Stack and its components, such as Movement SDK, are core foundational components for Movement technologies. The Move Stack provides a structured categorization of software components, one example of which is the Movement SDK.

Motivation

The Move Stack’s definition and its components, such as the Movement SDK, address key challenges outlined in MD-91 to improve the developer experience and standardize Movement technologies. By aligning with these goals, this MIP aims to:

D1: Standardization: Provide a well-documented stack with clear categorization of components to standardize the language and interfaces for Movement technologies.

D2.1: Accessibility: Enable developers to easily locate and understand relevant components through structured categorization and intuitive organization.

D2.2: Alignment: Establish consistent terminology and documentation to create a unified understanding across the ecosystem.

D3: Visualization: Offer visual representations to help developers quickly grasp the structure and relationships within the Move Stack.

D4: Clarity: Clearly define the scope and relationships between the Move Stack and the Movement SDK, reducing ambiguity and confusion about their roles.

Specification

The Move Stack is the set of all software components and tools. It is, in effect, a dependency for all Movement Labs’ networks and dApps.

The Move Stack is organized into first-order and second-order categories:

flowchart TD
  direction TB

  linkStyle default stroke:white,stroke-width:0;

  classDef titleStyle font-size:18px,font-weight:bold;

  subgraph Move_Stack["Move Stack"]
    direction TB
    style Move_Stack fill:#f0f8ff,stroke:#000,stroke-width:2;

    Movement_SDK["Movement SDK"]:::titleStyle
    style Movement_SDK fill:#d1e7dd,stroke:#000;

    Move_Stack_Core["Move Stack Core (protocol units)"]:::titleStyle
    style Move_Stack_Core fill:#cff4fc,stroke:#000;

    Move_Stack_Binder["Move Stack Binder (protocol units)"]:::titleStyle
    style Move_Stack_Binder fill:#ffe5d9,stroke:#000;

    Services["Services"]:::titleStyle
    style Services fill:#fff3cd,stroke:#000;

    Clients["Clients"]:::titleStyle
    style Clients fill:#f8d7da,stroke:#000;

    Movement_SDK --> Move_Stack_Core
    Move_Stack_Core --> Move_Stack_Binder
    Move_Stack_Binder --> Services
    Services --> Clients

    subgraph Movement_SDK["Movement SDK"]
      direction TB
      style Movement_SDK fill:#d1e7dd,stroke:#000;

      CLI["CLI"]
      Network_Builder_SDK["Network Builder SDK"]
      dApp_Builder_SDK["dApp Builder SDK"]
      Infrastructure_Tooling["Infrastructure Tooling"]
      Smart_Contract_Frameworks["Smart Contract Frameworks"]
      Software_Analysis["Software Analysis"]
    end

    subgraph Move_Stack_Core["Move Stack Core (protocol units)"]
      direction TB
      style Move_Stack_Core fill:#cff4fc,stroke:#000;

      Cryptography["Cryptography"]
      Proving["Proving"]
      Governance["Governance"]
      Ledger["Ledger"]
      Storage["Storage"]
      Settlement["Settlement"]
      Compiler["Compiler"]
      Execution["Execution"]
    end

    subgraph Move_Stack_Binder["Move Stack Binder (protocol units)"]
      direction TB
      style Move_Stack_Binder fill:#ffe5d9,stroke:#000;

      Consensus["Consensus"]
      Mempool["Mempool"]
      Data_Availability["Data Availability (DA)"]
      Networking["Networking"]
      Shared_Sequencers["Shared Sequencers"]
      Censorship["Censorship"]
    end

    subgraph Services["Services"]
      direction TB
      style Services fill:#fff3cd,stroke:#000;

      L1["L1"]
      L2["L2"]
      Provers["Provers"]
      Messaging["Messaging"]
      Data_Analytics_Services["Data and Analytics"]
      Modality["Modality"]
    end

    subgraph Clients["Clients"]
      direction TB
      style Clients fill:#f8d7da,stroke:#000;

      L1_Clients["L1"]
      L2_Clients["L2"]
      Provers_Clients["Provers"]
      Messaging_Clients["Messaging"]
      Data_Analytics_Clients["Data and Analytics"]
      Third_Party["Third-Party"]
    end
  end


First-Order Categories

  1. Movement SDK: Tools for interacting with Movement technologies and its deployment. For more, see Section Movement SDK.
  2. Move Stack Core (protocol units): Core components required for the operation of a Move-based Chain, as well as principal components.
  3. Move Stack Binder (protocol units): Components to which the Move-based chains can connect and that provide a greater environment for the chains to operate in. Such as cross-chain communication, FFS Validators, and decentralized shared sequencing:
  4. Services: Modular components providing network or dApp remote APIs.
  5. Clients: Interfaces for low-level interaction and components providing network or dApp remote APIs.

Second-Order Categories

!!! warning The following categories are not exhaustive and are subject to change.

Each first-order category is further categorized into second-order categories:

Movement SDK

  1. CLI: Command-line interfaces.
  2. Network Builder SDK: Tools for network development.
  3. dApp Builder SDK: Tools for building dApps.
  4. Infrastructure Tooling: Deployment and monitoring tools.
  5. Smart Contract Frameworks: Frameworks for staking and governance.
  6. Software Analysis: Tools for formal verification and analysis (e.g., Move Prover).

Move Stack Core (protocol units) For a code example, see movementlabsxyz/movement/protocol-units.

  1. Cryptography: Cryptographic functions (e.g., hash functions, encryption).
  2. Proving: Proving systems (e.g., ZK-SNARKs).
  3. Governance: Mechanisms for network governance (e.g., RunningVote).
  4. Ledger: Tools for ledger operations, state transitions, and state management.
  5. Storage: State storage solutions (e.g., TrailerPark).
  6. Settlement: Settlement mechanisms (e.g., R0M ETH Settlement).
  7. Compiler: Smart contract compilers for the Move language (e.g., Move LLVM).
  8. Execution: Virtual machines and block executors (e.g., Aptos Block Executor).

Move Stack Binder (protocol units) For a code example, see movementlabsxyz/movement/protocol-units.

  1. Consensus: Components for consensus mechanisms (e.g., HotStuff).
  2. Mempool: Transaction memory pools (e.g., JellyRoll).
  3. Data Availability (DA): Proofs and layers for data availability (e.g., SOV Labs DA).
  4. Networking: Networking utilities (e.g., MovePackets).
  5. Shared Sequencers: Components enabling shared sequencing of transactions.
  6. Censorship: Components addressing transaction censorship.

Services

  1. L1: Core network services (e.g., block producers).
  2. L2: Layer 2 services (e.g., rollup validators).
  3. Provers: Proving system services.
  4. Messaging: Cross-ledger messaging services (e.g., Hyperlane Aptos).
  5. Data and Analytics: Indexing services (e.g., M1 Indexer Service).
  6. Modality: Services enabling different modes (e.g., light clients).

Clients

  1. L1: Core network clients.
  2. L2: Layer 2 clients.
  3. Provers: Clients for proving systems.
  4. Messaging: Messaging clients.
  5. Data and Analytics: Indexer clients.
  6. Third-Party: Bespoke clients for external integrations.

Movement SDK

The Movement SDK provides:

  1. A unified interface for interacting with Movement technologies.
  2. A curated toolkit for developers to deploy networks and dApps.

The SDK includes smaller, specialized SDKs that offer ergonomic tools for:

  • Command-line operations.
  • Network and dApp development.
  • Infrastructure deployment and observability.

Reference Implementation

For the reference implementation of the Move Stack refer to the Movement GitHub repository.

Verification

Changelog

Appendix

A1 RFC-1

RFC-1 in RFCs is an initial document that outlines the components of the Move Stack and Movement SDK. It provides a detailed enumeration of components, their aliases, and purposes.

Copyright and related rights waived via CC0.