FuelLabs/fuels-rs

This release delivers a comprehensive overhaul of the SDK's core architecture, introducing a unified \fuels-core\ crate with robust, bounded ABI encoding and decoding, alongside new \Parameterize\ and \Tokenizable\ traits for type conversion. The \fuels-accounts\ module is significantly enhanced with configurable retry logic, resource caching, and support for AWS and Google Cloud KMS signers. Additionally, the SDK now supports deploying large contracts via code blobs and provides extensive end-to-end test coverage for Sway types, logging, and debugging utilities.

The ABI decoder now uses a new \BoundedDecoder\ that enforces limits on recursion depth and token count to prevent crashes and memory issues during decoding. Additionally, a \decode\_as\_debug\_str\ function has been added to the \ABIDecoder\, allowing users to obtain a human-readable debug string representation of decoded tokens, which is useful for logging and debugging.

_packages/fuels-core/src/codec/abi\decoder · high confidence

Added a new example in \examples/contracts/src/lib.rs\ that demonstrates how to deploy a contract using the SDK. The example covers basic instantiation, deploying a contract with default settings, using the \setup\_program\_test!\ macro, estimating transaction costs, and deploying a contract with custom parameters such as salt, storage slots, and transaction policies.

examples/contracts · high confidence

Added new example code in the cookbook demonstrating how to interact with a liquidity pool contract, configure a custom chain with specific consensus and fee parameters, and perform transfers of multiple asset types in a single transaction.

examples/cookbook · high confidence

A new \examples/debugging\ crate was added, providing concrete examples for encoding function selectors and decoding ABI data into debug strings. The examples demonstrate using \encode\_fn\_selector\ and the \ABIDecoder::decode\_as\_debug\_str\ method to verify that decoded values match expected Rust debug representations for various types, including structs, enums, and logged types.

examples/debugging · high confidence

The examples/macros location now includes a new lib.rs file that demonstrates how to use the abigen macro to generate bindings for multiple contract, script, and predicate ABIs, as well as how to derive Parameterize and Tokenizable traits on custom structs and enums, including support for custom paths and no\_std configurations.

examples/macros · high confidence

The repository now includes several new configuration and documentation files to standardize formatting and improve documentation. A new .editorconfig file enforces consistent indentation for TOML files. The README.md has been significantly expanded with badges, feature lists, and detailed instructions for running tests, building documentation, and troubleshooting. Additionally, new files include .env.example for environment variables, .markdownlint.yaml and .markdownlintignore for markdown linting, a .gitignore update to exclude generated files, a SECURITY.md file outlining the security policy and reporting process, and a \_typos.toml file to exclude specific schema files from typo checking.

(repo-wide) · high confidence

A new Sway predicate has been added at e2e/sway/predicates/swap/src/main.sw to support end-to-end testing of swap functionality. The predicate validates that a transaction output matches a specific receiver address, a fixed ask amount of 100, and the zero asset ID, ensuring the correct asset and quantity are being swapped in the test scenario.

e2e/sway/predicates/swap · high confidence

Added new examples in the types module demonstrating how to construct and convert between core types such as Bytes32, Address, AssetId, and ContractId, including conversions to and from Identity and Bits256.

examples/types · high confidence

A new Rust-based CLI tool has been added to the repository to automatically replace version placeholders (e.g., \{{versions.fuels}}\) in files with actual versions from \Cargo.toml\. This script scans directories for matching files, reads package versions via \cargo metadata\, and updates the files in place, streamlining the maintenance of versioned links and references across the project.

scripts/versions-replacer · high confidence

The \examples/wallets\ directory now includes a new \lib.rs\ file containing comprehensive test cases for wallet operations. These tests demonstrate how to create wallets from random keys, secret keys, and mnemonics, as well as how to perform standard transfers between wallets and transfer assets to contracts. The file also includes tests for storing and recovering mnemonic keys using a keystore.

examples/wallets · medium confidence

A new Rust-based tool has been added to the \scripts/change-log\ directory. This utility automates the creation of release notes by querying the GitHub API to fetch pull requests, releases, and branch information. It aggregates this data to generate a structured Markdown changelog, including sections for features, fixes, chores, and breaking changes, while also extracting migration notes and release summaries.

scripts/change-log · high confidence

