MystenLabs/sui

This system is the core infrastructure for the Sui blockchain, encompassing the consensus engine, execution layer, and networking stack. It provides cross-chain interoperability through a native bridge connecting Sui and EVM chains, alongside a decentralized exchange framework. The codebase also includes comprehensive tooling for indexing blockchain data, benchmarking performance, and managing the Move smart contract framework.

156 changes.

This period focused on migrating the Sui framework and Move tooling to the Move 2024 edition, introducing new core modules and protocol configuration systems. It also involved a comprehensive overhaul of the development environment, CI automation, and networking stack, including the adoption of the anemo RPC framework and the removal of legacy FastPay components.

107 changes.

This period focused on building the Sui Native Bridge, including Move and EVM contracts, CLI tools, and a dedicated indexer for cross-chain token transfers. Simultaneously, the team developed the sui-indexer-alt framework, introducing a new gRPC-based architecture, PostgreSQL storage, and GraphQL APIs to replace legacy indexing systems.

33 changes.

This period focused on overhauling the analytics indexing pipeline with the new Alt Framework and introducing bitmap-based query engines for efficient data retrieval. Simultaneously, the codebase established robust historical execution support by isolating protocol versions v0 through v3 into dedicated adapters, enabling accurate backtesting and legacy state processing.

The \language-benchmarks\ crate now provides a comprehensive benchmarking suite for the Move language and VM, powered by the Criterion framework. This includes Rust utilities to compile Move source files, set up an in-memory VM with the standard library, and execute benchmark functions (identified by the \bench\_\ prefix). The suite covers performance characteristics of arithmetic, memory allocation, control flow, native functions, vectors, structs, generics, enums, and deep call stacks. It also introduces specific benchmarks for interpreter step overhead to validate tracing optimizations, and benchmarks comparing cross-package call dispatch performance between regular packages and pinned system packages.

external-crates/move/crates/language-benchmarks · high confidence

This change introduces new Move modules in the \bridge/move/tokens\ directory to define bridged versions of Bitcoin (BTC), Ethereum (ETH), USD Coin (USDC), Tether (USDT), and a mock token (KA). Each module initializes a new Sui Coin type with specific decimal precision (8 for BTC/ETH, 6 for USDC/USDT, 9 for KA) and transfers the treasury capability to the sender, establishing the foundational token structures for the Sui native bridge.

bridge/move · high confidence

The move-vm-profiler crate now includes a new \trace\_converter\ module that converts Move execution traces into the speedscope gas profile format. This allows users to visualize gas usage in profiling tools by transforming raw trace events (such as frame opens/closes and instruction gas costs) into structured speedscope-compatible JSON profiles.

external-crates/move/crates/move-vm-profiler · high confidence

A new nuspec file has been added to define the Chocolatey package for the Sui binary. This file configures the package metadata, including the package ID, versioning, and project URLs, and specifies the file structure for distribution, ensuring that the main executable, license, and verification files are correctly included in the package.

chocolatey · high confidence

A new Rust-based command-line interface has been added to the \examples/tic-tac-toe/cli\ directory, enabling users to interact with on-chain tic-tac-toe games. The tool supports creating new games (both shared and multi-sig variants), making moves, viewing game states, and deleting finished games. It connects to the Sui network using the local wallet configuration and handles game logic such as turn management, board rendering, and winner detection.

examples/tic-tac-toe/cli · high confidence

The \examples/tic-tac-toe/ui\ directory now contains a complete React frontend for a Tic-Tac-Toe game on Sui. Users can create games in two modes: 'Shared' (single transaction per move via consensus) and 'Multi-sig' (two fast-path transactions per move using a 1-of-2 multi-sig address). The UI includes components for the game board, move validation, and object ID management, and supports network configuration for localnet, devnet, testnet, and mainnet.

examples/tic-tac-toe/ui · high confidence

The \examples/rust/basic-sui-indexer\ directory now contains a complete, runnable example of a custom Sui indexer. This example demonstrates how to use the \sui\_indexer\_alt\_framework\ to build a sequential pipeline that processes checkpoints, extracts transaction digests, and stores them in a PostgreSQL database using Diesel for schema management and migrations. It serves as a reference implementation for users looking to create their own custom indexers.

examples/rust/basic-sui-indexer · high confidence

The analytics indexer now supports writing checkpoint data to both CSV and Parquet formats in memory. The new CsvWriter serializes rows using pipe-delimited fields with proper escaping, while the ParquetWriter dynamically infers column schemas from the first row and writes compressed (Snappy) Arrow RecordBatches to an in-memory buffer. These writers are exposed via the writers module and can be used to export analytics data without immediate disk I/O.

crates/sui-analytics-indexer/src/writers · high confidence

The sui-tool now includes a new \db-shell\ command that provides an interactive shell for navigating the validator database. It supports two operating modes: direct mode, which opens RocksDB files directly (requiring the node to be stopped), and proxy mode, which delegates operations to the running sui-node admin API. The shell exposes a virtual filesystem with commands like \ls\, \cat\, \dbg\, and \bcs\ to inspect checkpoints, transactions, epochs, and consensus commits, and includes tab completion for easier navigation.

crates/sui-tool · high confidence

Introduces a new boilerplate crate that provides a ready-to-use template for building services. It sets up an Axum-based HTTP server with integrated Prometheus metrics collection and tracing, including a sample route and application state structure to help developers quickly start new projects.

crates/mysten-service-boilerplate · high confidence

A new \consensus/types\ crate has been introduced to house data structures shared between Sui and the Consensus layer, ensuring minimal dependencies. This location specifically provides the foundational types for consensus blocks, including \BlockRef\ for uniquely identifying verified blocks by round, author, and digest, as well as \BlockDigest\ for block signatures. It also defines type aliases for round numbers, timestamps, and transaction indices, including a reserved index for ping transactions.

consensus/types · high confidence

A new demo application has been added to the \dapps/sponsored-transactions\ directory that demonstrates how to implement sponsored transactions on the Sui testnet. The app provides a user interface to connect a wallet, build a transaction, and then use a simulated backend service to sponsor the gas fees. It walks through the full lifecycle: sponsoring the transaction bytes, signing with the user's key, and executing the transaction on-chain with both signatures.

dapps/sponsored-transactions · high confidence

Introduces a new CLI tool that generates and manages bytecode snapshots of system packages (MoveStdLib, Sui Framework, Sui System, Deepbook, and Bridge) for each protocol version. The tool writes serialized package data into versioned directories and maintains a manifest file mapping protocol versions to package metadata and git revisions, enabling the Sui binary to load pre-compiled framework bytecode for specific protocol versions.

crates/sui-framework-snapshot/src · high confidence

A new standalone binary, \anemo-benchmark\, is introduced to measure Anemo network performance. It supports both server and client modes, allowing users to configure connection addresses, request concurrency, payload sizes, and socket buffer limits via command-line flags. The tool generates synthetic traffic by uploading and downloading bytes to benchmark throughput and latency.

crates/anemo-benchmark · high confidence

Added example code for DeepBook margin and spot trading, including client setup, order placement, collateral management, and risk monitoring.

examples/deepbook-margin, examples/deepbook-spot · high confidence

This change introduces two new Foundry scripts in the bridge EVM directory to manage the lifecycle of the bridge contracts. The \deploy\_bridge.s.sol\ script automates the deployment of the core bridge infrastructure (Committee, Config, Vault, Limiter) by reading configuration from JSON files, including support for local network mock tokens (WETH, WBTC, USDC, USDT, KA) and specific token metadata like Sui decimals. The \upgrade\_bridge\_v2.s.sol\ script provides a validated path to upgrade the SuiBridge implementation to SuiBridgeV2, outputting the necessary governance action details and nonce information for committee signature collection.

bridge/evm/script · high confidence

The analytics indexer's store implementation has been expanded to support two distinct operational modes for writing checkpoint data to object storage. In live mode, the indexer derives watermarks by scanning file names in the bucket, allowing it to track progress without maintaining separate watermark files. In migration mode, the indexer uses explicit watermark files and conditional PUT operations to safely rewrite existing data files, such as adding new columns to Parquet files. This change introduces the \LiveStore\ and \MigrationStore\ implementations, along with an asynchronous upload worker that handles serialization and uploading with backpressure and retry logic.

crates/sui-analytics-indexer/src/store · high confidence

The \sui-kv-rpc\ crate now provides a new archival read service backed by Google BigTable, exposing the \LedgerService\ and \MovePackageService\ gRPC endpoints. This service implements a configurable, multi-stage read pipeline (for transactions, objects, checkpoints, and digests) with request-scoped concurrency limiting, bitmap scan budgets, and an object cache to deduplicate in-flight fetches. Operators can tune per-endpoint limits, timeouts, and stage-specific chunk sizes via a TOML configuration file, while deprecated CLI flags for connection pooling and watermarks are retained for migration but now log warnings.

crates/sui-kv-rpc · high confidence

The benchmarking tool now automatically merges multiple gas coins into a single primary coin at startup to prevent fragmentation exhaustion during long-running sessions, and introduces a new \BenchmarkBank\ component to manage gas generation and workload initialization. Additionally, the framework adds support for party objects via new Move modules and workload data, allowing benchmarks to test transactions involving single-owner party objects.

crates/sui-benchmark/src · high confidence

The bridge server now supports signing governance actions (such as emergency pauses, limit updates, and committee blocklist changes) in addition to standard token transfers. This is enabled by a new \GovernanceVerifier\ component that validates incoming governance actions against a pre-approved list, and a \BridgeRequestHandler\ that routes these requests through the verification logic before signing. The server exposes new HTTP endpoints for these governance actions (e.g., \/sign/emergency\_button\, \/sign/update\_limit\) alongside existing bridge transaction signing paths, and includes a mock handler for testing these new capabilities.

crates/sui-bridge/src/server · high confidence

This change introduces the DeepBook V2 framework, a decentralized central limit order book (CLOB) for the Sui ecosystem. The package includes the core \clob\_v2\ module for managing pools, orders, and matching logic, alongside \custodian\_v2\ for handling asset balances and account capabilities, and \critbit\ for efficient order book data structures. It also provides \order\_query\ for paginated retrieval of open bids and asks. The original DeepBook V1 implementation is present but deprecated, directing users to V3 for new account creation and pool management.

crates/sui-framework/packages/deepbook · high confidence

The sui-execution/historical-versions/v0/sui-adapter module has been added to provide a self-contained execution environment for historical protocol version 0. This adapter implements the core transaction execution engine, including gas charging and metering, bytecode verification, and the handling of programmable transactions. It defines specific execution modes (Normal, Genesis, System) to control access restrictions and visibility bypasses, and includes logic to substitute package IDs and manage object lifecycles during execution. This change isolates the v0 execution logic, allowing the system to process transactions according to the rules and behaviors defined in that specific historical version.

sui-execution/historical-versions/v0/sui-adapter · high confidence

New adapter implementations for historical execution versions v1 and v2 have been added to the sui-execution module. These versions isolate the Move VM configuration, transaction execution engine, gas charging and metering logic, and programmable transaction handling for their respective protocol eras, ensuring that legacy execution behaviors are preserved and correctly applied when processing historical data.

sui-execution/historical-versions/v1/sui-adapter, sui-execution/historical-versions/v2/sui-adapter · high confidence

This change introduces the core Solidity contracts for the SuiBridge on EVM chains, establishing the foundational infrastructure for cross-chain token transfers. The suite includes SuiBridge and its V2 variant for handling token deposits and claims, BridgeCommittee for validator signature verification and governance, BridgeConfig for managing supported tokens and chain IDs, BridgeLimiter for enforcing rolling 24-hour transfer limits, and BridgeVault for secure asset custody and WETH unwrapping. These contracts collectively enable users to deposit ERC20 tokens and ETH to be bridged to Sui, with operations secured by committee signatures and subject to configurable rate limits.

bridge/evm/contracts · high confidence

The \sui-indexer-alt-consistent-api\ crate now exposes a new gRPC service (\ConsistentService\) that allows clients to query consistent historical state. The interface includes RPCs to retrieve the available data range (including checkpoint stride), fetch account balances (single, batch, and paginated lists), and list owned objects with type filtering and pagination. Service configuration details, such as default and maximum page sizes, are also exposed via a dedicated configuration RPC.

crates/sui-indexer-alt-consistent-api · high confidence

This change introduces the \sui-axelar-cgp\ Move package, providing the core infrastructure for the Axelar General Message Passing protocol on the Sui blockchain. It includes the \gateway\ module for processing incoming cross-chain call approvals and validating operator signatures, the \channel\ module which defines \Channel\ objects as destinations for messages and handles the consumption of \ApprovedCall\ hot-potato objects, and the \validators\ module for managing operator sets and proof verification. A JavaScript preset script is also added to generate test data for these Move modules.

crates/sui-axelar-cgp · high confidence

This change introduces the Move language support extension for Visual Studio Code, providing syntax highlighting, auto-completion, go-to-definition, and hover information for Move source files. It includes a bundled move-analyzer binary for advanced IDE features and integrates with the Sui CLI for building and testing Move packages. The extension also supports trace-debugging of Move unit tests, allowing users to step through code execution and inspect variables within the VS Code debugging interface.

external-crates/move/crates/move-analyzer · high confidence

The \move-decompiler\ crate is introduced to generate human-readable Move source code from compiled \.mv\ module files. It implements a full pipeline that translates bytecode into an intermediate AST, applies structural refinements (such as simplifying boolean conditionals, collapsing redundant let-bindings, and deduplicating freeze operations), and renders the result using a pretty-printer that infers mutability annotations and manages module/type aliases. This enables users to reverse-engineer and inspect on-chain Move packages.

external-crates/move/crates/move-decompiler · high confidence

The sui-field-count-derive crate now provides a FieldCount derive macro that automatically implements the FieldCount trait for structs and enums. For structs, it sets the FIELD\_COUNT constant to the number of fields; for enums, it sets it to the number of variants. Unions are not supported and will cause a compile-time panic.

crates/sui-field-count-derive · high confidence

This change adds the \sui-rosetta\ crate, implementing the Mesh API (formerly Rosetta) specification to allow external wallets and services to interact with the Sui network. It provides both an online server (for querying balances, blocks, and submitting transactions) and an offline server (for constructing and signing transactions). The implementation connects to a Sui full node via gRPC, supports account and block lookups, and includes Docker Compose configurations for running the servers locally or against the devnet.

crates/sui-rosetta · high confidence

The Sui framework package has been updated to the Move 2024.beta edition, establishing the new baseline for the framework's Move code. This change introduces a comprehensive set of new core modules that form the foundation for modern Sui development, including \sui::allowance\ for delegated spending with rate limits, \sui::address\_alias\ for managing sender aliases, \sui::accumulator\ and \sui::accumulator\_settlement\ for handling balance accumulations and event streams, and \sui::authenticator\_state\ for zklogin JWK management. It also adds essential utility modules such as \sui::address\ for address conversions, \sui::bag\ for heterogeneous key-value storage, \sui::balance\ for handling coin balances and supplies, \sui::bcs\ for serialization, and \sui::borrow\ for safe object borrowing mechanics. These modules are now available for use in Move 2024 smart contracts.

