wavesplatform/Waves

This system is the Waves blockchain node, a distributed ledger implementation written in Scala that manages consensus, state persistence via RocksDB, and peer-to-peer networking. It provides a comprehensive smart contract environment through the RIDE language, supporting multiple versions with extensive documentation and a standalone evaluation service. The platform exposes blockchain data and state updates through both legacy REST and modern gRPC APIs, while offering tooling for development, load testing, and interactive scripting.

30 changes.

This period focused on migrating the core blockchain infrastructure from Java to Scala, including the database, network stack, and cryptographic modules, while modernizing the build system with SBT and Apache Pekko. Concurrently, the project established the RIDE smart contract language by implementing its JVM and JavaScript runtimes, adding compiler tooling, and creating benchmarking infrastructure for performance testing.

24 changes.

This period focused on establishing the foundational infrastructure for the Waves Node Testkit, including comprehensive integration test suites for blockchain features, transaction types, and network behavior. Concurrently, a new gRPC API server was introduced to expose blockchain state and updates, supported by extensive documentation and testing for the RIDE language specification.

24 changes.

This period focused on documenting and implementing the RIDE language specifications for versions 4, 5, and 6, including comprehensive function references and type definitions. Concurrently, the team developed a new interactive REPL with JavaScript and JVM support, enabling live node interaction and script compilation. Extensive integration tests were added to validate these language features, the new crypto implementations, and the REPL's functionality.

9 changes.

This period focused on documenting the progression of the RIDE smart contract language through versions 7, 8, and 9, while introducing a standalone service for script evaluation. Concurrently, the team significantly expanded the testing infrastructure by extracting a dedicated testkit module, adding deterministic blockchain generation utilities, and implementing comprehensive integration tests for light node behaviors.

The \lang\ directory now includes new template files (\doc.template.html\, \doc.template.md\, and \func-doc.template.md\) that define the structure for generating RIDE language documentation. These templates support the rendering of types, input variables, functions (including cost and parameter details), and transaction fields (both common and class-specific) in both HTML and Markdown formats, enabling the generation of comprehensive reference guides for the language.

lang · high confidence

The REPL now includes a new HTTP client implementation (SttpClient) that allows it to send requests to a node URL. This change introduces a new capability for the REPL to interact with external nodes via HTTP, using the Sttp library for network communication.

repl/jvm/src/main · high confidence

This update introduces new sample RIDE scripts for the \lang/shared\ module, specifically \fomo.ride\ (a Fear of Missing Out contract) and \wallet.ride\ (a basic deposit/withdrawal wallet), providing reference implementations for DApp developers. Additionally, it adds foundational Scala utility libraries to the language runtime, including a high-performance \FastBase58\ encoder/decoder, a \Merkle\ tree implementation with proof verification, and a \ScryptoMerkleProof\ parser, alongside a new \ByteStr\ value type for handling byte arrays.

lang/shared · high confidence

The V3 documentation now includes the \types.hjson\ and \vars.json\ files, which formally define the language's data types (such as \Order\, \Address\, and \AssetPair\) and global variables (including rounding modes, digest algorithms, and transaction context variables). This provides users with a structured reference for the available types and runtime variables in the V3 specification.

lang/doc/v3 · high confidence

A new \application.conf\ file has been added to the benchmark resources, defining a \waves.benchmark.state\ configuration block. This block specifies file paths and starting heights for loading various blockchain state components, including network configuration, aliases, REST transactions, blocks, accounts, assets, and general data, while also including a local configuration profile.

benchmark/src/main/resources · high confidence

The v4 language documentation now includes formal definitions for built-in types and global variables. The new \types.hjson\ file defines the structure of core types such as \Address\, \Order\, \Transfer\, and various rounding modes (e.g., \CEILING\, \HALFUP\), while \vars.json\ documents global constants and context variables like \tx\, \this\, and \lastBlock\. This provides users with a reference for the available data structures and environment variables in the v4 language specification.

lang/doc/v4 · high confidence