New Sway source files were added to the e2e test suite, introducing several test contracts and a signature predicate. The \lib\_contract\_caller\ contract implements methods for calling other contracts, including re-entrant calls and minting assets before interaction. The \liquidity\_pool\ contract provides deposit and withdraw functionality for a base token. The \token\_ops\ contract exposes mint, burn, transfer, and balance-checking operations. Additionally, a new predicate in \e2e/sway/predicates/signatures\ validates Secp256k1 signatures against a set of expected public keys. These files serve as the underlying test fixtures for the e2e test crate.

(repo-wide) · high confidence

A new Sway contract, var\_outputs, was added to the e2e test suite. The contract implements a minting function that uses a while loop to incrementally mint assets, serving as an end-to-end test case for variable output estimation.

_e2e/sway/contracts/var\outputs · high confidence

The provider client now includes a built-in retry mechanism with configurable backoff strategies (linear, exponential, or fixed intervals) to automatically recover from transient network failures. Additionally, the provider caches consensus parameters and node information with a configurable TTL, reducing the frequency of remote API calls. A new version compatibility check issues a soft warning if the connected node's version differs from the SDK's supported version (currently 0.48.0).

packages/fuels-accounts/src/provider · high confidence

The \fuels-core\ crate has been reorganized to serve as the central hub for core functionality, merging previously separate concerns. This includes the codec (encoding/decoding), traits (Parameterize, Tokenizable), and type definitions. The \Configurables\ struct and its \offsets\_with\_data\ field are now exposed, allowing users to access configurable data offsets and raw data. Additionally, utility functions for padding and alignment are now part of the public API, supporting the unified structure.

packages/fuels-core/src · high confidence

The \packages/fuels\ crate now provides a unified entry point that re-exports core types, macros, and modules (such as \tx\, \client\, \macros\, \programs\, \core\, \crypto\, \accounts\, \types\, and \test\_helpers\) under a single namespace. This includes a \prelude\ module that aggregates the most commonly used types and traits for quick bootstrapping, streamlining the developer experience by reducing the need to import from multiple sub-crates.

packages/fuels · high confidence

A new Rust utility at scripts/fuel-core-version is added to automate the synchronization of the supported fuel-core version. The tool reads the version from the Cargo.toml file and can either write the version to a Rust source file or verify that the version in the source file matches the one in the manifest, ensuring consistency across the project.

scripts/fuel-core-version · high confidence

Added new wrapper structs for block, chain info, coin, coin type, message, message proof, node info, and transaction response. These wrappers provide a consistent interface for interacting with the underlying fuel-core client types, including support for transaction policies and various transaction types (script, create, mint, upgrade, upload, blob).

packages/fuels-core/src/types/wrappers · high confidence

The SDK now uses a unified \CallHandler\ struct to manage contract and script calls, providing a consistent builder API for transaction construction and response parsing. Users can now explicitly configure transaction policies, variable output policies, and log decoders via the \CallHandler\. The change introduces \with\_inputs\ and \with\_outputs\ methods on \ContractCall\ and \ScriptCall\ to allow custom transaction inputs and outputs. Additionally, the \ReceiptParser\ has been refactored to handle both contract and script call responses, improving how transaction receipts are decoded into tokens.

packages/fuels-programs/src/calls · high confidence

The change adds two new modules to the \utils\ directory: \constants.rs\, which defines default values such as \DEFAULT\_GAS\_ESTIMATION\_TOLERANCE\ and \DEFAULT\_GAS\_ESTIMATION\_BLOCK\_HORIZON\, and \offsets.rs\, which provides functions like \base\_offset\_script\ and \call\_script\_data\_offset\ to calculate script and predicate offsets based on consensus parameters. These modules encapsulate core calculation logic and default configuration values previously scattered or implicit.

packages/fuels-core/src/utils · high confidence

The \fuels-core\ crate introduces new \Parameterize\ and \Tokenizable\ traits to handle type conversions for the SDK. The \Parameterize\ trait, implemented for primitive types (u8, u16, u32, u64, u128, bool), collections (Vec, arrays), and complex types (Option, Result, tuples, strings), allows the SDK to understand how to serialize and deserialize data. The \Tokenizable\ trait provides the reverse, enabling the conversion of internal \Token\ representations back into Rust types. These traits are foundational for the \abigen\ code generation and runtime type handling.

packages/fuels-core/src/traits · high confidence