crates/sui-framework/packages/sui-framework · high confidence

The move-ir-compiler crate is now available, providing both a command-line tool and a Rust library API to compile Move IR source files into bytecode. The CLI accepts .mvir files, supports linking with external dependencies, and automatically runs the bytecode verifier (with a --no-verify flag to skip this step). It also supports generating source maps for debugging. The library exposes a Compiler struct that allows programmatic compilation of Move IR modules, including support for named addresses and optional source map generation.

external-crates/move/crates/move-ir-compiler · high confidence

A new crate, move-ir-to-bytecode-syntax, has been added to provide the lexical and syntactic analysis for the Move Intermediate Representation (MVIR). This component introduces a dedicated lexer that tokenizes MVIR source code, supporting specific tokens such as \mvir\ (to distinguish IR from Move source), \enum\, \const\, and named addresses, alongside standard operators and literals. The accompanying parser implements the MVIR grammar defined in the crate's documentation, handling module declarations, struct and enum definitions, constant declarations, procedure bodies, and transaction scripts. This change establishes the foundational syntax layer required to convert Move IR into bytecode.

external-crates/move/crates/move-ir-to-bytecode-syntax · high confidence

This change introduces the \move-trace-format\ crate, defining the structure and serialization for Move VM execution traces. It establishes a new trace format (version 3) with support for compressed JSON output (.json.zst) and provides a \Tracer\ trait for capturing execution events. The crate includes built-in tracers for different levels of detail—such as \FunctionOnlyTracer\, \InstructionOnlyTracer\, and a \MemoryTracer\ that snapshots VM state—and defines the \SerializableMoveValue\ type to ensure integer sizing is preserved during serialization.

external-crates/move/crates/move-trace-format · high confidence

The \move-bytecode-source-map\ crate has been introduced to provide a structured mapping between Move source code and compiled bytecode. This new component enables developers to generate, store, and retrieve source maps, now including the ability to serialize and deserialize these maps into JSON format for easier integration with debugging and analysis tools. The crate exposes core data structures for mapping functions, structs, and enums, along with utilities for marking specific code locations, enhancing the overall debugging experience for Move smart contracts.

external-crates/move/crates/move-bytecode-source-map · high confidence

Adds a new test-generation crate that automatically generates valid and invalid Move bytecode programs to verify the correctness of the Move bytecode verifier and VM runtime. The tool models the VM's abstract state—including the stack, locals, and borrow graph—to construct control flow graphs and bytecode sequences that satisfy instruction preconditions, then executes these modules to detect verification or runtime errors.

external-crates/move/crates/test-generation · high confidence

The \move-coverage\ crate now includes a new lcov test coverage emitter, adding support for generating lcov-formatted coverage reports for Move code. This change introduces new binary tools (\coverage-summaries\, \move-trace-conversion\, \source-coverage\) and library modules (\lcov\, \differential\_coverage\, \source\_coverage\) to process VM trace data, compute coverage maps, and output detailed coverage summaries in both human-readable and CSV formats, as well as differential reports comparing passing and failing test results.

external-crates/move/crates/move-coverage · high confidence

The \move-unit-test\ crate is added, providing the core logic for running and reporting Move unit tests. It includes a test runner that executes tests in parallel using a thread pool and a reporter that displays source-level error messages for failures. The framework supports features such as gas limits, package size bounds, test filtering, random testing with seeds, and execution tracing. A CLI entry point and a Cargo test runner macro are also included to facilitate integration.

external-crates/move/crates/move-unit-test · high confidence

The consensus core has been replaced with a new v3 implementation (Mysticeti) that introduces a modular architecture including a BlockManager for causal history management, a BlockSyncService for shared synchronization logic, and a new AncestorStateManager for reputation-based ancestor exclusion. The system now supports v3 blocks with transaction voting, utilizes a Linearizer for commit ordering, and integrates a CommitFinalizer with dedicated benchmarks. This change also adds a new benchmark suite for the commit finalizer to measure direct and indirect commit processing performance.

consensus/core/src · high confidence

This change introduces the core implementation of the Sui Bridge Node in Rust, replacing the previous architecture. It adds a new \sui-bridge\ crate containing the \EthSyncer\ to monitor and synchronize Ethereum blockchain events, an \ActionExecutor\ to process bridge actions and submit transactions on Sui, and comprehensive ABI definitions for interacting with Ethereum bridge contracts. The node now handles token transfers, governance actions, and contract upgrades via a new orchestrator and action execution pipeline, supported by new configuration structures, cryptographic signing logic, and error handling specific to the bridge protocol.

crates/sui-bridge/src · high confidence

Adds the \simulacrum\ crate, providing a standalone, in-memory simulation of the Sui blockchain state. This tool allows developers to manually drive chain progression, execute transactions, and advance epochs in a deterministic environment (supporting seeded RNGs), serving as a foundation for testing and local development without requiring a full validator network.

crates/simulacrum/src · high confidence

Adds the Sui Native Bridge Move package (published at 0xb), providing the core on-chain logic for cross-chain token transfers between Sui and Ethereum. This includes the main bridge module for managing transfer states and committee approvals, a limiter module enforcing hourly transfer caps per route, a treasury module for handling minting and burning of bridged tokens, and chain ID definitions for supported Sui and Ethereum networks.

crates/sui-framework/packages/bridge · high confidence

The \sui-transactional-test-runner\ crate now provides a dedicated test runner for the Sui adapter, enabling users to execute transactional tests using programmable transactions (PTBs) and gasless transaction features. This includes a new CLI interface with arguments for configuring gas prices, budgets, and protocol feature flags, as well as a parser and printer for converting between Rust \ProgrammableTransactionBuilder\ commands and test syntax. The runner also supports persisted simulation state via a RocksDB-backed store, offchain state reading for GraphQL and JSON-RPC queries, and cursor parsing for pagination in tests.

crates/sui-transactional-test-runner · high confidence

The sui-transaction-builder crate now provides a high-level API for constructing transactions, introducing a DataReader trait to fetch full object details and the current reference gas price. This change ensures that transaction building relies on up-to-date network state (specifically the reference gas price) rather than potentially stale or local estimates, and mandates fetching full object references to support complex object transfers and payments correctly.

crates/sui-transaction-builder · high confidence

Adds a new VS Code extension that enables formatting for Move source files. The extension integrates with Prettier via a dedicated plugin and uses a background worker thread to perform formatting, ensuring the UI remains responsive. It supports format-on-save and respects user configuration from .prettierrc files as well as specific extension settings for options like tab width, print width, comment wrapping, and import grouping.

external-crates/move/tooling/prettier-extension · high confidence

The \sui-sql-macro\ crate now provides two new procedural macros: \sql!\ and \query!\. The \sql!\ macro allows users to construct \diesel::SqlLiteral\ instances using a format-string syntax with curly-brace binders for typed parameters, generating chained \.bind()\ and \.sql()\ calls. The \query!\ macro constructs full SQL queries implementing \diesel::query\_builder::Query\, supporting both value binding and nested query interpolation via the same format-string syntax. These macros simplify the creation of complex, type-safe SQL statements within the Sui PostgreSQL database layer.

crates/sui-sql-macro · high confidence

The Sui CLI now includes the \sui prompt\ subcommand, providing an agent-agnostic interface to expert Move knowledge. This feature embeds curated skill bundles and usage categories (such as security auditing and bytecode comprehension) directly into the binary at build time, ensuring the content is self-contained and available offline. Users can discover available skills, list categories, and retrieve detailed workflows and reference materials via CLI commands, enabling AI agents or developers to access structured guidance for tasks like auditing Move packages or interpreting compiled bytecode without external dependencies.

crates/sui-prompt · high confidence

The Sui light client now includes a new authenticated events client that allows users to cryptographically verify blockchain events using Merkle Mountain Range (MMR) commitments. This feature adds support for streaming and verifying events via the v2alpha proof service, including new modules for epoch caching, MMR stream updates, and proof conversion. Users can now ensure the authenticity and validity of on-chain state, such as transactions, their effects including events and object contents, without the cost of running a full node.

crates/sui-light-client · high confidence

Added the \BridgeClient\ and \BridgeAuthorityAggregator\ modules to handle communication with bridge authorities and aggregate their signatures. \BridgeClient\ manages HTTP requests to individual bridge nodes, supporting various governance and bridge actions such as blocklisting, emergency actions, limit updates, asset price updates, EVM contract upgrades, and token additions on both Sui and EVM chains. \BridgeAuthorityAggregator\ coordinates these requests, filters out blocklisted authorities, and aggregates signatures to reach the required validity threshold for certified bridge actions.

crates/sui-bridge/src/client · high confidence

The \sui-test-transaction-builder\ crate now provides a new, composable \TestTransactionBuilder\ API for constructing test transactions. This builder supports paying gas from address balances (via \AddressBalanceGasConfig\) in addition to traditional coin objects, and introduces \FundSource\ variants for address funds and object-based funds (allowing withdrawals from owned or shared objects). The builder exposes a fluent interface for building Move calls and managing gas budgets, replacing previous patterns that relied on \WalletContext\ for transaction construction in tests.

crates/sui-test-transaction-builder · high confidence

A new composite benchmark workload has been added to exercise heterogeneous transaction types, combining multiple distinct operations such as shared counter increments, address and object balance deposits/withdrawals, test coin minting, accumulator root reads, and authenticated event emissions. This workload allows stress testing and protocol validation across a broader range of Sui system interactions than previous single-operation benchmarks.

crates/sui-benchmark/src/workloads/composite · high confidence

The \move-core-types\ crate now includes a new compressed layout system (under \src/compressed/\) that represents Move type structures as deduplicated, flat node tables shared via \Arc\. This system provides two parallel implementations: annotated layouts (preserving field names and type tags) and runtime layouts (optimized for VM execution), both supporting efficient serialization and deserialization of Move values. This change enables more compact memory representation and faster processing of complex Move types without losing structural information.

external-crates/move/crates/move-core-types · high confidence

Added a new \Store\ trait and its implementations (\MemStore\ for testing, \RocksDBStore\ for production) in \consensus/core/src/storage\. This provides a unified interface for persisting and retrieving consensus blocks, commits, commit votes, and commit info, enabling the consensus engine to switch between volatile and persistent storage backends.

consensus/core/src/storage · high confidence

The \sui-indexer-alt-consistent-store\ crate is introduced as a new indexer component that provides a RocksDB-backed store with snapshot-based reads, allowing the RPC and other consumers to query data at specific checkpoints. It includes CLI commands to run the indexer and RPC, or to restore the database from formal snapshots, and exposes configurable ingestion, consistency, and RocksDB parameters via TOML. The store implements pipelines for indexing object ownership, object types, coin balances, and address balances, using bincode-encoded keys and BCS-encoded values to maintain lexicographic ordering for efficient iteration and prefix scans.

crates/sui-indexer-alt-consistent-store · high confidence

The \sui-bridge-cli\ crate has been extracted and established as the primary interface for bridge operations, introducing V2 bridge protocol support which adds timestamp-awareness for limiter bypass on mature messages. Users can now execute bridge actions via new subcommands including \governance\ (with dry-run capabilities), \client\, \view-eth-bridge\, \view-sui-bridge\, and key management tools like \examine-key\. The CLI leverages the \alloy\ library for Ethereum interactions and integrates with the Sui RPC API for on-chain operations, providing a unified command-line tool for managing bridge validators, clients, and governance actions across both Sui and Ethereum networks.

crates/sui-bridge-cli · high confidence

The data ingestion core now supports persisting task progress to a local JSON file via the new \FileProgressStore\ implementation, alongside a \ProgressStoreWrapper\ that tracks pending state and exposes statistics. This change also includes shim implementations for testing, allowing the ingestion engine to maintain checkpoint sequence numbers locally when a distributed store is not used.

_crates/sui-data-ingestion-core/src/progress\store · high confidence

The \move-symbol-pool\ crate has been added to provide a global, uniqued cache of strings that persists for the entire duration of a program. This feature allows the Move compiler and runtime to represent identifiers as lightweight, copyable \Symbol\ pointers rather than full string data, improving performance and reducing memory overhead. The implementation supports static, inlined (for short strings), and dynamically pooled symbols, and includes tests to verify serialization safety and lifetime stability.

external-crates/move/crates/move-symbol-pool · high confidence

The simulacrum component now includes an in-memory implementation of the store interface (InMemoryStore) and its associated trait (SimulatorStore). This allows the simulation environment to persist and retrieve checkpoints, committees, transactions, effects, events, and objects entirely in memory without requiring a persistent database backend, facilitating faster and isolated testing of consensus and execution logic.

crates/simulacrum/src/store · high confidence

This change adds the \module-generation\ crate, which provides a random module generator for creating test fixtures, and the \move-borrow-graph\ crate, which implements the graph data structure used by the borrow checker. These new internal tools support the Move compiler's testing and analysis capabilities by providing standardized ways to generate bytecode modules and track reference borrowing relationships.

external-crates/move/crates/move-compiler · high confidence

The new \move-model-2\ crate provides a unified, generic \Model\ abstraction for Move packages that supports both source-based and compiled-module-based construction. It introduces a \SourceKind\ trait to distinguish between \WithSource\ and \WithoutSource\ contexts, allowing the same core data structures to be used for both the traditional compiler pipeline and decompilation scenarios. The crate includes a \compiled\_model\ module for building models directly from \CompiledModule\s, a \source\_model\ module for integrating with the existing Move compiler's typing and expansion phases, and a \summary\ module that generates serializable, human-readable package summaries. Additionally, it provides a \pretty\_printer\ for rendering these summaries and a \display\ module for formatting naming-level types.

external-crates/move/crates/move-model-2 · high confidence

A new \move-ir-to-bytecode\ crate has been added to the Move toolchain, providing the compiler logic that translates Move Intermediate Representation (IR) into compiled bytecode. This implementation includes a parser for Move source files (with support for named addresses and character validation), a context manager for handling compiled dependencies, and a core compiler that generates bytecode while maintaining detailed source maps for debugging and error reporting.

external-crates/move/crates/move-ir-to-bytecode · high confidence

The \move-package-alt-compilation\ crate has been added to provide a flexible and extensible compilation system for Move packages. This new component introduces a customizable compilation pipeline with multi-flavor support, allowing for fine-grained control over build settings such as test modes, documentation generation, and linting. It manages the entire build lifecycle, including dependency resolution, bytecode compilation, and artifact storage, while also supporting package migration to the Move 2024 edition and the generation of comprehensive documentation.