This change introduces the complete function, type, and variable reference documentation for the v7 language specification. It defines the available built-in functions for account data storage, blockchain interactions, byte-array and string manipulation, encoding/decoding, mathematical operations, and cryptographic verification (including Curve25519, RSA, and Groth16 zero-knowledge proofs). It also documents the supported data types, operators, and global variables available to smart contracts in this version.

lang/doc/v7 · high confidence

The node testkit module has been extracted and populated with a comprehensive set of Scala-based testing utilities. This includes helpers for managing blockchain state (WithState, Domain), generating test transactions and blocks (TransactionGen, TestBlock), and providing assertion matchers for API errors and Either types (ApiErrorMatchers, EitherMatchers). These components provide the foundational infrastructure for running node-level integration and unit tests.

node/testkit · high confidence

This change introduces the official Docker infrastructure for running the Waves Node, including the main Dockerfile, entrypoint script, and build automation. The production image now runs on Java 21 (using the eclipse-temurin:21-jre-noble base image) and bundles the Amazon Corretto Crypto Provider and RocksDB JNI libraries for cryptographic and storage operations. Users can deploy the node with configurable environment variables for network selection (mainnet, testnet, stagenet), wallet credentials, heap size, and logging levels, while data and configuration are persisted via Docker volumes. A separate builder image using Java 11 is also provided to compile the node artifacts.

docker · high confidence

This change introduces the \Global.scala\ file for the JavaScript target, providing the concrete implementations for core cryptographic (Base58, Base64, Base16, Keccak256, Blake2b256, SHA256, Curve25519, RSA), mathematical (pow, log), and utility functions required by the language runtime. While stubs are present for advanced cryptographic features like Groth16, Bn256, ecrecover, and P-256, the entry establishes the foundational global context that allows scripts to execute these basic operations in a JavaScript environment.

lang/js/src/main/scala/com/wavesplatform/lang · high confidence

This change introduces the complete reference documentation for the RIDE v8 standard library, defining the available functions, types, and global variables. It covers account data storage accessors (e.g., \getString\, \getInteger\), blockchain introspection (e.g., \blockInfoByHeight\, \transactionHeightById\), cryptographic verification (e.g., \sigVerify\, \rsaVerify\, \groth16Verify\), and utility functions for lists, strings, and math. It also documents the \calculateDelay\ function for Fair PoS mining delay calculation and the \reentrantInvoke\ function for dApp interactions.

lang/doc/v8 · high confidence

This location introduces the foundational structure for the Waves Node Testkit, including a README pointing to external documentation, Protobuf API definitions for data requests and database entities (such as asset details, block metadata, and transaction states), and default configuration files for network settings (testnet, devnet, mainnet, stagenet), logging (Logback), and metrics (Kamon). It also includes a patch file for cancelling all leases, indicating initial state management capabilities.

node · high confidence

The node-generator now includes its foundational configuration resources, establishing the baseline for transaction generation. The new accounts.conf defines the initial set of test accounts, while preconditions.conf sets up the required environment state (balances, leases, and assets). The application.conf configures the generator's runtime behavior, including network targets, worker parameters, and transaction probability distributions for modes like NARROW and wide, alongside specific settings for scripts, multisig, and oracle transactions. Additionally, logback.xml is added to standardize logging output.

node-generator/src/main/resources · high confidence

Added \data.json\ and \types.hjson\ files for both language version 1 and version 2. These files define the available variables (such as rounding modes and blockchain state), functions (including cryptographic hashes, base encoding, and account data retrieval), and type structures (such as \Order\, \Transfer\, and transaction types) for the language reference.

lang/doc/v1, lang/doc/v2 · high confidence

Added a new \lang/testkit\ module providing utilities for testing the RIDE language, including a \TestCompiler\ for compiling scripts and DApps, \ScriptGen\ and \TypedScriptGen\ for property-based testing of RIDE expressions, and helper classes like \ProduceError\ and \NumericExt\ for test assertions.

lang/testkit · high confidence