The Rust bindings example now includes a new \abigen!\ macro that generates Rust structs and methods from an ABI JSON file. This allows developers to easily create contract bindings and interact with smart contracts using generated types like \MyContract\ and \MyContractMethods\. The example demonstrates both file-based and inline JSON ABI usage, providing a clear template for integrating Fuel contracts into Rust applications.

_examples/rust\bindings · high confidence

The \fuels-accounts\ crate has been restructured to introduce a unified \Account\ and \ViewOnlyAccount\ trait system, enabling consistent interactions for wallets, predicates, and contracts. A new \CoinsCache\ implementation provides TTL-based caching of spendable resources to reduce redundant network calls. Additionally, a \Keystore\ module has been added to manage encrypted key storage, and the \Provider\ has been updated to support coin caching and retry mechanisms.

packages/fuels-accounts/src · high confidence

Added new assertion functions (assert\_eq, assert\_ne) that support comparison of structs and enums, not just primitives. The e2e/sway/contracts/asserts and e2e/sway/scripts/script\_asserts crates now include implementations for comparing TestStruct and TestEnum types, enabling equality and inequality checks on complex data structures in Sway contracts and scripts.

_e2e/sway/contracts/asserts, e2e/sway/scripts/script\asserts · high confidence

A new Rust-based tool (scripts/check-docs) has been added to automatically validate the project's documentation. It checks for broken internal links and includes, verifies that anchor tags are correctly paired and ordered, and ensures that all Markdown files referenced in the documentation build are present. This provides immediate feedback on documentation integrity during development.

scripts/check-docs · high confidence

The codec module now introduces new \ABIEncoder\ and \ABIDecoder\ implementations that enforce configurable limits on encoding and decoding depth and token count. These limits prevent potential memory issues or infinite recursion by capping the number of nested structures and total tokens processed. Users can now configure \EncoderConfig\ and \DecoderConfig\ with \max\_depth\ and \max\_tokens\ parameters to control these boundaries, ensuring robust handling of complex or deeply nested data structures.

packages/fuels-core/src/codec · high confidence

The \fuels-core\ crate now includes new type definitions for handling blockchain identifiers and large integers. This includes \Bits256\ and \B512\ for 256-bit and 512-bit unsigned integers, an \Identity\ enum that unifies \Address\ and \ContractId\ types, and \U256\ for 256-bit unsigned integers. Additionally, \Bytes\ and \RawSlice\ wrappers are introduced for handling raw byte sequences, while \AsciiString\ and \SizedAsciiString\ provide safe, length-constrained string types for interacting with contract ABIs.

packages/fuels-core/src/types/core · high confidence

The \fuels-accounts\ crate now includes new signer implementations: a \FakeSigner\ for testing, a \PrivateKeySigner\ for local key management, and cloud KMS signers for AWS (\AwsKmsSigner\) and Google Cloud (\GoogleKmsSigner\). These additions provide users with secure, hardware-backed, or mock signing capabilities directly within the accounts package.

packages/fuels-accounts/src/signers · high confidence

The \fuels-test-helpers\ crate now provides utilities to launch local Fuel nodes and generate test wallets. Users can use \launch\_provider\_and\_get\_wallet\ for a quick single-wallet setup, or \launch\_custom\_provider\_and\_get\_wallets\ to configure multiple wallets with specific asset distributions. The helpers also support configuring the node via \NodeConfig\ (e.g., database type, block production triggers) and \ChainConfig\, allowing for more complex test scenarios involving multiple assets and custom node settings.

packages/fuels-test-helpers · high confidence

The \fuels-core\ types module has been restructured and expanded with new files to support core functionality. A new \checksum\_address.rs\ file introduces functions to encode and validate checksummed Ethereum-style addresses. A \token.rs\ file defines the \Token\ enum and \StaticStringToken\ for representing various data types. The \transaction\_builders.rs\ and its submodules (\blob.rs\, \script\_tx\_estimator.rs\) introduce builders for script, create, upload, and upgrade transactions, including support for blob transactions and gas estimation. Additionally, \errors.rs\ defines a comprehensive error handling system with context support, and \tx\_status.rs\ defines transaction status types. These changes provide the foundational types and builders for interacting with the Fuel network.

packages/fuels-core/src/types · high confidence

The \fuels-macros\ crate has been restructured to include new derive macros for \Parameterize\ and \Tokenizable\, as well as a \TryFrom\ implementation for byte slices. Additionally, the \setup\_program\_test!\ macro now supports configuring build profiles and loading scripts, providing a more flexible way to set up test environments with wallets, contracts, and scripts.