external-crates/move/crates/move-package-alt-compilation · high confidence

A new alternative bridge indexer service has been added, featuring a main entry point that initializes and runs concurrent pipelines for token transfers, token transfer data, governance actions, and error handling. The service includes a dedicated metrics module exposing Prometheus counters, gauges, and histograms for monitoring bridge events, token transfer volumes and latency, governance actions, errors, and bridge state such as committee voting power and pause status.

crates/sui-bridge-indexer-alt/src · high confidence

The analytics indexer has been restructured to use a new configuration-driven architecture that supports multiple sequential pipelines (Checkpoint, Object, Transaction, Event, MoveCall, MovePackage, DynamicField, WrappedObject, and their BCS variants). Users can now configure output to GCS, S3, Azure, or local file systems, with support for CSV and Parquet formats. The indexer includes built-in progress monitoring for Snowflake tables, configurable ingestion concurrency and backoff parameters, and metrics for tracking upload progress and file sizes.

crates/sui-analytics-indexer/src · high confidence

The new \sui-telemetry\ crate enables Sui nodes to automatically send usage statistics to Google Analytics. This feature collects and transmits the node's IP address, chain identifier, node type (validator or full node), and the current git revision, allowing the network operators to monitor node distribution and version adoption.

crates/sui-telemetry · high confidence

The \sui-indexer-alt-object-store\ crate now provides the concrete implementation for storing and managing indexer watermarks using a generic object store (e.g., S3, GCS). It defines \ObjectStore\ and \ObjectStoreConnection\ structs that implement the framework's \Store\, \Connection\, and \ConcurrentStore\ traits. The implementation handles reading and writing watermark metadata as JSON files, including logic to initialize new watermarks with correct \reader\_lo\ and \pruner\_hi\ values derived from \checkpoint\_hi\_inclusive\. It also supports conditional writes via E-tag/versioning to prevent race conditions and includes a migration path to handle legacy watermark formats that lacked newer fields like \reader\_lo\ and \pruner\_hi\.

crates/sui-indexer-alt-object-store · high confidence

The \crates/x\ tool now includes a new \lint\ subcommand that enforces project-wide standards using \nexlint\. This linter bans specific dependencies (lazy\_static, tracing-test, openssl-sys, actix-web, warp, pq-sys), checks for direct duplicate dependencies, ensures all crates reside in the \crates/\ directory, and verifies that workspace members inherit lint configurations. Additionally, a new \external-crates-tests\ subcommand was added to execute tests for external crates located in the \external-crates/\ directory.

crates/x · high confidence

This change adds a new \move-regex-borrow-graph\ crate that implements a graph-based model for tracking reference relationships using regular expressions. The library provides a custom \GraphMap\ data structure and a \Graph\ abstraction that represents memory locations and their borrow relationships as nodes and edges labeled with regex patterns. It includes a \Meter\ trait for resource accounting during graph operations and a \Regex\ type to represent path constraints. The crate also ships with extensive property-based tests (\proptest\) and file-based test harnesses to verify that the graph's closure properties correctly mirror concrete memory states, ensuring the bytecode verifier can accurately detect borrow violations.

external-crates/move/crates/move-regex-borrow-graph · high confidence

Adds a new \sui-single-node-benchmark\ binary that allows users to measure the performance of a single Sui validator node by submitting parallel transactions and timing their execution. The tool supports multiple benchmark components—including baseline execution, execution-only (in-memory), transaction manager scheduling, and checkpoint executor modes—and features various workloads such as PTB transfers, Move package publishing, NFT minting, and balance-based fund sending. It also includes support for shared objects and dynamic fields to stress-test specific parts of the execution engine.

crates/sui-single-node-benchmark · high confidence

A new \consensus/config\ crate has been added to centralize and decouple consensus configuration from core Sui crates. It defines the \Committee\ type (including a new V3 variant with hybrid fault-tolerance thresholds), \Parameters\ for operational settings (such as leader timeouts, round delays, and sync limits), and \ConsensusProtocolConfig\ for protocol-level flags (like V3 enablement and leader schedule windows). The crate also standardizes cryptographic types by switching protocol keys to Ed25519 and making \AuthorityName\ variable-length, while providing test utilities and snapshot tests to ensure serialization stability.

consensus/config · high confidence

A new standalone binary, \sui-synthetic-ingestion\, has been added to generate synthetic checkpoint data for benchmarking purposes. This tool uses the Simulacrum framework to create configurable workloads of synthetic transactions and checkpoints, writing the results as compressed Protocol Buffer files to a specified directory. It allows users to customize the starting checkpoint sequence, the total number of checkpoints, and the transaction count per checkpoint, facilitating performance testing of the indexer against realistic but generated data loads.

crates/sui-synthetic-ingestion · high confidence

The \sui-snapshot\ crate now provides the core infrastructure for creating, storing, and restoring state snapshots. This includes a writer that persists the live object set into partitioned \.obj\ and \.ref\ files with a \MANIFEST\ for metadata, a reader that downloads and verifies these snapshots from remote object stores (supporting both standard and archive paths), and an uploader that automates the creation and upload of snapshots to S3/GCS with retry logic and archival support.

crates/sui-snapshot · high confidence

Adds a new \stress\ binary to the \sui-benchmark\ crate that allows users to run load tests against a Sui cluster. The tool supports configurable client/server thread counts, target QPS, and workload splits (e.g., shared counter vs. transfer object percentages). It integrates with Prometheus for metrics collection, provides a system state observer to track reference gas prices and protocol config changes, and supports comparing benchmark results against previous runs via JSON stats files. The binary also handles graceful shutdown of server runtimes and outputs detailed benchmark and stress performance reports to stderr.

crates/sui-benchmark/src/bin · high confidence

The new sui-consistent-store crate provides a type-safe wrapper around RocksDB for Sui's on-disk indexes, featuring typed column families, atomic batched writes, in-memory snapshots, and built-in support for indexing pipelines. It includes auto-registered bookkeeping column families for restore progress, watermarks, and chain IDs, along with implementations of the indexer-alt framework's Store and SequentialStore traits to enable pipeline-driven indexing.

crates/sui-consistent-store · high confidence

A new \sui-field-count\ crate has been added, providing a \FieldCount\ trait and a corresponding derive macro that allows structs to expose a constant \FIELD\_COUNT\ indicating the number of fields they contain. This capability enables compile-time verification of struct field counts, supporting basic structs, generics, lifetimes, and where clauses, which can be leveraged by other components like \sui-indexer-alt\ for validation or optimization purposes.

crates/sui-field-count · high confidence

Adds the sui-fork crate, a development tool that allows developers to start a local Sui network initialized with state from mainnet, testnet, or devnet at a specific checkpoint. The tool runs in lock-step mode, enabling sequential transaction execution and explicit control over checkpoint and time progression via a new gRPC service (ForkingService) defined in proto files. This service exposes RPCs to advance the clock, seal checkpoints, and retrieve network status. The entry includes the protocol buffer definitions, build scripts for generating gRPC code, and comprehensive documentation explaining usage, impersonation capabilities, and limitations.

crates/sui-fork · high confidence

The new sui-genesis-builder crate provides the core logic for constructing the initial network state. It includes a Builder API to assemble genesis parameters, validator sets, and initial objects, and introduces the ValidatorInfo struct to define and validate public validator metadata (such as addresses, keys, and commission rates) along with proof-of-possession verification.

crates/sui-genesis-builder · high confidence

Adds the sui-indexer-alt crate, a new indexer implementation that uses a file-based TOML configuration system to manage ingestion, pipeline execution, and database storage. The indexer supports multiple pipeline types (sequential and concurrent) for indexing checkpoints, transactions, events, and object states into a Postgres-compatible database, and includes CLI commands to generate configuration examples, merge config files, reset the database, and run benchmarks.

crates/sui-indexer-alt · high confidence

This change adds the initial scaffolding for the new \sui-indexer-alt-graphql\ service, including its documentation, a GraphiQL web IDE asset, and the foundational Rust source files for the GraphQL API. It establishes the core query and mutation entry points, a suite of custom GraphQL scalars (such as \Base64\, \BigInt\, \Digest\, and \DateTime\), and the initial GraphQL schema definition, laying the groundwork for the service's data access and type system.

crates/sui-indexer-alt-graphql · high confidence

The \sui-json\ crate has been introduced to handle Sui-specific JSON serialization and deserialization. It defines \SuiJsonValue\ which enforces strict validation rules: JSON numbers must be unsigned integers (u64), arrays must be homogeneous, and null values are rejected. The crate provides conversion methods between JSON values and Move types (via BCS bytes) and supports resolving call arguments for programmable transactions.

crates/sui-json · high confidence

The new \sui-json-rpc-api\ crate defines the core JSON-RPC API surface for the Sui network, organizing methods into distinct traits: \ReadApi\ (standard object, transaction, and checkpoint queries), \WriteApi\ (transaction execution and dry-run/inspect modes), \IndexerApi\ (advanced pagination, event/transaction subscriptions, and Name Service resolution), \CoinReadApi\ (coin balances and metadata), \GovernanceReadApi\ (staking, committee info, and gas prices), \ExtendedApi\ (epoch and object querying), \BridgeReadApi\ (bridge state), \DeepBookApi\ (DEX status), and \MoveUtils\ (normalized Move module/struct/function introspection). It also includes the \TransactionBuilder\ trait under the \unsafe\ namespace for constructing unsigned transactions (transfers, payments, Move calls, publishing, and coin splitting/merging). This change establishes the formal API contracts and OpenRPC documentation for these endpoints.

crates/sui-json-rpc-api · high confidence

The new sui-keys crate provides the foundational key management infrastructure for the Sui CLI, introducing support for external signers (such as Ledger devices) via a JSON-RPC interface, allowing users to provision and manage keys stored outside the local wallet. It also adds a robust aliasing system that lets users assign and resolve human-readable names to addresses, with validation to ensure uniqueness and valid formatting. Additionally, the crate standardizes key derivation paths for Ed25519, Secp256k1, and Secp256r1 schemes and provides utilities for reading and writing keypairs in various formats (Base64, Bech32, Hex) from files.

crates/sui-keys · high confidence

Added the sui-metric-checker crate, a new tool for querying Prometheus and validating results to detect performance regressions in nightly deployments. Users can define metric checks in a YAML configuration file, specifying instant or range queries with specific percentiles (e.g., p50, p95) and threshold conditions (Greater, Less, Equal). The tool executes these queries against a Prometheus instance, applies exponential backoff for retries, and reports failures if queried values violate the defined thresholds.

crates/sui-metric-checker · high confidence

A new \sui-move-build\ crate has been added to provide Sui-specific wrappers around the core Move build system. It introduces \BuildConfig\ and \CompiledPackage\ structs that extend the underlying Move compiler with Sui-specific features, including network-aware system dependency resolution via \SuiFlavor\, bytecode verification, and automatic address management. The crate also includes unit tests to validate framework compilation and enforce edition restrictions.

crates/sui-move-build · high confidence

The \crates/sui-open-rpc\ crate has been added to centralize the generation of the Sui JSON-RPC OpenRPC specification. It provides the core data structures (\Project\, \Module\, \Method\) and logic to assemble API documentation from various RPC modules (Read, Coin, Governance, Transaction Builder, etc.) and injects runtime-generated examples for each method. The crate includes a test that generates the \openrpc.json\ spec file (version 1.81.0) and validates it against a snapshot, ensuring the documentation stays in sync with the actual RPC implementation.

crates/sui-open-rpc · high confidence

Adds the sui-oracle crate, providing a Rust-based oracle node and Move smart contracts to publish and consume on-chain data feeds. The Move package defines a SimpleOracle for individual data submission and a MetaOracle that aggregates multiple sources using a configurable threshold and time window to compute a median value. The Rust implementation includes an OracleNode that fetches external data, uploads it to the on-chain SimpleOracle objects, and optionally reads on-chain data, with Prometheus metrics exposed for monitoring.

crates/sui-oracle · high confidence

A new sui-package-management crate has been added to centralize the management of system package versions. It includes a build script that generates a static version table from a bytecode snapshot manifest, allowing the system to look up the correct system package metadata (git revision and package paths) for any given protocol version. This replaces previous ad-hoc handling of system package versions, providing a structured API (system\_packages\_for\_protocol) to retrieve the appropriate system packages for a specific protocol version, ensuring consistency between the protocol version and the bundled system framework.

crates/sui-package-management · high confidence

Adds a new sui-proxy service that acts as a secure gateway for collecting and forwarding metrics from Sui validators, bridge nodes, and hashi committee members. The proxy accepts metrics via a gRPC/Protobuf endpoint, validates client identities using on-chain data (validators, bridge, and optional hashi committees) or static public keys, and relays the data to a remote write destination (e.g., Mimir) with Snappy compression. It also exposes local Prometheus metrics and a Kubernetes pod health check endpoint to monitor its own operational status.

crates/sui-proxy · high confidence

The \sui-rpc-benchmark\ crate is added as a new utility to measure performance across different Sui RPC access methods. It supports benchmarking direct database queries against a PostgreSQL instance (enriching templates with real data) and replaying JSON RPC requests from a JSONL file against an endpoint, including pagination cursor handling and method filtering. A \pull\_grafana\_logs\ binary is also included to extract and group sampled JSON RPC requests from Grafana/Loki logs for use as benchmark input.

crates/sui-rpc-benchmark · high confidence

A new CLI utility, sui-rpc-loadgen, is added to generate read and write loads on Sui RPC servers. It supports concurrent multi-threaded execution, cross-validating results across multiple RPC endpoints to ensure data consistency, and comparing performance between vanilla and Enhanced Full nodes. The tool includes commands for fetching checkpoints (with optional transaction and object verification), executing PaySui transactions, querying transaction blocks (single and multi-get), retrieving objects (single and multi-get), getting all balances, and fetching the reference gas price. It also features caching of object references and transaction digests to files for persistence across runs.

crates/sui-rpc-loadgen · high confidence

This change introduces the new \sui-rpc-store\ crate, providing a dedicated indexing and storage layer optimized for RPC workloads. It defines a new protobuf schema (\sui.rpc\_store.v1alpha.types\) for storage-side messages—including \StoredObject\, \StoredTransaction\, \StoredEffects\, and \BalanceDelta\—separating internal storage representations from the public gRPC API. The crate implements a pipeline-based indexer (using \sui\_indexer\_alt\_framework\) that populates specific column families such as \objects\, \effects\, \events\, \balance\, and \epochs\. It includes configuration for pruning historical data (\PrunerConfig\) and a \CheckpointBroadcast\ pipeline to stream committed checkpoints. This component serves as the backend storage engine for the RPC node, enabling efficient point-in-time reads and balance queries.

crates/sui-rpc-store · high confidence