Adds a new standalone service that allows running RIDE scripts without a local Waves Node, exposing a REST API on port 6890 (including the \/utils/script/evaluate\ endpoint) and providing Docker, DEB, and standalone distribution options. The service supports configuration for mainnet, testnet, and custom networks, includes Prometheus metrics via Kamon on port 9095, and utilizes Apache Pekko for its underlying actor system.

ride-runner · high confidence

The JavaScript language implementation now exposes native bindings for runtime environment data and cryptographic operations directly to user scripts. The new Environment object provides access to the current block height, chain ID, the invoking account (this), and functions to query account balances, resolve aliases, and fetch transaction details by ID. Additionally, the Global object exposes native implementations for curve25519 verification, RSA signature verification, and hashing algorithms (keccak256, blake2b256, sha256), as well as an HTTP GET function, allowing scripts to perform these operations natively in the browser or Node.js environment.

lang/js/src/main/scala/com/wavesplatform/lang/impl · high confidence

This change introduces a new set of JVM-specific Scala files (FileCompiler, Global, Lang, model) that provide the concrete implementation for the Waves language runtime on the JVM. It adds a command-line file compiler (FileCompiler) that supports importing other script files, exposes cryptographic functions (base58, base64, base16, keccak256, blake2b256, sha256, curve25519, rsaVerify, ecrecover, p256verify, groth16Verify, bn256Groth16Verify) via the Global object, and provides high-level compilation APIs (Lang.compile, Lang.compileDApp, Lang.parseAndCompile) that return structured results including DApp metadata. These files serve as the JVM binding layer for the language engine, handling input parsing, estimation, compilation, and serialization.

lang/jvm/src/main/scala/com/wavesplatform/lang · high confidence

The Waves platform now exposes a new JavaScript API (JsAPI) that allows users to parse and compile scripts, retrieve detailed documentation for functions and variables, and inspect script metadata and contract limits directly from the JS environment. This addition provides programmatic access to the language's compiler capabilities, including AST generation and complexity estimation, without requiring external tooling.

lang/js/src/main/scala/com/wavesplatform · high confidence

The REPL is now accessible from JavaScript environments via a new \repl\ global function. This API allows external applications to initialize the REPL with optional node connection settings and libraries, and provides methods to evaluate expressions (\evaluate\), retrieve information (\info\, \totalInfo\), clear state (\clear\), and reconfigure the environment (\reconfigure\). Evaluation results are returned as JavaScript Promises, resolving with either a result object or an error object.

repl/js · high confidence

The benchmark module now includes a new RocksDB-backed state implementation (DBState.scala) and configuration model (Settings.scala) to support performance testing of state-related operations. This change introduces a JMH benchmark state class that initializes a RocksDBWriter and WavesEnvironment using pureconfig for settings loading, enabling benchmarks to run against a realistic RocksDB storage layer rather than in-memory or legacy storage. The Settings class defines the configuration structure for benchmark inputs (network, aliases, transactions, blocks, accounts, assets, data files) and uses pureconfig to parse them from the application config.

benchmark/src/main/scala/com/wavesplatform/state · high confidence

A new Docker image for running a Waves private node is now available, designed to facilitate the development of dApps and smart contracts. The image is based on the standard Waves node but includes a custom configuration that pre-activates all blockchain features, sets a 10-second block generation interval, and uses a custom chain ID ('R'). It comes with a pre-funded miner account containing Waves tokens for testing purposes, exposes the REST API on port 6869, and disables external peer connections and metrics collection to ensure a self-contained local environment.

docker/private · high confidence

This change introduces a new gRPC server module (\grpc-server\) that exposes a comprehensive API for interacting with the blockchain state. The server provides endpoints for querying accounts (balances, scripts, active leases, data entries, aliases), assets (info, NFT lists), blocks (current height, block range, specific blocks), blockchain features (activation status, base target, cumulative score), and transactions (by ID, sender, recipient, unconfirmed, snapshots, state changes, and status). It also includes a separate gRPC service for Blockchain Updates, which persists block and microblock events to RocksDB and streams them to subscribers, handling rollbacks and queue management. The server is configured via \application.conf\ with specific ports and worker thread settings.