packages/fuels-macros/src · high confidence

The \fuels-code-gen\ crate has been reintroduced to handle the generation of Rust bindings from Fuel ABI (Application Binary Interface) files. This change introduces a new module structure for \abigen\, generating type-safe Rust code for contracts, scripts, and predicates. The implementation includes dedicated modules for handling contract, script, and predicate bindings, as well as configurable constants and log formatters. This allows developers to generate Rust code that interacts with Fuel programs in a type-safe manner, supporting both standard and \no\_std\ (WASM) environments.

packages/fuels-code-gen · high confidence

The e2e test suite has been restructured into a separate crate, introducing a new \build.rs\ script that automatically downloads the \fuel-core\ WASM executor binary based on the supported version. Additionally, the suite now includes a new \aws\_kms\ module that provides a test harness for AWS KMS integration, utilizing a Localstack container to simulate the AWS KMS service for testing purposes.

e2e · high confidence

The \fuels-programs\ crate now supports deploying large contracts by splitting their code into multiple code blobs and deploying a loader contract that references them. This is achieved through new \loader.rs\ and \regular.rs\ modules, along with \storage.rs\ for managing storage slots. The \Contract\ type now includes \loader\_from\_blobs\ and \upload\_blobs\ methods to handle blob uploads and loader contract deployment, as well as \deploy\_if\_not\_exists\ to avoid redundant deployments. This change enables the deployment of contracts that exceed the maximum transaction size limit by distributing their code across multiple blobs.

packages/fuels-programs/src/contract · high confidence

A new WASM test crate has been introduced, containing a \.cargo/config.toml\ that configures the \wasm32-unknown-unknown\ target and sets the runner to \wasm-bindgen-test-runner\. The crate's \src/lib.rs\ includes a comprehensive test module that validates ABI encoding and decoding for contracts and predicates using \wasm\_abigen\ and \wasm\_bindgen\_test\. This provides a dedicated environment for running WASM-specific integration tests.

wasm-tests · high confidence

A new Sway contract has been added to the e2e test suite to validate tuple type handling. The contract defines an ABI and implementation that exercise various tuple scenarios, including basic tuples, tuples containing structs and enums, single-element tuples, and tuples with b256 types. This provides the backend logic for the corresponding end-to-end tests.

e2e/sway/types/contracts/tuples · high confidence

New Sway source files were added to the e2e test suite, including a predicate that validates arguments and configurable secrets, an empty script, a script demonstrating complex types and assertions, and a proxy script that interacts with contract methods. These additions provide new test cases for the Sway compiler and runtime.

(repo-wide) · low confidence

New Sway source files were added for a contract, a predicate, and a script that validate transaction inputs and outputs. The contract exposes \check\_input\ and \check\_output\_is\_change\ methods, the predicate verifies input and output conditions, and the script enforces these checks, all configurable via \ASSET\_ID\ and \OWNER\.

_e2e/sway/contracts/tx\_input\_output, e2e/sway/predicates/predicate\_tx\_input\_output, e2e/sway/scripts/script\_tx\_input\output · medium confidence

A new Sway contract implementation has been added to the e2e test suite, providing a concrete example of contract storage, ABI definitions, and function implementations for end-to-end testing.

_e2e/sway/contracts/contract\test · high confidence

The \param\_types\ module has been refactored to support the new ABI specification, introducing a \ParamType\ enum that explicitly represents all supported Solidity and Move types (including structs, enums, vectors, and tuples) and a new \try\_from\_type\_application\ method to convert ABI type applications into internal parameter types. This change replaces the previous, less structured approach to type mapping, enabling better handling of complex types like enums and generic structures in contract calls and script execution.

_packages/fuels-core/src/types/param\types · medium confidence

The \fuels-programs\ crate has been restructured to separate concerns for contract and script handling. A new \assembly\ module now encapsulates the logic for generating VM instructions for contract calls (\contract\_call.rs\) and managing script/predicate loading via a \LoaderCode\ abstraction (\script\_and\_predicate\_loader.rs\). The \Contract\ type has been refactored to support both regular and loader-based deployment, while \Executable\ is split into \Regular\ and \Loader\ variants to handle large contract deployments. Additionally, a new \Execution\ struct in \calls.rs\ provides a unified interface for controlling simulation modes (realistic vs. state-read-only) and block height targeting.