Adds the sui-surfer crate, a new tool that spins up a local test cluster and automatically publishes and exercises Move packages to validate their behavior under randomized transaction patterns. Users can run the tool via CLI (providing package paths and optional duration/epoch settings) or invoke it programmatically to receive statistics on successful/failed transactions, shared vs. owned object usage, and unique functions called. The implementation includes a SurfStrategy for controlling transaction intervals and argument selection, a SurferState for tracking cluster object pools, and a SurferTask for concurrent execution, supported by test Move modules (move\_building\_blocks, random) and a smoke test to verify the runner operates correctly.

crates/sui-surfer · high confidence

This change adds the new \sui-swarm-config\ crate, which centralizes the configuration structures and builders used for local development, testing, and simulated networks. It introduces \NetworkConfig\ to hold the full set of validator configurations and genesis state, \ValidatorGenesisConfig\ for individual validator setup, and dedicated builders (\ConfigBuilder\, \ValidatorConfigBuilder\) to programmatically construct these configurations. The crate also includes \CommitteeFixture\ in \test\_utils\ to simplify the creation of test committees and checkpoints, along with snapshot tests to ensure configuration stability.

crates/sui-swarm-config · high confidence

This change adds the core implementation for the \sui client ptb\ command, introducing a dedicated lexer, parser, and builder within \crates/sui/src/client\_ptb\. It enables users to construct and execute programmable transactions via a new command-line syntax, supporting commands like \transfer-objects\, \move-call\, and \publish\, along with metadata flags such as \--gas-budget\, \--gas-price\, \--gas-sponsor\, and \--sender\.

_crates/sui/src/client\ptb · high confidence

This change introduces the \sui-fork\ crate, providing a new command-line tool that allows users to fork an existing Sui network (mainnet, testnet, devnet, or a custom GraphQL endpoint) at a specific checkpoint. The tool supports starting a forked node with configurable RPC addresses, data directories, and optional seeding of specific addresses or object IDs. It also provides commands to advance the network clock, move to the next checkpoint, and check the current status of the forked network, enabling developers to test and interact with a local copy of the chain state.

crates/sui-fork/src · high confidence

The \crates/sui-move\ crate now provides a standalone \sui-move\ CLI binary that exposes subcommands for building (\sui move build\), testing (\sui move test\), linting, formatting (\sui move format\), disassembling bytecode, and generating package summaries. The test command is updated to use Sui's native gas schedule and protocol configuration, ensuring unit tests reflect on-chain execution behavior, while the build command gains support for generating struct layout schemas and dumping bytecode as base64.

crates/sui-move · high confidence

This change adds the core Solidity utilities for the Sui Native Bridge on EVM chains. It introduces the BridgeUtils library to define message formats (including TokenTransferPayload), encode/decode logic, and decimal conversion between ERC20 and Sui. It also adds BridgeUtilsV2, which extends the payload with a timestamp and enforces a 48-hour maturity window for messages. Additionally, it provides the CommitteeUpgradeable abstract contract, which enables UUPS upgradeability via committee-signed messages, and the MessageVerifier contract, which handles nonce tracking and signature verification against the BridgeCommittee.

bridge/evm/contracts/utils · high confidence

The analytics indexer now includes a new handler module that provides a generic \AnalyticsHandler\ for batching and committing checkpoint data to object stores, ensuring batches do not span epoch boundaries. Additionally, a \SystemPackageEviction\ processor has been added to manage the eviction of system package addresses from the RPC package cache at each epoch boundary.

crates/sui-analytics-indexer/src/handlers · high confidence

Adds new bitmap index processing pipelines in the kvstore that build Roaring bitmap inverted indexes for both events and transactions. The \EventBitmapProcessor\ creates an event-keyed index where bit positions correspond to packed event sequences, enabling \list\_events\ queries to resolve matches directly in event-space without over-fetching. The \TransactionBitmapProcessor\ creates a transaction-keyed index where bits correspond to transaction sequence numbers, supporting efficient transaction-based lookups. Both processors are integrated into the \BitmapIndexHandler\ which manages checkpoint processing, batching, and sharded commit to BigTable.

crates/sui-kvstore/src/handlers/bitmap · high confidence

The \sui-authority-aggregation\ crate now provides a new, generic \quorum\_map\_then\_reduce\_with\_timeout\_and\_prefs\ function that allows callers to define custom mapping and reduction logic for interacting with authority nodes. This implementation introduces a prefetch phase where results are gathered for a specified duration before falling back to arrival order, and supports optional authority preference ordering to optimize request routing. A simpler variant without preferences is also available, enabling more flexible and efficient signature aggregation across the committee.

crates/sui-authority-aggregation · high confidence

The \sui-indexer-alt-framework-store-traits\ crate now provides the core abstractions for the indexer's data layer, defining \Store\, \Connection\, \ConcurrentConnection\, and \SequentialConnection\ traits. These interfaces allow the indexer to manage watermark operations (such as tracking committed checkpoints, reader bounds, and pruning limits) and arbitrary writes without being tied to a specific database backend. The crate also includes a \MockStore\ implementation and shared test macros to ensure consistent behavior across different storage implementations.

crates/sui-indexer-alt-framework-store-traits · high confidence

This change adds the v3 historical version of the Sui adapter, establishing a new execution path that includes a \LinkedDataStore\ for resolving modules and types under specific linkage contexts, a \CachedPackageStore\ to optimize package loading and type resolution, and a \LinkageView\ to manage module and type identity changes during package upgrades. The adapter also introduces an \ExecutionMode\ trait to differentiate execution behaviors (such as for genesis transactions versus normal transactions) and implements a metered bytecode verifier to enforce timeout limits during verification.

sui-execution/historical-versions/v3/sui-adapter · high confidence

The \sui-display\ crate now exposes a new \v2\ module alongside the existing \v1\ implementation, providing a significantly more capable display system. This new version introduces a richer format string syntax supporting multiple alternates (pipe-separated), dynamic field and dynamic object field access, and various value transforms (such as hex, base64, JSON, and timestamp formatting). To ensure system stability, the V2 parser and interpreter enforce strict resource metering, limiting recursion depth, AST node allocation, and the number of object loads per display operation. The V1 module remains available for backward compatibility.

crates/sui-display/src · high confidence

The \move-ir-types\ crate now provides the foundational AST structures for the Move Intermediate Representation, including definitions for modules, structs, enums, constants, and primitive types. It also introduces a \Loc\ struct for tracking source file locations and byte ranges, enabling precise error reporting and source-map generation for Move programs.

external-crates/move/crates/move-ir-types · high confidence

A new Rust library for the Sui Name Service has been added to the codebase, providing structured types and logic for interacting with SuiNS. This includes definitions for domain records, name records, and registration NFTs, along with utilities for parsing domain formats (such as the new '@' separator style) and managing registry configurations. This change establishes the foundational data structures and client-side logic required for the SuiNS feature within the Rust tooling.

crates/sui-name-service · high confidence

The \sui-framework\ crate now exposes a \BuiltInFramework\ struct that manages metadata for core system packages (MoveStdlib, Sui, SuiSystem, DeepBook, and Bridge). This includes methods to iterate over system package metadata, retrieve packages by ID, and generate genesis objects and move packages. Additionally, a new function is introduced to check framework compatibility between on-chain modules and the local framework definition, returning the current framework digest if compatible.

crates/sui-framework/src · high confidence

The \sui-simulator\ crate has been introduced to provide a deterministic, randomized execution environment for the entire Sui network within a single process. This enables testing under adverse network conditions (such as high latency, packet loss, and partitions) and allows for the reproduction of rare bugs using specific random seeds. The implementation includes a simulated runtime with a global seeded PRNG, network latency/packet loss simulation, and interceptors for POSIX API calls to ensure determinism. It provides \\#\[sui\_test\]\ and \\#\[sim\_test\]\ macros for declaring tests, with \\#\[sim\_test\]\ running exclusively in the simulator environment, and exposes configuration helpers for network behavior via \SimConfig\.

crates/sui-simulator · high confidence

The sui-macros crate now provides a comprehensive fail-point system, allowing tests to inject faults or control execution flow at specific code locations. This includes macros like \fail\_point\_if\ for conditional branching, \register\_fail\_point\ for synchronous interruptions, and \register\_fail\_point\_async\ for asynchronous delays, along with a \nondeterministic\ macro to isolate random number generation and clock calls during deterministic simulations.

crates/sui-macros · high confidence

The \external-crates/move\ directory now includes the foundational structure for the Move language integration. This adds the Move Book (mdBook), coding guidelines, and VM specification documentation. It also introduces the Move Prettier plugin (\prettier-move\) and its VS Code extension (\prettier-extension\), providing a formatter for Move source code. Additionally, it adds \deny.toml\ for dependency/license auditing and \.clippy.toml\ to configure Rust linting thresholds for the upstream Move code.

external-crates · high confidence

The Move standard library has been updated to the 2024.beta edition, as defined in the new Move.toml manifest. This release introduces the \defining\_id\ and \original\_id\ functions to the \std::type\_name\ module, allowing developers to retrieve type names using either the current defining package ID or the original package ID. Additionally, the library now includes comprehensive documentation for the \std::macros\ module, exposing new macro functions such as \num\_max\, \num\_min\, and \num\_pow\ for use in Move code.

external-crates/move/crates/move-stdlib · high confidence

The Multisig Toolkit application has been rebuilt with a new UI layer and a transaction effects preview feature. The interface now uses shadcn/ui components (Button, Dialog, Tabs, Command, etc.) and Tailwind CSS for styling, replacing the previous design. A key addition is the 'Effects Preview' capability, which allows users to run a dry run of a transaction and view a detailed breakdown of the results, including balance changes, object changes, emitted events, and the specific transaction inputs, all presented in a tabbed view. The toolkit also introduces a new wallet connection component for account switching and disconnection, and a mobile-responsive header with a hamburger menu.

dapps/multisig-toolkit · high confidence

A new internal CLI tool has been added to automate the process of creating duplicate versions of specific crates for new feature branches. The tool scans source directories for specified packages, copies them to destination paths, updates package names with a feature suffix to avoid conflicts, and rewrites dependency references so that duplicated crates point to their duplicated dependencies. It respects workspace membership and exclusion rules, supports a dry-run mode to preview changes, and ensures that existing packages are not overwritten.

sui-execution/cut · high confidence

The \move-command-line-common\ crate introduces several new modules to support command-line tooling. The \character\_sets\ module adds strict validation for permitted printable characters, newlines, and Unicode text-directionality control characters to ensure safe input handling. The \display\ module provides logic to render Move bytecode constants (such as integers, addresses, and vectors) into human-readable strings for CLI output. The \testing\ module replaces the previous \.exp\ baseline test system with \cargo-insta\ snapshot testing, introducing the \insta\_assert!\ macro and \InstaOptions\ for managing test snapshots. Additionally, the crate adds \env\ for environment variable handling (including bytecode version configuration), \error\_bitset\ for compact error code serialization, \files\ for file discovery and hash management, and \interactive\ for terminal prompts.

external-crates/move/crates/move-command-line-common · high confidence

Added a complete example application in \examples/deepbook-predict\ that demonstrates how to interact with the DeepBook Predict protocol on Sui. The code provides a client-side implementation for creating trading accounts, querying live market data, and minting directional or range binary options with cost and probability caps. It also includes functionality for redeeming positions, managing liquidity pool (PLP) supply and withdrawals, and utilizing the Sessions system to authorize and manage ephemeral trading keys for delegated access.

examples/deepbook-predict · high confidence

Added a new example bot in \examples/mev\_bot\ that demonstrates how to interact with Deepbook (CLOB v2) to identify and clean up expired orders. The script connects to the Sui mainnet, retrieves all trading pools via \PoolCreated\ events, fetches order data from the underlying Critbit trees, and constructs a transaction to remove expired orders to reclaim storage fees. It utilizes the \@mysten/sui\ SDK (Transaction and SuiClient) and BCS deserialization to parse on-chain state.

_examples/mev\bot · high confidence

This change introduces a comprehensive set of new Dockerfiles and supporting scripts for building and running various Sui components, including the fullnode, stress test tool, analytics indexer, bridge indexers, and several indexer-alt services (graphql, jsonrpc, consistent-store). It also adds a deterministic canary build infrastructure using the StageX toolchain to ensure reproducible builds, and provides local development tooling with docker-compose configurations for Grafana, Prometheus, Tempo, and Jaeger to facilitate local metrics and tracing.

docker · high confidence