grpc-server/src/main · high confidence

The Waves language now includes an interactive Read-Eval-Print Loop (REPL) accessible via the \Repl\ class. This feature allows users to execute expressions, define functions and variables, and view the updated context state in real-time. The REPL supports library loading, integrates with the Waves node via HTTP for blockchain interactions, and provides formatted output for declarations and evaluation results.

repl/shared/src/main/scala/com/wavesplatform/lang/v1/repl · high confidence

Added new utility classes in the generator module to support synthetic transaction and script generation. The \Gen\ object provides methods to create complex and oracle scripts, generate multi-signature scripts, and produce iterators of standard transfer and mass-transfer transactions with configurable fees and senders. Supporting utilities include \Implicits\ for random iterator handling and unit conversion, and \Universe\ for tracking issued assets and leases.

node-generator/src/main/scala/com/wavesplatform/generator/utils · high confidence

The REPL environment now supports connecting to a live Waves node over HTTP. This change introduces a new \WebEnvironment\ that fetches real-time data such as block height, account balances, asset details, and transaction history from the node, replacing the previous offline or mock behavior. Users can now configure their connection settings (URL, chain ID, address) and interact with the actual blockchain state directly within the REPL.

repl/shared/src/main/scala/com/wavesplatform/lang/v1/repl/node · high confidence

This update introduces the documentation for the RIDE V9 language version, defining the new standard library functions and types available to smart contract developers. The changes add comprehensive reference material for account data storage (reading/writing binary, boolean, integer, and string values), blockchain interaction (asset info, block info, transaction details, and reentrant invokes), and cryptographic verification (including RSA, Groth16 zero-knowledge proofs, and size-optimized Curve25519 signature checks). It also documents expanded utility functions for byte-array manipulation, encoding/decoding (Base16/58/64, Keccak/BLAKE/SHA variants), list operations, mathematical computations with rounding modes, and string processing, alongside the core type definitions and global variables (such as \this\, \height\, and \lastBlock\) that constitute the V9 runtime environment.

lang/doc/v9 · high confidence

This change establishes the foundational project structure for the Waves Node (version 1.6.4), introducing essential build and development tooling. It adds configuration for the SBT build system (\.sbtopts\, \version.sbt\), code formatting (\.scalafmt.conf\), and static analysis (\scalastyle-config.xml\). The repository also includes a \CODE\_OF\_CONDUCT.md\, an \MIT License\, and a comprehensive \README.md\ detailing installation and development steps. Additionally, it updates \.gitignore\ to exclude build artifacts and local settings, while removing legacy configuration files (\settings.json\, \start.sh\) that are no longer part of the standard workflow.

(repo-wide) · high confidence

Added documentation files for the Ride V6 language specification, including \types.hjson\ which defines core data types such as cryptographic hashes (MD5, SHA1, SHA2, SHA3), rounding modes, and blockchain entities like Addresses, Orders, and Transactions, alongside \vars.json\ which documents global variables and constants available in the language environment.

lang/doc/v6 · high confidence

The documentation for the RIDE V6 standard library functions has been added, covering account data storage, blockchain interactions, byte-array and string manipulation, encoding/decoding (including Keccak, BLAKE2b, SHA-256, and Base16/58/64), mathematical operations, list handling, and cryptographic verification (Curve25519, RSA, and Groth16 zero-knowledge proofs). Each function entry specifies its parameters, description, and execution complexity, providing a complete reference for developers using the RIDE V6 language.

lang/doc/v6/funcs · high confidence

The V3 language reference now includes detailed documentation for standard library functions, organized into categories such as account data storage, blockchain queries, byte-array and string manipulation, encoding/decoding, math, and verification. Each function entry specifies its parameters, documentation, and execution complexity, providing users with clear guidance on usage and resource costs.

lang/doc/v3/funcs · high confidence

