FuelLabs/fuels-rs
62.3
Adequate · 14 November 2026
24.3k
lines of production code
Rust
primary language
7
measurements over time
What this system is
This system is the Fuel Rust SDK, a library for interacting with the Fuel blockchain from Rust applications. It provides core capabilities for managing wallets, signing transactions via local or cloud-based key management services, and deploying or calling Sway smart contracts and scripts. The SDK includes a code generation engine to create type-safe bindings from ABIs, a bounded codec for serializing complex data types, and a comprehensive end-to-end test suite to validate these interactions against the Fuel protocol.
How it got here
2021–2022 — SDK restructuring and example expansion
15 changes.
The project reorganized its core packages into modular structures and consolidated them under a unified entry point to simplify usage. This period also focused on comprehensive documentation by adding extensive examples for wallets, contracts, providers, and debugging, alongside tools to validate documentation integrity.
2023 — SDK core infrastructure and macro generation
17 changes.
This period focused on establishing the foundational type system and serialization mechanisms for the Fuel SDK, introducing the Parameterize and Tokenizable traits alongside a bounded ABI codec. It also centralized code generation through the new fuels-macros and fuels-code-gen crates, enabling automated binding creation and test setup. Concurrently, account management and provider reliability were enhanced with features like coin caching, keystore support, and configurable retry strategies.
2024–2025 — E2E test expansion and signer integration
25 changes.
This period focused on establishing a comprehensive end-to-end testing framework by adding extensive Sway contracts, predicates, and scripts to validate complex type handling, logging, and transaction flows. Concurrently, the SDK introduced cloud-based signer implementations for AWS and Google KMS, unified call handling logic, and support for deploying large contracts via blob loaders.
Features
Add cookbook examples for liquidity pools, custom chains, and multi-asset transfers
Introduces new example code in the cookbook demonstrating how to deploy and interact with a liquidity pool contract, configure a custom test chain with specific consensus parameters, and perform transfers involving multiple asset types using the Fuel SDK.
examples/cookbook · high confidence
Add predicate usage examples
Added integration tests in the \examples/predicates\ crate that demonstrate how to load and use Sway predicates. The examples show configuring a predicate with signature data for multi-signer validation and encoding numeric data for basic predicate logic, including transferring assets to and from the predicate address.
examples/predicates · high confidence
Add provider usage examples for testnet connection and resource querying
The \examples/providers\ crate now includes a library with integration tests demonstrating how to connect to the Fuel testnet, configure retry policies for providers, and query wallet resources such as coins, spendable resources, and balances using the updated API that retrieves the base asset ID from the provider.
examples/providers · high confidence
Add wallet usage examples and tests
The \examples/wallets\ crate now provides a library of documented examples and tests demonstrating core wallet operations. Users can see how to create wallets from random keys, secret keys, or mnemonics (including key storage via Keystore), perform standard asset transfers between wallets, and transfer assets to contracts using \force\_transfer\_to\_contract\. These examples also illustrate configuring wallets with multiple custom assets and verifying balances.
examples/wallets · high confidence
Added Sway examples for contract and script revert logs with generic types
New Sway source files were added to the \e2e/sway/logs\ directory to demonstrate how revert logs are captured in both contract and script contexts. The \contract\_revert\_logs\ example defines a contract that triggers reverts using \require\ and \revert\_with\_log\ with primitive values, strings, and deeply nested generic structures. The \script\_revert\_logs\ example provides a script that exercises similar scenarios, including custom error types via the \\#\[error\_type\]\ attribute and panic handling, allowing end-to-end tests to verify log output for these specific revert conditions.
_e2e/sway/logs/contract\_revert\_logs, e2e/sway/logs/script\_revert\logs · high confidence
Added contract deployment and interaction examples
The \examples/contracts\ crate now provides a comprehensive set of Rust test-based examples demonstrating how to use the Fuel SDK for contract operations. These examples cover instantiating a local Fuel node client, deploying contracts with default and custom parameters (including salt, storage slots, and transaction policies), using the \setup\_program\_test!\ macro for streamlined testing, and estimating transaction costs before execution.
examples/contracts · high confidence
Added encoding and decoding examples for the codec library
The \examples/codec\ directory now includes a \lib.rs\ file containing documentation examples for encoding and decoding data using the \fuels\ codec. These examples demonstrate how to encode structs using \ABIEncoder\, decode bytes into tokens using \ABIDecoder\, and configure encoder/decoder limits such as \max\_depth\ and \max\_tokens\.
examples/codec · high confidence
Added examples for Fuel SDK type conversions and usage
The \examples/types\ crate now includes a comprehensive test suite demonstrating how to create, convert, and format core Fuel SDK types. Users can see practical examples for \Bytes32\, \Address\, \AssetId\, and \ContractId\, including zeroing values, constructing them from byte arrays or hex strings, and converting between related types like \Bits256\ and \EvmAddress\.
examples/types · high confidence
E2E test suite restructured with AWS KMS support and comprehensive Sway contract assets
The end-to-end test environment has been reorganized into a dedicated crate, introducing a new build script that automatically downloads the fuel-core WASM executor binary to ensure test consistency. A new AWS KMS integration has been added, allowing tests to spin up a LocalStack container to simulate AWS Key Management Service for signing operations. Additionally, the suite now includes a comprehensive set of Sway contracts, predicates, and scripts covering diverse scenarios such as complex type generics, large contract deployments, proxy patterns, and detailed logging, providing a robust foundation for validating the SDK against the latest Fuel protocol features.
e2e · high confidence
Introduce SDK-side type wrappers for Fuel client types
The SDK now defines its own wrapper types for core Fuel client responses in \packages/fuels-core/src/types/wrappers\, including \Block\, \ChainInfo\, \Coin\, \CoinType\, \Message\, \MessageProof\, \NodeInfo\, and \TransactionResponse\. These wrappers implement \From\ conversions from the underlying \fuel-core-client\ types, allowing the SDK to abstract the client layer and provide a consistent, SDK-native API for accessing blockchain data, transaction statuses, and node information.
packages/fuels-core/src/types/wrappers · high confidence
Introduce coin caching and keystore support in account management
The account module now includes an optional coin cache (enabled via the \coin-cache\ feature) that stores recently used UTXOs and message nonces with a configurable TTL, reducing redundant network calls for balance and resource lookups. Additionally, a new keystore module allows users to securely encrypt, save, and load \SecretKey\s to disk using passwords, providing a persistent storage mechanism for wallet credentials.
packages/fuels-accounts/src · high confidence
Introduce unified \`fuels\` crate with consolidated prelude and module structure
The \fuels\ package now serves as the primary entry point for the SDK, providing a single \prelude\ module that aggregates essential types, traits, and macros (such as \abigen\ and \setup\_program\test\) from underlying crates like \fuels-core\, \fuels-accounts\, \fuels-programs\, and \fuels-macros\. This change simplifies project bootstrapping by allowing users to import all necessary components via \use fuels::prelude::\\, while also exposing structured sub-modules for transactions (\tx\), client interactions (\client\), and cryptographic utilities (\crypto\).
packages/fuels · high confidence
Introduces bounded decoding and debug string conversion for ABI data
The ABI decoder in \fuels-core\ now includes a \BoundedDecoder\ that enforces limits on recursion depth and token count during decoding, preventing crashes and resource exhaustion on malformed or deeply nested inputs. Additionally, a new \decode\_as\_debug\_str\ capability allows users to convert decoded tokens directly into human-readable debug strings, simplifying logging and debugging of contract interactions.
_packages/fuels-core/src/codec/abi\decoder · high confidence
New Sway contract test contract added
A new Sway contract source file (\main.sw\) has been added to the \e2e/sway/contracts/contract\_test\ location. This contract defines a \TestContract\ ABI and implementation featuring storage operations (counter initialization, incrementing, and reading), complex type handling (structs, enums, arrays), and message amount retrieval, serving as a test fixture for end-to-end testing.
_e2e/sway/contracts/contract\test · high confidence
New Sway contracts and predicates added to e2e test suite
The e2e test suite now includes several new Sway source files defining contracts and predicates for testing specific functionality. These include \lib\_contract\_caller\ for testing inter-contract calls and re-entrancy, \liquidity\_pool\ for testing payable deposit/withdraw flows, \token\_ops\ for testing minting, burning, transfers, and message sending, and \signatures\ for testing Secp256k1 signature verification within predicates.
(repo-wide) · high confidence
New Sway examples for validating transaction inputs and outputs
Added new Sway contract, predicate, and script examples in the \e2e/sway\ directory that demonstrate how to inspect and validate transaction inputs and outputs. The contract exposes \check\_input\ and \check\_output\_is\_change\ methods, while the predicate and script implementations verify that specific inputs are coins owned by a configurable owner with a matching asset ID, and that specific outputs are change outputs sent to that same owner.
_e2e/sway/contracts/tx\_input\_output, e2e/sway/predicates/predicate\_tx\_input\_output, e2e/sway/scripts/script\_tx\_input\output · high confidence
New changelog generation script for LTS releases
A new Rust-based changelog generator has been added to the \scripts/change-log\ directory. This tool automates the creation of release notes by querying GitHub for pull requests and releases, then generating a structured Markdown changelog. It supports interactive selection of target branches (including LTS branches) and previous release tags, categorizes changes into Features, Fixes, and Chores, and explicitly highlights breaking changes and migration notes.
scripts/change-log · high confidence
New checksum address validation and enhanced transaction error context
The \fuels-core\ types module now includes a new \checksum\_address\ module that provides \checksum\_encode\ and \is\_checksum\_valid\ functions to validate Ethereum-style checksummed addresses, ensuring addresses are correctly formatted before use. Additionally, the error handling system has been updated to support contextual error wrapping via a new \Context\ trait and \context\/\with\_context\ methods on \Result\ types, allowing developers to attach meaningful context to transaction, codec, and provider errors for better debugging. The \TxStatus\ enum also now distinguishes between \Success\ and \PreconfirmationSuccess\ (and their failure counterparts), reflecting support for preconfirmations and providing more granular transaction status information.
packages/fuels-core/src/types · high confidence
New core type definitions for Bits, Bytes, Identity, and U256
The \fuels-core\ library now includes new type wrappers for interacting with Fuel contracts: \Bits256\ and \B512\ for 256-bit and 512-bit bit sequences, \EvmAddress\ for EVM-compatible addresses, \Bytes\ and \RawSlice\ for byte arrays, \Identity\ to unify \Address\ and \ContractId\, \AsciiString\ and \SizedAsciiString\ for ASCII text, and \U256\ for 256-bit unsigned integers. These types implement \Parameterize\ and \Tokenizable\ traits, enabling them to be used directly in contract calls and allowing users to construct them from hex strings or native Rust types.
packages/fuels-core/src/types/core · high confidence
New debugging example demonstrating function selector encoding and debug-string decoding
A new \examples/debugging\ crate has been added to provide practical examples for debugging contract interactions. It demonstrates how to encode function selectors using \encode\_fn\_selector\ and how to decode binary data into human-readable debug strings via \ABIDecoder::decode\_as\_debug\_str\, covering scenarios with generic structs, nested generics, enums, and logged types.
examples/debugging · high confidence
New documentation validation script for anchors, includes, and file structure
A new \scripts/check-docs\ tool has been added to validate the integrity of the documentation source. It checks that \{{\#include}}\ directives reference existing files and valid anchors, ensures that anchor start/end pairs are correctly matched and ordered, and verifies that all Markdown files in \docs/src\ are listed in \SUMMARY.md\. This helps catch broken links, unused anchors, and missing documentation files before they reach the final build.
scripts/check-docs · high confidence
New fuel-core version synchronization script
A new CLI tool at scripts/fuel-core-version has been added to manage the synchronization of the supported fuel-core version. The tool reads the version directly from the Cargo.toml workspace dependencies and can either write it to a generated version.rs file or verify that the existing version.rs matches the Cargo.toml definition, ensuring consistency between the Rust code and the dependency manifest.
scripts/fuel-core-version · high confidence
New loader-based deployment and contract call assembly infrastructure
The SDK now supports deploying large contracts and scripts via a loader pattern, where the bytecode is uploaded as a blob and a small loader script handles execution. This change introduces new assembly modules to generate the necessary VM instructions for contract calls and loader scripts, and updates the \Contract\ and \Executable\ types to manage this new deployment flow. Additionally, the \CallResponse\ struct now includes the transaction ID, and the system provides improved debugging capabilities by detecting and parsing contract call structures from script binaries.
packages/fuels-programs/src · high confidence
New macros example crate demonstrating abigen and trait derivation
A new \examples/macros\ crate has been added to showcase the usage of the \fuels\ Rust SDK's macro capabilities. It includes test-based examples for generating contract, script, and predicate bindings via \abigen!\, as well as demonstrating how to derive \Parameterize\ and \Tokenizable\ traits on custom structs and enums, including advanced usage with custom path aliases and \NoStd\ configurations.
examples/macros · high confidence
New proc-macro crate for code generation and test setup
The \fuels-macros\ crate has been introduced to centralize procedural macro logic for the Fuel SDK. It provides the \abigen\ and \wasm\_abigen\ macros for generating Rust bindings from ABI sources, and the \setup\_program\_test\ macro to streamline integration testing by handling wallet initialization, contract deployment, and script loading. Additionally, it introduces \Parameterize\, \Tokenizable\, and \TryFrom\ derive macros, enabling automatic serialization and deserialization for user-defined structs and enums.
packages/fuels-macros/src · high confidence
New signer implementations for AWS KMS, Google KMS, and fake testing
The \signers\ module now includes dedicated implementations for cloud-based and testing key management. \AwsKmsSigner\ and \GoogleKmsSigner\ allow users to sign transactions using keys stored in AWS KMS and Google Cloud KMS respectively, handling the necessary protocol conversions and public key derivation. A new \FakeSigner\ has been added to facilitate testing by providing a deterministic, non-secure signer that returns default signatures, and the \PrivateKeySigner\ has been refactored to include mnemonic generation utilities and secure memory handling.
packages/fuels-accounts/src/signers · high confidence
New utility modules for constants and script offsets
Added \constants.rs\ and \offsets.rs\ to \packages/fuels-core/src/utils\. The constants module defines core size values (e.g., \WORD\_SIZE\, \SIGNATURE\_WITNESS\_SIZE\) and default parameters for gas estimation (tolerance and block horizon). The offsets module provides functions to calculate base script/predicate offsets and the specific data offset for call scripts based on consensus parameters, enabling more accurate transaction construction.
packages/fuels-core/src/utils · high confidence
New versions-replacer script for automatic variable substitution
A new \scripts/versions-replacer\ tool has been added to automatically replace version placeholders (e.g., \{{versions.fuels}}\) in files with actual package versions defined in \Cargo.toml\. This utility scans specified directories, reads version metadata from the workspace manifest, and updates matching files in-place, ensuring documentation and other assets remain synchronized with current dependency versions.
scripts/versions-replacer · high confidence
Reintroduce Abigen in a dedicated fuels-code-gen crate
The ABI code generation logic (Abigen) is now available as a standalone, publicly exported crate named \fuels-code-gen\. This module provides the \Abigen\ struct and related types to generate type-safe Rust bindings for Sway contracts, scripts, and predicates from their ABIs, including support for configurable constants, log decoding, and WASM compatibility.
packages/fuels-code-gen · high confidence
Support for deploying large contracts via blob loader
Users can now deploy contracts that exceed the block size limit by splitting the contract bytecode into chunks (blobs) and deploying a small loader contract that references them. The new \loader\_from\_blobs\ API constructs this loader, and calling \deploy\ on it automatically uploads the required blobs (checking for existing blobs first to avoid redundancy) and then deploys the loader. A \deploy\_if\_not\_exists\ variant is also provided to prevent redeployment if the loader is already present. Additionally, the loader contract can be reverted to a regular contract containing the full bytecode if needed.
packages/fuels-programs/src/contract · high confidence
Behavioural changes
Introduce deterministic wallet generation in test helpers
The \fuels-test-helpers\ crate now generates test wallets using deterministic keys derived from a counter, replacing the previous random generation. This ensures that test wallets are reproducible across runs, which simplifies debugging and state verification in integration tests. The change is implemented in the new \accounts.rs\ module, which exposes \launch\_provider\_and\_get\_wallet\ and \launch\_custom\_provider\_and\_get\_wallets\ functions that build wallets from these deterministic \PrivateKeySigner\ instances.
packages/fuels-test-helpers · high confidence
New bounded ABI codec with configurable depth and token limits
The codec module has been replaced with a new implementation that introduces \ABIEncoder\ and \ABIDecoder\ with configurable \EncoderConfig\ and \DecoderConfig\. These configs allow users to set \max\_depth\ (default 45) and \max\_tokens\ (default 10,000) to prevent stack overflows and excessive memory usage during encoding and decoding. The new codec supports encoding and decoding of various types including integers, booleans, strings, bytes, and complex structures like structs, enums, and vectors. It also provides debug string decoding via \decode\_as\_debug\_str\ and \decode\_multiple\_as\_debug\_str\. The \ABIFormatter\ and \LogDecoder\ components have been updated to use the new bounded decoder, ensuring consistent behavior across ABI parsing and log decoding.
packages/fuels-core/src/codec · high confidence
New param type definitions and ABI resolution logic
The \param\_types\ module now includes explicit definitions for \ParamType\ (covering primitives, collections, structs, and enums) and \EnumVariants\, along with a new \from\_type\_application.rs\ file that implements the logic to resolve ABI JSON \UnifiedTypeApplication\ entries into these internal types. This provides the foundational type system and resolution engine used by the core library to interpret contract ABIs.
_packages/fuels-core/src/types/param\types · high confidence
New parameterization and tokenization traits for type conversion
The \fuels-core\ crate now exposes \Parameterize\ and \Tokenizable\ traits in the \traits\ module to handle type mapping between Rust and the Fuel VM. The \Parameterize\ trait defines how Rust types (including primitives, \String\, \Vec\, \Option\, \Result\, and specific Fuel types like \Address\ and \ContractId\) map to ABI parameter types, while \Tokenizable\ implements the bidirectional conversion between these types and \Token\ representations. This change establishes the foundational mechanism for serializing and deserializing function arguments and return values in smart contract interactions.
packages/fuels-core/src/traits · high confidence
Provider reliability improvements with caching, retries, and version checks
The provider now includes a caching layer for consensus parameters and node info to reduce redundant network calls, a configurable retry mechanism with linear, exponential, and fixed backoff strategies for transient failures, and a version compatibility check that emits a warning when the connected fuel-core node version differs from the SDK's supported version (0.48.3).
packages/fuels-accounts/src/provider · high confidence
Reorganized fuels-core into a modular structure with configurable offset support
The \fuels-core\ package has been restructured into distinct modules (\codec\, \traits\, \types\, \utils\) to improve code organization. This change introduces a new \Configurables\ type that allows users to manage configurable contract data offsets, including the ability to shift these offsets programmatically. Additionally, the \codec\ module now exposes a \try\_from\_bytes\ function for decoding bytes into typed structures, and utility functions for byte alignment and witness size calculation are available in the \utils\ module.
packages/fuels-core/src · high confidence
Unified call handling with explicit input/output control
The SDK now uses a single \CallHandler\ to manage both contract and script calls, replacing the previous separate handlers. This change introduces \with\_inputs\ and \with\_outputs\ methods on both \ContractCall\ and \ScriptCall\, allowing users to explicitly define custom transaction inputs and outputs. The \CallHandler\ also consolidates transaction building, estimation, and response parsing, while introducing \with\_contract\_ids\ and \with\_contracts\ to automatically manage external contract dependencies and log decoders for nested calls.
packages/fuels-programs/src/calls · high confidence
Updated Rust bindings example to use new ABI spec and CallHandler API
The \examples/rust\_bindings\ example now demonstrates the SDK's new ABI specification format (specVersion 1) and the unified \CallHandler\ interface for contract interactions. The generated bindings in \rust\_bindings\_formatted.rs\ show that contract methods like \increment\_counter\ now return a \CallHandler\ object, requiring users to explicitly invoke methods on the handler to execute transactions, replacing the previous direct-call pattern. The example also includes updated test code in \lib.rs\ showing how to use the \abigen!\ macro with the new JSON ABI structure.
_examples/rust\bindings · high confidence
Updated Sway ABI test contracts and predicate
The end-to-end Sway ABI test suite has been updated to reflect new ABI specification changes. The simple\_contract now exposes a function that accepts a u32 and returns a boolean, while the wasm\_contract has been expanded to include a test function accepting a generic enum containing a struct. Additionally, the wasm\_predicate has been updated to use a configurable constant for its comparison logic.
_e2e/sway/abi/simple\_contract, e2e/sway/abi/wasm\_contract, e2e/sway/abi/wasm\predicate · high confidence
Test coverage
Add e2e tests for complex vector type compositions; Add e2e tests for raw\_slice and string types; Add end-to-end tests for \str\ type in predicates and scripts; Added Sway contract for testing tuple type handling; Added Sway contract sources for end-to-end testing; Added Sway e2e test cases for predicates and scripts; Added Sway end-to-end test contracts and scripts; Added UI tests for macro usage validation; Added UI tests for macro validation and error reporting; Added swap predicate for e2e testing; Added tests for the docs validation script; New WASM test crate for ABI encoding and predicate validation; New basic Sway script for end-to-end testing; New e2e test contract for variable output estimation; New e2e test contracts and scripts for assert, assert\_eq, and assert\_ne; New end-to-end tests for contract logging and ABI interactions.
Dependencies
Fuel Rust SDK v0.77.0 release with Rust 2024 and fuel-core 0.48 integration
The Fuel Rust SDK has been updated to version 0.77.0, raising the Minimum Supported Rust Version (MSRV) to 1.94.1 and adopting the Rust 2024 edition. This release synchronizes the SDK with fuel-core 0.48.3 (including fuel-vm 0.66.4) and updates fuel-abi-types to 0.16.0. The workspace now utilizes Cargo's new resolver (resolver = "2") to prevent dev-dependencies from affecting production builds, and standardizes dependency management across all packages and examples.
(dependencies) · high confidence
Housekeeping
Initial repository setup and documentation
The repository has been initialized with standard project configuration files, including an Apache 2.0 license, a security policy, and CI check scripts. The README has been expanded to provide comprehensive documentation on features, dependencies, and testing instructions, while configuration files for formatting, linting, and environment variables have been added to support development workflows.
(repo-wide) · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 61 → 62 (+1.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.
Lenses
- Code Health 98 → 98 (-0.9)
- Architecture 99 → 99 (+0.0)
- Maturity 49 → 49 (+0.0)
- Readiness 60 → 67 (+7.4)
- Security 64 → 64 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (2)
- Duplicated block (11–12 lines × 2) (packages/fuels-programs/src/calls/call_handler.rs)
- change_log::domain::changelog::generate_changelog (cognitive 23) (scripts/change-log/src/domain/changelog.rs)
New (34)
- Duplicated block (11–12 lines × 2) (packages/fuels-programs/src/calls/call_handler.rs)
- Duplicated block (9 lines × 2) (packages/fuels-macros/src/derive/parameterize.rs)
- Edited copies of one member (3 members, 10+ corresponding lines) (packages/fuels-accounts/src/provider.rs)
- Edited copies of one member (3 members, 14+ corresponding lines) (packages/fuels-macros/src/abigen/parsing.rs)
- Edited copies of one member (3 members, 17+ corresponding lines) (packages/fuels-macros/src/derive/parameterize.rs)
- Edited copies of one member (3 members, 19+ corresponding lines) (packages/fuels-programs/src/calls/call_handler.rs)
- Edited copies of one member (3 members, 27+ corresponding lines) (packages/fuels-accounts/src/provider.rs)
- Edited copies of one member (4 members, 17+ corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (1 corresponding lines) (packages/fuels-core/src/types/transaction_builders.rs)
- Edited copy of a member (12 corresponding lines) (packages/fuels-accounts/src/signers/kms/aws.rs)
- …and 14 more
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit f5191b6aab3d553ce2348234015e3523b46beb1e — the exact code this score is about.
- Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.