This change introduces a new HTTP key-value store implementation in \crates/sui-storage\ that allows nodes to fetch transactions, effects, objects, and checkpoint data from remote HTTP endpoints (such as \https://transactions.sui.io\). It includes a \HttpKVStore\ with built-in caching, a \TransactionKeyValueStore\ wrapper for standardized access, and a new \http\_kv\_tool\ binary for debugging and manual data retrieval. The implementation supports Google Cloud Storage, Amazon S3, and local file storage backends via a unified HTTP downloader interface, enabling archive nodes and tools to retrieve state without direct database access.

crates/sui-storage · high confidence

A new \jsonrpc\ crate has been added to the Move external crates, providing a lightweight JSON-RPC 2.0 client implementation. This library introduces an \Endpoint\ type that handles asynchronous communication over generic read/write streams, supporting both single method calls and batched requests. It includes built-in serialization and deserialization for JSON-RPC requests and responses, along with error handling for remote errors and I/O issues. The library is designed to be independent and can be used by other Move components, such as the CLI, to interact with JSON-RPC endpoints.

external-crates/move/crates/jsonrpc · high confidence

A new interactive demo application has been added at dapps/kiosk, providing a complete user interface for interacting with the Sui Kiosk protocol. The app allows users to connect their wallets, search for and view any kiosk by address or ID, and manage their own kiosks. Key capabilities include creating a new kiosk, viewing owned items and kiosk inventory, listing items for sale with a custom price, purchasing items from other kiosks, withdrawing profits, and taking items back to the wallet. The interface supports network selection (localnet, devnet, testnet, mainnet) and handles multi-kiosk ownership via a selector dropdown.

dapps/kiosk · high confidence

This change introduces a suite of new Move native functions in the sui-move-natives crate. It adds cryptographic verification natives for BLS12-381 (min\_sig and min\_pk), ECDSA (secp256k1 and secp256r1 recovery and verification), Ed25519, ECVRF, and Groth16 zero-knowledge proofs, all with configurable gas costs. It also provides address conversion natives (from/to bytes, to/from u256), a native for reading protocol config settings with epoch-aware consistency, and accumulator natives for emitting deposit/withdraw events and recording SUI conservation in settlement transactions.

sui-execution/latest/sui-move-natives · high confidence

This location introduces the new Move package management system (move-package-alt), which replaces the legacy move-package crate. For users, this brings a redesigned manifest format that removes the \[addresses\] section in favor of unified dependency naming, introduces environment-specific dependency pinning via a new Move.lock format, and supports dependency replacements for different networks. The system includes a migration guide for updating Move.toml files, CLI commands for building and updating dependencies, and compatibility layers to parse legacy manifests and lockfiles during transition.

external-crates/move/crates/move-package-alt · high confidence

The nre directory now provides a comprehensive set of resources for deploying and operating Sui nodes, including an Ansible role for automated Linux provisioning, Docker Compose and systemd service configurations, and a Helm chart for Kubernetes StatefulSet deployment. It also introduces a new configuration template (validator.yaml) with updated consensus and metrics settings, a guide for State Sync Fullnodes (SSFN), and hardened scripts for downloading and verifying private security release binaries using cosign.

nre · high confidence

The \sui-json-rpc-types\ crate now exposes dedicated \BalanceChange\ and \ObjectChange\ types for transaction responses, allowing users to see granular details of coin balance shifts and object lifecycle events (created, transferred, mutated, deleted, wrapped, published) directly in RPC output. Additionally, the crate introduces structured \Display\ implementations for \SuiProgrammableTransactionBlock\, \SuiCommand\, and related types, which enhances the readability of transaction data in the CLI by formatting inputs and commands into clear, table-like outputs.

crates/sui-json-rpc-types · high confidence

The regulated-coin example now includes a Rust command-line client that allows users to manage deny lists, mint, transfer, and burn coins. The client provides subcommands for adding and removing addresses from the deny list, as well as standard coin operations, and handles gas selection and transaction execution via the Sui SDK.

examples/regulated-coin/rust-client · high confidence

Added a new \SerializeRow\ procedural macro in the \sui-analytics-indexer-derive\ crate. This macro automatically implements the \RowSchema\ trait for structs, enabling them to be serialized into Parquet format by generating the necessary schema definitions and column-value getters at compile time.

crates/sui-analytics-indexer-derive · high confidence

The \sui-bridge-indexer\ crate introduces a new indexing service for the Sui-Ethereum bridge, replacing the previous implementation. It features a modular architecture with separate data sources for Ethereum finalized block syncing and WebSocket log subscriptions, allowing for robust live and backfill indexing. The indexer supports configurable backfill strategies (simple or partitioned) and implements a progress-saving policy that persists indexing checkpoints to a PostgreSQL database either after a specified duration or when out-of-order blocks are filled, ensuring resilience against restarts. Configuration is loaded from a YAML file, with the database URL optionally overridable via the \DB\_URL\ environment variable, and the service exposes Prometheus metrics for monitoring task progress and bridge transaction counts.

crates/sui-bridge-indexer/src · high confidence

The consensus module now uses a new Tonic (gRPC) network implementation that introduces a unified \PeerId\ type for both validators and observers, enabling validators to communicate with observer peers via a dedicated observer interface alongside the existing validator-to-validator path. This change adds a \SynchronizerClient\ and \CommitSyncerClient\ that route requests to the appropriate client based on node role and peer type, and introduces a \TonicObserverClient\ for block streaming and fetch operations. To support observability, the network layer now exposes comprehensive Prometheus metrics for request counts, latency, sizes, inflight requests, errors, and TCP socket buffer sizes, tracked via a reusable \MetricsLayer\.

consensus/core/src/network · high confidence

Added a new example indexer in \examples/rust/walrus-attributes-indexer\ that demonstrates how to index custom Walrus blob metadata. The implementation includes a \BlogPostPipeline\ processor that extracts blog post details (title, view count, publisher) from Walrus metadata dynamic fields on-chain and persists them to a PostgreSQL database using the \sui-indexer-alt-framework\. The example provides the full stack: database schema and migrations for the \blog\_post\ table, storage types, and a main entry point that wires the pipeline into the indexer service.

examples/rust/walrus-attributes-indexer · high confidence

Sui nodes now include a local admin HTTP server (default port 1337) providing operational endpoints for managing node configuration, traffic control, epoch management, and database inspection, alongside a new \sui-metrics-push-client\ crate that periodically pushes Prometheus metrics to a configured remote endpoint using Snappy-compressed Protobuf over TLS.

crates/sui-node · high confidence

A new adversarial benchmark workload has been added to the benchmarking suite, defined by a Move package (\adversarial\) using the 2024.beta edition. This workload introduces specific stress-test scenarios, including the creation of large objects (targeting \~250KB via chunked vectors) and the manipulation of dynamic fields (up to 1,000 fields), allowing users to evaluate system performance under these extreme data conditions.

crates/sui-benchmark/src/workloads/data/adversarial · high confidence

The mysten-network crate now implements a new networking layer built on the anemo framework, replacing previous implementations. This includes an AnemoConnectionMonitor that tracks peer connectivity, RTT, packet loss, and buffer sizes via Prometheus metrics, and a WaitingPeer utility that allows RPC calls to block until a known peer connects. The crate introduces BcsCodec and BcsSnappyCodec for serializing messages using the BCS format with optional Snappy compression, and adds a GrpcRequestLogLayer for opt-in capture of gRPC request payloads to the tracing system. Client connections are managed via a new client module that supports lazy channel creation with a configurable caching DNS resolver and applies connection timeouts.

crates/mysten-network · high confidence

The benchmarking suite adds several new workload types to \crates/sui-benchmark/src/workloads\. The \addr\_bal\_deposit\ workload seeds address balances and deposits them into coin balances. The \batch\_payment\ workload enables round-robin batch transfers among a cluster of addresses using an in-memory wallet. The \large\_transaction\ workload generates transactions with configurable payload sizes to measure consensus throughput as a function of block size. Additionally, \expected\_failure\ workloads allow injecting specific failure types (such as invalid signatures) for testing error handling, while \party\ and \delegation\ workloads exercise object transfer and staking flows respectively.

crates/sui-benchmark/src/workloads · high confidence

A new \bin-version\ crate has been added to provide macros (\bin\_version!\ and \git\_revision!\) for defining binary version constants at compile time. These macros expose \GIT\_REVISION\ and \VERSION\ constants, deriving the git revision from the \GIT\_REVISION\ environment variable or by querying git via \git\_version\ if the variable is not set. The \bin\_version!\ macro combines the package version with the git revision (separated by a hyphen if present) to form a full version string, while \git\_revision!\ separately exposes the short and full SHA revisions. This utility is intended for use within binary targets to standardize how version information is embedded.

crates/bin-version · high confidence

The \sui-inverted-index\ crate now includes a new bitmap query engine that evaluates Disjunctive Normal Form (DNF) queries over ordered bucket streams. This engine supports both synchronous iterators and asynchronous streams, enabling efficient, back-pressure-aware scanning of indexed dimensions such as sender, affected addresses, and event types. It introduces a packed \event\_seq\ encoding to map transaction and event coordinates into a globally ordered space, and defines a set of queryable dimensions (including compound keys for Move calls and events) alongside internal markers for negation and package tracking. This change provides the underlying query execution layer for fullnode and list APIs, allowing consumers to scan and filter checkpoint data using bitmap intersections and unions.

crates/sui-inverted-index · high confidence

The \mysten-common\ crate now includes a suite of blocking synchronization primitives designed to prevent deadlocks in the transaction execution pool. This introduces \AsyncOnceCell\ for async single-write cells, \NotifyOnce\ and \NotifyRead\ for signaling state changes, and a blocking \oneshot\ channel. Crucially, these primitives integrate with a new \ExecutionPermit\ system: when a thread blocks waiting for a value, it temporarily releases its execution permit, allowing other tasks to proceed and preventing the pool from exhausting its concurrency slots while waiting.

crates/mysten-common/src/sync · high confidence

The \sui-bridge-schema\ crate now provides the database schema and Diesel models for the new bridge indexer. This includes tables for tracking token transfers (\token\_transfer\, \token\_transfer\_data\), error transactions (\sui\_error\_transactions\), governance actions (\governance\_actions\), and progress checkpoints (\progress\_store\, \sui\_progress\_store\). The schema supports V2 bridge events by including a \message\_timestamp\_ms\ field in \token\_transfer\_data\, which allows the frontend to determine rate-limiter bypass eligibility based on the embedded message timestamp.

crates/sui-bridge-schema · high confidence

The bridge indexer now includes dedicated handlers to index Sui bridge activity into the database. The \TokenTransferHandler\ tracks token deposits (including V2 events), approvals, and claims, recording their status and gas usage. The \GovernanceActionHandler\ captures administrative events such as route limit updates, emergency operations, committee blocklist changes, and token registrations/pricing. Additionally, the \ErrorTransactionHandler\ indexes failed bridge transactions, storing the failure reason and command index, while the \TokenTransferDataHandler\ stores detailed deposit metadata. All handlers process checkpoint transactions identified as bridge transactions and commit results to their respective database tables.

crates/sui-bridge-indexer-alt/src/handlers · high confidence

This change introduces the \sui-checkpoint-blob-indexer\ crate, a new tool that indexes Sui checkpoints by writing them to object storage (S3, GCS, Azure, HTTP, or local filesystem). It supports three distinct pipeline types: \CheckpointBlob\ (writing checkpoint data as compressed or uncompressed binary blobs), \Epochs\ (maintaining a sorted JSON list of epoch numbers), and \CheckpointBcs\ (BCS-encoded checkpoints). The indexer allows runtime configuration of concurrency, ingestion, and commit behaviors via a TOML config file and CLI arguments, including optional Zstd compression for blob pipelines. It also disables internal object store retries to rely on application-level control and deprecates the \checkpoint-buffer-size\ config field in favor of per-pipeline \subscriber-channel-size\.

crates/sui-checkpoint-blob-indexer/src · high confidence

The \sui-checkpoint-blob-indexer\ now includes new handler implementations that process checkpoints into specific storage formats. The \CheckpointBcsPipeline\ encodes checkpoint data into BCS format and stores it as \.chk\ files. The \CheckpointBlobPipeline\ serializes checkpoints into Protocol Buffers, optionally compressing them with zstd into \.binpb\ or \.zst\ files based on configuration. Additionally, the \EpochsPipeline\ tracks the last checkpoint of each epoch by maintaining and updating an \epochs.json\ file in object storage, using conditional updates to ensure consistency.

crates/sui-checkpoint-blob-indexer/src/handlers · high confidence

The mysten-common crate now provides a suite of shared utilities: robust logging macros (fatal!, debug\_fatal!, assert\_reachable!, assert\_sometimes!) that integrate with Antithesis and simtests for better invariant tracking; a corrected ExponentialBackoff implementation with jitter; moving-window and decay-moving-average types for metrics; a Format trait with JSON and Protobuf (prost) implementations plus a Meter for resource-limit tracking during serialization; and a zip\_debug\_eq iterator extension that logs mismatches instead of panicking.

crates/mysten-common/src · high confidence

A new composite benchmark workload has been added to exercise heterogeneous transaction types. This workload includes Move modules for a shared counter, a balance pool using the funds accumulator, immutable object reads, authenticated event emission, random number generation, and a test coin for multi-currency stress testing, providing a comprehensive set of operations for benchmarking.

crates/sui-benchmark/src/workloads/data/composite · high confidence

The sui-futures crate now exposes several new utilities for managing async workloads. A Service abstraction provides structured lifecycle management with primary and secondary tasks, configurable shutdown signals, and a grace period for graceful termination. An adaptive concurrency controller allows stream processing to dynamically adjust parallelism based on channel fill levels, supporting both fixed and adaptive limits. For debugging, a slow-future monitor detects stuck tasks by racing them against a timer, and a traced timeout captures span traces of pending await points when deadlines expire. Additionally, a TaskGuard wrapper ensures spawned tasks are aborted when dropped.

crates/sui-futures · high confidence

The sui-config crate has been split into multiple modules, introducing dedicated configuration structures for genesis (including loading and saving genesis blobs), node settings (NodeConfig with consensus, P2P, and RPC options), and transaction deny lists (CertificateDenyConfig and TransactionDenyConfig). It also adds support for dynamic transaction signing checks via Starlark scripts and object storage configuration for cloud providers (S3, GCS, Azure).

crates/sui-config/src · high confidence

The \sui-indexer-alt-schema\ crate now provides the complete database schema for the new indexer architecture. This includes migrations for core tables such as \kv\_checkpoints\, \kv\_objects\, \kv\_transactions\, \obj\_versions\, and \obj\_info\, as well as summary and write-ahead log tables for object types and coin balances (which were later removed in favor of a new \coin\_balance\_buckets\ table). The schema also covers epoch data (\kv\_epoch\_starts\, \kv\_epoch\_ends\), protocol configuration, genesis state, feature flags, and transaction metadata like balances, affected objects, and signatures. Additionally, it includes the \cp\_sequence\_numbers\ table for checkpoint-to-epoch mapping and a script to generate the Diesel schema from migrations.

crates/sui-indexer-alt-schema · high confidence

This change introduces a suite of new scripts to the repository to support development workflows, CI automation, and release management. Key additions include \cargo-deny-autofix.sh\ for automatically resolving Rust security advisories via semver-compatible lockfile bumps, \dual\_replay.py\ for orchestrating dual-execution replay tests to validate execution-layer cuts, and \execution\_layer.py\ for managing the lifecycle of execution-layer feature cuts (cut, merge, rebase). Release and compatibility workflows are supported by \gen\_branch\_cut\_prs.sh\ for generating framework bytecode snapshot PRs, \generate-release-notes.sh\ for extracting release notes from PRs, and \check-protocol-compatibility.sh\ for validating protocol snapshots against deployed network versions. Network testing is enhanced with \fullnode-sync.sh\ and \monitor\_synced.py\ for verifying fullnode synchronization, \split-cluster-check.sh\ for validating mixed-version cluster reconfiguration, and \bench\_sweep.py\ for latency vs. throughput benchmarking. Additional utilities include \dependency.py\ for managing Move repository dependencies, \config-traffic-control.sh\ for configuring client-ID sources, \git-checks.sh\ for enforcing git hygiene (no submodules, case-insensitive filename conflicts), and \changed-files.sh\ for detecting uncommitted changes in CI.

scripts · high confidence

The \dapps\ directory now includes several new full implementations of example Sui decentralized applications. This adds the Kiosk CLI for managing kiosks via command line, a Kiosk Demo web app for interactive kiosk management and purchases, and a Multisig Toolkit for creating, analyzing, and executing multi-signature transactions. It also introduces a Regulated Token example demonstrating a closed-loop token with a denylist feature, and a Sponsored Transactions demo. These additions provide users with ready-to-run codebases and documentation for common Sui development patterns.

dapps · high confidence

Adds a new example indexer in \examples/rust/clickhouse-sui-indexer\ that indexes Sui blockchain data directly into a local ClickHouse database. The implementation includes a custom \ClickHouseStore\ to manage database connections and schema creation (watermarks and transaction tables), and a \TxDigests\ handler that processes checkpoints to extract and bulk-insert transaction digests into ClickHouse.

examples/rust/clickhouse-sui-indexer · high confidence

This update adds several new example projects to the repository. It introduces a Rust-based custom indexer example demonstrating local and remote checkpoint reading, and standalone TypeScript packages for DeepBook spot, margin, and predict trading workflows. Additionally, a collection of Move examples under \examples/move\ has been added or updated to use the Move 2024 edition, covering basics like shared objects and coins, as well as advanced cryptographic operations such as BLS signatures, ECDSA, ElGamal encryption, and Groth16 proofs.

examples · high confidence

The \sui-rpc-api\ crate now exposes a new gRPC v2 Ledger Service that provides checkpoint, epoch, and object retrieval via the \sui.rpc.v2\ proto definitions. This service introduces server-side request deadlines to prevent hanging streams, implements chunked scanning with bitmap-based index lookups for efficient ledger history queries, and supports partial responses through FieldMasks. It also includes a dedicated client implementation for interacting with the new v2 endpoints.

crates/sui-rpc-api · high confidence

The \sui-indexer-alt-reader\ crate now includes new modules (\alpha\_ledger\_grpc\_reader\, \consistent\_reader\, \kv\_loader\, \ledger\_grpc\_reader\, \fullnode\_client\) that provide gRPC-based access to the ledger service, consistent store, and full node execution APIs. These additions introduce \LedgerGrpcReader\ and \AlphaLedgerGrpcReader\ for fetching objects, transactions, checkpoints, and events via the v2 LedgerService, \ConsistentReader\ for balance and watermark queries, and \FullnodeClient\ for transaction simulation and execution. The crate also adds DataLoader implementations for various entity types (checkpoints, epochs, events, displays) to optimize batched loading from these new gRPC sources.

crates/sui-indexer-alt-reader · high confidence

The sui-swarm crate now provides a new in-memory (in-process) backend for building and managing Sui networks, primarily intended for end-to-end testing and benchmarking. This backend runs nodes in isolation on separate threads with their own Tokio runtimes, enabling proper shutdown and lifecycle management. It supports both single-threaded and multi-threaded runtime configurations, initializes Prometheus metrics, and includes utilities for health checks, node spawning, and swarm configuration via a builder pattern.

crates/sui-swarm · high confidence

The \sui-indexer-alt-framework\ crate introduces a new indexing architecture that groups pipelines into ingestion cohorts based on their distance from the network tip, ensuring that lagging pipelines only apply backpressure to similarly-lagging peers. It supports runtime-configurable adaptive concurrency for both ingestion and processing stages, allowing the system to automatically adjust parallelism based on downstream channel fill levels. The framework provides a fluent \IndexerClusterBuilder\ for setting up a complete indexer with PostgreSQL, metrics, and tracing, and includes a robust ingestion service that combines remote store fetching with gRPC streaming, featuring exponential backoff, streaming timeouts, and detailed cohort-level metrics.

crates/sui-indexer-alt-framework · high confidence

The mysten-metrics crate now provides built-in support for tracking in-flight operations and runtime health. It introduces \InflightGuard\ and \InflightGuardFutureExt\ to automatically increment and decrement gauges for active futures, and adds metered channel wrappers (\Sender\, \Receiver\) that expose \monitored\_channel\_inflight\, \sent\, and \received\ metrics. A custom \Histogram\ implementation is included to report percentiles via Prometheus gauges with lower overhead than standard histograms. Additionally, a \thread\_stall\_monitor\ has been added to detect and record long-running stalls in the Tokio scheduler via the \thread\_stall\_duration\_sec\ histogram.

crates/mysten-metrics · high confidence

The \move-bytecode-utils\ crate now exposes a \Modules\ helper for managing sets of compiled Move modules, including methods to retrieve immediate and transitive dependencies and to compute topological ordering. It also introduces a \SerdeLayoutBuilder\ that generates serde-reflection-friendly type layouts for Move structs and enums, supporting configuration options such as custom separators, address omission, phantom type handling, and shallow vs. deep resolution modes. Additionally, a \ModuleCache\ trait and its implementations (\ModuleCache\ and \SyncModuleCache\) provide in-memory caching for module resolution, and utility functions for resolving struct handles and formatting signature tokens are now available.

external-crates/move/crates/move-bytecode-utils · high confidence

A new \mysten-service\ crate has been introduced to centralize common service infrastructure, providing standardized health checks, metrics, logging, and server timing capabilities. The health module exposes a \/health\ endpoint that returns the service name, version, and status, while the metrics module offers a convenience function to start a Prometheus server on port 9184. Additionally, the crate includes a logging initializer for telemetry configuration and an Axum middleware to automatically append Server-Timing headers to responses, streamlining the setup of these cross-cutting concerns for dependent services.

crates/mysten-service · high confidence

The Move VM runtime now includes a new \cache\ module that manages package loading and caching, featuring an arena-based allocator (\arena.rs\) for bounded memory usage, an identifier interner (\identifier\_interner.rs\) to deduplicate identifiers, and a \MoveCache\ orchestrator that caches verified and JIT-compiled packages along with linkage virtual dispatch tables. Additionally, a new \dev\_utils\ module has been added to support testing and development, providing in-memory storage (\storage.rs\), a test adapter (\in\_memory\_test\_adapter.rs\), compilation utilities (\compilation\_utils.rs\), debug printing helpers (\dbg\_print.rs\), and gas scheduling implementations (\gas\_schedule.rs\ and \tiered\_gas\_schedule.rs\).

external-crates/move/crates/move-vm-runtime · high confidence

The \move-stackless-bytecode-2\ crate introduces a new intermediate representation (stackless bytecode) for Move modules, providing a public API to translate compiled modules or source models into this format. The translation process includes an optimization pass that inlines immediate values to simplify the resulting bytecode. This new representation is validated by snapshot tests covering basic operations, generic calls, and control flow.

external-crates/move/crates/move-stackless-bytecode-2 · high confidence

The \move-disassembler\ crate now provides a standalone command-line tool that disassembles Move bytecode (.mv) files into human-readable text. Users can specify input bytecode files and optionally provide source maps and coverage data to enrich the output. The tool supports filtering options to skip private functions, bytecode instructions, locals, or basic blocks, and includes a safety limit on output size to prevent excessive memory usage.

external-crates/move/crates/move-disassembler · high confidence

The \sui-indexer-alt-metrics\ crate now provides a standalone HTTP service that exposes Prometheus metrics on a configurable address (defaulting to 0.0.0.0:9184) at the \/metrics\ route. This service includes a new \DbConnectionStatsCollector\ that reports detailed PostgreSQL connection pool statistics (such as active/idle connections, wait times, and closure reasons) and an \uptime\ metric that tracks service duration with a version label. Users can now monitor indexer-alt infrastructure health and database connection efficiency via these new endpoints.

crates/sui-indexer-alt-metrics · high confidence

The sui-adapter crate now provides the core execution engine for the latest protocol version, introducing a new \CachedPackageStore\ to optimize package loading by caching verified Move packages and resolving types during transaction execution. The adapter also implements a comprehensive \GasCharger\ that supports gas smashing (combining multiple coins or address balances into a single payment source), gasless transaction handling, and unmetered execution modes, while enforcing protocol-configured limits on bytecode verification and runtime behavior.

sui-execution/latest/sui-adapter · high confidence

The \sui-data-store\ crate introduces a flexible, multi-tier caching system for retrieving and caching Sui blockchain data (transactions, epochs, and objects). It provides a set of core traits (\TransactionStore\, \EpochStore\, \ObjectStore\) and several implementations: \DataStore\ for remote GraphQL-backed retrieval, \FileSystemStore\ for persistent local disk caching, \InMemoryStore\ for unbounded in-memory caching, \LruMemoryStore\ for bounded LRU caching, and \ReadThroughStore\ for composable two-tier caching patterns. The crate also includes a \Node\ enum to configure network endpoints (mainnet, testnet, or custom URLs) and uses the GraphQL schema from \sui-indexer-alt-graphql\ to define its data retrieval queries.

crates/sui-data-store · high confidence

A new \sui-execution-backtest\ crate has been added to re-execute historical mainnet transactions under the current execution rules and report divergences from on-chain results. This tool helps measure the behavioral impact of execution or protocol changes before they ship. It runs as a concurrent pipeline using \sui-indexer-alt-framework\, reconstructing checkpoint state (including version-correct system packages via GraphQL and user packages via gRPC) to re-execute transactions. Divergences are recorded in two PostgreSQL tables (\divergence\ and \run\_stats\) or an ndjson file, allowing users to identify regressions in transaction status, effects, or gas usage.

crates/sui-execution-backtest · high confidence

The \sui-indexer-alt-jsonrpc\ crate now exposes a comprehensive set of new JSON-RPC methods implemented in \src/api/\. This includes \sui\_getCheckpoint\ for retrieving checkpoint data, \suix\_getCoins\, \suix\_getCoinMetadata\, \suix\_getAllBalances\, and \suix\_getBalance\ for coin and balance queries, \suix\_getDynamicFieldObject\ and \suix\_getDynamicFields\ for dynamic field lookups, \suix\_getReferenceGasPrice\, \suix\_getLatestSuiSystemState\, \suix\_getStakes\, \suix\_getStakesByIds\, and \suix\_getValidatorsApy\ for governance and staking information, \sui\_getNormalizedMoveFunction\ for Move function introspection, and \suix\_resolveNameServiceAddress\ and \suix\_resolveNameServiceNames\ for SuiNS resolution. These endpoints are wired to the indexer's consistent store and database readers to serve the data.

crates/sui-indexer-alt-jsonrpc · high confidence

The sui-network crate introduces a new peer-to-peer networking layer built on the anemo RPC framework, providing core infrastructure for the Sui network. This includes a discovery service for peer management with rate limiting and address source prioritization, a state sync service for checkpoint propagation, and a randomness service for DKG operations with inflight limits and peer authorization. The crate also defines the Validator gRPC service interface with methods for transaction submission, effects waiting, and system state retrieval, along with an endpoint manager for dynamic address updates across P2P and consensus endpoints.

crates/sui-network · high confidence

A new \sui-package-dump\ crate has been added, providing a command-line tool to export Sui Move packages to a local directory. The tool connects to a GraphQL service (configured via \rpc\_url\) to fetch package data in paginated batches, supporting checkpoint-based filtering to dump packages created before a specific checkpoint or to resume previous downloads. It uses the \cynic\ GraphQL client library and generates code from the \sui-indexer-alt-graphql\ schema, writing the resulting package files (identified by address) to a specified output directory.

crates/sui-package-dump · high confidence

A new \sui-rpc-resolver\ crate has been added to provide utilities for resolving Move type layouts and deserializing BCS-encoded data into JSON via a Sui fullnode RPC connection. It introduces \RpcPackageStore\, which fetches package data directly from the network (with optional LRU caching for performance), and \JsonVisitor\, which traverses BCS bytes to construct \serde\_json::Value\ representations. This enables off-chain applications, such as indexers, to process events and objects by resolving their types and converting them to JSON, handling numeric precision (e.g., strings for u64+) and address formatting automatically.

crates/sui-rpc-resolver · high confidence

The new sui-tls crate introduces utilities for managing TLS connections using self-signed certificates with Ed25519 keys. It provides a TlsAcceptor for Axum that extracts peer public keys and SNI hostnames into request extensions, and a SelfSignedCertificate generator for creating test or internal TLS identities. The crate also implements custom rustls verifiers (ServerCertVerifier and ClientCertVerifier) that validate certificates against specific public keys or allowlists, enabling secure, key-based mutual TLS for validator interfaces without relying on traditional Certificate Authorities.

crates/sui-tls · high confidence

The \crates/telemetry-subscribers\ library has been introduced to centralize telemetry configuration, providing a unified way to initialize tracing, logging, and metrics. Key capabilities include exporting distributed traces via OTLP (with support for local Grafana Tempo and production endpoints), writing trace data to local files via a new \FileExporter\, and automatically recording span latencies into Prometheus histograms. The library introduces a \GlobalLevelFilter\ to optimize tracing overhead by short-circuiting high-verbosity callsites, and supports dynamic log level reloading via a \reload\ handle. It also features per-target log file tails (configured via \RUST\_LOG\_TAILS\), a custom panic hook for error logging, and an \import-trace\ binary for ingesting trace files into OTLP collectors.

crates/telemetry-subscribers · high confidence

The \sui-proc-macros\ crate now provides \sui\_test\ and \sim\_test\ attributes to conditionally run tests using the Sui simulator or standard Tokio, with \sim\_test\ adding timeout handling and node-leak detection. It also introduces \checked\_arithmetic\ and \with\_checked\_arithmetic\ to replace unchecked arithmetic with safe checks, allowing code to opt out via \\#\[skip\_checked\_arithmetic\]\.

crates/sui-proc-macros · high confidence

The \sui-indexer-alt-e2e-tests\ crate now includes a comprehensive set of Move packages (coins, coin registry variants, events, SuiNS mocks, and command results) and Rust test utilities to support end-to-end testing of the indexer-alt system. This addition provides the necessary on-chain fixtures and helper functions to validate indexer behavior against various transaction types and object states.

crates/sui-indexer-alt-e2e-tests · high confidence

The trading example frontend has been rewritten to support a trustless escrow workflow. Users can now lock their owned Sui objects to make them eligible for trade, browse a list of locked objects from other users, and initiate or accept escrow exchanges. The interface includes a dashboard for managing pending requests and owned locked items, with components for infinite scrolling, object display, and on-chain state validation to ensure accurate ownership tracking.

examples/trading/frontend · high confidence

Two new Move crates have been added to the external-crates directory. The \bytecode-interpreter-crypto\ crate provides a local copy of cryptographic functions (SHA-256, SHA3-256, and Ed25519 verification) to support the stackless bytecode interpreter while decoupling it from Diem-specific dependencies. The \enum-compat-util\ crate introduces a runtime check mechanism that validates enum variant ordering against a snapshot file, ensuring backward compatibility by preventing the removal or reordering of existing variants.

external-crates/move/crates/bytecode-interpreter-crypto, external-crates/move/crates/enum-compat-util · high confidence

The \sui-pg-db\ crate introduces a new PostgreSQL-backed database implementation for the indexer, featuring an async connection pool with configurable timeouts and statement limits. It supports read-only mode for safe querying and includes TLS/SSL connection handling with optional server certificate verification and custom CA certificates. The layer manages a \watermarks\ table to track pipeline progress (epochs, checkpoints, transactions) and enforces chain ID consistency, while exposing metrics for connection pool acquisition to aid in operational monitoring.

crates/sui-pg-db · high confidence

The \sui-protocol-config\ crate now provides the central configuration system for the Sui network, defining supported protocol versions (1 through 137) and exposing a comprehensive set of feature flags, gas cost tables, and transaction limits. This change introduces a new \mainnet\_amendments.json\ file that maps specific package IDs to their original and versioned identifiers for mainnet, alongside a \reachability.rs\ module that enables runtime-gated reachability assertions for Antithesis testing. Users should note that this establishes the foundational configuration structure that governs network behavior, gas metering, and consensus parameters across all supported protocol versions.

crates/sui-protocol-config · high confidence

The sui-replay-2 tool now generates structured output artifacts for replayed transactions, including transaction data, effects, gas reports, Move execution traces, and a cache summary of accessed objects. It also introduces a new --skip-artifacts flag to bypass file writes for performance profiling. Additionally, the tool adds subcommands to rebuild, extract, and overwrite Move packages in the local cache, supporting debugging and package inspection workflows.

crates/sui-replay-2 · high confidence

The \crates/sui-sdk\ crate now includes a comprehensive README and a set of runnable examples (such as \coin\_read\_api\, \event\_api\, \programmable\_transactions\_api\, and \sign\_tx\_guide\) that demonstrate how to connect to Sui networks, manage coins, query events, and execute transactions.

crates/sui-sdk · high confidence

The transaction fuzzer now includes a new account-universe subsystem that manages accounts, balances, and peer-to-peer transfer generation (including random gas budgets, prices, and sponsorship scenarios). It adds a gas-data generator that can create random gas coins and address-balance payments, and introduces Move packages (coin\_factory and type\_factory) with generated source code to support fuzzing programmable transactions and type arguments.

crates/transaction-fuzzer · high confidence

The FastPay benchmarking harness and command-line interfaces for the client and server have been removed. This change deletes the source files for the benchmark runner (bench.rs), the client application (client.rs), the server application (server.rs), and the configuration handling logic (config.rs). Users will no longer be able to run the provided performance benchmarks or launch the FastPay authority and client binaries via the previous CLI structure, although the core network transport and library code remains available.

rust/fastpay · high confidence

The \fastpay\_core\ library has been removed from the codebase. This deletion eliminates the core implementation of the FastPay payment system, including the authority state management, client-side transaction handling, committee logic, and the associated cryptographic primitives and message definitions.

_rust/fastpay\core · high confidence

The core abstract interpretation engine and control-flow graph (CFG) logic previously embedded in the bytecode verifier have been extracted into a new, standalone \move-abstract-interpreter\ crate. This change refactors the verifier's internal architecture by separating the generic analysis infrastructure (including the \AbstractInterpreter\ trait, \analyze\_function\ driver, and CFG construction) from the Move-specific transfer functions and safety checks. The bytecode verifier now depends on this shared library to drive its static analysis, making the abstract interpretation logic reusable for other tools or future compiler passes while preserving the existing verification behavior for Move modules.

external-crates/move/crates/move-bytecode-verifier · high confidence

The JSON-RPC server implementation has been reorganized into distinct, dedicated modules for each API domain (coin, governance, indexer, bridge, read, transaction execution, and transaction builder). This change introduces a \StateRead\ trait to abstract state access, centralizes error handling in a new \error\ module, and adds a \balance\_changes\ module to compute balance deltas from transaction effects, improving code maintainability and separation of concerns.

crates/sui-json-rpc · high confidence

A change to existing behaviour in crates/sui-framework-snapshot/bytecode\_snapshot/77, crates/sui-framework-snapshot/bytecode\_snapshot/78 — 1 commit, 10 files.

(repo-wide) · medium confidence · unverified

A change to existing behaviour in crates/sui-framework-snapshot/bytecode\_snapshot/32 — 11 commits (1 fix), 4 files.

(repo-wide) · medium confidence · unverified

A change to existing behaviour in crates/sui-framework-snapshot/bytecode\_snapshot/103 — 2 commits, 5 files.

(repo-wide) · medium confidence · unverified

The \sui-kvstore\ crate now uses the \protox\ compiler to generate Rust bindings for the Google Bigtable v2 API, replacing the previous build-time mechanism. This change introduces a new \build-protos\ script and includes the necessary Google API annotation and routing proto definitions, ensuring the generated client code aligns with the updated \tonic-prost-build\ 0.14.2 tooling.

crates/sui-kvstore · high confidence

The \.agents/skills\ location is now a symbolic link pointing to \../.claude/skills\. This change consolidates agent skill definitions under the \.claude\ directory, meaning any updates to agent behavior or available skills will now be managed in that central location rather than within the \.agents\ folder itself.

.agents · medium confidence

The Sui CLI now provides clearer, human-readable error messages when Move transactions abort. A new \clever\_error\_rendering\ module parses raw Move abort status strings and, by fetching the relevant on-chain package via the RPC client, decodes the abort code to display the specific error identifier and value. This replaces the previous opaque error output with a structured message that includes the function, line number, and error details, making it easier for users to debug transaction failures.

crates/sui/src · high confidence

The sui-test-validator binary has been deprecated and replaced by the sui start command. Users should now use sui start --with-faucet --force-regenesis for basic local network functionality, or include --with-indexer and --with-graphql flags to enable indexer and GraphQL services respectively. For those requiring the previous behavior, a drop-in replacement script is available at sui/scripts/sui-test-validator.sh.

crates/sui-test-validator · high confidence

The \DBMapUtils\ derive macro in \crates/typed-store-derive\ has been updated to parse and handle specific struct field attributes. Users can now use \\#\[default\_options\_override\_fn = "..."\]\ to specify a custom function for database options, \\#\[rename = "..."\]\ to assign a different column family name than the struct field, and \\#\[deprecated\]\ to mark a column family as deprecated. The macro also supports a \tidehunter\ attribute on the struct itself to enable tidehunter-specific behavior.

crates/typed-store-derive · high confidence

The Sui CLI now performs upgrade compatibility checks by default when upgrading Move packages. This new functionality validates that package upgrades adhere to compatibility rules, preventing breaking changes to existing structs, enums, and functions. The implementation includes detailed error reporting for specific incompatibilities, such as missing structs, ability mismatches, or signature changes, ensuring that only safe upgrades are applied.

_crates/sui/src/upgrade\compatibility · high confidence

The system now validates that gasless transactions meet a minimum deposit threshold, preventing low-value or dust transactions from being processed without gas fees. This change ensures that the cost of processing these transactions is justified by the deposit amount, improving network efficiency and security.

crates/sui-types · high confidence

The CLI now provides structured, table-based displays for transaction dry runs, simulations, and Programmable Transaction Block (PTB) results. Users will see clearer breakdowns of object and balance changes, explicit gas cost estimates (including computation, storage, and rebates), and more detailed execution error sources (including the specific command that failed) when transactions fail. PTB previews also now explicitly list gas budget, price, sponsor, and sender metadata in a readable table format.

crates/sui/src/displays · high confidence

The consensus core now uses a new Tonic-based gRPC implementation for network communication, replacing the previous approach. This change introduces a build script that generates service definitions for both the validator interface (ConsensusService) and the observer interface (ObserverService), enabling features such as block streaming, commit fetching, and round synchronization via gRPC methods like send\_block, subscribe\_blocks, and stream\_blocks.

consensus/core · high confidence

The data ingestion core now allows operators to control the maximum number of checkpoints processed concurrently via the \MAX\_CHECKPOINTS\_IN\_PROGRESS\ environment variable, defaulting to 10,000. This limit is enforced by the \IndexerExecutor\ to cap the number of in-flight checkpoints and is used to size internal channels for progress reporting and checkpoint distribution to worker pools, helping to manage memory and resource usage during high-throughput ingestion.

crates/sui-data-ingestion-core/src · high confidence

The local faucet now uses a new \LocalFaucet\ implementation that retries gas-coin lookups with exponential backoff to handle startup races and executes transactions with configurable retries. It includes load shedding to return 503 Service Unavailable when overloaded, supports CORS, and exposes gas-dispensing endpoints at /v2/gas, /v1/gas, and /gas. The service is configurable via CLI (port, host, amount, number of coins, and wallet client timeout) and is designed for local development use, including integration with sui start.

crates/sui-faucet · high confidence

The \sui-package-alt\ crate replaces the legacy \sui-package-management\ crate, providing a new package management system for Move packages on Sui. This change introduces a \SuiFlavor\ implementation that resolves system dependencies by querying the network's protocol version via gRPC, ensuring correct dependency versions for the active environment. It also adds robust environment resolution logic in \find\_env.rs\, which matches CLI active environments to \Move.toml\ definitions by name and chain ID, supporting explicit environment selection and providing clear error messages when mismatches occur. The crate exposes utilities for defining mainnet and testnet environments and handles legacy package loading and manifest migration.

crates/sui-package-alt · high confidence

The sui-system module is now a standalone framework package using the Move 2024 edition, with its dependencies pinned via a new Move.lock file. This release introduces a versioned system state architecture (SuiSystemStateInnerV1 and SuiSystemStateInnerV2) to support safe on-chain upgrades, and adds a new minimum staking threshold of 1 SUI enforced in the staking pool logic.

crates/sui-framework/packages/sui-system · high confidence

The \sui-open-rpc-macros\ crate now supports routing RPC methods to different implementations based on the client's version. The \open\_rpc\ attribute macro parses \version\_routing\ definitions from trait methods and generates code to register these routes via \builder.add\_method\_routing\, enabling backward compatibility by directing requests to specific API versions.

crates/sui-open-rpc-macros · high confidence

The \shared-crypto\ crate now enforces intent-based domain separation for all cryptographic signatures. A new \intent\ module defines \Intent\ (comprising scope, version, and application ID) and \IntentMessage\ wrappers, ensuring that signatures commit to a structured domain prefix rather than raw message data. This prevents cross-application or cross-scope signature collisions (e.g., between Sui transactions, Narwhal headers, and personal messages) by appending a 3-byte intent prefix to signed content.

crates/shared-crypto · high confidence

The \sui-cluster-test\ framework now communicates with fullnodes exclusively via gRPC services (\LedgerService\, \StateService\, \TransactionExecutionService\) instead of the previous JSON-RPC interface. This change introduces a new \WalletClient\ that wraps the wallet context to expose the gRPC client, updates the \Cluster\ abstraction to support local and remote environments, and adds helper utilities like \ObjectChecker\ and \BalanceChangeChecker\ to verify object state and balance changes over the new transport. Existing test cases (e.g., native transfers, staking, coin merging) are now executed against these gRPC endpoints.

crates/sui-cluster-test/src · high confidence

The Move CLI has been rewritten to use the new \move\_package\_alt\ package management system, replacing the legacy implementation. This change introduces a new set of base commands (\build\, \coverage\, \decompile\, \disassemble\, \docgen\, \lint\, \migrate\, \new\, \profile\, \summary\, \test\, \update\_deps\) that operate on the modern package structure. Notable behavioral updates include the \sui move new\ command now defaulting to the Move 2024 edition, the addition of a \lint\ command for running linters, a \migrate\ command for upgrading packages to Move 2024, and a \summary\ command for generating package metadata. The CLI also now supports LCOV coverage generation via \move coverage lcov\ and integrates with the new tracing format for gas profiling.

external-crates/move/crates/move-cli · high confidence

The Move VM configuration crate now exposes explicit configuration structs for the verifier, runtime, and gas metering, establishing new default limits and behavioral flags. Key changes include a reduction in default gas meter units per function, module, and package from 8,000,000 to 2,200,000, and the introduction of new verifier options such as \reject\_mutable\_random\_on\_entry\_functions\ (enabled by default), \framework\_tx\_context\_mut\_restrictions\, and \disallow\_jump\_orphans\. Runtime defaults now enforce checking for extraneous bytes during deserialization, normalize depth formulas, and charge \LdConst\ based on abstract value size rather than serialized byte length. The crate also introduces a \tracing\ feature flag to control VM profiling capabilities, replacing the previous \gas-profiler\ naming convention.

external-crates/move/crates/move-vm-config · high confidence

The Move analyzer binary now configures its memory allocator based on the operating system to optimize resource usage. On Linux, it integrates jemalloc to better handle temporary memory allocations and reduce memory retention, while on macOS and Windows, it continues to use the standard system allocator, which is considered more suitable for those environments. This change is implemented in the new \move-analyzer.rs\ binary entry point within the \sui-move-lsp\ crate.

crates/sui-move-lsp · high confidence

The move-binary-format crate has been reorganized to introduce a new \BinaryConfig\ system that centralizes deserialization settings, including explicit min/max version enforcement, extraneous byte checking, and global storage operation deprecation. This change adds a new \TableConfig\ to enforce limits on binary table sizes and introduces a comprehensive compatibility checking framework (\compatibility.rs\) that validates module upgrades by comparing struct, enum, and function signatures. Additionally, the crate now supports an 'unpublishable' magic number for test-only modules and captures backtraces on error creation in debug builds to aid in debugging.

external-crates/move/crates/move-binary-format · high confidence

The Move bytecode viewer has been refactored to replace the unmaintained \tui\ crate with \ratatui\, updating the terminal UI backend. The viewer now features a split-screen interface: the left pane displays the disassembled bytecode, while the right pane shows the corresponding source code. Moving the cursor in the bytecode pane automatically highlights the relevant source code location in the right pane, providing a direct correlation between compiled instructions and their original source.

external-crates/move/crates/move-bytecode-viewer · high confidence

The \move-package\ crate has been reorganized into distinct modules for parsing, resolution, compilation, and migration, introducing a new lock file schema (version 3) that records toolchain versions, editions, and managed package metadata. The compilation pipeline now supports explicit migration to the Move 2024 edition, generates documentation and disassembly artifacts, and utilizes a robust caching system based on source digests. Package resolution now handles on-chain dependencies via registered hooks and enforces stricter named address unification, while the build process ensures thread-safe access to the package cache through process-level locking.

external-crates/move/crates/move-package · high confidence

The Move standard library package has been reorganized and updated to the Move 2024 beta edition. This change introduces a new package manifest (Move.toml) and lock file (Move.lock) for the MoveStdlib package, establishing it as a distinct, versioned unit. The source files have been migrated to use Move 2024 syntax, including method syntax for standard library calls and updated macro implementations. Additionally, the package now includes a broader set of standard modules such as ascii, bit\_vector, and internal::Permit, while deprecating older fixed-point types in favor of uq32\_32.

crates/sui-framework/packages/move-stdlib · high confidence

The analytics indexer now includes a new set of table-specific processors under \crates/sui-analytics-indexer/src/handlers/tables\ that extract structured data from checkpoints using the \sui\_indexer\_alt\_framework\. These new processors—covering checkpoints, dynamic fields, events, Move calls, objects, packages (including BCS), transactions (including BCS), transaction objects, and wrapped objects—replace the previous indexing logic. This change introduces support for \Owner::Party\ and \Owner::ConsensusAddressOwner\ in object ownership tracking, utilizes \sui\_rpc\_resolver\ for package resolution, and provides detailed transaction metrics such as command counts and gas summaries, enabling richer analytics queries on the Sui network state.

crates/sui-analytics-indexer/src/handlers/tables · high confidence

The sui-verifier crate now enforces several Sui-specific bytecode rules: entry points must follow strict signature constraints (e.g., init functions are private, have at most two parameters, and cannot be called from other Move functions); global storage access via deprecated Move opcodes is forbidden; object IDs cannot leak out of functions; one-time witness types are validated; private generics in transfer and event modules are restricted; structs with the key ability must have an 'id' field of type sui::object::UID, and enums cannot have the key ability; and system packages cannot return mutable references rooted in TxContext without another mutable parameter. Additionally, a new metering system tracks verifier ticks at transaction, package, module, and function scopes, using PROGRAM\_TOO\_COMPLEX for limits.

sui-execution/latest/sui-verifier · high confidence

The benchmarking tooling in \crates/sui-benchmark/src/drivers\ has been refactored to introduce a new \BenchDriver\ and a generic \Driver\ trait, replacing the previous implementation. This change introduces a new \SubmissionAmplification\ configuration that allows users to simulate network conditions by enabling transaction duplication and amplification (sending multiple copies of a transaction to different validators) with configurable probabilities and validator selection strategies (random or highest-performance). The driver now tracks detailed metrics including success/error counts by workload, latency histograms, CPU usage, and validator contribution stats, providing more granular insights into benchmark performance.

crates/sui-benchmark/src/drivers · high confidence

The \sui-execution\ crate now provides a strict abstraction layer that isolates the execution engine from the rest of the network, preventing accidental forks by ensuring validators and fullnodes use the protocol-configured execution version rather than hardcoded binaries. This change introduces a versioning system with \latest\, versioned snapshots (e.g., \v0\ through \v3\), and feature cuts, alongside a new \Executor\ trait that standardizes transaction execution across these versions. It also includes a new \ModuleBuilder\ test utility for the verifier and enforces stricter restrictions on \TxContext\ usage in system packages to improve security.

sui-execution · high confidence

The bytecode verifier metering logic has been rewritten to support granular resource limits at the package, module, and function levels. Users can now configure maximum meter units per package, module, and function via the new MeterConfig, and the verifier will reject programs that exceed these specific bounds with a 'program too complex' error. The metering system is now abstracted behind a Meter trait, allowing for both a bounded implementation that enforces these limits and a dummy implementation for testing or disabled metering scenarios.

external-crates/move/crates/move-bytecode-verifier-meter · high confidence

The \sui-transaction-checks\ crate now includes a dedicated \deny\ module that enforces a configurable deny list at transaction signing time. This allows the network to temporarily disable specific features or block specific accounts, including: user transactions, gasless transactions, zkLogin authenticators (and specific OAuth providers), package publishing/upgrades, and access to specific receiving objects or input object IDs. A new \check\_transaction\_for\_signing\ function applies these checks before execution, ensuring that denied transactions are rejected early with clear error messages.

crates/sui-transaction-checks · high confidence

The package resolver now provides a dedicated \Error\ enum with specific variants for resolution failures (such as \ModuleNotFound\, \FunctionNotFound\, \DatatypeNotFound\, and \TypeArityMismatch\) and enforces configurable limits on type parameter depth, width, and value nesting to prevent excessive resource consumption during type resolution.

crates/sui-package-resolver · high confidence

The \sui-protocol-config-macros\ crate now generates a \render\ method that includes every protocol config field in its output, even if the field is not configured for the current protocol version. Previously, unset fields might have been omitted, potentially causing instability in the set of keys returned to RPC clients. With this change, unset fields are explicitly rendered as \Format::null\, allowing consumers to distinguish between a key that is unknown and a key that is present but unset. This ensures a stable keyset across protocol versions for any format implementation (such as JSON or Prost).

crates/sui-protocol-config-macros · high confidence

The \sui client verify-source\ command has been reimplemented to verify that a Move source package compiles to the exact bytecode and linkage of the on-chain package it was published as. The tool now downloads and caches historical \sui\ toolchain binaries (with least-recently-used eviction) to rebuild the source with the specific compiler version used at publication, ensuring reproducible builds. It compares the rebuilt module bytecode and the full dependency linkage table against the on-chain package, reporting all mismatches together. The command supports overriding the toolchain version via \--toolchain-version\ and includes a \--verify-only\ mode for comparing locally pre-built bytecode against the chain. It also detects dependencies pinned to moving revisions (branches/tags) that prevent reproducible builds and warns about them.

crates/sui-source-verification · high confidence

The typed-store workspace-hack crate has been reintroduced to the workspace. This addition ensures that the workspace-hack mechanism is scoped specifically to typed-store, likely to manage dependency resolution or build configuration for that component. The crate includes a stub library, a minimal build script, and git attributes to handle Cargo.toml generation correctly.

crates/typed-store-workspace-hack · medium confidence

The \rust/rust-toolchain\ file, which previously pinned the project to the \stable\ Rust version, has been deleted. This change removes the local toolchain constraint, aligning with the shift to a CI matrix-based configuration for managing Rust versions.

rust · high confidence

This change introduces a comprehensive set of new configuration files and updates to existing ones to standardize the development environment. It adds root-level configuration for Rust (rust-toolchain.toml, rustfmt.toml, .clippy.toml), JavaScript/TypeScript (prettier.config.js, .eslintrc.js, .npmrc, pnpm-workspace.yaml, turbo.json), and general repo hygiene (.gitignore, .dockerignore, .lycheeignore, .typos.toml). It also establishes new documentation standards with CLAUDE.md and AGENTS.md, updates the README to reflect the Sui brand and architecture, and configures cargo-deny (deny.toml) for license and advisory checks. Additionally, it removes the legacy Calibra/FastPay branding and documentation, replacing it with Sui-specific content in CONTRIBUTING.md and CODE\_OF\_CONDUCT.md.

(repo-wide) · high confidence

The \move-docgen\ crate has been rewritten to use the new Move model v2, replacing the previous implementation. This change introduces a new \CodeWriter\ utility for structured output generation and updates the core documentation logic to align with the new model architecture, ensuring generated documentation reflects the current state of the Move language model.

external-crates/move/crates/move-docgen · high confidence

The checkpoint notification mechanism in sui-core has been refactored to no longer require a PendingCheckpoint object as an argument. This change streamlines the interface for notifying about checkpoint progress, reducing complexity in how checkpoint state is communicated within the core authority logic.

crates/sui-core · medium confidence

The test-cluster crate has been refactored to use a gRPC client for test interactions, deprecating the previous HTTP-based RPC and Sui SDK clients on FullNodeHandle. Additionally, a new addr\_balance\_test\_env module has been added to provide test utilities for funding and managing address balances, and the TestClusterBuilder now supports injecting custom genesis objects to override framework packages or add test-specific state.

crates/test-cluster · high confidence

The Move transactional test runner's snapshot output now includes standalone comments that appear after source-bearing tasks (such as \publish\ or \run\), while comments attached directly to the task directives are excluded. This change improves the readability of test logs by preserving explanatory context without cluttering the output with directive-specific annotations.

external-crates/move/crates/move-transactional-test-runner · high confidence

The typed-store crate has been reorganized into a modular structure, introducing a build script that gates the TideHunter storage backend via the USE\_TIDEHUNTER environment variable. This change adds a new InMemoryDB implementation for testing, a dedicated TideHunter utility module for handling TideHunter-specific configuration and key-space management, and a SafeIter implementation that provides robust, error-safe iteration over RocksDB and TideHunter data. The library now exposes a unified StorageType enum (Rocks, InMemory, TideHunter) and re-exports the underlying RocksDB crate, allowing consumers to access the storage backend through a consistent API while supporting configurable compaction, write buffers, and metrics collection.

crates/typed-store · high confidence

Package upgrades now automatically verify compatibility with the existing package by default, preventing breaking changes to public interfaces such as removing or modifying structs, enums, functions, and their fields, types, abilities, and signatures. The CLI will report detailed errors (e.g., missing declarations, type mismatches, ability changes) and fail the upgrade if the new package is not compatible with the upgrade policy (compatible, additive, or dependency only). Users can bypass this local verification using the --skip-verify-compatibility flag.

_crates/sui/src/unit\tests/snapshots · high confidence

A fix in crates/sui-framework-snapshot/bytecode\_snapshot/117, crates/sui-framework-snapshot/bytecode\_snapshot/118 — 1 commit (1 fix), 10 files.

(repo-wide) · medium confidence · unverified

The sui-benchmark crate now conditionally enables the \tidehunter\ configuration flag during the build process when the \USE\_TIDEHUNTER\ environment variable is set, ensuring that simtests compile correctly in environments where this feature is required.

crates/sui-benchmark · high confidence

The tree-sitter grammar for the Move language has been updated to support module extensions and fix several parsing bugs, including issues with return reference parsing and \spec\ variable-name parsing. This update ensures that the language server and IDE tooling can correctly parse and analyze Move code that utilizes these features.

external-crates/move/tooling/tree-sitter · high confidence

Add end-to-end tests for Sui Bridge functionality; Add integration tests for CLI, PTB, and shell scripts; Add transactional tests for address balance gas payment and coin reservations; Added DeepBook client test fixture; Added Move IR transactional tests for bytecode generation and parsing; Added Move VM transactional tests for vector operations and control flow; Added RPC integration tests for display v2, transaction-to-object transfers, and dry-run balance changes; Added benchmark test packages for Move VM performance testing; Added cluster-test cases for coin management, transaction execution, and staking via gRPC; Added comprehensive test coverage for consensus commit logic; Added comprehensive test suite for EVM Bridge contracts; Added empirical transaction cost tests for common operations; Added end-to-end tests for GraphQL module introspection; Added end-to-end tests for the Sui Analytics Indexer; Added framework compatibility and integrity tests; Added historical bytecode verifier test suite; Added local cluster integration test; Added serializer roundtrip and fuzz tests for Move compiled modules; Added shell test for git-based package caching; Added shell test for the \cache-package\ CLI command; Added shell tests for CLI package summary generation; Added shell tests for Sui client chain\_id caching behavior; Added shell tests for \sui move new\ behavior; Added shell tests for bytecode dumping and dry-run publishing; Added shell tests for implicit dependencies and linter suppression stats; Added shell tests for sui move format command; Added simulated load testing infrastructure for Sui benchmarking; Added test coverage for package dependency override resolution; Added test coverage for renaming packages with identical names; Added test fixtures for Move 2024 upgrade error scenarios; Added test fixtures for package management and tree shaking; Added test fixtures for package resolution validation; Added test fixtures for package resolver enum and struct resolution; Added test fixtures for package resolver type resolution; Added test fixtures for package summary generation; Added test for PTB package publishing with hex chain identifier; Added test for Sui-specific Move linting; Added test for bytecode dump with published dependency original-id; Added test for publishing packages with unpublished dependencies; Added test mocks for Sui Bridge V2 and ERC20 tokens; Added test package for PackageResolver type resolution; Added test package for module resolution validation; Added test to verify sui-framework package builds match checked-in artifacts; Added tests for CLI config creation and external key bootstrapping; Added tests for CLI environment override behavior; Added tests for CLI package summary generation in JSON and YAML formats; Added tests for GraphQL package typeOrigins query; Added tests for Move environment resolution logic; Added tests for Move package linkage GraphQL queries; Added tests for environment validation error messages; Added tests for ephemeral bytecode dump with pubfile resolution; Added tests for ephemeral package publication and upgrade workflows; Added tests for legacy system dependency handling in Move packages; Added tests for package dependency repinning behavior; Added tests for package publish and upgrade workflows; Added transactional tests for Move 2024 constant folding and cross-module constant usage; Added transactional upgrade compatibility tests for Move packages; Added type limits test package for deep and wide struct validation; Added unit tests for keytool, upgrade compatibility, and validator commands; Move documentation generator test suite added; New bytecode verifier transactional tests for Move IR; New consensus simulation test suite for crash recovery and randomized DAG logic; New e2e test coverage for address balances, allowances, and admission queue; New entry-point parameter validation tests for the Sui Move verifier; New fuzzing and property-based tests for the Move bytecode verifier; New test harness for framework and example package verification; Snapshot tests for PTB file parsing and execution.

A dependency / build maintenance change in (dependencies) — 3358 commits (234 fixs), 272 files.

(dependencies) · high confidence · unverified

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 49.

• Code Health 73
• Architecture 92
• Maturity 77
• Readiness 49
• Security 41
• Domain Modelling 100
• Event Sourcing 100
• Accessibility 44

• 300 commits — 277 feature/other, 23 fixes

• docs/content — 67 commits
• crates/sui-indexer-alt-graphql — 31 commits
• external-crates/move — 27 commits
• crates/sui-core — 20 commits
• (root) — 11 commits
• consensus/core — 11 commits
• crates/sui-rpc-api — 11 commits
• crates/sui-adapter-transactional-tests — 10 commits
• crates/sui-source-verification — 7 commits
• sui-execution/latest — 7 commits
• crates/sui-fork — 6 commits
• crates/sui-indexer-alt-reader — 6 commits
• crates/sui — 5 commits
• crates/sui-protocol-config — 5 commits
• crates/sui-framework — 4 commits
• crates/sui-framework-snapshot — 4 commits
• crates/sui-indexer-alt-e2e-tests — 4 commits
• crates/sui-kv-rpc — 4 commits
• crates/sui-kvstore — 4 commits
• crates/sui-types — 4 commits

• fix: Better (protocol-gated) fix for accumulator DoS
• fix: Fix cargo-deny advisories (#27527)
• fix: Fix controller observation bug (#27704)
• fix: Fix for accumulator settlement DoS
• fix: [chore] Fix cargo deny (#27745)
• fix: [chore] Fix cargo deny imbl (#27693)
• fix: [chore] try to fix windows build failing by switching to a beefier runner (#27694)
• fix: [cli] Fix sui client verify-bytecode-meter panicking on a package path (#27489)
• fix: [docs] fix dApp Kit ImportContent 404s on wallet pages (#27824)
• fix: [move-compiler] Fix cast optimization (#27604)
• fix: [move-model] Fix stackless bytecode from-bytecode tests (#27453)
• fix: [move][move-decompiler] emit mut annotations, recover match guards, fix by-ref unpack rendering (#27843)
• fix: [ptbs] Fix Read argument generation (#27885)
• fix: [sui-execution-backtest] Fix system package versions (#27497)
• fix: [sui-indexer-alt-graphql] Fix queries_in_flight gauge never decrementing on request cancellation (#27581)
• fix: [trace] Fixed handling of large integers in PTB execution traces (#27645)
• fix: fix the source-verification-matrix nightly test (#27657)
• fix: fix(docs): correct LBTC name in bridging docs (#27825)
• fix: fix(sui-rpc-api): include object id in resolve version/digest mismatch errors (#27632)
• fix: fix[cli]: use keytool keystore path (#27662)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

MystenLabs/sui was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.