The V4 language documentation now includes a comprehensive reference for built-in functions, organized into categories such as account data storage, blockchain queries, byte-array and string manipulation, encoding/decoding, cryptography (including Keccak, SHA, RSA, and Groth16 verification), and list operations. This addition provides users with detailed specifications for available functions, including their parameters, descriptions, and computational complexity costs.

lang/doc/v4/funcs · high confidence

The \Curve25519\ class, which provided a Java implementation for Curve25519 Elliptic Curve Diffie-Hellman key agreement and digital signatures, has been removed from the codebase. This deletion eliminates the local cryptographic primitives for key generation, key agreement, and signature verification previously handled by this file.

src/main/java · high confidence

The NTP module (src/main/scala/ntp/NTP.scala) has been removed from the codebase. This eliminates the functionality that previously synchronized system time with the 'pool.ntp.org' server, including the logic for calculating time offsets and the 'getTime' method used to retrieve corrected time.

src/main/scala/ntp · high confidence

The \Start.scala\ entry point has been removed, eliminating the application's built-in testing script that automatically generated random payments and the legacy CLI interface. Users can no longer launch the node with the \-cli\ flag or rely on the automatic \testingScript()\ execution during startup.

src/main/scala · high confidence

The legacy \Block\ and \GenesisBlock\ classes in \src/main/scala/scorex/block\ have been removed. This deletion eliminates the old serialization logic, JSON conversion methods, and database-dependent parent/child lookups that were previously handled by these classes, indicating a shift to a new block structure or storage mechanism elsewhere in the codebase.

src/main/scala/scorex/block · high confidence

The legacy \Controller.scala\ singleton, which previously managed application state, database connections, wallet logic, and the Spray-based HTTP API (\ApiService\), has been removed. This change eliminates the monolithic controller pattern, removing direct dependencies on the old RPC service and wallet implementations from this location, and aligns the codebase with the newer Akka-based network layer and modular service architecture.

src/main/scala/controller · high confidence

The Java-based HTTP API layer in \src/main/scala/api\ has been removed, deleting the Jersey/REST resource classes (such as \AddressesResource\, \BlocksResource\, \TransactionsResource\, \WalletResource\, and \PaymentResource\), the \ApiService\ server configuration, and the \ApiClient\ command-line tool. This change eliminates the Spray-based HTTP API infrastructure and its associated error handling (\ApiErrorFactory\) and utility classes (\ObserverMessage\, \Pair\, \ReverseComparator\, \TransactionsList\), signaling a migration to a different API implementation strategy.

src/main/scala/api · high confidence

The \scorex\ module has removed its legacy Java implementation files, including \BlockBuffer\, \BlockChain\, \BlockGenerator\, \Synchronizer\, \TransactionCreator\, the \Account\ hierarchy (\Account\, \PublicKeyAccount\, \PrivateKeyAccount\), and the transaction layer (\Transaction\, \GenesisTransaction\, \PaymentTransaction\, \TransactionFactory\). This deletion signifies the completion of the migration of these core blockchain and networking capabilities to Scala, as referenced in the commit history.

src/main/scala/scorex · high confidence

The legacy network implementation, including connection management, peer handling, and message broadcasting, has been removed from the codebase. This change deletes the \ConnectionAcceptor\, \ConnectionCreator\, \Network\, \Peer\, \PeerManager\, \Pinger\, and \ConnectionCallback\ components that previously managed peer connections via Java sockets and the \java.util\ concurrency utilities.

src/main/scala/network · high confidence

The \src/main/scala/network/message\ directory has been completely removed, deleting all legacy network message classes including \BlockMessage\, \TransactionMessage\, \VersionMessage\, \PeersMessage\, and the base \Message\ trait. This change eliminates the previous serialization logic, checksum generation, and message routing mechanisms defined in this package, indicating a shift away from the old network protocol implementation.

src/main/scala/network/message · high confidence

The legacy Wallet class and its associated database access logic have been removed from the codebase. This deletion eliminates the previous mechanism for managing wallet state, account generation, and transaction history, indicating that wallet functionality has been migrated to a different module or implementation.

src/main/scala/scorex/wallet · high confidence