packages/fuels-programs/src · high confidence

The Sway end-to-end tests for vector types have been refactored by moving the contract and script test files into their own respective crates (e2e/sway/types/contracts/vectors and e2e/sway/types/scripts/script\_vectors). This change introduces new Sway source files defining data structures, equality implementations, and test logic for various vector configurations, including vectors of structs, enums, arrays, and nested collections.

_e2e/sway/types/contracts/vectors, e2e/sway/types/scripts/script\vectors · medium confidence

Add Sway ABI test contracts and predicate for end-to-end testing; Add Sway contracts and scripts for end-to-end logging tests; Add Sway test cases for revert and panic error handling; Add end-to-end tests for string and raw slice types; Add end-to-end tests for string slice handling in predicates and scripts; Add predicate examples and tests; Add provider example tests for testnet and local node connections; Added UI tests for macro usage; Added UI tests for macro validation errors; Added basic\_script e2e test script; Added codec example tests for encoding and decoding; Added end-to-end tests for Sway bindings and core types; Added tests for the docs validation script.

The SDK has been updated to version 0.77.0, aligning with fuel-core 0.48.0 and fuel-vm 0.66.2. This update brings the latest features and fixes from the Fuel ecosystem, including updated dependencies for \fuel-abi-types\ (0.15.3) and various standard library dependencies. Users should be aware that this is a significant dependency update that may require minor adjustments if relying on specific older versions of these underlying crates.

(dependencies) · high confidence

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

• CAI 41 → 59 (+18.0)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 98 (-2.0)
• Architecture 96 (new)
• Maturity 52 → 56 (+3.8)
• Readiness 23 → 53 (+30.0)
• Security 50 → 55 (+4.6)

• Dimension evaluation failed
• 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)
• 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)
• 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)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 16 more

• Ambiguous transaction submission semantics. One method implies waiting for final commit, the other for a status update (which may be pre-confirmation). The naming suggests a split in lifecycle handling that is not clearly distinguished by the return type or documentation context provided.
• Boundary-crossing change coupling: param_types.rs ↔ contract.rs (packages/fuels-core/src/types/param_types.rs)
• Boundary-crossing change coupling: resolved_type.rs ↔ function_selector.rs (packages/fuels-code-gen/src/program_bindings/resolved_type.rs)
• Boundary-crossing change coupling: resolved_type.rs ↔ param_types.rs (packages/fuels-code-gen/src/program_bindings/resolved_type.rs)
• Boundary-crossing change coupling: tokenizable.rs ↔ contract.rs (packages/fuels-core/src/traits/tokenizable.rs)
• Change coupling: abi_decoder.rs ↔ tokenizable.rs (packages/fuels-core/src/codec/abi_decoder.rs)
• Change coupling: abi_encoder.rs ↔ tokenizable.rs (packages/fuels-core/src/codec/abi_encoder.rs)
• Change coupling: predicate.rs ↔ wallet.rs (packages/fuels-accounts/src/predicate.rs)
• Change coupling: supported_fuel_core_version.rs ↔ service.rs (packages/fuels-accounts/src/provider/supported_fuel_core_version.rs)
• Change-coupling hub: function_selector.rs → abi_decoder.rs, types.rs, param_types.rs (packages/fuels-core/src/codec/function_selector.rs)
• ClassTooLong: Provider (packages/fuels-accounts/src/provider.rs)
• Concentrated knowledge decay
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Duplicated block (10 lines × 2) (packages/fuels-core/src/codec/abi_decoder/bounded_decoder.rs)
• Duplicated block (10 lines × 2) (packages/fuels-programs/src/assembly/script_and_predicate_loader.rs)
• Duplicated block (11–12 lines × 2) (packages/fuels-programs/src/calls/call_handler.rs)
• Duplicated block (12 lines × 2) (packages/fuels-core/src/types/transaction_builders.rs)
• Duplicated block (12 lines × 2) (scripts/change-log/src/adapters/octocrab.rs)
• Duplicated block (12–13 lines × 4) (packages/fuels-core/src/types/transaction_builders.rs)
• Duplicated block (12–14 lines × 2) (packages/fuels-code-gen/src/program_bindings/custom_types/enums.rs)
• …and 65 more

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

FuelLabs/fuels-rs 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.