A change to existing behaviour in wallet — 13 commits (3 fixs), 6 files.

wallet · medium confidence · unverified

A new ByteStrComparator object has been introduced in the common module to provide explicit comparison logic for ByteStr instances. This change supports the removal of implicit byte array conversions by offering a dedicated method to compare ByteStr values based on their underlying byte arrays, ensuring consistent and predictable ordering behavior for users relying on these comparisons.

lang/js/src/main/scala/com/wavesplatform/common · high confidence

The cryptographic utilities in the \scorex.crypto\ package have been migrated from Java to Scala. This change replaces the previous Java implementations of Base58 encoding/decoding, RIPEMD160 hashing, and Curve25519 signing/verification with new Scala equivalents. For users, this ensures consistent Scala-style error handling (using \Try\ for decoding results) and aligns the crypto layer with the rest of the Scala codebase, while maintaining the same cryptographic standards for address generation and transaction signing.

src/main/scala/scorex/crypto · high confidence

The database persistence layer in \src/main/scala/database\ has been rewritten from Java to Scala. This change replaces the previous Java-based implementations of core data structures—including \BalanceMap\, \BlockMap\, \TransactionMap\, and the \DBSet\ singleton—with new Scala versions (e.g., \PeerMap.scala\), while removing the legacy Java files. Users will experience this as a backend refactoring that maintains existing data storage and retrieval behaviors but utilizes the Scala language for the underlying database operations.

src/main/scala/database · high confidence

The JVM crypto module has been replaced with a new implementation that introduces P-256 (secp256r1) signature verification and certificate chain validation, alongside optimized hashing and Curve25519 operations. The new codebase uses thread-local instances of cryptographic providers (Amazon Corretto, Conscrypt, or Bouncy Castle) to improve performance and stability for SHA-256, Keccak-256, and Blake2b-256 hashing, as well as Curve25519 key generation and signing.

lang/jvm/src/main/scala/com/wavesplatform/crypto · high confidence

The V5 language reference documentation has been updated to reflect the new standard library functions. This includes definitions for account data storage access (such as \assetBalance\, \wavesBalance\, and \isDataStorageUntouched\), self-state storage functions, and blockchain interactions like \scriptHash\ (renamed from \hashScriptAtAddress\) and \reentrantInvoke\. The documentation also covers the new \BigInt\ type support in conversion and math functions, updated cryptographic verifiers (including \groth16Verify\ variants), and the removal of the \HALFDOWN\ and \UP\ rounding modes from the \pow\ and \log\ functions.

lang/doc/v5/funcs · high confidence

The Java implementations for serializing and deserializing Block and Transaction objects (BlockSerializer.java and TransactionSerializer.java) have been removed from the codebase. This change eliminates the manual byte-level serialization logic that previously handled reading and writing these entities to the database, aligning with the broader migration of the transaction layer to Scala.

src/main/scala/database/serializer · high confidence

The \Settings.scala\ file, which previously handled application configuration by manually parsing a \settings.json\ file using the \org.json.simple\ library, has been removed. This change eliminates the legacy mechanism for loading network parameters (such as peer connections, timeouts, and RPC ports) and data directory paths, indicating a migration to a different configuration strategy (likely the Play JSON-based approach mentioned in commit history) that no longer relies on this specific manual JSON parsing implementation.

src/main/scala/settings · high confidence

The node generator has been completely rewritten to use pureconfig for configuration management and scopt for command-line argument parsing, replacing the previous implementation. This introduces a modular architecture with distinct transaction generation modes accessible via CLI commands: narrow (pre-defined accounts), wide (random recipients), dyn-wide (growing transaction count), multisig (multisig script cycles), oracle (oracle data updates), and swarm (SetScript and exchange load tests). The new generator supports configurable transaction probabilities, fee limits, recipient limits, and warm-up phases, providing more flexible and structured load testing capabilities for the Waves node.

node-generator/src/main/scala/com/wavesplatform/generator · high confidence

The V5 language documentation now includes the formal type system and global variables. The new \types.hjson\ file defines the available data types, including primitives like \Unit\, \Int\, and \String\, as well as complex structures such as \Address\, \Alias\, \Transfer\, \AssetPair\, and \Order\. The \vars.json\ file documents the global variables and constants available in V5 scripts, such as rounding modes (\CEILING\, \HALFUP\, \HALFEVEN\, \FLOOR\, \DOWN\), cryptographic algorithms (\MD5\, \SHA1\, \SHA256\, \SHA3\*\), and context variables (\this\, \tx\, \height\, \lastBlock\).

lang/doc/v5 · high confidence

A fix in src/main/resources — 3 commits (2 fixs), 6 files.

src/main/resources · medium confidence · unverified

Added BlockchainGenerator for deterministic test blockchain creation; Added JavaScript language tests for RIDE built-in functions and compilation; Added LoadTest annotation for test categorization; Added REPL integration tests; Added base test infrastructure for transaction integration tests; Added benchmark test data model for state benchmarks; Added cross-verification tests for native and Java Curve25519 implementations; Added cryptographic and blockchain state benchmarks; Added gRPC integration tests for core transaction types and blockchain features; Added gRPC server test suite and configuration; Added integration test configuration resources; Added integration tests for InvokeExpression transactions; Added integration tests for account storage entry removal; Added integration tests for asset management and script action limits; Added integration tests for block header and reward consistency; Added integration tests for block size constraints, microblock fees, and state generation; Added integration tests for gRPC Blocks API and Reflection API; Added integration tests for light node block challenge, mining, broadcast, and rollback behaviors; Added integration tests for network connectivity and transaction handling; Added integration tests for new blockchain features and API behaviors; Added integration tests for smart asset transaction validation; Added integration tests for smart contract validation scenarios; Added integration tests for the Waves REPL; Added serialization tests for transaction types; Added test configuration and resource files for node testing; Added test utilities for asset distribution and pagination; Expanded integration test coverage for core transaction types; Expanded test coverage for RIDE language compiler and evaluator; Integration tests for blockchain feature activation and failed transaction handling; New integration test API client libraries for HTTP and gRPC; New integration test infrastructure and test suites.

The build configuration has been refactored from a single monolithic project into a multi-module structure, introducing dedicated subprojects for the RIDE language compiler (\lang\), the main node (\node\), a gRPC server (\grpc-server\), a standalone RIDE runner (\ride-runner\), and integration tests (\node-it\). This change introduces new packaging capabilities, including Debian packages for the node and RIDE runner, and adds a JMH benchmark module. It also updates the JavaScript build for the RIDE language and REPL to output CommonJS modules and configures the integration test module to build Docker images for test execution.

(dependencies) · high confidence

The build infrastructure has been significantly modernized, upgrading the SBT version from 0.13.6 to 1.12.12 and migrating the core actor framework from Akka to Apache Pekko 1.7.0. This change includes a comprehensive update of dependencies, such as Jackson 3.1.4, Netty 4.2.17, and Scala 3, alongside the introduction of new build plugins for assembly, native packaging, and integration testing. For users, this ensures better compatibility with modern Java and Scala environments, improved build performance, and a stable foundation for future feature development.

project · high confidence

Deleted several sbt configuration class cache files from the project's target directory, removing stale internal DSL entry caches.

project/project · high confidence

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

• CAI 42 → 53 (+10.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 82 (-18.0)
• Architecture 69 → 95 (+25.6)
• Maturity 52 → 58 (+6.0)
• Readiness 25 → 59 (+34.3)
• Security 50 → 55 (+4.8)
• Domain Modelling 100 (new)
• Accessibility 42 (new)

• Change coupling: swagger-ui-bundle.js ↔ swagger-ui-standalone-preset.js (node/src/main/resources/swagger-ui/swagger-ui-bundle.js)
• Change coupling: swagger-ui-bundle.js ↔ swagger-ui.js (node/src/main/resources/swagger-ui/swagger-ui-bundle.js)
• Change coupling: swagger-ui-standalone-preset.js ↔ swagger-ui.js (node/src/main/resources/swagger-ui/swagger-ui-standalone-preset.js)
• Coverage not measured — test suite did not build
• Dimension evaluation failed
• High IaC: DS-0002 (docker/node-sbt-builder.Dockerfile)
• High IaC: DS-0002 (docker/private/Dockerfile)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• Leaked secret: hardcoded-credential (node/waves-sample.conf)
• Low IaC: DS-0026 (docker/node-sbt-builder.Dockerfile)
• Low IaC: DS-0026 (docker/private/Dockerfile)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• …and 27 more

• API.parseAndCompile (cognitive 16) (lang/shared/src/main/scala/com/wavesplatform/lang/API.scala)
• AddressDataIterator.doComputeNext (cognitive 19) (node/src/main/scala/com/wavesplatform/api/common/CommonAccountsApi.scala)
• ApiError.fromValidationError (cyclomatic 34) (node/src/main/scala/com/wavesplatform/api/http/ApiError.scala)
• Application.run (cognitive 20) (node/src/main/scala/com/wavesplatform/Application.scala)
• Application.run (cyclomatic 16) (node/src/main/scala/com/wavesplatform/Application.scala)
• AssetTransactionsDiffs.issue (cognitive 24) (node/src/main/scala/com/wavesplatform/state/diffs/AssetTransactionsDiffs.scala)
• AssetTransactionsDiffs.setAssetScript (cognitive 19) (node/src/main/scala/com/wavesplatform/state/diffs/AssetTransactionsDiffs.scala)
• AssetTransactionsDiffs.updateInfo (cognitive 19) (node/src/main/scala/com/wavesplatform/state/diffs/AssetTransactionsDiffs.scala)
• BalanceDiffValidation.apply (cognitive 22) (node/src/main/scala/com/wavesplatform/state/diffs/BalanceDiffValidation.scala)
• BalanceIterator.findNextBalance (cognitive 17) (node/src/main/scala/com/wavesplatform/api/common/BalanceDistribution.scala)
• BaseGlobal.divide (cognitive 17) (lang/shared/src/main/scala/com/wavesplatform/lang/v1/BaseGlobal.scala)
• BaseGlobal.median (cognitive 21) (lang/shared/src/main/scala/com/wavesplatform/lang/v1/BaseGlobal.scala)
• Bindings.transactionObject (cyclomatic 29) (lang/shared/src/main/scala/com/wavesplatform/lang/v1/evaluator/ctx/impl/waves/Bindings.scala)
• BlockChallengerImpl.challengeMicroblock (cognitive 23) (node/src/main/scala/com/wavesplatform/mining/BlockChallenger.scala)
• BlockChallengerImpl.createChallengingBlock (cognitive 46) (node/src/main/scala/com/wavesplatform/mining/BlockChallenger.scala)
• BlockDiffer.fromBlockTraced (cognitive 85) (node/src/main/scala/com/wavesplatform/state/diffs/BlockDiffer.scala)
• BlockDiffer.fromBlockTraced (cyclomatic 25) (node/src/main/scala/com/wavesplatform/state/diffs/BlockDiffer.scala)
• BlockSnapshotIterator.computeNext (cognitive 21) (node/src/main/scala/com/wavesplatform/Exporter.scala)
• BlockchainGeneratorApp.start (cognitive 31) (node/src/main/scala/com/wavesplatform/utils/generator/BlockchainGeneratorApp.scala)
• BlockchainGeneratorApp.start (cyclomatic 17) (node/src/main/scala/com/wavesplatform/utils/generator/BlockchainGeneratorApp.scala)
• …and 469 more

• 4 commits — 3 feature/other, 1 fixes

• .github/workflows — 2 commits
• (root) — 1 commit
• node/src — 1 commit

• fix: Dependency updates + fixes (#4085)
• change: Adjusted block reward distribution (#4086)
• change: Bumped Jackson version (#4087)
• change: Version 1.6.4 (Mainnet + Testnet + Stagenet) (#4088)

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

wavesplatform/Waves 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.