Full Code of FuelLabs/fuels-rs for AI

gitextract_yk9mjvhk/

├── .editorconfig
├── .github/
│   ├── CODEOWNERS
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── workflows/
│       ├── ci.yml
│       ├── docs.yml
│       ├── gh-pages.yml
│       ├── repo-plan.toml
│       └── scripts/
│           └── verify_tag.sh
├── .gitignore
├── .markdownlint.yaml
├── .markdownlintignore
├── Cargo.toml
├── LICENSE
├── README.md
├── SECURITY.md
├── _typos.toml
├── ci_checks.sh
├── docs/
│   ├── .spellcheck.yml
│   ├── book.toml
│   ├── spell-check-custom-words.txt
│   ├── src/
│   │   ├── SUMMARY.md
│   │   ├── abigen/
│   │   │   ├── index.md
│   │   │   ├── the-abigen-macro.md
│   │   │   └── the-json-abi-file.md
│   │   ├── accounts.md
│   │   ├── calling-contracts/
│   │   │   ├── call-params.md
│   │   │   ├── call-response.md
│   │   │   ├── calls-with-different-wallets.md
│   │   │   ├── cost-estimation.md
│   │   │   ├── custom-asset-transfer.md
│   │   │   ├── custom-inputs-outputs.md
│   │   │   ├── index.md
│   │   │   ├── logs.md
│   │   │   ├── low-level-calls.md
│   │   │   ├── multicalls.md
│   │   │   ├── other-contracts.md
│   │   │   ├── simulation.md
│   │   │   ├── tx-dependency-estimation.md
│   │   │   ├── tx-policies.md
│   │   │   └── variable-outputs.md
│   │   ├── cli/
│   │   │   ├── fuels-abi-cli.md
│   │   │   └── index.md
│   │   ├── codec/
│   │   │   ├── decoding.md
│   │   │   ├── encoding.md
│   │   │   └── index.md
│   │   ├── connecting/
│   │   │   ├── external-node.md
│   │   │   ├── index.md
│   │   │   ├── querying.md
│   │   │   ├── retrying.md
│   │   │   ├── rocksdb.md
│   │   │   └── short-lived.md
│   │   ├── contributing/
│   │   │   ├── CONTRIBUTING.md
│   │   │   └── tests-structure.md
│   │   ├── cookbook/
│   │   │   ├── custom-chain.md
│   │   │   ├── deposit-and-withdraw.md
│   │   │   ├── index.md
│   │   │   └── transfer-all-assets.md
│   │   ├── custom-transactions/
│   │   │   ├── custom-calls.md
│   │   │   ├── index.md
│   │   │   └── transaction-builders.md
│   │   ├── debugging/
│   │   │   ├── decoding-script-transactions.md
│   │   │   ├── function-selector.md
│   │   │   └── index.md
│   │   ├── deploying/
│   │   │   ├── configurable-constants.md
│   │   │   ├── index.md
│   │   │   ├── interacting-with-contracts.md
│   │   │   ├── large_contracts.md
│   │   │   ├── storage-slots.md
│   │   │   └── the-fuelvm-binary-file.md
│   │   ├── getting-started.md
│   │   ├── glossary.md
│   │   ├── index.md
│   │   ├── predicates/
│   │   │   ├── index.md
│   │   │   └── send-spend-predicate.md
│   │   ├── preuploading-code.md
│   │   ├── reference.md
│   │   ├── running-scripts.md
│   │   ├── testing/
│   │   │   ├── basics.md
│   │   │   ├── chains.md
│   │   │   ├── index.md
│   │   │   └── the-setup-program-test-macro.md
│   │   ├── types/
│   │   │   ├── B512.md
│   │   │   ├── address.md
│   │   │   ├── asset-id.md
│   │   │   ├── bits256.md
│   │   │   ├── bytes.md
│   │   │   ├── bytes32.md
│   │   │   ├── contract-id.md
│   │   │   ├── conversion.md
│   │   │   ├── custom_types.md
│   │   │   ├── evm_address.md
│   │   │   ├── index.md
│   │   │   ├── string.md
│   │   │   └── vectors.md
│   │   └── wallets/
│   │       ├── access.md
│   │       ├── checking-balances-and-coins.md
│   │       ├── fake_signer.md
│   │       ├── index.md
│   │       ├── keystore.md
│   │       ├── kms.md
│   │       ├── private_key_signer.md
│   │       ├── signing.md
│   │       └── test-wallets.md
│   └── theme/
│       └── highlight.js
├── e2e/
│   ├── Cargo.toml
│   ├── Forc.toml
│   ├── build.rs
│   ├── src/
│   │   ├── aws_kms.rs
│   │   ├── e2e_helpers.rs
│   │   └── lib.rs
│   ├── sway/
│   │   ├── abi/
│   │   │   ├── simple_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── wasm_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   └── wasm_predicate/
│   │   │       ├── Forc.toml
│   │   │       └── src/
│   │   │           └── main.sw
│   │   ├── bindings/
│   │   │   ├── sharing_types/
│   │   │   │   ├── contract_a/
│   │   │   │   │   ├── Forc.toml
│   │   │   │   │   └── src/
│   │   │   │   │       └── main.sw
│   │   │   │   ├── contract_b/
│   │   │   │   │   ├── Forc.toml
│   │   │   │   │   └── src/
│   │   │   │   │       └── main.sw
│   │   │   │   └── shared_lib/
│   │   │   │       ├── Forc.toml
│   │   │   │       └── src/
│   │   │   │           └── lib.sw
│   │   │   ├── simple_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   └── type_paths/
│   │   │       ├── Forc.toml
│   │   │       └── src/
│   │   │           ├── another_lib.sw
│   │   │           ├── contract_a_types.sw
│   │   │           └── main.sw
│   │   ├── contracts/
│   │   │   ├── asserts/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── auth_testing_abi/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── auth_testing_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── block_timestamp/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── configurables/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── contract_test/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── huge_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── large_return_data/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── lib_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── lib_contract_abi/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── lib_contract_caller/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── library_test/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── liquidity_pool/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── low_level_caller/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── msg_methods/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── multiple_read_calls/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── needs_custom_decoder/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── payable_annotation/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── proxy/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── revert_transaction_error/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── storage/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── token_ops/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── transaction_block_height/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── tx_input_output/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   └── var_outputs/
│   │   │       ├── Forc.toml
│   │   │       └── src/
│   │   │           └── main.sw
│   │   ├── logs/
│   │   │   ├── contract_logs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── contract_logs_abi/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── contract_revert_logs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── contract_with_contract_logs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_heap_logs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_logs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_revert_logs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   └── script_with_contract_logs/
│   │   │       ├── Forc.toml
│   │   │       └── src/
│   │   │           └── main.sw
│   │   ├── predicates/
│   │   │   ├── basic_predicate/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── predicate_blobs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── predicate_configurables/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── predicate_tx_input_output/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── predicate_witnesses/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── signatures/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   └── swap/
│   │   │       ├── Forc.toml
│   │   │       └── src/
│   │   │           └── main.sw
│   │   ├── scripts/
│   │   │   ├── arguments/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── basic_script/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── empty/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── require_from_contract/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── reverting/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_array/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_asserts/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_blobs/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_configurables/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_enum/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_needs_custom_decoder/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_proxy/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_struct/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   ├── script_tx_input_output/
│   │   │   │   ├── Forc.toml
│   │   │   │   └── src/
│   │   │   │       └── main.sw
│   │   │   └── transfer_script/
│   │   │       ├── Forc.toml
│   │   │       └── src/
│   │   │           └── main.sw
│   │   └── types/
│   │       ├── contracts/
│   │       │   ├── b256/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── b512/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── bytes/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── call_empty_return/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── complex_types_contract/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── contract_output_test/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── empty_arguments/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── enum_as_input/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── enum_encoding/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── enum_inside_struct/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── evm_address/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── generics/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── heap_type_in_enums/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── heap_types/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── identity/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── native_types/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── nested_structs/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── options/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── raw_slice/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── results/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── std_lib_string/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── str_in_array/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── string_slice/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── tuples/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── two_structs/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── type_inside_enum/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── u128/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── u256/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── vector_output/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   └── vectors/
│   │       │       ├── Forc.toml
│   │       │       └── src/
│   │       │           ├── data_structures.sw
│   │       │           ├── eq_impls.sw
│   │       │           ├── main.sw
│   │       │           └── utils.sw
│   │       ├── predicates/
│   │       │   ├── address/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── enums/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_b256/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_bytes/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_bytes_hash/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_generics/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_raw_slice/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_std_lib_string/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_string_slice/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_tuples/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_u128/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_u256/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_vector/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── predicate_vectors/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   ├── structs/
│   │       │   │   ├── Forc.toml
│   │       │   │   └── src/
│   │       │   │       └── main.sw
│   │       │   └── u64/
│   │       │       ├── Forc.toml
│   │       │       └── src/
│   │       │           └── main.sw
│   │       └── scripts/
│   │           ├── options_results/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_b256/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_bytes/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_generics/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_heap_types/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_raw_slice/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_std_lib_string/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_string_slice/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_tuples/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_u128/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           ├── script_u256/
│   │           │   ├── Forc.toml
│   │           │   └── src/
│   │           │       └── main.sw
│   │           └── script_vectors/
│   │               ├── Forc.toml
│   │               └── src/
│   │                   ├── data_structures.sw
│   │                   ├── eq_impls.sw
│   │                   ├── main.sw
│   │                   └── utils.sw
│   └── tests/
│       ├── aws.rs
│       ├── binary_format.rs
│       ├── bindings.rs
│       ├── configurables.rs
│       ├── contracts.rs
│       ├── debug_utils.rs
│       ├── from_token.rs
│       ├── imports.rs
│       ├── logs.rs
│       ├── predicates.rs
│       ├── providers.rs
│       ├── scripts.rs
│       ├── storage.rs
│       ├── types_contracts.rs
│       ├── types_predicates.rs
│       ├── types_scripts.rs
│       └── wallets.rs
├── examples/
│   ├── codec/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── contracts/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── cookbook/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── debugging/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── macros/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── predicates/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── providers/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── rust_bindings/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── abi.json
│   │       ├── lib.rs
│   │       └── rust_bindings_formatted.rs
│   ├── types/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   └── wallets/
│       ├── Cargo.toml
│       └── src/
│           └── lib.rs
├── packages/
│   ├── fuels/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── fuels-accounts/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── account.rs
│   │       ├── accounts_utils.rs
│   │       ├── coin_cache.rs
│   │       ├── keystore.rs
│   │       ├── lib.rs
│   │       ├── predicate.rs
│   │       ├── provider/
│   │       │   ├── cache.rs
│   │       │   ├── retry_util.rs
│   │       │   ├── retryable_client.rs
│   │       │   ├── supported_fuel_core_version.rs
│   │       │   └── supported_versions.rs
│   │       ├── provider.rs
│   │       ├── schema/
│   │       │   └── schema.sdl
│   │       ├── signers/
│   │       │   ├── fake.rs
│   │       │   ├── kms/
│   │       │   │   ├── aws.rs
│   │       │   │   └── google.rs
│   │       │   ├── kms.rs
│   │       │   └── private_key.rs
│   │       ├── signers.rs
│   │       └── wallet.rs
│   ├── fuels-code-gen/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── error.rs
│   │       ├── lib.rs
│   │       ├── program_bindings/
│   │       │   ├── abigen/
│   │       │   │   ├── abigen_target.rs
│   │       │   │   ├── bindings/
│   │       │   │   │   ├── contract.rs
│   │       │   │   │   ├── function_generator.rs
│   │       │   │   │   ├── predicate.rs
│   │       │   │   │   ├── script.rs
│   │       │   │   │   └── utils.rs
│   │       │   │   ├── bindings.rs
│   │       │   │   ├── configurables.rs
│   │       │   │   └── logs.rs
│   │       │   ├── abigen.rs
│   │       │   ├── custom_types/
│   │       │   │   ├── enums.rs
│   │       │   │   ├── structs.rs
│   │       │   │   └── utils.rs
│   │       │   ├── custom_types.rs
│   │       │   ├── generated_code.rs
│   │       │   ├── resolved_type.rs
│   │       │   └── utils.rs
│   │       ├── program_bindings.rs
│   │       └── utils.rs
│   ├── fuels-core/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── codec/
│   │       │   ├── abi_decoder/
│   │       │   │   ├── bounded_decoder.rs
│   │       │   │   └── decode_as_debug_str.rs
│   │       │   ├── abi_decoder.rs
│   │       │   ├── abi_encoder/
│   │       │   │   └── bounded_encoder.rs
│   │       │   ├── abi_encoder.rs
│   │       │   ├── abi_formatter.rs
│   │       │   ├── function_selector.rs
│   │       │   ├── logs.rs
│   │       │   └── utils.rs
│   │       ├── codec.rs
│   │       ├── lib.rs
│   │       ├── traits/
│   │       │   ├── parameterize.rs
│   │       │   ├── signer.rs
│   │       │   └── tokenizable.rs
│   │       ├── traits.rs
│   │       ├── types/
│   │       │   ├── checksum_address.rs
│   │       │   ├── core/
│   │       │   │   ├── bits.rs
│   │       │   │   ├── bytes.rs
│   │       │   │   ├── identity.rs
│   │       │   │   ├── raw_slice.rs
│   │       │   │   ├── sized_ascii_string.rs
│   │       │   │   └── u256.rs
│   │       │   ├── core.rs
│   │       │   ├── dry_runner.rs
│   │       │   ├── errors.rs
│   │       │   ├── method_descriptor.rs
│   │       │   ├── param_types/
│   │       │   │   ├── from_type_application.rs
│   │       │   │   └── param_type.rs
│   │       │   ├── param_types.rs
│   │       │   ├── token.rs
│   │       │   ├── transaction_builders/
│   │       │   │   ├── blob.rs
│   │       │   │   └── script_tx_estimator.rs
│   │       │   ├── transaction_builders.rs
│   │       │   ├── tx_response.rs
│   │       │   ├── tx_status.rs
│   │       │   ├── wrappers/
│   │       │   │   ├── block.rs
│   │       │   │   ├── chain_info.rs
│   │       │   │   ├── coin.rs
│   │       │   │   ├── coin_type.rs
│   │       │   │   ├── coin_type_id.rs
│   │       │   │   ├── input.rs
│   │       │   │   ├── message.rs
│   │       │   │   ├── message_proof.rs
│   │       │   │   ├── node_info.rs
│   │       │   │   ├── transaction.rs
│   │       │   │   └── transaction_response.rs
│   │       │   └── wrappers.rs
│   │       ├── types.rs
│   │       ├── utils/
│   │       │   ├── constants.rs
│   │       │   └── offsets.rs
│   │       └── utils.rs
│   ├── fuels-macros/
│   │   ├── .gitignore
│   │   ├── Cargo.toml
│   │   ├── src/
│   │   │   ├── abigen/
│   │   │   │   └── parsing.rs
│   │   │   ├── abigen.rs
│   │   │   ├── derive/
│   │   │   │   ├── parameterize.rs
│   │   │   │   ├── tokenizable.rs
│   │   │   │   ├── try_from.rs
│   │   │   │   └── utils.rs
│   │   │   ├── derive.rs
│   │   │   ├── lib.rs
│   │   │   ├── parse_utils/
│   │   │   │   ├── command.rs
│   │   │   │   ├── unique_lit_strs.rs
│   │   │   │   └── unique_name_values.rs
│   │   │   ├── parse_utils.rs
│   │   │   ├── setup_program_test/
│   │   │   │   ├── code_gen.rs
│   │   │   │   ├── parsing/
│   │   │   │   │   ├── command_parser.rs
│   │   │   │   │   ├── commands/
│   │   │   │   │   │   ├── abigen.rs
│   │   │   │   │   │   ├── deploy_contract.rs
│   │   │   │   │   │   ├── initialize_wallet.rs
│   │   │   │   │   │   ├── load_script.rs
│   │   │   │   │   │   └── set_options.rs
│   │   │   │   │   ├── commands.rs
│   │   │   │   │   └── validations.rs
│   │   │   │   └── parsing.rs
│   │   │   └── setup_program_test.rs
│   │   └── tests/
│   │       ├── macro_usage.rs
│   │       └── ui/
│   │           ├── abigen/
│   │           │   ├── duplicate_attribute.rs
│   │           │   ├── duplicate_attribute.stderr
│   │           │   ├── invalid_abi_path.rs
│   │           │   ├── invalid_abi_path.stderr
│   │           │   ├── invalid_abi_value.rs
│   │           │   ├── invalid_abi_value.stderr
│   │           │   ├── invalid_name_value.rs
│   │           │   ├── invalid_name_value.stderr
│   │           │   ├── invalid_program_type.rs
│   │           │   ├── invalid_program_type.stderr
│   │           │   ├── malformed_abi.rs
│   │           │   ├── malformed_abi.stderr
│   │           │   ├── missing_abi_attribute.rs
│   │           │   ├── missing_abi_attribute.stderr
│   │           │   ├── missing_name_attr.rs
│   │           │   ├── missing_name_attr.stderr
│   │           │   ├── unrecognized_attribute.rs
│   │           │   └── unrecognized_attribute.stderr
│   │           ├── derive/
│   │           │   ├── parameterize/
│   │           │   │   ├── attribute_must_be_named_value.rs
│   │           │   │   ├── attribute_must_be_named_value.stderr
│   │           │   │   ├── only_generic_types_are_supported.rs
│   │           │   │   ├── only_generic_types_are_supported.stderr
│   │           │   │   ├── only_one_variant_element_supported.rs
│   │           │   │   ├── only_one_variant_element_supported.stderr
│   │           │   │   ├── struct_like_enum_variants_not_supported.rs
│   │           │   │   ├── struct_like_enum_variants_not_supported.stderr
│   │           │   │   ├── tuple_like_structs_not_supported.rs
│   │           │   │   └── tuple_like_structs_not_supported.stderr
│   │           │   └── tokenizable/
│   │           │       ├── attribute_must_be_named_value.stderr
│   │           │       ├── only_generic_types_are_supported.rs
│   │           │       ├── only_generic_types_are_supported.stderr
│   │           │       ├── only_one_variant_element_supported.rs
│   │           │       ├── only_one_variant_element_supported.stderr
│   │           │       ├── struct_like_enum_variants_not_supported.rs
│   │           │       ├── struct_like_enum_variants_not_supported.stderr
│   │           │       ├── tuple_like_structs_not_supported.rs
│   │           │       └── tuple_like_structs_not_supported.stderr
│   │           └── setup_program_test/
│   │               ├── abigen_command_is_missing.rs
│   │               ├── abigen_command_is_missing.stderr
│   │               ├── duplicate_wallet_command.rs
│   │               ├── duplicate_wallet_command.stderr
│   │               ├── duplicate_wallet_names.rs
│   │               ├── duplicate_wallet_names.stderr
│   │               ├── invalid_path.rs
│   │               ├── invalid_path.stderr
│   │               ├── invalid_project_path.rs
│   │               ├── invalid_project_path.stderr
│   │               ├── unknown_command.rs
│   │               ├── unknown_command.stderr
│   │               ├── unknown_contract.rs
│   │               ├── unknown_contract.stderr
│   │               ├── unknown_options_key.rs
│   │               ├── unknown_options_key.stderr
│   │               ├── unknown_options_value.rs
│   │               └── unknown_options_value.stderr
│   ├── fuels-programs/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── assembly/
│   │       │   ├── contract_call.rs
│   │       │   ├── cursor.rs
│   │       │   └── script_and_predicate_loader.rs
│   │       ├── assembly.rs
│   │       ├── calls/
│   │       │   ├── call_handler.rs
│   │       │   ├── contract_call.rs
│   │       │   ├── receipt_parser.rs
│   │       │   ├── script_call.rs
│   │       │   ├── traits/
│   │       │   │   ├── contract_dep_configurator.rs
│   │       │   │   ├── response_parser.rs
│   │       │   │   └── transaction_tuner.rs
│   │       │   ├── traits.rs
│   │       │   └── utils.rs
│   │       ├── calls.rs
│   │       ├── contract/
│   │       │   ├── loader.rs
│   │       │   ├── regular.rs
│   │       │   └── storage.rs
│   │       ├── contract.rs
│   │       ├── debug.rs
│   │       ├── executable.rs
│   │       ├── lib.rs
│   │       ├── responses/
│   │       │   ├── call.rs
│   │       │   └── submit.rs
│   │       ├── responses.rs
│   │       └── utils.rs
│   └── fuels-test-helpers/
│       ├── Cargo.toml
│       └── src/
│           ├── accounts.rs
│           ├── fuel_bin_service.rs
│           ├── lib.rs
│           ├── node_types.rs
│           ├── service.rs
│           ├── utils.rs
│           └── wallets_config.rs
├── rustfmt.toml
├── scripts/
│   ├── change-log/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── adapters/
│   │       │   └── octocrab.rs
│   │       ├── adapters.rs
│   │       ├── domain/
│   │       │   ├── changelog.rs
│   │       │   └── models.rs
│   │       ├── domain.rs
│   │       ├── lib.rs
│   │       ├── main.rs
│   │       ├── ports/
│   │       │   └── github.rs
│   │       └── ports.rs
│   ├── check-docs/
│   │   ├── Cargo.toml
│   │   ├── src/
│   │   │   ├── lib.rs
│   │   │   └── main.rs
│   │   └── tests/
│   │       ├── harness.rs
│   │       └── test_data/
│   │           ├── docs/
│   │           │   └── src/
│   │           │       ├── SUMMARY.md
│   │           │       ├── test-not-there.md
│   │           │       └── test.md
│   │           ├── test_anchor_data.rs
│   │           └── test_include_data.md
│   ├── fuel-core-version/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── main.rs
│   └── versions-replacer/
│       ├── Cargo.toml
│       └── src/
│           ├── lib.rs
│           ├── main.rs
│           ├── metadata.rs
│           └── replace.rs
└── wasm-tests/
    ├── .cargo/
    │   └── config.toml
    ├── Cargo.toml
    └── src/
        └── lib.rs

SYMBOL INDEX (2300 symbols across 204 files)

FILE: docs/theme/highlight.js
  function t (line 6) | function t(e){
  class s (line 12) | class s{constructor(e){
    method constructor (line 12) | constructor(e){
    method ignoreMatch (line 14) | ignoreMatch(){this.isMatchIgnored=!0}
  function i (line 14) | function i(e){
  function a (line 16) | function a(e,...t){const n=Object.create(null);for(const t in e)n[t]=e[t]
  class o (line 18) | class o{constructor(e,t){
    method constructor (line 18) | constructor(e,t){
    method addText (line 19) | addText(e){
    method openNode (line 20) | openNode(e){if(!r(e))return;let t=e.kind
    method closeNode (line 24) | closeNode(e){
    method value (line 25) | value(){return this.buffer}
    method span (line 25) | span(e){
  class l (line 26) | class l{constructor(){this.rootNode={
    method constructor (line 26) | constructor(){this.rootNode={
    method top (line 27) | get top(){
    method root (line 28) | get root(){return this.rootNode}
    method add (line 28) | add(e){
    method openNode (line 29) | openNode(e){const t={kind:e,children:[]}
    method closeNode (line 30) | closeNode(){
    method closeAllNodes (line 31) | closeAllNodes(){
    method toJSON (line 32) | toJSON(){return JSON.stringify(this.rootNode,null,4)}
    method walk (line 33) | walk(e){return this.constructor._walk(e,this.rootNode)}
    method _walk (line 33) | static _walk(e,t){
    method _collapse (line 35) | static _collapse(e){
  class c (line 37) | class c extends l{constructor(e){super(),this.options=e}
    method constructor (line 37) | constructor(e){super(),this.options=e}
    method addKeyword (line 38) | addKeyword(e,t){""!==e&&(this.openNode(t),this.addText(e),this.closeNo...
    method addText (line 39) | addText(e){""!==e&&this.add(e)}
    method addSublanguage (line 39) | addSublanguage(e,t){const n=e.root
    method toHTML (line 40) | toHTML(){
    method finalize (line 41) | finalize(){return!0}
  function d (line 41) | function d(e){
  function u (line 42) | function u(e){return b("(?=",e,")")}
  function g (line 43) | function g(e){return b("(?:",e,")*")}
  function h (line 43) | function h(e){return b("(?:",e,")?")}
  function b (line 44) | function b(...e){return e.map((e=>d(e))).join("")}
  function p (line 44) | function p(...e){const t=(e=>{
  function f (line 48) | function f(e){return RegExp(e.toString()+"|").exec("").length-1}
  function E (line 50) | function E(e,{joinWith:t}){let n=0;return e.map((e=>{n+=1;const t=n
  function T (line 82) | function T(e,t){
  function D (line 83) | function D(e,t){
  function j (line 84) | function j(e,t){
  function C (line 87) | function C(e,t){
  function B (line 88) | function B(e,t){
  function L (line 91) | function L(e,t){
  function U (line 99) | function U(e,t,n="keyword"){const s=Object.create(null)
  function H (line 103) | function H(e,t){
  function W (line 107) | function W(e,t,{key:n}){let s=0;const i=e[n],a={},r={}
  function X (line 109) | function X(e){(e=>{
  function q (line 122) | function q(e){
  function V (line 169) | function V(e){
  class Q (line 170) | class Q extends Error{
    method constructor (line 171) | constructor(e,t){super(e),this.name="HTMLInjectionError",this.html=t}
  function f (line 178) | function f(e){
  function m (line 179) | function m(e,t,n){let s="",i=""
  function E (line 185) | function E(e,n,i,a){
  function _ (line 247) | function _(e,n){n=n||d.languages||Object.keys(t);const s=(e=>{
  function w (line 254) | function w(e){let t=null;const n=(e=>{
  function N (line 271) | function N(){
  function x (line 273) | function x(e){return e=(e||"").toLowerCase(),t[e]||t[i[e]]}
  function k (line 274) | function k(e,{languageName:t}){"string"==typeof e&&(e=[e]),e.forEach((e=>{
  function v (line 275) | function v(e){const t=x(e)
  function O (line 276) | function O(e,t){const n=e;a.forEach((e=>{

FILE: e2e/build.rs
  type Downloader (line 10) | struct Downloader {
    constant EXECUTOR_FILE_NAME (line 15) | const EXECUTOR_FILE_NAME: &'static str = "fuel-core-wasm-executor.wasm";
    method new (line 17) | pub fn new() -> Self {
    method should_download (line 25) | pub fn should_download(&self) -> anyhow::Result<bool> {
    method download (line 42) | pub fn download(&self) -> anyhow::Result<()> {
    method make_cargo_watch_downloaded_files (line 89) | fn make_cargo_watch_downloaded_files(&self) {
    method executor_path (line 97) | fn executor_path(&self) -> PathBuf {
    method version_path (line 101) | fn version_path(&self) -> PathBuf {
  function main (line 106) | fn main() {

FILE: e2e/src/aws_kms.rs
  type AwsKms (line 18) | pub struct AwsKms {
    method with_show_logs (line 43) | pub fn with_show_logs(mut self, show_logs: bool) -> Self {
    method start (line 48) | pub async fn start(self) -> Result<AwsKmsProcess> {
  type AwsKmsImage (line 22) | struct AwsKmsImage;
    method name (line 25) | fn name(&self) -> &str {
    method tag (line 29) | fn tag(&self) -> &str {
    method ready_conditions (line 33) | fn ready_conditions(&self) -> Vec<testcontainers::core::WaitFor> {
    method expose_ports (line 37) | fn expose_ports(&self) -> &[ContainerPort] {
  function spawn_log_printer (line 85) | fn spawn_log_printer(container: &testcontainers::ContainerAsync<AwsKmsIm...
  type AwsKmsProcess (line 124) | pub struct AwsKmsProcess {
    method create_signer (line 131) | pub async fn create_signer(&self) -> anyhow::Result<AwsKmsSigner> {
    method client (line 150) | pub fn client(&self) -> &Client {
    method url (line 154) | pub fn url(&self) -> &str {

FILE: e2e/src/e2e_helpers.rs
  function start_aws_kms (line 5) | pub async fn start_aws_kms(logs: bool) -> Result<AwsKmsProcess> {

FILE: e2e/tests/aws.rs
  function fund_aws_wallet (line 15) | async fn fund_aws_wallet() -> Result<()> {
  function deploy_contract (line 43) | async fn deploy_contract() -> Result<()> {

FILE: e2e/tests/binary_format.rs
  constant DATA_OFFSET_LOCATION (line 7) | const DATA_OFFSET_LOCATION: Range<usize> = 8..16;
  constant CONFIGURABLES_OFFSET_LOCATION (line 8) | const CONFIGURABLES_OFFSET_LOCATION: Range<usize> = 16..24;
  constant LEGACY_BINARY_PATH (line 10) | const LEGACY_BINARY_PATH: &str =
  constant NEW_BINARY_PATH (line 12) | const NEW_BINARY_PATH: &str =
  function no_configurables_offset_for_old_sway_binaries (line 16) | fn no_configurables_offset_for_old_sway_binaries() {
  function correct_data_offset_for_old_sway_binaries (line 28) | fn correct_data_offset_for_old_sway_binaries() {
  function correct_data_offset_for_new_sway_binaries (line 41) | fn correct_data_offset_for_new_sway_binaries() {
  function correct_configurables_offset_for_new_sway_binaries (line 54) | fn correct_configurables_offset_for_new_sway_binaries() {
  function read_offset (line 69) | pub fn read_offset(binary: &[u8], range: Range<usize>) -> usize {
  function load (line 75) | fn load(path: &str) -> (Vec<u8>, Executable<Regular>) {

FILE: e2e/tests/bindings.rs
  function setup_program_test_is_hygienic (line 5) | async fn setup_program_test_is_hygienic() {
  function compile_bindings_from_contract_file (line 23) | async fn compile_bindings_from_contract_file() {
  function compile_bindings_from_inline_contract (line 48) | async fn compile_bindings_from_inline_contract() -> Result<()> {
  function shared_types (line 101) | async fn shared_types() -> Result<()> {
  function type_paths_respected (line 220) | async fn type_paths_respected() -> Result<()> {

FILE: e2e/tests/configurables.rs
  function contract_default_configurables (line 8) | async fn contract_default_configurables() -> Result<()> {
  function script_default_configurables (line 56) | async fn script_default_configurables() -> Result<()> {
  function contract_configurables (line 99) | async fn contract_configurables() -> Result<()> {
  function contract_manual_configurables (line 167) | async fn contract_manual_configurables() -> Result<()> {
  function script_configurables (line 235) | async fn script_configurables() -> Result<()> {
  function configurable_encoder_config_is_applied (line 298) | async fn configurable_encoder_config_is_applied() {

FILE: e2e/tests/contracts.rs
  function test_multiple_args (line 22) | async fn test_multiple_args() -> Result<()> {
  function test_contract_calling_contract (line 53) | async fn test_contract_calling_contract() -> Result<()> {
  function test_reverting_transaction (line 129) | async fn test_reverting_transaction() -> Result<()> {
  function test_multiple_read_calls (line 159) | async fn test_multiple_read_calls() -> Result<()> {
  function test_multi_call_beginner (line 196) | async fn test_multi_call_beginner() -> Result<()> {
  function test_multi_call_pro (line 228) | async fn test_multi_call_pro() -> Result<()> {
  function test_contract_call_fee_estimation (line 282) | async fn test_contract_call_fee_estimation() -> Result<()> {
  function contract_call_has_same_estimated_and_used_gas (line 322) | async fn contract_call_has_same_estimated_and_used_gas() -> Result<()> {
  function mult_call_has_same_estimated_and_used_gas (line 359) | async fn mult_call_has_same_estimated_and_used_gas() -> Result<()> {
  function contract_method_call_respects_maturity_and_expiration (line 401) | async fn contract_method_call_respects_maturity_and_expiration() -> Resu...
  function test_auth_msg_sender_from_sdk (line 456) | async fn test_auth_msg_sender_from_sdk() -> Result<()> {
  function test_large_return_data (line 483) | async fn test_large_return_data() -> Result<()> {
  function can_handle_function_called_new (line 541) | async fn can_handle_function_called_new() -> Result<()> {
  function test_contract_setup_macro_deploy_with_salt (line 563) | async fn test_contract_setup_macro_deploy_with_salt() -> Result<()> {
  function test_wallet_getter (line 627) | async fn test_wallet_getter() -> Result<()> {
  function test_connect_wallet (line 649) | async fn test_connect_wallet() -> Result<()> {
  function setup_output_variable_estimation_test (line 705) | async fn setup_output_variable_estimation_test()
  function test_output_variable_estimation (line 730) | async fn test_output_variable_estimation() -> Result<()> {
  function test_output_variable_estimation_multicall (line 774) | async fn test_output_variable_estimation_multicall() -> Result<()> {
  function test_contract_instance_get_balances (line 823) | async fn test_contract_instance_get_balances() -> Result<()> {
  function contract_call_futures_implement_send (line 867) | async fn contract_call_futures_implement_send() -> Result<()> {
  function test_contract_set_estimation (line 902) | async fn test_contract_set_estimation() -> Result<()> {
  function test_output_variable_contract_id_estimation_multicall (line 960) | async fn test_output_variable_contract_id_estimation_multicall() -> Resu...
  function test_contract_call_with_non_default_max_input (line 1027) | async fn test_contract_call_with_non_default_max_input() -> Result<()> {
  function test_add_custom_assets (line 1080) | async fn test_add_custom_assets() -> Result<()> {
  function contract_load_error_messages (line 1149) | async fn contract_load_error_messages() {
  function test_payable_annotation (line 1171) | async fn test_payable_annotation() -> Result<()> {
  function multi_call_from_calls_with_different_account_types (line 1221) | async fn multi_call_from_calls_with_different_account_types() -> Result<...
  function low_level_call (line 1246) | async fn low_level_call() -> Result<()> {
  function db_rocksdb (line 1347) | fn db_rocksdb() {
  function can_configure_decoding_of_contract_return (line 1448) | async fn can_configure_decoding_of_contract_return() -> Result<()> {
  function test_contract_submit_and_response (line 1510) | async fn test_contract_submit_and_response() -> Result<()> {
  function test_heap_type_multicall (line 1552) | async fn test_heap_type_multicall() -> Result<()> {
  function heap_types_correctly_offset_in_create_transactions_w_storage_slots (line 1600) | async fn heap_types_correctly_offset_in_create_transactions_w_storage_sl...
  function test_arguments_with_gas_forwarded (line 1640) | async fn test_arguments_with_gas_forwarded() -> Result<()> {
  function contract_custom_call_no_signatures_strategy (line 1704) | async fn contract_custom_call_no_signatures_strategy() -> Result<()> {
  function contract_encoder_config_is_applied (line 1760) | async fn contract_encoder_config_is_applied() -> Result<()> {
  function test_reentrant_calls (line 1821) | async fn test_reentrant_calls() -> Result<()> {
  function msg_sender_gas_estimation_issue (line 1849) | async fn msg_sender_gas_estimation_issue() {
  function variable_output_estimation_is_optimized (line 1903) | async fn variable_output_estimation_is_optimized() -> Result<()> {
  function config_for_high_price_node (line 1942) | fn config_for_high_price_node() -> (WalletsConfig, NodeConfig, ChainConf...
  function setup_node_with_high_price (line 1966) | async fn setup_node_with_high_price() -> Result<Vec<Wallet>> {
  function setup_node_with_high_price_historical_execution (line 1980) | async fn setup_node_with_high_price_historical_execution()
  function simulations_can_be_made_without_coins (line 2001) | async fn simulations_can_be_made_without_coins() -> Result<()> {
  function simulations_can_be_made_at_specific_block_height (line 2033) | async fn simulations_can_be_made_at_specific_block_height() -> Result<()> {
  function simulations_can_be_made_without_coins_multicall (line 2084) | async fn simulations_can_be_made_without_coins_multicall() -> Result<()> {
  function contract_call_with_non_zero_base_asset_id_and_tip (line 2125) | async fn contract_call_with_non_zero_base_asset_id_and_tip() -> Result<(...
  function max_fee_estimation_respects_tolerance (line 2176) | async fn max_fee_estimation_respects_tolerance() -> Result<()> {
  function blob_contract_deployment (line 2301) | async fn blob_contract_deployment() -> Result<()> {
  function regular_contract_can_be_deployed (line 2349) | async fn regular_contract_can_be_deployed() -> Result<()> {
  function unuploaded_loader_can_be_deployed_directly (line 2383) | async fn unuploaded_loader_can_be_deployed_directly() -> Result<()> {
  function unuploaded_loader_can_upload_blobs_separately_then_deploy (line 2410) | async fn unuploaded_loader_can_upload_blobs_separately_then_deploy() -> ...
  function loader_blob_already_uploaded_not_an_issue (line 2449) | async fn loader_blob_already_uploaded_not_an_issue() -> Result<()> {
  function loader_works_via_proxy (line 2482) | async fn loader_works_via_proxy() -> Result<()> {
  function loader_storage_works_via_proxy (line 2534) | async fn loader_storage_works_via_proxy() -> Result<()> {
  function adjust_for_fee_errors (line 2608) | async fn adjust_for_fee_errors() -> Result<()> {
  function tx_input_output (line 2634) | async fn tx_input_output() -> Result<()> {
  function multicall_tx_input_output (line 2718) | async fn multicall_tx_input_output() -> Result<()> {
  function test_returned_method_descriptors_are_valid (line 2844) | async fn test_returned_method_descriptors_are_valid() -> Result<()> {

FILE: e2e/tests/debug_utils.rs
  function can_debug_single_call_tx (line 11) | async fn can_debug_single_call_tx() -> Result<()> {
  function can_debug_multi_call_tx (line 128) | async fn can_debug_multi_call_tx() -> Result<()> {
  function can_debug_sway_script (line 330) | async fn can_debug_sway_script() -> Result<()> {
  function debugs_sway_script_with_no_configurables (line 384) | async fn debugs_sway_script_with_no_configurables() -> Result<()> {
  function generate_modern_sway_binary (line 412) | fn generate_modern_sway_binary(len: usize) -> Vec<u8> {
  function data_section_offset_not_set_if_out_of_bounds (line 426) | async fn data_section_offset_not_set_if_out_of_bounds() -> Result<()> {
  function can_detect_a_loader_script_w_data_section (line 440) | async fn can_detect_a_loader_script_w_data_section() -> Result<()> {
  function can_detect_a_loader_script_wo_data_section (line 496) | async fn can_detect_a_loader_script_wo_data_section() -> Result<()> {

FILE: e2e/tests/from_token.rs
  function create_struct_from_decoded_tokens (line 4) | async fn create_struct_from_decoded_tokens() -> Result<()> {
  function create_nested_struct_from_decoded_tokens (line 21) | async fn create_nested_struct_from_decoded_tokens() -> Result<()> {

FILE: e2e/tests/imports.rs
  function provides_output_type (line 4) | fn provides_output_type() {

FILE: e2e/tests/logs.rs
  function parse_logged_variables (line 10) | async fn parse_logged_variables() -> Result<()> {
  function parse_logs_values (line 49) | async fn parse_logs_values() -> Result<()> {
  function parse_logs_custom_types (line 84) | async fn parse_logs_custom_types() -> Result<()> {
  function parse_logs_generic_types (line 125) | async fn parse_logs_generic_types() -> Result<()> {
  function decode_logs (line 178) | async fn decode_logs() -> Result<()> {
  function decode_logs_with_no_logs (line 233) | async fn decode_logs_with_no_logs() -> Result<()> {
  function multi_call_log_single_contract (line 261) | async fn multi_call_log_single_contract() -> Result<()> {
  function multi_call_log_multiple_contracts (line 310) | async fn multi_call_log_multiple_contracts() -> Result<()> {
  function multi_call_contract_with_contract_logs (line 363) | async fn multi_call_contract_with_contract_logs() -> Result<()> {
  function assert_revert_containing_msg (line 425) | fn assert_revert_containing_msg(msg: &str, error: Error) {
  function revert_logs (line 437) | async fn revert_logs() -> Result<()> {
  function multi_call_revert_logs_single_contract (line 511) | async fn multi_call_revert_logs_single_contract() -> Result<()> {
  function multi_call_revert_logs_multi_contract (line 579) | async fn multi_call_revert_logs_multi_contract() -> Result<()> {
  function script_decode_logs (line 655) | async fn script_decode_logs() -> Result<()> {
  function contract_with_contract_logs (line 722) | async fn contract_with_contract_logs() -> Result<()> {
  function script_logs_with_contract_logs (line 768) | async fn script_logs_with_contract_logs() -> Result<()> {
  function script_decode_logs_with_type (line 846) | async fn script_decode_logs_with_type() -> Result<()> {
  function script_require_log (line 923) | async fn script_require_log() -> Result<()> {
  function contract_require_from_contract (line 1000) | async fn contract_require_from_contract() -> Result<()> {
  function multi_call_contract_require_from_contract (line 1041) | async fn multi_call_contract_require_from_contract() -> Result<()> {
  function script_require_from_contract (line 1100) | async fn script_require_from_contract() -> Result<()> {
  function loader_script_require_from_loader_contract (line 1139) | async fn loader_script_require_from_loader_contract() -> Result<()> {
  function assert_assert_eq_containing_msg (line 1183) | fn assert_assert_eq_containing_msg<T: std::fmt::Debug>(left: T, right: T...
  function assert_assert_ne_containing_msg (line 1190) | fn assert_assert_ne_containing_msg<T: std::fmt::Debug>(left: T, right: T...
  function contract_asserts_log (line 1198) | async fn contract_asserts_log() -> Result<()> {
  function script_asserts_log (line 1354) | async fn script_asserts_log() -> Result<()> {
  function contract_token_ops_error_messages (line 1512) | async fn contract_token_ops_error_messages() -> Result<()> {
  function log_results (line 1553) | async fn log_results() -> Result<()> {
  function can_configure_decoder_for_contract_log_decoding (line 1592) | async fn can_configure_decoder_for_contract_log_decoding() -> Result<()> {
  function can_configure_decoder_for_script_log_decoding (line 1689) | async fn can_configure_decoder_for_script_log_decoding() -> Result<()> {
  function contract_heap_log (line 1743) | async fn contract_heap_log() -> Result<()> {
  function script_heap_log (line 1800) | async fn script_heap_log() -> Result<()> {
  function contract_panic (line 1851) | async fn contract_panic() -> Result<()> {
  function contract_with_contract_panic (line 1910) | async fn contract_with_contract_panic() -> Result<()> {
  function script_panic (line 1980) | async fn script_panic() -> Result<()> {
  function script_with_contract_panic (line 2035) | async fn script_with_contract_panic() -> Result<()> {

FILE: e2e/tests/predicates.rs
  function assert_address_balance (line 15) | async fn assert_address_balance(
  function get_test_coins_and_messages (line 28) | fn get_test_coins_and_messages(
  function get_test_message_w_data (line 52) | fn get_test_message_w_data(address: Address, amount: u64, nonce: u64) ->...
  function setup_predicate_test (line 64) | async fn setup_predicate_test(
  function transfer_coins_and_messages_to_predicate (line 117) | async fn transfer_coins_and_messages_to_predicate() -> Result<()> {
  function spend_predicate_coins_messages_basic (line 152) | async fn spend_predicate_coins_messages_basic() -> Result<()> {
  function pay_with_predicate (line 207) | async fn pay_with_predicate() -> Result<()> {
  function pay_with_predicate_vector_data (line 269) | async fn pay_with_predicate_vector_data() -> Result<()> {
  function predicate_contract_transfer (line 330) | async fn predicate_contract_transfer() -> Result<()> {
  function predicate_transfer_to_base_layer (line 385) | async fn predicate_transfer_to_base_layer() -> Result<()> {
  function predicate_transfer_with_signed_resources (line 436) | async fn predicate_transfer_with_signed_resources() -> Result<()> {
  function contract_tx_and_call_params_with_predicate (line 512) | async fn contract_tx_and_call_params_with_predicate() -> Result<()> {
  function diff_asset_predicate_payment (line 592) | async fn diff_asset_predicate_payment() -> Result<()> {
  function predicate_default_configurables (line 646) | async fn predicate_default_configurables() -> Result<()> {
  function predicate_configurables (line 706) | async fn predicate_configurables() -> Result<()> {
  function predicate_adjust_fee_persists_message_w_data (line 774) | async fn predicate_adjust_fee_persists_message_w_data() -> Result<()> {
  function predicate_transfer_non_base_asset (line 814) | async fn predicate_transfer_non_base_asset() -> Result<()> {
  function predicate_can_access_manually_added_witnesses (line 877) | async fn predicate_can_access_manually_added_witnesses() -> Result<()> {
  function tx_id_not_changed_after_adding_witnesses (line 944) | async fn tx_id_not_changed_after_adding_witnesses() -> Result<()> {
  function predicate_encoder_config_is_applied (line 1000) | async fn predicate_encoder_config_is_applied() -> Result<()> {
  function predicate_transfers_non_base_asset (line 1030) | async fn predicate_transfers_non_base_asset() -> Result<()> {
  function predicate_with_invalid_data_fails (line 1070) | async fn predicate_with_invalid_data_fails() -> Result<()> {
  function predicate_blobs (line 1110) | async fn predicate_blobs() -> Result<()> {
  function predicate_configurables_in_blobs (line 1177) | async fn predicate_configurables_in_blobs() -> Result<()> {
  function predicate_transfer_respects_maturity_and_expiration (line 1250) | async fn predicate_transfer_respects_maturity_and_expiration() -> Result...
  function transfer_to_predicate (line 1325) | async fn transfer_to_predicate(
  function predicate_tx_input_output (line 1339) | async fn predicate_tx_input_output() -> Result<()> {

FILE: e2e/tests/providers.rs
  function test_provider_launch_and_connect (line 25) | async fn test_provider_launch_and_connect() -> Result<()> {
  function test_network_error (line 71) | async fn test_network_error() -> Result<()> {
  function test_input_message (line 100) | async fn test_input_message() -> Result<()> {
  function test_input_message_pays_fee (line 157) | async fn test_input_message_pays_fee() -> Result<()> {
  function can_increase_block_height (line 207) | async fn can_increase_block_height() -> Result<()> {
  function can_set_custom_block_time (line 227) | async fn can_set_custom_block_time() -> Result<()> {
  function can_retrieve_latest_block_time (line 273) | async fn can_retrieve_latest_block_time() -> Result<()> {
  function contract_deployment_respects_maturity_and_expiration (line 289) | async fn contract_deployment_respects_maturity_and_expiration() -> Resul...
  function test_gas_forwarded_defaults_to_tx_limit (line 342) | async fn test_gas_forwarded_defaults_to_tx_limit() -> Result<()> {
  function test_amount_and_asset_forwarding (line 382) | async fn test_amount_and_asset_forwarding() -> Result<()> {
  function test_gas_errors (line 484) | async fn test_gas_errors() -> Result<()> {
  function test_call_param_gas_errors (line 549) | async fn test_call_param_gas_errors() -> Result<()> {
  function test_get_gas_used (line 591) | async fn test_get_gas_used() -> Result<()> {
  function test_parse_block_time (line 620) | async fn test_parse_block_time() -> Result<()> {
  function test_get_spendable_with_exclusion (line 651) | async fn test_get_spendable_with_exclusion() -> Result<()> {
  function given_a_message (line 712) | fn given_a_message(address: Address, message_amount: u64) -> Message {
  function convert_to_datetime (line 722) | fn convert_to_datetime(timestamp: u64) -> DateTime<Utc> {
  function test_sway_timestamp (line 731) | async fn test_sway_timestamp() -> Result<()> {
  function create_transfer (line 789) | async fn create_transfer(wallet: &Wallet, amount: u64, to: Address) -> R...
  function transactions_with_the_same_utxo (line 806) | async fn transactions_with_the_same_utxo() -> Result<()> {
  function coin_caching (line 835) | async fn coin_caching() -> Result<()> {
  function create_revert_tx (line 878) | async fn create_revert_tx(wallet: &Wallet) -> Result<ScriptTransaction> {
  function test_cache_invalidation_on_await (line 898) | async fn test_cache_invalidation_on_await() -> Result<()> {
  function can_fetch_mint_transactions (line 938) | async fn can_fetch_mint_transactions() -> Result<()> {
  function test_build_with_provider (line 978) | async fn test_build_with_provider() -> Result<()> {
  function send_transaction_and_await_status (line 1011) | async fn send_transaction_and_await_status() -> Result<()> {
  function send_transaction_and_subscribe_status (line 1048) | async fn send_transaction_and_subscribe_status() -> Result<()> {
  function can_produce_blocks_with_trig_never (line 1099) | async fn can_produce_blocks_with_trig_never() -> Result<()> {
  function can_upload_executor_and_trigger_upgrade (line 1136) | async fn can_upload_executor_and_trigger_upgrade() -> Result<()> {
  function tx_respects_policies (line 1185) | async fn tx_respects_policies() -> Result<()> {
  function can_setup_static_gas_price (line 1252) | async fn can_setup_static_gas_price() -> Result<()> {
  function tx_with_witness_data (line 1269) | async fn tx_with_witness_data() -> Result<()> {
  function contract_call_with_impersonation (line 1347) | async fn contract_call_with_impersonation() -> Result<()> {
  function is_account_query_test (line 1389) | async fn is_account_query_test() -> Result<()> {
  function script_tx_get_owner_returns_owner_when_policy_set_multiple_inputs (line 1457) | async fn script_tx_get_owner_returns_owner_when_policy_set_multiple_inpu...
  function script_tx_get_owner_panics_when_policy_unset_multiple_inputs (line 1534) | async fn script_tx_get_owner_panics_when_policy_unset_multiple_inputs() ...
  function script_tx_get_owner_returns_owner_when_policy_unset_all_inputs_same_owner (line 1595) | async fn script_tx_get_owner_returns_owner_when_policy_unset_all_inputs_...

FILE: e2e/tests/scripts.rs
  function main_function_arguments (line 19) | async fn main_function_arguments() -> Result<()> {
  function script_call_has_same_estimated_and_used_gas (line 45) | async fn script_call_has_same_estimated_and_used_gas() -> Result<()> {
  function test_basic_script_with_tx_policies (line 78) | async fn test_basic_script_with_tx_policies() -> Result<()> {
  function test_output_variable_estimation (line 111) | async fn test_output_variable_estimation() -> Result<()> {
  function test_script_struct (line 149) | async fn test_script_struct() -> Result<()> {
  function test_script_enum (line 174) | async fn test_script_enum() -> Result<()> {
  function test_script_array (line 196) | async fn test_script_array() -> Result<()> {
  function can_configure_decoder_on_script_call (line 218) | async fn can_configure_decoder_on_script_call() -> Result<()> {
  function test_script_submit_and_response (line 266) | async fn test_script_submit_and_response() -> Result<()> {
  function test_script_transaction_builder (line 296) | async fn test_script_transaction_builder() -> Result<()> {
  function script_encoder_config_is_applied (line 336) | async fn script_encoder_config_is_applied() {
  function simulations_can_be_made_without_coins (line 383) | async fn simulations_can_be_made_without_coins() -> Result<()> {
  function can_be_run_in_blobs_builder (line 413) | async fn can_be_run_in_blobs_builder() -> Result<()> {
  function can_be_run_in_blobs_high_level (line 461) | async fn can_be_run_in_blobs_high_level() -> Result<()> {
  function high_level_blob_upload_sets_max_fee_tolerance (line 492) | async fn high_level_blob_upload_sets_max_fee_tolerance() -> Result<()> {
  function no_data_section_blob_run (line 558) | async fn no_data_section_blob_run() -> Result<()> {
  function loader_script_calling_loader_proxy (line 578) | async fn loader_script_calling_loader_proxy() -> Result<()> {
  function loader_can_be_presented_as_a_normal_script_with_shifted_configurables (line 632) | async fn loader_can_be_presented_as_a_normal_script_with_shifted_configu...
  function script_call_respects_maturity_and_expiration (line 691) | async fn script_call_respects_maturity_and_expiration() -> Result<()> {
  function script_tx_input_output (line 738) | async fn script_tx_input_output() -> Result<()> {

FILE: e2e/tests/storage.rs
  function test_storage_initialization (line 8) | async fn test_storage_initialization() -> Result<()> {
  function test_init_storage_automatically (line 44) | async fn test_init_storage_automatically() -> Result<()> {
  function storage_load_error_messages (line 90) | async fn storage_load_error_messages() {

FILE: e2e/tests/types_contracts.rs
  function test_methods_typeless_argument (line 9) | async fn test_methods_typeless_argument() -> Result<()> {
  function call_with_empty_return (line 36) | async fn call_with_empty_return() -> Result<()> {
  function call_with_structs (line 56) | async fn call_with_structs() -> Result<()> {
  function abigen_different_structs_same_arg_name (line 100) | async fn abigen_different_structs_same_arg_name() -> Result<()> {
  function nested_structs (line 130) | async fn nested_structs() -> Result<()> {
  function calls_with_empty_struct (line 191) | async fn calls_with_empty_struct() -> Result<()> {
  function can_use_try_into_to_construct_struct_from_bytes (line 225) | async fn can_use_try_into_to_construct_struct_from_bytes() -> Result<()> {
  function test_tuples (line 255) | async fn test_tuples() -> Result<()> {
  function test_evm_address (line 330) | async fn test_evm_address() -> Result<()> {
  function test_array (line 398) | async fn test_array() -> Result<()> {
  function test_arrays_with_custom_types (line 426) | async fn test_arrays_with_custom_types() -> Result<()> {
  function str_in_array (line 469) | async fn str_in_array() -> Result<()> {
  function test_enum_inside_struct (line 510) | async fn test_enum_inside_struct() -> Result<()> {
  function native_types_support (line 553) | async fn native_types_support() -> Result<()> {
  function enum_coding_w_variable_width_variants (line 592) | async fn enum_coding_w_variable_width_variants() -> Result<()> {
  function enum_coding_w_unit_enums (line 634) | async fn enum_coding_w_unit_enums() -> Result<()> {
  function enum_as_input (line 674) | async fn enum_as_input() -> Result<()> {
  function can_use_try_into_to_construct_enum_from_bytes (line 726) | async fn can_use_try_into_to_construct_enum_from_bytes() -> Result<()> {
  function type_inside_enum (line 751) | async fn type_inside_enum() -> Result<()> {
  function test_rust_option_can_be_decoded (line 816) | async fn test_rust_option_can_be_decoded() -> Result<()> {
  function test_rust_option_can_be_encoded (line 869) | async fn test_rust_option_can_be_encoded() -> Result<()> {
  function test_rust_result_can_be_decoded (line 924) | async fn test_rust_result_can_be_decoded() -> Result<()> {
  function test_rust_result_can_be_encoded (line 977) | async fn test_rust_result_can_be_encoded() -> Result<()> {
  function test_identity_can_be_decoded (line 1013) | async fn test_identity_can_be_decoded() -> Result<()> {
  function test_identity_can_be_encoded (line 1059) | async fn test_identity_can_be_encoded() -> Result<()> {
  function test_identity_with_two_contracts (line 1108) | async fn test_identity_with_two_contracts() -> Result<()> {
  function generics_test (line 1155) | async fn generics_test() -> Result<()> {
  function contract_vectors (line 1313) | async fn contract_vectors() -> Result<()> {
  function test_b256 (line 1401) | async fn test_b256() -> Result<()> {
  function test_b512 (line 1440) | async fn test_b512() -> Result<()> {
  function u128_from (line 1480) | fn u128_from(parts: (u64, u64)) -> u128 {
  function test_u128 (line 1489) | async fn test_u128() -> Result<()> {
  function u256_from (line 1528) | fn u256_from(parts: (u64, u64, u64, u64)) -> U256 {
  function test_u256 (line 1542) | async fn test_u256() -> Result<()> {
  function test_base_type_in_vec_output (line 1580) | async fn test_base_type_in_vec_output() -> Result<()> {
  function test_composite_types_in_vec_output (line 1620) | async fn test_composite_types_in_vec_output() -> Result<()> {
  function test_bytes_output (line 1690) | async fn test_bytes_output() -> Result<()> {
  function test_bytes_as_input (line 1714) | async fn test_bytes_as_input() -> Result<()> {
  function contract_raw_slice (line 1751) | async fn contract_raw_slice() -> Result<()> {
  function contract_string_slice (line 1797) | async fn contract_string_slice() -> Result<()> {
  function contract_std_lib_string (line 1824) | async fn contract_std_lib_string() -> Result<()> {
  function test_heap_type_in_enums (line 1863) | async fn test_heap_type_in_enums() -> Result<()> {
  function nested_heap_types (line 1976) | async fn nested_heap_types() -> Result<()> {

FILE: e2e/tests/types_predicates.rs
  function assert_predicate_spendable (line 9) | async fn assert_predicate_spendable(data: Vec<u8>, project_path: impl As...
  function project_binary (line 54) | fn project_binary(project_root: impl AsRef<Path>) -> String {
  function assert_address_balance (line 69) | async fn assert_address_balance(
  function get_test_coins_and_messages (line 82) | fn get_test_coins_and_messages(
  function setup_predicate_test (line 99) | async fn setup_predicate_test(
  function spend_predicate_coins_messages_single_u64 (line 139) | async fn spend_predicate_coins_messages_single_u64() -> Result<()> {
  function spend_predicate_coins_messages_address (line 153) | async fn spend_predicate_coins_messages_address() -> Result<()> {
  function spend_predicate_coins_messages_enums (line 170) | async fn spend_predicate_coins_messages_enums() -> Result<()> {
  function spend_predicate_coins_messages_structs (line 185) | async fn spend_predicate_coins_messages_structs() -> Result<()> {
  function spend_predicate_coins_messages_tuple (line 205) | async fn spend_predicate_coins_messages_tuple() -> Result<()> {
  function spend_predicate_coins_messages_vector (line 220) | async fn spend_predicate_coins_messages_vector() -> Result<()> {
  function spend_predicate_coins_messages_vectors (line 234) | async fn spend_predicate_coins_messages_vectors() -> Result<()> {
  function spend_predicate_coins_messages_generics (line 282) | async fn spend_predicate_coins_messages_generics() -> Result<()> {
  function spend_predicate_coins_messages_bytes_hash (line 300) | async fn spend_predicate_coins_messages_bytes_hash() -> Result<()> {
  function spend_predicate_coins_messages_bytes (line 322) | async fn spend_predicate_coins_messages_bytes() -> Result<()> {
  function spend_predicate_coins_messages_raw_slice (line 342) | async fn spend_predicate_coins_messages_raw_slice() -> Result<()> {
  function u128_from (line 361) | fn u128_from(parts: (u64, u64)) -> u128 {
  function predicate_handles_u128 (line 370) | async fn predicate_handles_u128() -> Result<()> {
  function predicate_handles_b256 (line 383) | async fn predicate_handles_b256() -> Result<()> {
  function u256_from (line 395) | fn u256_from(parts: (u64, u64, u64, u64)) -> U256 {
  function predicate_handles_u256 (line 409) | async fn predicate_handles_u256() -> Result<()> {
  function predicate_handles_std_string (line 422) | async fn predicate_handles_std_string() -> Result<()> {
  function predicate_string_slice (line 435) | async fn predicate_string_slice() -> Result<()> {

FILE: e2e/tests/types_scripts.rs
  function script_b256 (line 7) | async fn script_b256() -> Result<()> {
  function main_function_generic_arguments (line 30) | async fn main_function_generic_arguments() -> Result<()> {
  function main_function_option_result (line 72) | async fn main_function_option_result() -> Result<()> {
  function main_function_tuple_types (line 106) | async fn main_function_tuple_types() -> Result<()> {
  function main_function_vector_arguments (line 151) | async fn main_function_vector_arguments() -> Result<()> {
  function script_raw_slice (line 210) | async fn script_raw_slice() -> Result<()> {
  function main_function_bytes_arguments (line 237) | async fn main_function_bytes_arguments() -> Result<()> {
  function u128_from (line 262) | fn u128_from(parts: (u64, u64)) -> u128 {
  function script_handles_u128 (line 271) | async fn script_handles_u128() -> Result<()> {
  function u256_from (line 294) | fn u256_from(parts: (u64, u64, u64, u64)) -> U256 {
  function script_handles_u256 (line 308) | async fn script_handles_u256() -> Result<()> {
  function script_std_string (line 332) | async fn script_std_string() -> Result<()> {
  function script_string_slice (line 358) | async fn script_string_slice() -> Result<()> {
  function nested_heap_types (line 382) | async fn nested_heap_types() -> Result<()> {

FILE: e2e/tests/wallets.rs
  function assert_address_balance (line 8) | async fn assert_address_balance(
  function test_wallet_balance_api_multi_asset (line 22) | async fn test_wallet_balance_api_multi_asset() -> Result<()> {
  function test_wallet_balance_api_single_asset (line 54) | async fn test_wallet_balance_api_single_asset() -> Result<()> {
  function base_asset_wallet_config (line 85) | fn base_asset_wallet_config(num_wallets: u64) -> WalletsConfig {
  function adjust_fee_empty_transaction (line 95) | async fn adjust_fee_empty_transaction() -> Result<()> {
  function adjust_for_fee_with_message_data_input (line 123) | async fn adjust_for_fee_with_message_data_input() -> Result<()> {
  function adjust_fee_resources_to_transfer_with_base_asset (line 192) | async fn adjust_fee_resources_to_transfer_with_base_asset() -> Result<()> {
  function test_transfer (line 224) | async fn test_transfer() -> Result<()> {
  function send_transfer_transactions (line 260) | async fn send_transfer_transactions() -> Result<()> {
  function transfer_coins_with_change (line 322) | async fn transfer_coins_with_change() -> Result<()> {
  function test_wallet_get_coins (line 357) | async fn test_wallet_get_coins() -> Result<()> {
  function setup_transfer_test (line 378) | async fn setup_transfer_test(amount: u64) -> Result<(Wallet, Wallet)> {
  function transfer_more_than_owned (line 392) | async fn transfer_more_than_owned() -> Result<()> {
  function transfer_coins_of_non_base_asset (line 415) | async fn transfer_coins_of_non_base_asset() -> Result<()> {
  function test_transfer_with_multiple_signatures (line 454) | async fn test_transfer_with_multiple_signatures() -> Result<()> {
  function wallet_transfer_respects_maturity_and_expiration (line 506) | async fn wallet_transfer_respects_maturity_and_expiration() -> Result<()> {

FILE: examples/codec/src/lib.rs
  function encoding_a_type (line 9) | fn encoding_a_type() -> Result<()> {
  function encoding_via_macro (line 28) | fn encoding_via_macro() -> Result<()> {
  function decoding_example (line 43) | fn decoding_example() -> Result<()> {
  function decoding_example_try_into (line 70) | fn decoding_example_try_into() -> Result<()> {
  function configuring_the_decoder (line 88) | fn configuring_the_decoder() -> Result<()> {
  function configuring_the_encoder (line 103) | fn configuring_the_encoder() -> Result<()> {

FILE: examples/contracts/src/lib.rs
  function instantiate_client (line 20) | async fn instantiate_client() -> Result<()> {
  function deploy_contract (line 40) | async fn deploy_contract() -> Result<()> {
  function setup_program_test_example (line 64) | async fn setup_program_test_example() -> Result<()> {
  function contract_call_cost_estimation (line 94) | async fn contract_call_cost_estimation() -> Result<()> {
  function deploy_with_parameters (line 134) | async fn deploy_with_parameters() -> std::result::Result<(), Box<dyn std...
  function deploy_with_multiple_wallets (line 231) | async fn deploy_with_multiple_wallets() -> Result<()> {
  function contract_tx_and_call_params (line 283) | async fn contract_tx_and_call_params() -> Result<()> {
  function token_ops_tests (line 354) | async fn token_ops_tests() -> Result<()> {
  function dependency_estimation (line 448) | async fn dependency_estimation() -> Result<()> {
  function get_contract_outputs (line 520) | async fn get_contract_outputs() -> Result<()> {
  function call_params_gas (line 543) | async fn call_params_gas() -> Result<()> {
  function multi_call_example (line 581) | async fn multi_call_example() -> Result<()> {
  function multi_call_cost_estimation (line 641) | async fn multi_call_cost_estimation() -> Result<()> {
  function connect_wallet (line 687) | async fn connect_wallet() -> Result<()> {
  function custom_assets_example (line 724) | async fn custom_assets_example() -> Result<()> {
  function low_level_call_example (line 769) | async fn low_level_call_example() -> Result<()> {
  function configure_the_return_value_decoder (line 851) | async fn configure_the_return_value_decoder() -> Result<()> {
  function storage_slots_override (line 883) | async fn storage_slots_override() -> Result<()> {
  function contract_custom_call (line 912) | async fn contract_custom_call() -> Result<()> {
  function configure_encoder_config (line 957) | async fn configure_encoder_config() -> Result<()> {
  function contract_call_impersonation (line 989) | async fn contract_call_impersonation() -> Result<()> {
  function deploying_via_loader (line 1045) | async fn deploying_via_loader() -> Result<()> {
  function decoding_script_transactions (line 1206) | async fn decoding_script_transactions() -> Result<()> {

FILE: examples/cookbook/src/lib.rs
  function liquidity (line 25) | async fn liquidity() -> Result<()> {
  function custom_chain (line 104) | async fn custom_chain() -> Result<()> {
  function transfer_multiple (line 147) | async fn transfer_multiple() -> Result<()> {
  function create_or_use_rocksdb (line 217) | async fn create_or_use_rocksdb() -> Result<()> {
  function custom_transaction (line 235) | async fn custom_transaction() -> Result<()> {

FILE: examples/debugging/src/lib.rs
  function encode_fn_selector (line 13) | fn encode_fn_selector() {
  function decoded_debug_matches_rust_debug (line 32) | fn decoded_debug_matches_rust_debug() -> Result<()> {

FILE: examples/macros/src/lib.rs
  function example_of_abigen_usage (line 8) | fn example_of_abigen_usage() {
  function macro_deriving (line 32) | fn macro_deriving() {
  function macro_deriving_extra (line 51) | fn macro_deriving_extra() {

FILE: examples/predicates/src/lib.rs
  function predicate_example (line 12) | async fn predicate_example() -> Result<()> {
  function predicate_data_example (line 123) | async fn predicate_data_example() -> Result<()> {

FILE: examples/providers/src/lib.rs
  function connect_to_fuel_node (line 9) | async fn connect_to_fuel_node() -> Result<()> {
  function query_the_blockchain (line 40) | async fn query_the_blockchain() -> Result<()> {

FILE: examples/rust_bindings/src/lib.rs
  function transform_json_to_bindings (line 7) | async fn transform_json_to_bindings() -> Result<()> {

FILE: examples/rust_bindings/src/rust_bindings_formatted.rs
  type MyContract (line 4) | pub struct MyContract<A: ::fuels::accounts::Account> {
  function new (line 11) | pub fn new(contract_id: ::fuels::types::ContractId, account: A) -> Self {
  function contract_id (line 23) | pub fn contract_id(&self) -> &::fuels::types::ContractId {
  function account (line 26) | pub fn account(&self) -> A {
  function with_account (line 29) | pub fn with_account<U: ::fuels::accounts::Account>(self, account: U) -> ...
  function with_encoder_config (line 37) | pub fn with_encoder_config(
  function get_balances (line 44) | pub async fn get_balances(
  function methods (line 54) | pub fn methods(&self) -> MyContractMethods<A> {
  type MyContractMethods (line 63) | pub struct MyContractMethods<A: ::fuels::accounts::Account> {
  function increment_counter (line 72) | pub fn increment_counter(
  function initialize_counter (line 90) | pub fn initialize_counter(
  function id (line 110) | fn id(&self) -> ::fuels::types::ContractId {
  function log_decoder (line 113) | fn log_decoder(&self) -> ::fuels::core::codec::LogDecoder {
  type MyContractConfigurables (line 118) | pub struct MyContractConfigurables {
    method new (line 123) | pub fn new(encoder_config: ::fuels::core::codec::EncoderConfig) -> Self {
  function from (line 131) | fn from(config: MyContractConfigurables) -> Self {

FILE: examples/types/src/lib.rs
  function bytes32 (line 9) | async fn bytes32() -> Result<()> {
  function address (line 52) | async fn address() -> Result<()> {
  function asset_id (line 100) | async fn asset_id() -> Result<()> {
  function contract_id (line 131) | async fn contract_id() -> Result<()> {
  function type_conversion (line 171) | async fn type_conversion() -> Result<()> {
  function unused_generics (line 198) | async fn unused_generics() -> Result<()> {

FILE: examples/wallets/src/lib.rs
  function create_random_wallet (line 14) | async fn create_random_wallet() -> Result<()> {
  function create_wallet_from_secret_key (line 29) | async fn create_wallet_from_secret_key() -> std::result::Result<(), Box<...
  function create_wallet_from_mnemonic (line 51) | async fn create_wallet_from_mnemonic() -> Result<()> {
  function create_and_store_mnemonic_key (line 80) | async fn create_and_store_mnemonic_key() -> Result<()> {
  function wallet_transfer (line 104) | async fn wallet_transfer() -> Result<()> {
  function wallet_contract_transfer (line 141) | async fn wallet_contract_transfer() -> Result<()> {
  function setup_multiple_wallets (line 205) | async fn setup_multiple_wallets() -> Result<()> {
  function setup_wallet_multiple_assets (line 231) | async fn setup_wallet_multiple_assets() -> Result<()> {
  function setup_wallet_custom_assets (line 255) | async fn setup_wallet_custom_assets() -> std::result::Result<(), Box<dyn...
  function get_balances (line 306) | async fn get_balances() -> Result<()> {
  function wallet_transfer_to_base_layer (line 337) | async fn wallet_transfer_to_base_layer() -> Result<()> {

FILE: packages/fuels-accounts/src/account.rs
  type WithdrawToBaseResponse (line 30) | pub struct WithdrawToBaseResponse {
  type ViewOnlyAccount (line 37) | pub trait ViewOnlyAccount: Send + Sync {
    method address (line 38) | fn address(&self) -> Address;
    method try_provider (line 40) | fn try_provider(&self) -> Result<&Provider>;
    method get_transactions (line 42) | async fn get_transactions(
    method get_coins (line 53) | async fn get_coins(&self, asset_id: AssetId) -> Result<Vec<Coin>> {
    method get_asset_balance (line 63) | async fn get_asset_balance(&self, asset_id: &AssetId) -> Result<u128> {
    method get_messages (line 70) | async fn get_messages(&self) -> Result<Vec<Message>> {
    method get_balances (line 77) | async fn get_balances(&self) -> Result<HashMap<String, u128>> {
    method get_spendable_resources (line 84) | async fn get_spendable_resources(
    method get_asset_outputs_for_amount (line 105) | fn get_asset_outputs_for_amount(
    method get_asset_inputs_for_amount (line 121) | async fn get_asset_inputs_for_amount(
    method adjust_for_fee (line 132) | async fn adjust_for_fee<Tb: TransactionBuilder + Sync>(
  type Account (line 166) | pub trait Account: ViewOnlyAccount {
    method add_witnesses (line 168) | fn add_witnesses<Tb: TransactionBuilder>(&self, _tb: &mut Tb) -> Resul...
    method transfer (line 175) | async fn transfer(
    method force_transfer_to_contract (line 224) | async fn force_transfer_to_contract(
    method withdraw_to_base_layer (line 291) | async fn withdraw_to_base_layer(
  type MockDryRunner (line 349) | struct MockDryRunner {
  method dry_run (line 355) | async fn dry_run(&self, _: FuelTransaction) -> Result<DryRun> {
  method consensus_parameters (line 363) | async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
  method estimate_gas_price (line 367) | async fn estimate_gas_price(&self, _block_header: u32) -> Result<u64> {
  method estimate_predicates (line 371) | async fn estimate_predicates(
  function sign_tx_and_verify (line 381) | async fn sign_tx_and_verify() -> std::result::Result<(), Box<dyn std::er...

FILE: packages/fuels-accounts/src/accounts_utils.rs
  function extract_message_nonce (line 16) | pub fn extract_message_nonce(receipts: &[Receipt]) -> Option<Nonce> {
  function calculate_missing_base_amount (line 20) | pub async fn calculate_missing_base_amount(
  function available_base_assets_and_amount (line 42) | pub fn available_base_assets_and_amount(
  function split_into_utxo_ids_and_nonces (line 77) | pub fn split_into_utxo_ids_and_nonces(
  function is_consuming_utxos (line 92) | fn is_consuming_utxos(tb: &impl TransactionBuilder) -> bool {
  function add_base_change_if_needed (line 98) | pub fn add_base_change_if_needed(
  function try_provider_error (line 114) | pub(crate) fn try_provider_error() -> Error {

FILE: packages/fuels-accounts/src/coin_cache.rs
  type CoinCacheKey (line 10) | type CoinCacheKey = (Address, AssetId);
  type CoinsCache (line 13) | pub(crate) struct CoinsCache {
    method new (line 25) | pub fn new(ttl: Duration) -> Self {
    method insert_multiple (line 32) | pub fn insert_multiple(
    method get_active (line 44) | pub fn get_active(&mut self, key: &CoinCacheKey) -> HashSet<CoinTypeId> {
    method remove_items (line 56) | pub fn remove_items(
    method remove (line 67) | fn remove(&mut self, key: &CoinCacheKey, id: CoinTypeId) {
    method remove_expired_entries (line 74) | fn remove_expired_entries(&mut self, key: &CoinCacheKey) {
  method default (line 19) | fn default() -> Self {
  type CoinCacheItem (line 82) | struct CoinCacheItem {
    method new (line 100) | pub fn new(id: CoinTypeId) -> Self {
    method is_valid (line 107) | pub fn is_valid(&self, ttl: Duration) -> bool {
  method eq (line 88) | fn eq(&self, other: &Self) -> bool {
  method hash (line 94) | fn hash<H: Hasher>(&self, state: &mut H) {
  function get_items (line 119) | fn get_items() -> (CoinTypeId, CoinTypeId) {
  function test_insert_and_get_active (line 127) | fn test_insert_and_get_active() {
  function test_insert_and_expire_items (line 144) | async fn test_insert_and_expire_items() {
  function test_get_active_no_items (line 169) | fn test_get_active_no_items() {
  function test_remove_items (line 179) | fn test_remove_items() {

FILE: packages/fuels-accounts/src/keystore.rs
  type KeySaved (line 9) | pub struct KeySaved {
    method key (line 16) | pub fn key(&self) -> &SecretKey {
    method uuid (line 20) | pub fn uuid(&self) -> &str {
  type Keystore (line 27) | pub struct Keystore {
    method new (line 33) | pub fn new<P: AsRef<Path>>(dir: P) -> Self {
    method load_key (line 40) | pub fn load_key<S>(&self, uuid: &str, password: S) -> Result<SecretKey>
    method save_key (line 54) | pub fn save_key<R, S>(&self, key: SecretKey, password: S, mut rng: R) ...
  function wallet_from_mnemonic_phrase (line 74) | async fn wallet_from_mnemonic_phrase() -> Result<()> {
  function encrypt_and_store_keys_from_mnemonic (line 99) | async fn encrypt_and_store_keys_from_mnemonic() -> Result<()> {

FILE: packages/fuels-accounts/src/lib.rs
  function sdl_is_the_same_as_from_fuel (line 23) | fn sdl_is_the_same_as_from_fuel() {

FILE: packages/fuels-accounts/src/predicate.rs
  type Predicate (line 16) | pub struct Predicate {
    method address (line 25) | pub fn address(&self) -> Address {
    method code (line 29) | pub fn code(&self) -> &[u8] {
    method data (line 33) | pub fn data(&self) -> &[u8] {
    method calculate_address (line 37) | pub fn calculate_address(code: &[u8]) -> Address {
    method load_from (line 41) | pub fn load_from(file_path: &str) -> Result<Self> {
    method from_code (line 51) | pub fn from_code(code: Vec<u8>) -> Self {
    method with_data (line 61) | pub fn with_data(mut self, data: Vec<u8>) -> Self {
    method with_code (line 66) | pub fn with_code(self, code: Vec<u8>) -> Self {
    method with_configurables (line 75) | pub fn with_configurables(mut self, configurables: impl Into<Configura...
    method provider (line 86) | pub fn provider(&self) -> Option<&Provider> {
    method set_provider (line 90) | pub fn set_provider(&mut self, provider: Provider) {
    method with_provider (line 94) | pub fn with_provider(self, provider: Provider) -> Self {
  method address (line 105) | fn address(&self) -> Address {
  method try_provider (line 109) | fn try_provider(&self) -> Result<&Provider> {
  method get_asset_inputs_for_amount (line 113) | async fn get_asset_inputs_for_amount(

FILE: packages/fuels-accounts/src/provider.rs
  constant NUM_RESULTS_PER_REQUEST (line 59) | const NUM_RESULTS_PER_REQUEST: i32 = 100;
  type TransactionCost (line 63) | pub struct TransactionCost {
  type ResourceQueries (line 72) | pub(crate) struct ResourceQueries {
    method exclusion_query (line 80) | pub fn exclusion_query(&self) -> Option<(Vec<UtxoId>, Vec<Nonce>)> {
    method spend_query (line 88) | pub fn spend_query(&self, base_asset_id: AssetId) -> Vec<(AssetId, u12...
  type ResourceFilter (line 95) | pub struct ResourceFilter {
    method owner (line 105) | pub fn owner(&self) -> Address {
    method resource_queries (line 109) | pub(crate) fn resource_queries(&self) -> ResourceQueries {
  type Provider (line 123) | pub struct Provider {
    method from (line 130) | pub async fn from(addr: impl Into<SocketAddr>) -> Result<Self> {
    method client (line 136) | pub fn client(&self) -> &FuelClient {
    method set_cache_ttl (line 140) | pub fn set_cache_ttl(&mut self, ttl: TtlConfig) {
    method clear_cache (line 144) | pub async fn clear_cache(&self) {
    method healthy (line 148) | pub async fn healthy(&self) -> Result<bool> {
    method connect (line 153) | pub async fn connect(url: impl AsRef<str>) -> Result<Provider> {
    method url (line 167) | pub fn url(&self) -> &str {
    method blob (line 171) | pub async fn blob(&self, blob_id: BlobId) -> Result<Option<Blob>> {
    method blob_exists (line 179) | pub async fn blob_exists(&self, blob_id: BlobId) -> Result<bool> {
    method send_transaction_and_await_commit (line 184) | pub async fn send_transaction_and_await_commit<T: Transaction>(
    method send_transaction_and_await_status (line 218) | pub async fn send_transaction_and_await_status<T: Transaction>(
    method prepare_transaction_for_sending (line 266) | async fn prepare_transaction_for_sending<T: Transaction>(&self, mut tx...
    method send_transaction (line 287) | pub async fn send_transaction<T: Transaction>(&self, tx: T) -> Result<...
    method await_transaction_commit (line 292) | pub async fn await_transaction_commit<T: Transaction>(&self, id: TxId)...
    method submit (line 301) | async fn submit<T: Transaction>(&self, tx: T) -> Result<TxId> {
    method find_in_cache (line 306) | async fn find_in_cache<'a>(
    method check_inputs_already_in_cache (line 330) | async fn check_inputs_already_in_cache<'a>(
    method submit (line 352) | async fn submit<T: Transaction>(&self, tx: T) -> Result<TxId> {
    method tx_status (line 365) | pub async fn tx_status(&self, tx_id: &TxId) -> Result<TxStatus> {
    method subscribe_transaction_status (line 373) | pub async fn subscribe_transaction_status<'a>(
    method chain_info (line 386) | pub async fn chain_info(&self) -> Result<ChainInfo> {
    method consensus_parameters (line 390) | pub async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
    method node_info (line 394) | pub async fn node_info(&self) -> Result<NodeInfo> {
    method latest_gas_price (line 398) | pub async fn latest_gas_price(&self) -> Result<LatestGasPrice> {
    method estimate_gas_price (line 402) | pub async fn estimate_gas_price(&self, block_horizon: u32) -> Result<E...
    method dry_run (line 409) | pub async fn dry_run(&self, tx: impl Transaction) -> Result<TxStatus> {
    method dry_run_multiple (line 423) | pub async fn dry_run_multiple(
    method dry_run_opt (line 436) | pub async fn dry_run_opt(
    method dry_run_opt_multiple (line 461) | pub async fn dry_run_opt_multiple(
    method get_coins (line 483) | pub async fn get_coins(&self, from: &Address, asset_id: AssetId) -> Re...
    method request_coins_to_spend (line 512) | async fn request_coins_to_spend(&self, filter: ResourceFilter) -> Resu...
    method get_spendable_resources (line 538) | pub async fn get_spendable_resources(&self, filter: ResourceFilter) ->...
    method get_spendable_resources (line 547) | pub async fn get_spendable_resources(
    method extend_filter_with_cached (line 557) | async fn extend_filter_with_cached(&self, filter: &mut ResourceFilter)...
    method get_asset_balance (line 594) | pub async fn get_asset_balance(&self, address: &Address, asset_id: &As...
    method get_contract_asset_balance (line 602) | pub async fn get_contract_asset_balance(
    method get_balances (line 616) | pub async fn get_balances(&self, address: &Address) -> Result<HashMap<...
    method get_contract_balances (line 663) | pub async fn get_contract_balances(
    method get_transaction_by_id (line 700) | pub async fn get_transaction_by_id(&self, tx_id: &TxId) -> Result<Opti...
    method get_transactions (line 708) | pub async fn get_transactions(
    method get_transactions_by_owner (line 723) | pub async fn get_transactions_by_owner(
    method latest_block_height (line 741) | pub async fn latest_block_height(&self) -> Result<u32> {
    method latest_block_time (line 745) | pub async fn latest_block_time(&self) -> Result<Option<DateTime<Utc>>> {
    method produce_blocks (line 749) | pub async fn produce_blocks(
    method block (line 763) | pub async fn block(&self, block_id: &Bytes32) -> Result<Option<Block>> {
    method block_by_height (line 771) | pub async fn block_by_height(&self, height: BlockHeight) -> Result<Opt...
    method get_blocks (line 780) | pub async fn get_blocks(
    method estimate_transaction_cost (line 794) | pub async fn estimate_transaction_cost<T: Transaction>(
    method apply_tolerance (line 820) | fn apply_tolerance(value: u64, tolerance: f64) -> u64 {
    method get_script_gas_used (line 824) | fn get_script_gas_used(receipts: &[Receipt]) -> u64 {
    method get_messages (line 836) | pub async fn get_messages(&self, from: &Address) -> Result<Vec<Message...
    method get_message_proof (line 864) | pub async fn get_message_proof(
    method is_user_account (line 883) | pub async fn is_user_account(&self, address: impl Into<Bytes32>) -> Re...
    method with_retry_config (line 889) | pub fn with_retry_config(mut self, retry_config: RetryConfig) -> Self {
    method contract_exists (line 895) | pub async fn contract_exists(&self, contract_id: &ContractId) -> Resul...
    method uncached_client (line 899) | fn uncached_client(&self) -> &RetryableClient {
    method uncached_client_mut (line 903) | fn uncached_client_mut(&mut self) -> &mut RetryableClient {
  method dry_run (line 910) | async fn dry_run(&self, tx: FuelTransaction) -> Result<DryRun> {
  method estimate_gas_price (line 942) | async fn estimate_gas_price(&self, block_horizon: u32) -> Result<u64> {
  method consensus_parameters (line 946) | async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
  method estimate_predicates (line 950) | async fn estimate_predicates(

FILE: packages/fuels-accounts/src/provider/cache.rs
  type CacheableRpcs (line 12) | pub trait CacheableRpcs {
    method consensus_parameters (line 13) | async fn consensus_parameters(&self) -> Result<ConsensusParameters>;
    method node_info (line 14) | async fn node_info(&self) -> Result<NodeInfo>;
    method consensus_parameters (line 102) | async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
    method node_info (line 130) | async fn node_info(&self) -> Result<NodeInfo> {
  type Clock (line 17) | trait Clock {
    method now (line 18) | fn now(&self) -> DateTime<Utc>;
    method now (line 49) | fn now(&self) -> DateTime<Utc> {
    method now (line 185) | fn now(&self) -> DateTime<Utc> {
  type TtlConfig (line 22) | pub struct TtlConfig {
  method default (line 27) | fn default() -> Self {
  type Dated (line 35) | struct Dated<T> {
  function is_stale (line 41) | fn is_stale(&self, now: DateTime<Utc>, ttl: Duration) -> bool {
  type SystemClock (line 47) | pub struct SystemClock;
  type CachedClient (line 55) | pub struct CachedClient<Client, Clock = SystemClock> {
  function new (line 64) | pub fn new(client: Client, ttl: TtlConfig, clock: Clock) -> Self {
  function set_ttl (line 74) | pub fn set_ttl(&mut self, ttl: TtlConfig) {
  function inner (line 78) | pub fn inner(&self) -> &Client {
  function inner_mut (line 82) | pub fn inner_mut(&mut self) -> &mut Client {
  function clear (line 91) | pub async fn clear(&self) {
  type TestClock (line 174) | struct TestClock {
    method update_time (line 179) | fn update_time(&self, time: DateTime<Utc>) {
  function initial_call_to_consensus_params_fwd_to_api (line 191) | async fn initial_call_to_consensus_params_fwd_to_api() {
  function new_call_to_consensus_params_cached (line 207) | async fn new_call_to_consensus_params_cached() {
  function if_ttl_expired_cache_is_updated (line 231) | async fn if_ttl_expired_cache_is_updated() {
  function clear_cache_clears_consensus_params_cache (line 278) | async fn clear_cache_clears_consensus_params_cache() {
  function dummy_node_info (line 316) | fn dummy_node_info() -> NodeInfo {
  function initial_call_to_node_info_fwd_to_api (line 339) | async fn initial_call_to_node_info_fwd_to_api() {
  function new_call_to_node_info_cached (line 355) | async fn new_call_to_node_info_cached() {
  function if_ttl_expired_node_info_cache_is_updated (line 378) | async fn if_ttl_expired_node_info_cache_is_updated() {

FILE: packages/fuels-accounts/src/provider/retry_util.rs
  type Backoff (line 29) | pub enum Backoff {
    method wait_duration (line 43) | pub fn wait_duration(&self, attempt: u32) -> Duration {
  method default (line 37) | fn default() -> Self {
  type RetryConfig (line 77) | pub struct RetryConfig {
    method new (line 84) | pub fn new(max_attempts: u32, interval: Backoff) -> Result<Self> {
  method default (line 96) | fn default() -> Self {
  function retry (line 125) | pub(crate) async fn retry<Fut, T, ShouldRetry>(
  function returns_last_received_response (line 162) | async fn returns_last_received_response() -> Result<()> {
  function stops_retrying_when_predicate_is_satisfied (line 189) | async fn stops_retrying_when_predicate_is_satisfied() -> Result<()> {
  function retry_respects_delay_between_attempts_fixed (line 210) | async fn retry_respects_delay_between_attempts_fixed() -> Result<()> {
  function retry_respects_delay_between_attempts_linear (line 251) | async fn retry_respects_delay_between_attempts_linear() -> Result<()> {
  function retry_respects_delay_between_attempts_exponential (line 293) | async fn retry_respects_delay_between_attempts_exponential() -> Result<(...

FILE: packages/fuels-accounts/src/provider/retryable_client.rs
  type RequestError (line 30) | pub(crate) enum RequestError {
  type RequestResult (line 35) | type RequestResult<T> = std::result::Result<T, RequestError>;
  method from (line 38) | fn from(e: RequestError) -> Self {
  type RetryableClient (line 44) | pub(crate) struct RetryableClient {
    method connect (line 63) | pub(crate) async fn connect(url: impl AsRef<str>, retry_config: RetryC...
    method version_compatibility_warning (line 78) | fn version_compatibility_warning(node_info: &NodeInfo) -> Result<Optio...
    method url (line 102) | pub(crate) fn url(&self) -> &str {
    method client (line 106) | pub fn client(&self) -> &FuelClient {
    method set_retry_config (line 110) | pub(crate) fn set_retry_config(&mut self, retry_config: RetryConfig) {
    method wrap (line 114) | async fn wrap<T, Fut>(&self, action: impl Fn() -> Fut) -> RequestResul...
    method health (line 131) | pub async fn health(&self) -> RequestResult<bool> {
    method transaction (line 135) | pub async fn transaction(&self, id: &TxId) -> RequestResult<Option<Tra...
    method chain_info (line 139) | pub(crate) async fn chain_info(&self) -> RequestResult<ChainInfo> {
    method await_transaction_commit (line 143) | pub async fn await_transaction_commit(&self, id: &TxId) -> RequestResu...
    method submit_and_await_commit (line 147) | pub async fn submit_and_await_commit(
    method submit_and_await_status (line 154) | pub async fn submit_and_await_status<'a>(
    method subscribe_transaction_status (line 166) | pub async fn subscribe_transaction_status<'a>(
    method submit (line 178) | pub async fn submit(&self, tx: &Transaction) -> RequestResult<Transact...
    method transaction_status (line 182) | pub async fn transaction_status(&self, id: &TxId) -> RequestResult<Tra...
    method node_info (line 186) | pub async fn node_info(&self) -> RequestResult<NodeInfo> {
    method blob (line 190) | pub async fn blob(&self, blob_id: BlobId) -> RequestResult<Option<Blob...
    method blob_exists (line 194) | pub async fn blob_exists(&self, blob_id: BlobId) -> RequestResult<bool> {
    method latest_gas_price (line 198) | pub async fn latest_gas_price(&self) -> RequestResult<LatestGasPrice> {
    method estimate_gas_price (line 202) | pub async fn estimate_gas_price(&self, block_horizon: u32) -> RequestR...
    method estimate_predicates (line 208) | pub async fn estimate_predicates(&self, tx: &Transaction) -> RequestRe...
    method dry_run (line 217) | pub async fn dry_run(
    method dry_run_opt (line 224) | pub async fn dry_run_opt(
    method coins (line 238) | pub async fn coins(
    method coins_to_spend (line 248) | pub async fn coins_to_spend(
    method balance (line 261) | pub async fn balance(
    method contract_balance (line 269) | pub async fn contract_balance(
    method contract_balances (line 277) | pub async fn contract_balances(
    method balances (line 286) | pub async fn balances(
    method transactions (line 295) | pub async fn transactions(
    method transactions_by_owner (line 303) | pub async fn transactions_by_owner(
    method produce_blocks (line 312) | pub async fn produce_blocks(
    method block (line 324) | pub async fn block(&self, id: &BlockId) -> RequestResult<Option<Block>> {
    method block_by_height (line 328) | pub async fn block_by_height(&self, height: BlockHeight) -> RequestRes...
    method blocks (line 332) | pub async fn blocks(
    method messages (line 339) | pub async fn messages(
    method message_proof (line 349) | pub async fn message_proof(
    method contract_exists (line 363) | pub async fn contract_exists(&self, contract_id: &ContractId) -> Reque...
    method is_user_account (line 380) | pub async fn is_user_account(&self, address: [u8; 32]) -> Result<bool> {
  method consensus_parameters (line 53) | async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
  method node_info (line 57) | async fn node_info(&self) -> Result<NodeInfo> {
  type IsUserAccountVariables (line 411) | pub struct IsUserAccountVariables {
  type IsUserAccountQuery (line 423) | pub struct IsUserAccountQuery {
  type ContractExistsQuery (line 438) | pub struct ContractExistsQuery {

FILE: packages/fuels-accounts/src/provider/supported_fuel_core_version.rs
  constant SUPPORTED_FUEL_CORE_VERSION (line 1) | pub const SUPPORTED_FUEL_CORE_VERSION: semver::Version = semver::Version...

FILE: packages/fuels-accounts/src/provider/supported_versions.rs
  type VersionCompatibility (line 6) | pub(crate) struct VersionCompatibility {
  function compare_node_compatibility (line 13) | pub(crate) fn compare_node_compatibility(network_version: Version) -> Ve...
  function check_version_compatibility (line 17) | fn check_version_compatibility(
  function should_validate_all_possible_version_mismatches (line 38) | fn should_validate_all_possible_version_mismatches() {

FILE: packages/fuels-accounts/src/signers.rs
  constant BIP44_PURPOSE (line 2) | pub const BIP44_PURPOSE: &str = "44'";
  constant COIN_TYPE (line 3) | pub const COIN_TYPE: &str = "1179993420'";
  constant DEFAULT_DERIVATION_PATH (line 4) | pub const DEFAULT_DERIVATION_PATH: &str = "m/44'/1179993420'/0'/0/0";

FILE: packages/fuels-accounts/src/signers/fake.rs
  type FakeSigner (line 11) | pub struct FakeSigner {
    method from (line 16) | fn from(signer: PrivateKeySigner) -> Self {
    method new (line 24) | pub fn new(address: Address) -> Self {
  method sign (line 32) | async fn sign(&self, _message: Message) -> Result<Signature> {
  method address (line 36) | fn address(&self) -> Address {

FILE: packages/fuels-accounts/src/signers/kms.rs
  function normalize_signature (line 14) | pub fn normalize_signature(
  function determine_recovery_id (line 31) | pub fn determine_recovery_id(
  function convert_to_fuel_signature (line 62) | pub fn convert_to_fuel_signature(

FILE: packages/fuels-accounts/src/signers/kms/aws.rs
  constant AWS_KMS_ERROR_PREFIX (line 21) | const AWS_KMS_ERROR_PREFIX: &str = "AWS KMS Error";
  constant EXPECTED_KEY_SPEC (line 23) | const EXPECTED_KEY_SPEC: KeySpec = KeySpec::EccSecgP256K1;
  type AwsKmsSigner (line 26) | pub struct AwsKmsSigner {
    method new (line 34) | pub async fn new(key_id: impl Into<String>, client: &Client) -> Result...
    method validate_key_spec (line 48) | async fn validate_key_spec(client: &Client, key_id: &str) -> Result<()> {
    method retrieve_public_key (line 66) | async fn retrieve_public_key(client: &Client, key_id: &str) -> Result<...
    method derive_fuel_address (line 82) | fn derive_fuel_address(public_key: &[u8]) -> Result<Address> {
    method request_kms_signature (line 91) | async fn request_kms_signature(&self, message: Message) -> Result<Vec<...
    method key_id (line 113) | pub fn key_id(&self) -> &String {
    method public_key (line 117) | pub fn public_key(&self) -> &Vec<u8> {
  method sign (line 124) | async fn sign(&self, message: Message) -> Result<Signature> {
  method address (line 144) | fn address(&self) -> Address {
  function format_aws_error (line 149) | fn format_aws_error(err: impl std::fmt::Display) -> Error {

FILE: packages/fuels-accounts/src/signers/kms/google.rs
  constant GOOGLE_KMS_ERROR_PREFIX (line 23) | const GOOGLE_KMS_ERROR_PREFIX: &str = "Google KMS Error";
  type GoogleKmsSigner (line 26) | pub struct GoogleKmsSigner {
    method new (line 71) | pub async fn new(key_path: impl Into<String>, client: &Client) -> Resu...
    method retrieve_public_key (line 84) | async fn retrieve_public_key(client: &Client, key_path: &str) -> Resul...
    method derive_fuel_address (line 104) | fn derive_fuel_address(pem: &str) -> Result<Address> {
    method request_gcp_signature (line 114) | async fn request_gcp_signature(&self, message: Message) -> Result<Vec<...
    method key_path (line 141) | pub fn key_path(&self) -> &String {
    method public_key (line 145) | pub fn public_key(&self) -> &String {
  type CryptoKeyVersionName (line 34) | pub struct CryptoKeyVersionName {
    method new (line 43) | pub fn new(
    method fmt (line 61) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method sign (line 152) | async fn sign(&self, message: Message) -> Result<Signature> {
  method address (line 174) | fn address(&self) -> Address {
  function format_gcp_error (line 179) | fn format_gcp_error(err: impl std::fmt::Display) -> Error {

FILE: packages/fuels-accounts/src/signers/private_key.rs
  function generate_mnemonic_phrase (line 12) | pub fn generate_mnemonic_phrase<R: Rng>(rng: &mut R, count: usize) -> Re...
  type PrivateKeySigner (line 17) | pub struct PrivateKeySigner {
    method fmt (line 24) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
    method new (line 33) | pub fn new(private_key: SecretKey) -> Self {
    method random (line 43) | pub fn random(rng: &mut (impl CryptoRng + RngCore)) -> Self {
    method address (line 47) | pub fn address(&self) -> Address {
    method secret_key (line 51) | pub fn secret_key(&self) -> SecretKey {
  method sign (line 59) | async fn sign(&self, message: Message) -> Result<Signature> {
  method address (line 65) | fn address(&self) -> Address {
  function mnemonic_generation (line 80) | async fn mnemonic_generation() -> Result<()> {
  function sign_and_verify (line 91) | async fn sign_and_verify() -> Result<()> {

FILE: packages/fuels-accounts/src/wallet.rs
  type Wallet (line 4) | pub struct Wallet<S = Unlocked<PrivateKeySigner>> {
  function set_provider (line 10) | pub fn set_provider(&mut self, provider: Provider) {
  function provider (line 14) | pub fn provider(&self) -> &Provider {
  type Unlocked (line 36) | pub struct Unlocked<S> {
  function new (line 41) | fn new(signer: S) -> Self {
  function new (line 47) | pub fn new(signer: S, provider: Provider) -> Self {
  function signer (line 54) | pub fn signer(&self) -> &S {
  function random (line 60) | pub fn random(rng: &mut (impl CryptoRng + RngCore), provider: Provider) ...
  function lock (line 69) | pub fn lock(&self) -> Wallet<Locked> {
  method address (line 79) | fn address(&self) -> Address {
  method try_provider (line 83) | fn try_provider(&self) -> Result<&Provider> {
  method get_asset_inputs_for_amount (line 87) | async fn get_asset_inputs_for_amount(
  method add_witnesses (line 107) | fn add_witnesses<Tb: TransactionBuilder>(&self, tb: &mut Tb) -> Result<(...
  type Locked (line 126) | pub struct Locked {
    method new (line 131) | fn new(address: Address) -> Self {
  function new_locked (line 137) | pub fn new_locked(addr: Address, provider: Provider) -> Self {
  method address (line 147) | fn address(&self) -> Address {
  method try_provider (line 151) | fn try_provider(&self) -> Result<&Provider> {
  method get_asset_inputs_for_amount (line 155) | async fn get_asset_inputs_for_amount(

FILE: packages/fuels-code-gen/src/error.rs
  type Error (line 6) | pub struct Error(pub String);
    method combine (line 9) | pub fn combine<T: Into<Self>>(self, err: T) -> Self {
  type Result (line 21) | pub type Result<T> = std::result::Result<T, Error>;
  method fmt (line 24) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method fmt (line 30) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {

FILE: packages/fuels-code-gen/src/program_bindings/abigen.rs
  type Abigen (line 25) | pub struct Abigen;
    method generate (line 36) | pub fn generate(targets: Vec<AbigenTarget>, no_std: bool) -> Result<To...
    method wasm_paths_hotfix (line 52) | fn wasm_paths_hotfix(code: &TokenStream) -> TokenStream {
    method generate_code (line 68) | fn generate_code(no_std: bool, parsed_targets: Vec<AbigenTarget>) -> R...
    method generate_all_bindings (line 84) | fn generate_all_bindings(
    method generate_binding (line 97) | fn generate_binding(
    method generate_macro_recompile_trigger (line 122) | fn generate_macro_recompile_trigger(path: Option<&PathBuf>, no_std: bo...
    method generate_shared_types (line 135) | fn generate_shared_types(
    method filter_custom_types (line 150) | fn filter_custom_types(
    method filter_shared_types (line 166) | fn filter_shared_types<'a>(
  function correctly_determines_shared_types (line 178) | fn correctly_determines_shared_types() {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/abigen_target.rs
  type AbigenTarget (line 14) | pub struct AbigenTarget {
    method new (line 21) | pub fn new(name: String, source: Abi, program_type: ProgramType) -> Se...
    method name (line 29) | pub fn name(&self) -> &str {
    method source (line 33) | pub fn source(&self) -> &Abi {
    method program_type (line 37) | pub fn program_type(&self) -> ProgramType {
  type Abi (line 43) | pub struct Abi {
    method load_from (line 49) | pub fn load_from(path: impl AsRef<Path>) -> Result<Abi> {
    method canonicalize_path (line 67) | fn canonicalize_path(path: &Path) -> Result<PathBuf> {
    method parse_from_json (line 97) | fn parse_from_json(json_abi: &str) -> Result<FullProgramABI> {
    method path (line 102) | pub fn path(&self) -> Option<&PathBuf> {
    method abi (line 106) | pub fn abi(&self) -> &FullProgramABI {
  type Err (line 112) | type Err = Error;
  method from_str (line 114) | fn from_str(json_abi: &str) -> Result<Self> {
  type ProgramType (line 122) | pub enum ProgramType {
    type Error (line 148) | type Error = syn::Error;
    method try_from (line 150) | fn try_from(ident: Ident) -> std::result::Result<Self, Self::Error> {
  type Err (line 129) | type Err = Error;
  method from_str (line 131) | fn from_str(string: &str) -> std::result::Result<Self, Self::Err> {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/bindings.rs
  function generate_bindings (line 22) | pub(crate) fn generate_bindings(target: AbigenTarget, no_std: bool) -> R...

FILE: packages/fuels-code-gen/src/program_bindings/abigen/bindings/contract.rs
  function contract_bindings (line 19) | pub(crate) fn contract_bindings(
  function expand_functions (line 154) | fn expand_functions(functions: &[FullABIFunction]) -> Result<TokenStream> {
  function expand_fn (line 167) | pub(crate) fn expand_fn(abi_fun: &FullABIFunction) -> Result<TokenStream> {
  function generate_constant_methods_pattern (line 196) | fn generate_constant_methods_pattern(
  function expand_contract_method_simple (line 254) | fn expand_contract_method_simple() -> Result<()> {
  function expand_contract_method_complex (line 311) | fn expand_contract_method_complex() -> Result<()> {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/bindings/function_generator.rs
  type FunctionGenerator (line 15) | pub(crate) struct FunctionGenerator {
    method new (line 24) | pub fn new(fun: &FullABIFunction) -> Result<Self> {
    method set_name (line 43) | pub fn set_name(&mut self, name: String) -> &mut Self {
    method set_body (line 48) | pub fn set_body(&mut self, body: TokenStream) -> &mut Self {
    method set_docs (line 53) | pub fn set_docs(&mut self, docs: Vec<String>) -> &mut Self {
    method fn_selector (line 58) | pub fn fn_selector(&self) -> TokenStream {
    method tokenized_args (line 63) | pub fn tokenized_args(&self) -> TokenStream {
    method set_output_type (line 71) | pub fn set_output_type(&mut self, output_type: TokenStream) -> &mut Se...
    method output_type (line 76) | pub fn output_type(&self) -> &TokenStream {
    method generate (line 80) | pub fn generate(&self) -> TokenStream {
  function correct_fn_selector_resolving_code (line 122) | fn correct_fn_selector_resolving_code() -> Result<()> {
  function correct_tokenized_args (line 137) | fn correct_tokenized_args() -> Result<()> {
  function tokenizes_correctly (line 152) | fn tokenizes_correctly() -> Result<()> {
  function given_a_fun (line 181) | fn given_a_fun() -> FullABIFunction {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/bindings/predicate.rs
  function predicate_bindings (line 17) | pub(crate) fn predicate_bindings(
  function expand_fn (line 57) | fn expand_fn(fn_abi: &FullABIFunction) -> Result<TokenStream> {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/bindings/script.rs
  function script_bindings (line 20) | pub(crate) fn script_bindings(
  function expand_fn (line 149) | fn expand_fn(fn_abi: &FullABIFunction) -> Result<TokenStream> {
  function expand_script_main_function (line 188) | fn expand_script_main_function() -> Result<()> {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/bindings/utils.rs
  function extract_main_fn (line 5) | pub(crate) fn extract_main_fn(abi: &[FullABIFunction]) -> Result<&FullAB...
  function correctly_extracts_the_main_fn (line 32) | fn correctly_extracts_the_main_fn() {
  function fails_if_there_is_more_than_one_main_fn (line 41) | fn fails_if_there_is_more_than_one_main_fn() {
  function given_a_fun_named (line 52) | fn given_a_fun_named(fn_name: &str) -> FullABIFunction {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/configurables.rs
  type ResolvedConfigurable (line 12) | pub(crate) struct ResolvedConfigurable {
    method new (line 19) | pub fn new(configurable: &FullConfigurable) -> Result<ResolvedConfigur...
  function generate_code_for_configurable_constants (line 29) | pub(crate) fn generate_code_for_configurable_constants(
  function generate_struct_decl (line 49) | fn generate_struct_decl(configurable_struct_name: &Ident) -> TokenStream {
  function generate_struct_impl (line 59) | fn generate_struct_impl(
  function generate_builder_methods (line 79) | fn generate_builder_methods(resolved_configurables: &[ResolvedConfigurab...
  function generate_encoder_code (line 107) | fn generate_encoder_code(ttype: &ResolvedType) -> TokenStream {
  function generate_from_impl (line 115) | fn generate_from_impl(configurable_struct_name: &Ident) -> TokenStream {

FILE: packages/fuels-code-gen/src/program_bindings/abigen/logs.rs
  function log_formatters_instantiation_code (line 7) | pub(crate) fn log_formatters_instantiation_code(
  type ResolvedLog (line 17) | struct ResolvedLog {
  function resolve_logs (line 23) | fn resolve_logs(logged_types: &[FullLoggedType]) -> Vec<ResolvedLog> {
  function generate_log_id_log_formatter_pairs (line 56) | fn generate_log_id_log_formatter_pairs(
  function generate_id_error_codes_pairs (line 69) | pub(crate) fn generate_id_error_codes_pairs(

FILE: packages/fuels-code-gen/src/program_bindings/custom_types.rs
  function generate_types (line 32) | pub(crate) fn generate_types<'a>(
  function reexport_the_shared_type (line 63) | fn reexport_the_shared_type(ttype: &FullTypeDeclaration, no_std: bool) -...
  function should_skip_codegen (line 94) | pub fn should_skip_codegen(type_decl: &FullTypeDeclaration) -> bool {
  function is_type_sdk_provided (line 104) | fn is_type_sdk_provided(type_path: &TypePath) -> bool {
  function is_type_unused (line 108) | fn is_type_unused(type_path: &TypePath) -> bool {
  function test_expand_custom_enum (line 135) | fn test_expand_custom_enum() -> Result<()> {
  function test_enum_with_no_variants_cannot_be_constructed (line 203) | fn test_enum_with_no_variants_cannot_be_constructed() -> Result<()> {
  function test_expand_struct_inside_enum (line 223) | fn test_expand_struct_inside_enum() -> Result<()> {
  function test_expand_array_inside_enum (line 295) | fn test_expand_array_inside_enum() -> Result<()> {
  function test_expand_custom_enum_with_enum (line 360) | fn test_expand_custom_enum_with_enum() -> Result<()> {
  function test_expand_custom_struct (line 444) | fn test_expand_custom_struct() -> Result<()> {
  function test_struct_with_no_fields_can_be_constructed (line 538) | fn test_struct_with_no_fields_can_be_constructed() -> Result<()> {
  function test_expand_custom_struct_with_struct (line 578) | fn test_expand_custom_struct_with_struct() -> Result<()> {
  function shared_types_are_just_reexported (line 660) | fn shared_types_are_just_reexported() {

FILE: packages/fuels-code-gen/src/program_bindings/custom_types/enums.rs
  function expand_custom_enum (line 20) | pub(crate) fn expand_custom_enum(
  function maybe_impl_error (line 41) | fn maybe_impl_error(enum_ident: &Ident, components: &Components) -> Opti...
  function enum_decl (line 69) | fn enum_decl(

FILE: packages/fuels-code-gen/src/program_bindings/custom_types/structs.rs
  function expand_custom_struct (line 20) | pub(crate) fn expand_custom_struct(
  function unzip_field_names_and_types (line 44) | fn unzip_field_names_and_types(components: &Components) -> (Vec<&Ident>,...
  function struct_decl (line 57) | fn struct_decl(

FILE: packages/fuels-code-gen/src/program_bindings/custom_types/utils.rs
  function extract_generic_parameters (line 9) | pub(crate) fn extract_generic_parameters(type_decl: &FullTypeDeclaration...
  function extracts_generic_types (line 33) | fn extracts_generic_types() -> Result<()> {
  function can_extract_struct_name (line 81) | fn can_extract_struct_name() {
  function can_extract_enum_name (line 96) | fn can_extract_enum_name() {

FILE: packages/fuels-code-gen/src/program_bindings/generated_code.rs
  type GeneratedCode (line 10) | pub(crate) struct GeneratedCode {
    method new (line 18) | pub fn new(code: TokenStream, usable_types: HashSet<TypePath>, no_std:...
    method prelude (line 27) | fn prelude(&self) -> TokenStream {
    method code (line 49) | pub fn code(&self) -> TokenStream {
    method is_empty (line 79) | pub fn is_empty(&self) -> bool {
    method merge (line 83) | pub fn merge(mut self, another: GeneratedCode) -> Self {
    method wrap_in_mod (line 95) | pub fn wrap_in_mod(mut self, mod_name: impl Into<TypePath>) -> Self {
    method wrap_in_single_mod (line 106) | fn wrap_in_single_mod(self, mod_name: Ident) -> Self {
    method use_statements_for_uniquely_named_types (line 113) | pub fn use_statements_for_uniquely_named_types(&self) -> TokenStream {
    method types_with_unique_names (line 124) | fn types_with_unique_names(&self) -> Vec<TypePath> {
  function can_merge_top_level_code (line 151) | fn can_merge_top_level_code() {
  function wrapping_in_mod_updates_code (line 169) | fn wrapping_in_mod_updates_code() {
  function wrapping_in_mod_updates_use_statements (line 201) | fn wrapping_in_mod_updates_use_statements() {
  function merging_code_will_merge_mods_as_well (line 218) | fn merging_code_will_merge_mods_as_well() {
  function use_statement_not_generated_for_top_level_type (line 292) | fn use_statement_not_generated_for_top_level_type() {
  function use_statements_only_for_uniquely_named_types (line 311) | fn use_statements_only_for_uniquely_named_types() {
  function given_some_struct_code (line 340) | fn given_some_struct_code(struct_name: &str) -> GeneratedCode {
  function given_type_path (line 350) | fn given_type_path(path: &str) -> TypePath {

FILE: packages/fuels-code-gen/src/program_bindings/resolved_type.rs
  type GenericType (line 17) | pub enum GenericType {
  method to_tokens (line 23) | fn to_tokens(&self, tokens: &mut TokenStream) {
  type ResolvedType (line 37) | pub enum ResolvedType {
    method generics (line 50) | pub fn generics(&self) -> Vec<GenericType> {
  method to_tokens (line 66) | fn to_tokens(&self, tokens: &mut TokenStream) {
  method fmt (line 92) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type TypeResolver (line 98) | pub(crate) struct TypeResolver {
    method new (line 110) | pub(crate) fn new(current_mod: TypePath) -> Self {
    method resolve (line 114) | pub(crate) fn resolve(&self, type_application: &FullTypeApplication) -...
    method resolve_multiple (line 137) | fn resolve_multiple(
    method try_as_generic (line 147) | fn try_as_generic(
    method try_as_array (line 159) | fn try_as_array(&self, type_application: &FullTypeApplication) -> Resu...
    method try_as_sized_ascii_string (line 181) | fn try_as_sized_ascii_string(
    method try_as_ascii_string (line 197) | fn try_as_ascii_string(
    method try_as_tuple (line 213) | fn try_as_tuple(&self, type_application: &FullTypeApplication) -> Resu...
    method try_as_primitive_type (line 223) | fn try_as_primitive_type(
    method try_as_bits256 (line 251) | fn try_as_bits256(
    method try_as_raw_slice (line 266) | fn try_as_raw_slice(
    method try_as_custom_type (line 281) | fn try_as_custom_type(
  method default (line 104) | fn default() -> Self {
  function correctly_extracts_used_generics (line 322) | fn correctly_extracts_used_generics() {
  function test_resolve_first_type (line 352) | fn test_resolve_first_type(
  function test_resolve_primitive_type (line 377) | fn test_resolve_primitive_type(type_field: &str, expected: &str) -> Resu...
  function test_resolve_u8 (line 389) | fn test_resolve_u8() -> Result<()> {
  function test_resolve_u16 (line 394) | fn test_resolve_u16() -> Result<()> {
  function test_resolve_u32 (line 399) | fn test_resolve_u32() -> Result<()> {
  function test_resolve_u64 (line 404) | fn test_resolve_u64() -> Result<()> {
  function test_resolve_bool (line 409) | fn test_resolve_bool() -> Result<()> {
  function test_resolve_b256 (line 414) | fn test_resolve_b256() -> Result<()> {
  function test_resolve_unit (line 419) | fn test_resolve_unit() -> Result<()> {
  function test_resolve_array (line 424) | fn test_resolve_array() -> Result<()> {
  function test_resolve_vector (line 447) | fn test_resolve_vector() -> Result<()> {
  function test_resolve_bytes (line 516) | fn test_resolve_bytes() -> Result<()> {
  function test_resolve_std_string (line 579) | fn test_resolve_std_string() -> Result<()> {
  function test_resolve_static_str (line 642) | fn test_resolve_static_str() -> Result<()> {
  function test_resolve_struct (line 647) | fn test_resolve_struct() -> Result<()> {
  function test_resolve_enum (line 684) | fn test_resolve_enum() -> Result<()> {
  function test_resolve_tuple (line 721) | fn test_resolve_tuple() -> Result<()> {
  function custom_types_uses_correct_path_for_sdk_provided_types (line 774) | fn custom_types_uses_correct_path_for_sdk_provided_types() {
  function given_fn_arg_of_custom_type (line 792) | fn given_fn_arg_of_custom_type(type_path: &TypePath) -> FullTypeApplicat...

FILE: packages/fuels-code-gen/src/program_bindings/utils.rs
  type Component (line 16) | pub(crate) struct Component {
  type Components (line 23) | pub(crate) struct Components {
    method new (line 28) | pub fn new(
    method has_error_messages (line 58) | pub fn has_error_messages(&self) -> bool {
    method iter (line 64) | pub fn iter(&self) -> impl Iterator<Item = &Component> {
    method is_empty (line 68) | pub fn is_empty(&self) -> bool {
    method as_enum_variants (line 72) | pub fn as_enum_variants(&self) -> impl Iterator<Item = TokenStream> + ...
    method generate_parameters_for_unused_generics (line 88) | pub fn generate_parameters_for_unused_generics(
    method generate_variant_for_unused_generics (line 102) | pub fn generate_variant_for_unused_generics(
    method named_generics (line 121) | fn named_generics(&self) -> HashSet<Ident> {
    method unused_named_generics (line 135) | fn unused_named_generics<'a>(
  function tokenize_generics (line 146) | pub(crate) fn tokenize_generics(generics: &[Ident]) -> (TokenStream, Tok...
  function sdk_provided_custom_types_lookup (line 157) | pub(crate) fn sdk_provided_custom_types_lookup() -> HashMap<TypePath, Ty...
  function respects_snake_case_flag (line 192) | fn respects_snake_case_flag() -> Result<()> {
  function avoids_collisions_with_reserved_keywords (line 206) | fn avoids_collisions_with_reserved_keywords() -> Result<()> {
  function type_application_named (line 226) | fn type_application_named(name: &str) -> FullTypeApplication {

FILE: packages/fuels-code-gen/src/utils.rs
  function encode_fn_selector (line 3) | pub fn encode_fn_selector(name: &str) -> Vec<u8> {

FILE: packages/fuels-core/src/codec.rs
  function try_from_bytes (line 22) | pub fn try_from_bytes<T>(bytes: impl Read, decoder_config: DecoderConfig...
  function convert_all_from_bool_to_u64 (line 40) | fn convert_all_from_bool_to_u64() -> Result<()> {
  function convert_bytes_into_tuple (line 63) | fn convert_bytes_into_tuple() -> Result<()> {
  function convert_native_types (line 75) | fn convert_native_types() -> Result<()> {
  function string_slice_is_read_in_total (line 93) | fn string_slice_is_read_in_total() {

FILE: packages/fuels-core/src/codec/abi_decoder.rs
  type DecoderConfig (line 14) | pub struct DecoderConfig {
  method default (line 25) | fn default() -> Self {
  type ABIDecoder (line 35) | pub struct ABIDecoder {
    method new (line 40) | pub fn new(config: DecoderConfig) -> Self {
    method decode (line 63) | pub fn decode(&self, param_type: &ParamType, mut bytes: impl Read) -> ...
    method decode_multiple (line 81) | pub fn decode_multiple(
    method decode_as_debug_str (line 109) | pub fn decode_as_debug_str(
    method decode_multiple_as_debug_str (line 118) | pub fn decode_multiple_as_debug_str(
  function decode_multiple_uint (line 147) | fn decode_multiple_uint() -> Result<()> {
  function decode_bool (line 184) | fn decode_bool() -> Result<()> {
  function decode_b256 (line 198) | fn decode_b256() -> Result<()> {
  function decode_string_array (line 212) | fn decode_string_array() -> Result<()> {
  function decode_string_slice (line 236) | fn decode_string_slice() -> Result<()> {
  function decode_string (line 256) | fn decode_string() -> Result<()> {
  function decode_tuple (line 273) | fn decode_tuple() -> Result<()> {
  function decode_array (line 290) | fn decode_array() -> Result<()> {
  function decode_struct (line 303) | fn decode_struct() -> Result<()> {
  function decode_bytes (line 327) | fn decode_bytes() -> Result<()> {
  function decode_raw_slice (line 340) | fn decode_raw_slice() -> Result<()> {
  function decode_enum (line 353) | fn decode_enum() -> Result<()> {
  function decode_nested_struct (line 381) | fn decode_nested_struct() -> Result<()> {
  function decode_comprehensive (line 427) | fn decode_comprehensive() -> Result<()> {
  function enums_with_all_unit_variants_are_decoded_from_one_word (line 498) | fn enums_with_all_unit_variants_are_decoded_from_one_word() -> Result<()> {
  function out_of_bounds_discriminant_is_detected (line 517) | fn out_of_bounds_discriminant_is_detected() -> Result<()> {
  function division_by_zero (line 538) | pub fn division_by_zero() {
  function multiply_overflow_enum (line 545) | pub fn multiply_overflow_enum() {
  function multiply_overflow_arith (line 572) | pub fn multiply_overflow_arith() {
  function capacity_overflow (line 589) | pub fn capacity_overflow() {
  function stack_overflow (line 598) | pub fn stack_overflow() {
  function capacity_malloc (line 608) | pub fn capacity_malloc() {
  function max_depth_surpassed (line 615) | fn max_depth_surpassed() {
  function depth_is_not_reached (line 634) | fn depth_is_not_reached() {
  function too_many_tokens (line 665) | fn too_many_tokens() {
  function token_count_is_being_reset_between_decodings (line 703) | fn token_count_is_being_reset_between_decodings() {
  function assert_decoding_failed_w_data (line 722) | fn assert_decoding_failed_w_data(
  function nested_struct (line 739) | fn nested_struct(depth: usize) -> ParamType {
  function nested_enum (line 753) | fn nested_enum(depth: usize) -> ParamType {
  function nested_array (line 767) | fn nested_array(depth: usize) -> ParamType {
  function nested_tuple (line 777) | fn nested_tuple(depth: usize) -> ParamType {

FILE: packages/fuels-core/src/codec/abi_decoder/bounded_decoder.rs
  type BoundedDecoder (line 17) | pub(crate) struct BoundedDecoder {
    method new (line 23) | pub(crate) fn new(config: DecoderConfig) -> Self {
    method decode (line 34) | pub(crate) fn decode<R: Read>(
    method decode_multiple (line 42) | pub(crate) fn decode_multiple<R: Read>(
    method run_w_depth_tracking (line 50) | fn run_w_depth_tracking(
    method decode_param (line 61) | fn decode_param<R: Read>(&mut self, param_type: &ParamType, bytes: &mu...
    method decode_std_string (line 97) | fn decode_std_string<R: Read>(bytes: &mut R) -> Result<Token> {
    method decode_string_array (line 103) | fn decode_string_array<R: Read>(bytes: &mut R, length: usize) -> Resul...
    method decode_string_slice (line 112) | fn decode_string_slice<R: Read>(bytes: &mut R) -> Result<Token> {
    method decode_tuple (line 118) | fn decode_tuple<R: Read>(&mut self, param_types: &[ParamType], bytes: ...
    method decode_array (line 122) | fn decode_array<R: Read>(
    method decode_vector (line 133) | fn decode_vector<R: Read>(&mut self, param_type: &ParamType, bytes: &m...
    method decode_struct (line 140) | fn decode_struct<R: Read>(
    method decode_enum (line 150) | fn decode_enum<R: Read>(
    method decode_params (line 167) | fn decode_params<'a, R: Read>(
  function decode (line 181) | fn decode<const SIZE: usize, R: Read, Out>(
  function decode_sized (line 191) | fn decode_sized<R: Read>(bytes: &mut R, len: usize) -> Result<Vec<u8>> {
  function decode_len (line 198) | fn decode_len<R: Read>(bytes: &mut R) -> Result<usize> {
  function decode_slice (line 207) | fn decode_slice<R: Read>(bytes: &mut R) -> Result<Vec<u8>> {

FILE: packages/fuels-core/src/codec/abi_decoder/decode_as_debug_str.rs
  function inner_types_debug (line 9) | fn inner_types_debug(tokens: &[Token], inner_type: &ParamType, join_str:...
  function decode_as_debug_str (line 19) | pub(crate) fn decode_as_debug_str(param_type: &ParamType, token: &Token)...
  function param_type_decode_debug (line 108) | fn param_type_decode_debug() -> Result<()> {

FILE: packages/fuels-core/src/codec/abi_encoder.rs
  type EncoderConfig (line 11) | pub struct EncoderConfig {
  method default (line 22) | fn default() -> Self {
  type ABIEncoder (line 32) | pub struct ABIEncoder {
    method new (line 37) | pub fn new(config: EncoderConfig) -> Self {
    method encode (line 43) | pub fn encode(&self, tokens: &[Token]) -> Result<Vec<u8>> {
  function encode_multiple_uint (line 63) | fn encode_multiple_uint() -> Result<()> {
  function encode_bool (line 92) | fn encode_bool() -> Result<()> {
  function encode_b256 (line 105) | fn encode_b256() -> Result<()> {
  function encode_bytes (line 120) | fn encode_bytes() -> Result<()> {
  function encode_string (line 136) | fn encode_string() -> Result<()> {
  function encode_raw_slice (line 153) | fn encode_raw_slice() -> Result<()> {
  function encode_string_array (line 169) | fn encode_string_array() -> Result<()> {
  function encode_string_slice (line 188) | fn encode_string_slice() -> Result<()> {
  function encode_tuple (line 208) | fn encode_tuple() -> Result<()> {
  function encode_array (line 224) | fn encode_array() -> Result<()> {
  function encode_enum_with_deeply_nested_types (line 240) | fn encode_enum_with_deeply_nested_types() -> Result<()> {
  function encode_nested_structs (line 306) | fn encode_nested_structs() -> Result<()> {
  function encode_comprehensive (line 329) | fn encode_comprehensive() -> Result<()> {
  function enums_with_only_unit_variants_are_encoded_in_one_word (line 368) | fn enums_with_only_unit_variants_are_encoded_in_one_word() -> Result<()> {
  function vec_in_enum (line 382) | fn vec_in_enum() -> Result<()> {
  function enum_in_vec (line 404) | fn enum_in_vec() -> Result<()> {
  function vec_in_struct (line 428) | fn vec_in_struct() -> Result<()> {
  function vec_in_vec (line 447) | fn vec_in_vec() -> Result<()> {
  function max_depth_surpassed (line 466) | fn max_depth_surpassed() {
  function assert_encoding_failed (line 482) | fn assert_encoding_failed(config: EncoderConfig, token: Token, msg: &str) {
  function nested_struct (line 493) | fn nested_struct(depth: usize) -> Token {
  function nested_enum (line 503) | fn nested_enum(depth: usize) -> Token {
  function nested_array (line 521) | fn nested_array(depth: usize) -> Token {
  function nested_tuple (line 529) | fn nested_tuple(depth: usize) -> Token {

FILE: packages/fuels-core/src/codec/abi_encoder/bounded_encoder.rs
  type BoundedEncoder (line 9) | pub(crate) struct BoundedEncoder {
    method new (line 15) | pub(crate) fn new(config: EncoderConfig) -> Self {
    method encode (line 26) | pub fn encode(&mut self, tokens: &[Token]) -> Result<Vec<u8>> {
    method run_w_depth_tracking (line 37) | fn run_w_depth_tracking(
    method encode_token (line 48) | fn encode_token(&mut self, arg: &Token) -> Result<Vec<u8>> {
    method encode_u256 (line 75) | fn encode_u256(arg_u256: U256) -> Vec<u8> {
    method encode_bytes (line 82) | fn encode_bytes(data: Vec<u8>) -> Result<Vec<u8>> {
    method encode_string_array (line 88) | fn encode_string_array(arg_string: &StaticStringToken) -> Result<Vec<u...
    method encode_string_slice (line 92) | fn encode_string_slice(arg_string: &StaticStringToken) -> Result<Vec<u...
    method encode_vector (line 96) | fn encode_vector(&mut self, data: &[Token]) -> Result<Vec<u8>> {
    method encode_enum (line 102) | fn encode_enum(&mut self, selector: &EnumSelector) -> Result<Vec<u8>> {
    method encode_length (line 110) | fn encode_length(len: u64) -> Vec<u8> {
    method encode_discriminant (line 114) | fn encode_discriminant(discriminant: u64) -> Vec<u8> {

FILE: packages/fuels-core/src/codec/abi_formatter.rs
  type ABIFormatter (line 9) | pub struct ABIFormatter {
    method has_fn (line 16) | pub fn has_fn(&self, fn_name: &str) -> bool {
    method with_decoder_config (line 20) | pub fn with_decoder_config(mut self, config: DecoderConfig) -> Self {
    method from_abi (line 25) | pub fn from_abi(abi: UnifiedProgramABI) -> Result<Self> {
    method from_json_abi (line 72) | pub fn from_json_abi(abi: impl AsRef<str>) -> Result<Self> {
    method decode_fn_args (line 77) | pub fn decode_fn_args<R: Read>(&self, fn_name: &str, data: R) -> Resul...
    method decode_configurables (line 86) | pub fn decode_configurables<R: Read>(
  function gracefully_handles_missing_fn (line 115) | fn gracefully_handles_missing_fn() {

FILE: packages/fuels-core/src/codec/logs.rs
  type Log (line 9) | pub trait Log {
    constant LOG_ID (line 11) | const LOG_ID: &'static str;
    constant LOG_ID_U64 (line 13) | const LOG_ID_U64: u64;
  type ErrorDetails (line 17) | pub struct ErrorDetails {
    method new (line 27) | pub fn new(
  type LogFormatter (line 55) | pub struct LogFormatter {
    method new_log (line 61) | pub fn new_log<T: Tokenizable + Parameterize + Debug + 'static>() -> S...
    method new_error (line 68) | pub fn new_error<T: Tokenizable + Parameterize + std::error::Error + '...
    method format_log (line 75) | fn format_log<T: Parameterize + Tokenizable + Debug>(
    method format_error (line 84) | fn format_error<T: Parameterize + Tokenizable + std::error::Error>(
    method can_handle_type (line 93) | pub fn can_handle_type<T: Tokenizable + Parameterize + 'static>(&self)...
    method format (line 97) | pub fn format(&self, decoder_config: DecoderConfig, bytes: &[u8]) -> R...
  method fmt (line 103) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type LogId (line 112) | pub struct LogId(ContractId, String);
  type LogDecoder (line 116) | pub struct LogDecoder {
    method new (line 145) | pub fn new(
    method get_error_codes (line 156) | pub fn get_error_codes(&self, id: &u64) -> Option<&ErrorDetails> {
    method set_decoder_config (line 160) | pub fn set_decoder_config(&mut self, decoder_config: DecoderConfig) ->...
    method decode_logs (line 166) | pub fn decode_logs(&self, receipts: &[Receipt]) -> LogResult {
    method format_log (line 176) | fn format_log(&self, log_id: &LogId, data: &[u8]) -> Result<String> {
    method decode_last_log (line 191) | pub(crate) fn decode_last_log(&self, receipts: &[Receipt]) -> Result<S...
    method decode_last_two_logs (line 201) | pub(crate) fn decode_last_two_logs(&self, receipts: &[Receipt]) -> Res...
    method decode_logs_with_type (line 223) | pub fn decode_logs_with_type<T: Tokenizable + Parameterize + 'static>(
    method decode_logs_lazy (line 249) | pub fn decode_logs_lazy<'a, T: Tokenizable + Parameterize + 'static>(
    method merge (line 263) | pub fn merge(&mut self, log_decoder: LogDecoder) {
  type LogResult (line 124) | pub struct LogResult {
    method filter_succeeded (line 129) | pub fn filter_succeeded(&self) -> Vec<&str> {
    method filter_failed (line 136) | pub fn filter_failed(&self) -> Vec<&Error> {
  type ExtractLogIdData (line 269) | trait ExtractLogIdData {
    method extract_log_id_and_data (line 271) | fn extract_log_id_and_data(self) -> Self::Output;
    type Output (line 283) | type Output = FilterMap<Self, fn(&Receipt) -> Option<(LogId, Vec<u8>)>>;
    method extract_log_id_and_data (line 284) | fn extract_log_id_and_data(self) -> Self::Output {
  type ExtractLogIdLazy (line 274) | trait ExtractLogIdLazy {
    method extract_matching_logs_lazy (line 275) | fn extract_matching_logs_lazy<T: Tokenizable + Parameterize + 'static>(
    method extract_matching_logs_lazy (line 301) | fn extract_matching_logs_lazy<T: Tokenizable + Parameterize + 'static>(
  function log_formatters_lookup (line 345) | pub fn log_formatters_lookup(

FILE: packages/fuels-core/src/codec/utils.rs
  type CounterWithLimit (line 3) | pub(crate) struct CounterWithLimit {
    method new (line 26) | pub(crate) fn new(max: usize, name: impl Into<String>, direction: Code...
    method increase (line 35) | pub(crate) fn increase(&mut self) -> Result<()> {
    method decrease (line 49) | pub(crate) fn decrease(&mut self) {
  type CodecDirection (line 11) | pub(crate) enum CodecDirection {
    method fmt (line 17) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

FILE: packages/fuels-core/src/lib.rs
  type Configurable (line 11) | pub struct Configurable {
  type Configurables (line 19) | pub struct Configurables {
    method new (line 24) | pub fn new(offsets_with_data: Vec<Configurable>) -> Self {
    method with_shifted_offsets (line 28) | pub fn with_shifted_offsets(self, shift: i64) -> Result<Self> {
    method update_constants_in (line 59) | pub fn update_constants_in(&self, binary: &mut [u8]) {
  function from (line 68) | fn from(config: Configurables) -> Vec<Configurable> {
  function test_with_shifted_offsets_positive_shift (line 78) | fn test_with_shifted_offsets_positive_shift() {
  function test_with_shifted_offsets_negative_shift (line 96) | fn test_with_shifted_offsets_negative_shift() {
  function test_with_shifted_offsets_zero_shift (line 114) | fn test_with_shifted_offsets_zero_shift() {
  function test_with_shifted_offsets_overflow (line 129) | fn test_with_shifted_offsets_overflow() {
  function test_with_shifted_offsets_underflow (line 146) | fn test_with_shifted_offsets_underflow() {

FILE: packages/fuels-core/src/traits/parameterize.rs
  type Parameterize (line 10) | pub trait Parameterize {
    method param_type (line 11) | fn param_type() -> ParamType;
    method param_type (line 15) | fn param_type() -> ParamType {
    method param_type (line 21) | fn param_type() -> ParamType {
    method param_type (line 27) | fn param_type() -> ParamType {
    method param_type (line 33) | fn param_type() -> ParamType {
    method param_type (line 39) | fn param_type() -> ParamType {
    method param_type (line 45) | fn param_type() -> ParamType {
    method param_type (line 51) | fn param_type() -> ParamType {
    method param_type (line 61) | fn param_type() -> ParamType {
    method param_type (line 71) | fn param_type() -> ParamType {
    method param_type (line 81) | fn param_type() -> ParamType {
    method param_type (line 87) | fn param_type() -> ParamType {
    method param_type (line 93) | fn param_type() -> ParamType {
    method param_type (line 99) | fn param_type() -> ParamType {
    method param_type (line 105) | fn param_type() -> ParamType {
    method param_type (line 111) | fn param_type() -> ParamType {
    method param_type (line 117) | fn param_type() -> ParamType {
    method param_type (line 126) | fn param_type() -> ParamType {
    method param_type (line 146) | fn param_type() -> ParamType {
    method param_type (line 162) | fn param_type() -> ParamType {
    method param_type (line 168) | fn param_type() -> ParamType {
  function sized_ascii_string_is_parameterized_correctly (line 218) | fn sized_ascii_string_is_parameterized_correctly() {
  function test_param_type_b256 (line 225) | fn test_param_type_b256() {
  function test_param_type_raw_slice (line 230) | fn test_param_type_raw_slice() {

FILE: packages/fuels-core/src/traits/signer.rs
  type Signer (line 13) | pub trait Signer {
    method sign (line 14) | async fn sign(&self, message: Message) -> Result<Signature>;
    method address (line 15) | fn address(&self) -> Address;

FILE: packages/fuels-core/src/traits/tokenizable.rs
  type Tokenizable (line 12) | pub trait Tokenizable {
    method from_token (line 14) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 18) | fn into_token(self) -> Token;
    method from_token (line 22) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 25) | fn into_token(self) -> Token {
    method from_token (line 31) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 44) | fn into_token(self) -> Token {
    method from_token (line 50) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 64) | fn into_token(self) -> Token {
    method from_token (line 71) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 77) | fn into_token(self) -> Token {
    method from_token (line 83) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 93) | fn into_token(self) -> Token {
    method from_token (line 99) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 105) | fn into_token(self) -> Token {
    method from_token (line 111) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 117) | fn into_token(self) -> Token {
    method from_token (line 123) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 129) | fn into_token(self) -> Token {
    method from_token (line 135) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 141) | fn into_token(self) -> Token {
    method from_token (line 147) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 153) | fn into_token(self) -> Token {
    method from_token (line 159) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 172) | fn into_token(self) -> Token {
    method from_token (line 178) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 191) | fn into_token(self) -> Token {
    method from_token (line 197) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 210) | fn into_token(self) -> Token {
    method from_token (line 276) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 297) | fn into_token(self) -> Token {
    method from_token (line 304) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 325) | fn into_token(self) -> Token {
    method from_token (line 333) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 354) | fn into_token(self) -> Token {
    method from_token (line 364) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 382) | fn into_token(self) -> Token {
    method from_token (line 401) | fn from_token(token: Token) -> Result<Self> {
    method into_token (line 419) | fn into_token(self) -> Token {
    method from_token (line 434) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 465) | fn into_token(self) -> Token {
    method from_token (line 471) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 494) | fn into_token(self) -> Token {
    method from_token (line 500) | fn from_token(token: Token) -> Result<Self>
    method into_token (line 513) | fn into_token(self) -> Token {
  function test_from_token_b256 (line 523) | fn test_from_token_b256() -> Result<()> {
  function test_into_token_b256 (line 535) | fn test_into_token_b256() {
  function test_from_token_raw_slice (line 545) | fn test_from_token_raw_slice() -> Result<()> {
  function test_into_token_raw_slice (line 557) | fn test_into_token_raw_slice() {
  function sized_ascii_string_is_tokenized_correctly (line 567) | fn sized_ascii_string_is_tokenized_correctly() -> Result<()> {
  function sized_ascii_string_is_detokenized_correctly (line 586) | fn sized_ascii_string_is_detokenized_correctly() -> Result<()> {
  function test_into_token_std_string (line 598) | fn test_into_token_std_string() -> Result<()> {

FILE: packages/fuels-core/src/types.rs
  type ByteArray (line 23) | pub type ByteArray = [u8; 8];
  type Selector (line 24) | pub type Selector = Vec<u8>;
  function pad_u16 (line 27) | pub fn pad_u16(value: u16) -> ByteArray {
  function pad_u32 (line 34) | pub fn pad_u32(value: u32) -> ByteArray {
  function pad_string (line 40) | pub fn pad_string(s: &str) -> Result<Vec<u8>> {

FILE: packages/fuels-core/src/types/checksum_address.rs
  function checksum_encode (line 5) | pub fn checksum_encode(address: &str) -> Result<String> {
  function pre_validate (line 35) | fn pre_validate(s: &str) -> Result<()> {
  function is_checksum_valid (line 49) | pub fn is_checksum_valid(address: &str) -> bool {
  constant VALID_CHECKSUM (line 71) | const VALID_CHECKSUM: [&str; 4] = [
  constant INVALID_CHECKSUM (line 77) | const INVALID_CHECKSUM: [&str; 8] = [
  constant INVALID_LEN (line 89) | const INVALID_LEN: [&str; 6] = [
  constant INVALID_CHARACTERS (line 101) | const INVALID_CHARACTERS: &str =
  function will_detect_valid_checksums (line 105) | fn will_detect_valid_checksums() {
  function will_detect_invalid_checksums (line 112) | fn will_detect_invalid_checksums() {
  function can_construct_address_from_checksum (line 119) | fn can_construct_address_from_checksum() {
  function will_detect_invalid_lengths (line 125) | fn will_detect_invalid_lengths() {
  function will_detect_invalid_characters (line 133) | fn will_detect_invalid_characters() {

FILE: packages/fuels-core/src/types/core/bits.rs
  type Bits256 (line 11) | pub struct Bits256(pub [u8; 32]);
    method zeroed (line 15) | pub fn zeroed() -> Self {
    method from_hex_str (line 21) | pub fn from_hex_str(hex: &str) -> Result<Self> {
    method from (line 36) | fn from(value: AssetId) -> Self {
    method from (line 42) | fn from(value: SubAssetId) -> Self {
  type B512 (line 52) | pub struct B512 {
    method from (line 58) | fn from(bits_tuple: (Bits256, Bits256)) -> Self {
  type EvmAddress (line 69) | pub struct EvmAddress {
    method new (line 75) | fn new(b256: Bits256) -> Self {
    method value (line 81) | pub fn value(&self) -> Bits256 {
    method clear_12_bytes (line 86) | fn clear_12_bytes(bytes: [u8; 32]) -> [u8; 32] {
    method from (line 95) | fn from(b256: Bits256) -> Self {
  function from_hex_str_b256 (line 109) | fn from_hex_str_b256() -> Result<()> {
  function test_param_type_evm_addr (line 131) | fn test_param_type_evm_addr() {
  function evm_address_clears_first_12_bytes (line 143) | fn evm_address_clears_first_12_bytes() -> Result<()> {
  function test_into_token_evm_addr (line 158) | fn test_into_token_evm_addr() {

FILE: packages/fuels-core/src/types/core/bytes.rs
  type Bytes (line 4) | pub struct Bytes(pub Vec<u8>);
    method from_hex_str (line 9) | pub fn from_hex_str(hex: &str) -> Result<Self> {
    method eq (line 28) | fn eq(&self, other: &Vec<u8>) -> bool {
  function from (line 22) | fn from(bytes: Bytes) -> Vec<u8> {
  function eq (line 34) | fn eq(&self, other: &Bytes) -> bool {
  function from_hex_str_b256 (line 44) | fn from_hex_str_b256() -> Result<()> {

FILE: packages/fuels-core/src/types/core/identity.rs
  type Identity (line 20) | pub enum Identity {
    method as_ref (line 32) | fn as_ref(&self) -> &[u8] {
    method from (line 41) | fn from(address: &Address) -> Self {
    method from (line 46) | fn from(address: Address) -> Self {
    method from (line 52) | fn from(contract_id: &ContractId) -> Self {
    method from (line 57) | fn from(contract_id: ContractId) -> Self {
  method default (line 26) | fn default() -> Self {

FILE: packages/fuels-core/src/types/core/raw_slice.rs
  type RawSlice (line 2) | pub struct RawSlice(pub Vec<u8>);
    method eq (line 11) | fn eq(&self, other: &Vec<u8>) -> bool {
  function from (line 5) | fn from(raw_slice: RawSlice) -> Vec<u8> {
  function eq (line 17) | fn eq(&self, other: &RawSlice) -> bool {

FILE: packages/fuels-core/src/types/core/sized_ascii_string.rs
  type AsciiString (line 10) | pub struct AsciiString {
    method new (line 15) | pub fn new(data: String) -> Result<Self> {
    method to_trimmed_str (line 25) | pub fn to_trimmed_str(&self) -> &str {
    method to_left_trimmed_str (line 28) | pub fn to_left_trimmed_str(&self) -> &str {
    method to_right_trimmed_str (line 31) | pub fn to_right_trimmed_str(&self) -> &str {
    type Error (line 37) | type Error = Error;
    method try_from (line 39) | fn try_from(value: &str) -> Result<Self> {
    type Error (line 45) | type Error = Error;
    method try_from (line 47) | fn try_from(value: String) -> Result<Self> {
    method eq (line 71) | fn eq(&self, other: &&str) -> bool {
  method from (line 53) | fn from(ascii_str: AsciiString) -> Self {
  function as_ref (line 59) | fn as_ref(&self) -> &str {
  method fmt (line 65) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function eq (line 76) | fn eq(&self, other: &AsciiString) -> bool {
  type SizedAsciiString (line 85) | pub struct SizedAsciiString<const LEN: usize> {
  function new (line 90) | pub fn new(data: String) -> Result<Self> {
  function to_trimmed_str (line 106) | pub fn to_trimmed_str(&self) -> &str {
  function to_left_trimmed_str (line 109) | pub fn to_left_trimmed_str(&self) -> &str {
  function to_right_trimmed_str (line 112) | pub fn to_right_trimmed_str(&self) -> &str {
  function new_with_right_whitespace_padding (line 117) | pub fn new_with_right_whitespace_padding(data: String) -> Result<Self> {
  type Error (line 133) | type Error = Error;
  function try_from (line 135) | fn try_from(value: &str) -> Result<Self> {
  type Error (line 141) | type Error = Error;
  function try_from (line 143) | fn try_from(value: String) -> Result<Self> {
  method from (line 149) | fn from(sized_ascii_str: SizedAsciiString<LEN>) -> Self {
  method fmt (line 155) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function eq (line 161) | fn eq(&self, other: &&str) -> bool {
  function eq (line 167) | fn eq(&self, other: &SizedAsciiString<LEN>) -> bool {
  method serialize (line 173) | fn serialize<S: serde::Serializer>(
  function deserialize (line 182) | fn deserialize<D: serde::Deserializer<'de>>(
  function accepts_ascii_of_correct_length (line 195) | fn accepts_ascii_of_correct_length() {
  function refuses_non_ascii (line 205) | fn refuses_non_ascii() {
  function refuses_invalid_len (line 216) | fn refuses_invalid_len() {
  function can_be_constructed_from_str_ref (line 229) | fn can_be_constructed_from_str_ref() {
  function can_be_constructed_from_string (line 234) | fn can_be_constructed_from_string() {
  function can_be_converted_into_string (line 239) | fn can_be_converted_into_string() {
  function can_be_printed (line 249) | fn can_be_printed() {
  function can_be_compared_w_str_ref (line 256) | fn can_be_compared_w_str_ref() {
  function trim (line 265) | fn trim() -> Result<()> {
  function test_can_serialize_sized_ascii (line 280) | fn test_can_serialize_sized_ascii() {
  function test_can_deserialize_sized_ascii (line 288) | fn test_can_deserialize_sized_ascii() {
  function test_can_convert_sized_ascii_to_bytes (line 299) | fn test_can_convert_sized_ascii_to_bytes() {

FILE: packages/fuels-core/src/types/core/u256.rs
  method param_type (line 21) | fn param_type() -> ParamType {
  method from_token (line 27) | fn from_token(token: Token) -> FuelsResult<Self>
  method into_token (line 40) | fn into_token(self) -> Token {
  method serialize (line 46) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  method deserialize (line 55) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function u256_serialize_deserialize (line 68) | fn u256_serialize_deserialize() {

FILE: packages/fuels-core/src/types/dry_runner.rs
  type DryRun (line 9) | pub struct DryRun {
    method gas_with_tolerance (line 16) | pub fn gas_with_tolerance(&self, tolerance: f32) -> u64 {
  type DryRunner (line 25) | pub trait DryRunner: Send + Sync {
    method dry_run (line 26) | async fn dry_run(&self, tx: FuelTransaction) -> Result<DryRun>;
    method estimate_gas_price (line 27) | async fn estimate_gas_price(&self, block_horizon: u32) -> Result<u64>;
    method consensus_parameters (line 28) | async fn consensus_parameters(&self) -> Result<ConsensusParameters>;
    method estimate_predicates (line 29) | async fn estimate_predicates(
    method dry_run (line 39) | async fn dry_run(&self, tx: FuelTransaction) -> Result<DryRun> {
    method estimate_gas_price (line 43) | async fn estimate_gas_price(&self, block_horizon: u32) -> Result<u64> {
    method consensus_parameters (line 47) | async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
    method estimate_predicates (line 51) | async fn estimate_predicates(

FILE: packages/fuels-core/src/types/errors.rs
  type Reason (line 9) | pub enum Reason {
    method context (line 27) | pub(crate) fn context(self, context: impl std::fmt::Display) -> Self {
  type Error (line 52) | pub enum Error {
    method from (line 66) | fn from(value: std::io::Error) -> Self {
    method context (line 72) | pub(crate) fn context(self, context: impl Display) -> Self {
    method from (line 151) | fn from(err: fuel_vm::checked_transaction::CheckError) -> Error {
    method from (line 157) | fn from(err: fuel_tx::ValidityError) -> Error {
  type Result (line 83) | pub type Result<T> = std::result::Result<T, Error>;
  type Context (line 97) | pub trait Context<T>: Sealed {
    method context (line 98) | fn context<C>(self, context: C) -> Result<T>
    method with_context (line 102) | fn with_context<C, F>(self, f: F) -> Result<T>
  function context (line 112) | fn context<C>(self, context: C) -> Result<T>
  function with_context (line 120) | fn with_context<C, F>(self, context: F) -> Result<T>
  function result_context (line 185) | fn result_context() {
  function result_with_context (line 207) | fn result_with_context() {

FILE: packages/fuels-core/src/types/method_descriptor.rs
  type MethodDescriptor (line 4) | pub struct MethodDescriptor {
    method fn_selector (line 13) | pub const fn fn_selector(&self) -> &'static [u8] {
    method name (line 18) | pub const fn name(&self) -> &'static str {

FILE: packages/fuels-core/src/types/param_types/from_type_application.rs
  method try_from_type_application (line 21) | pub fn try_from_type_application(
  type Type (line 30) | struct Type {
    method try_from (line 45) | pub fn try_from(
    method resolve (line 52) | fn resolve(
    method determine_generics_for_type (line 122) | fn determine_generics_for_type(
  type Error (line 170) | type Error = Error;
  method try_from (line 172) | fn try_from(value: Type) -> Result<Self> {
  type Error (line 178) | type Error = Error;
  method try_from (line 180) | fn try_from(the_type: &Type) -> Result<Self> {
  function convert_into_param_types (line 209) | fn convert_into_param_types(coll: &[Type]) -> Result<Vec<ParamType>> {
  function named_param_types (line 213) | fn named_param_types(coll: &[Type]) -> Result<Vec<NamedParamType>> {
  function try_struct (line 219) | fn try_struct(the_type: &Type) -> Result<Option<ParamType>> {
  function try_vector (line 239) | fn try_vector(the_type: &Type) -> Result<Option<ParamType>> {
  function try_u128 (line 257) | fn try_u128(the_type: &Type) -> Result<Option<ParamType>> {
  function try_bytes (line 263) | fn try_bytes(the_type: &Type) -> Result<Option<ParamType>> {
  function try_std_string (line 269) | fn try_std_string(the_type: &Type) -> Result<Option<ParamType>> {
  function try_raw_slice (line 275) | fn try_raw_slice(the_type: &Type) -> Result<Option<ParamType>> {
  function try_enum (line 279) | fn try_enum(the_type: &Type) -> Result<Option<ParamType>> {
  function try_tuple (line 296) | fn try_tuple(the_type: &Type) -> Result<Option<ParamType>> {
  function param_types (line 307) | fn param_types(coll: &[Type]) -> Result<Vec<ParamType>> {
  function try_str_array (line 311) | fn try_str_array(the_type: &Type) -> Result<Option<ParamType>> {
  function try_str_slice (line 315) | fn try_str_slice(the_type: &Type) -> Result<Option<ParamType>> {
  function try_array (line 323) | fn try_array(the_type: &Type) -> Result<Option<ParamType>> {
  function try_primitive (line 340) | fn try_primitive(the_type: &Type) -> Result<Option<ParamType>> {
  function handles_simple_types (line 362) | fn handles_simple_types() -> Result<()> {
  function handles_arrays (line 402) | fn handles_arrays() -> Result<()> {
  function handles_vectors (line 449) | fn handles_vectors() -> Result<()> {
  function handles_structs (line 554) | fn handles_structs() -> Result<()> {
  function handles_enums (line 619) | fn handles_enums() -> Result<()> {
  function handles_tuples (line 684) | fn handles_tuples() -> Result<()> {
  function ultimate_example (line 747) | fn ultimate_example() -> Result<()> {
  function try_vector_correctly_resolves_param_type (line 1198) | fn try_vector_correctly_resolves_param_type() {
  function try_bytes_correctly_resolves_param_type (line 1207) | fn try_bytes_correctly_resolves_param_type() {
  function try_raw_slice_correctly_resolves_param_type (line 1216) | fn try_raw_slice_correctly_resolves_param_type() {
  function try_std_string_correctly_resolves_param_type (line 1230) | fn try_std_string_correctly_resolves_param_type() {
  function given_type_with_path (line 1238) | fn given_type_with_path(path: &str) -> Type {
  function given_generic_type_with_path (line 1247) | fn given_generic_type_with_path(path: &str) -> Type {

FILE: packages/fuels-core/src/types/param_types/param_type.rs
  type NamedParamType (line 3) | pub type NamedParamType = (String, ParamType);
  type ParamType (line 6) | pub enum ParamType {
  type ReturnLocation (line 36) | pub enum ReturnLocation {
  type EnumVariants (line 42) | pub struct EnumVariants {
    method new (line 47) | pub fn new(variants: Vec<NamedParamType>) -> Result<EnumVariants> {
    method variants (line 55) | pub fn variants(&self) -> &Vec<NamedParamType> {
    method param_types (line 59) | pub fn param_types(&self) -> impl Iterator<Item = &ParamType> {
    method select_variant (line 63) | pub fn select_variant(&self, discriminant: u64) -> Result<&NamedParamT...

FILE: packages/fuels-core/src/types/token.rs
  type EnumSelector (line 9) | pub type EnumSelector = (u64, Token, EnumVariants);
  type StaticStringToken (line 12) | pub struct StaticStringToken {
    method new (line 18) | pub fn new(data: String, expected_len: Option<usize>) -> Self {
    method validate (line 22) | fn validate(&self) -> Result<()> {
    method get_encodable_str (line 41) | pub fn get_encodable_str(&self) -> Result<&str> {
  type Error (line 48) | type Error = Error;
  method try_from (line 49) | fn try_from(string_token: StaticStringToken) -> Result<String> {
  type Token (line 56) | pub enum Token {
    method fmt (line 81) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method default (line 87) | fn default() -> Self {

FILE: packages/fuels-core/src/types/transaction_builders.rs
  constant GAS_ESTIMATION_BLOCK_HORIZON (line 48) | const GAS_ESTIMATION_BLOCK_HORIZON: u32 = DEFAULT_GAS_ESTIMATION_BLOCK_H...
  type UnresolvedWitnessIndexes (line 51) | struct UnresolvedWitnessIndexes {
  type BuildableTransaction (line 56) | pub trait BuildableTransaction: sealed::Sealed {
    method with_build_strategy (line 60) | fn with_build_strategy(self, strategy: Self::Strategy) -> Self;
    method build (line 61) | async fn build(self, provider: impl DryRunner) -> Result<Self::TxType>;
    type TxType (line 96) | type TxType = ScriptTransaction;
    type Strategy (line 97) | type Strategy = ScriptBuildStrategy;
    method with_build_strategy (line 99) | fn with_build_strategy(mut self, strategy: Self::Strategy) -> Self {
    method build (line 104) | async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {
    type TxType (line 113) | type TxType = CreateTransaction;
    type Strategy (line 114) | type Strategy = Strategy;
    method with_build_strategy (line 116) | fn with_build_strategy(mut self, strategy: Self::Strategy) -> Self {
    method build (line 121) | async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {
    type TxType (line 130) | type TxType = UploadTransaction;
    type Strategy (line 131) | type Strategy = Strategy;
    method with_build_strategy (line 133) | fn with_build_strategy(mut self, strategy: Self::Strategy) -> Self {
    method build (line 138) | async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {
    type TxType (line 147) | type TxType = UpgradeTransaction;
    type Strategy (line 148) | type Strategy = Strategy;
    method with_build_strategy (line 150) | fn with_build_strategy(mut self, strategy: Self::Strategy) -> Self {
    method build (line 155) | async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {
  type ScriptBuildStrategy (line 67) | pub enum ScriptBuildStrategy {
  type Strategy (line 83) | pub enum Strategy {
  type TransactionBuilder (line 161) | pub trait TransactionBuilder: BuildableTransaction + Send + sealed::Seal...
    method add_signer (line 164) | fn add_signer(&mut self, signer: impl Signer + Send + Sync + 'static) ...
    method add_signers (line 165) | fn add_signers<'a>(
    method estimate_max_fee (line 169) | async fn estimate_max_fee(&self, provider: impl DryRunner) -> Result<u...
    method enable_burn (line 170) | fn enable_burn(self, enable: bool) -> Self;
    method with_tx_policies (line 171) | fn with_tx_policies(self, tx_policies: TxPolicies) -> Self;
    method with_inputs (line 172) | fn with_inputs(self, inputs: Vec<Input>) -> Self;
    method with_outputs (line 173) | fn with_outputs(self, outputs: Vec<Output>) -> Self;
    method with_witnesses (line 174) | fn with_witnesses(self, witnesses: Vec<Witness>) -> Self;
    method inputs (line 175) | fn inputs(&self) -> &Vec<Input>;
    method inputs_mut (line 176) | fn inputs_mut(&mut self) -> &mut Vec<Input>;
    method outputs (line 177) | fn outputs(&self) -> &Vec<Output>;
    method outputs_mut (line 178) | fn outputs_mut(&mut self) -> &mut Vec<Output>;
    method witnesses (line 179) | fn witnesses(&self) -> &Vec<Witness>;
    method witnesses_mut (line 180) | fn witnesses_mut(&mut self) -> &mut Vec<Witness>;
    method with_estimation_horizon (line 181) | fn with_estimation_horizon(self, block_horizon: u32) -> Self;
  function estimate_max_fee_w_tolerance (line 467) | pub(crate) fn estimate_max_fee_w_tolerance<T: Chargeable>(
  method fmt (line 490) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  type VariableOutputPolicy (line 511) | pub enum VariableOutputPolicy {
  method default (line 520) | fn default() -> Self {
  type ScriptTransactionBuilder (line 526) | pub struct ScriptTransactionBuilder {
    method build (line 691) | async fn build(mut self, provider: impl DryRunner) -> Result<ScriptTra...
    method resolve_fuel_tx (line 716) | async fn resolve_fuel_tx(self, dry_runner: impl DryRunner) -> Result<S...
    method resolve_fuel_tx_for_state_reading (line 759) | async fn resolve_fuel_tx_for_state_reading(self, dry_runner: impl DryR...
    method set_witnesses (line 805) | async fn set_witnesses(self, tx: &mut fuel_tx::Script, provider: impl ...
    method set_script_gas_limit (line 815) | async fn set_script_gas_limit(
    method script_tx_estimator (line 846) | fn script_tx_estimator<D>(
    method add_variable_outputs (line 858) | async fn add_variable_outputs(
    method with_variable_output_policy (line 874) | pub fn with_variable_output_policy(mut self, variable_outputs: Variabl...
    method with_script (line 879) | pub fn with_script(mut self, script: Vec<u8>) -> Self {
    method with_script_data (line 884) | pub fn with_script_data(mut self, script_data: Vec<u8>) -> Self {
    method with_gas_estimation_tolerance (line 889) | pub fn with_gas_estimation_tolerance(mut self, tolerance: f32) -> Self {
    method with_max_fee_estimation_tolerance (line 894) | pub fn with_max_fee_estimation_tolerance(mut self, max_fee_estimation_...
    method prepare_transfer (line 899) | pub fn prepare_transfer(
    method prepare_contract_transfer (line 911) | pub fn prepare_contract_transfer(
    method prepare_message_to_output (line 954) | pub fn prepare_message_to_output(
  method default (line 544) | fn default() -> Self {
  type CreateTransactionBuilder (line 565) | pub struct CreateTransactionBuilder {
    method build (line 1004) | pub async fn build(mut self, provider: impl DryRunner) -> Result<Creat...
    method resolve_fuel_tx (line 1025) | async fn resolve_fuel_tx(self, provider: impl DryRunner) -> Result<Cre...
    method with_bytecode_length (line 1061) | pub fn with_bytecode_length(mut self, bytecode_length: u64) -> Self {
    method with_bytecode_witness_index (line 1066) | pub fn with_bytecode_witness_index(mut self, bytecode_witness_index: u...
    method with_storage_slots (line 1071) | pub fn with_storage_slots(mut self, mut storage_slots: Vec<StorageSlot...
    method with_salt (line 1079) | pub fn with_salt(mut self, salt: impl Into<Salt>) -> Self {
    method with_max_fee_estimation_tolerance (line 1084) | pub fn with_max_fee_estimation_tolerance(mut self, max_fee_estimation_...
    method prepare_contract_deployment (line 1089) | pub fn prepare_contract_deployment(
  method default (line 583) | fn default() -> Self {
  type UploadTransactionBuilder (line 604) | pub struct UploadTransactionBuilder {
    method build (line 1112) | pub async fn build(mut self, provider: impl DryRunner) -> Result<Uploa...
    method resolve_fuel_tx (line 1133) | async fn resolve_fuel_tx(self, provider: impl DryRunner) -> Result<Upl...
    method with_root (line 1173) | pub fn with_root(mut self, root: Bytes32) -> Self {
    method with_witness_index (line 1178) | pub fn with_witness_index(mut self, witness_index: u16) -> Self {
    method with_subsection_index (line 1183) | pub fn with_subsection_index(mut self, subsection_index: u16) -> Self {
    method with_subsections_number (line 1188) | pub fn with_subsections_number(mut self, subsections_number: u16) -> S...
    method with_proof_set (line 1193) | pub fn with_proof_set(mut self, proof_set: Vec<Bytes32>) -> Self {
    method with_max_fee_estimation_tolerance (line 1198) | pub fn with_max_fee_estimation_tolerance(mut self, max_fee_estimation_...
    method prepare_subsection_upload (line 1203) | pub fn prepare_subsection_upload(
  method default (line 628) | fn default() -> Self {
  type UpgradeTransactionBuilder (line 650) | pub struct UpgradeTransactionBuilder {
    method build (line 1231) | pub async fn build(mut self, provider: impl DryRunner) -> Result<Upgra...
    method resolve_fuel_tx (line 1250) | async fn resolve_fuel_tx(self, provider: impl DryRunner) -> Result<Upg...
    method with_purpose (line 1284) | pub fn with_purpose(mut self, upgrade_purpose: UpgradePurpose) -> Self {
    method with_max_fee_estimation_tolerance (line 1289) | pub fn with_max_fee_estimation_tolerance(mut self, max_fee_estimation_...
    method prepare_state_transition_upgrade (line 1294) | pub fn prepare_state_transition_upgrade(root: Bytes32, tx_policies: Tx...
    method prepare_consensus_parameters_upgrade (line 1300) | pub fn prepare_consensus_parameters_upgrade(
  method default (line 666) | fn default() -> Self {
  function add_variable_outputs (line 992) | fn add_variable_outputs(tx: &mut fuel_tx::Script, variable_outputs: usiz...
  function resolve_fuel_inputs (line 1324) | fn resolve_fuel_inputs(
  function resolve_signed_resource (line 1357) | fn resolve_signed_resource(
  function resolve_predicate_resource (line 1398) | fn resolve_predicate_resource(
  function create_coin_input (line 1413) | pub fn create_coin_input(coin: Coin, witness_index: u16) -> FuelInput {
  function create_coin_message_input (line 1424) | pub fn create_coin_message_input(message: Message, witness_index: u16) -...
  function create_coin_predicate (line 1445) | pub fn create_coin_predicate(
  function create_coin_message_predicate (line 1463) | pub fn create_coin_message_predicate(
  function generate_missing_witnesses (line 1492) | async fn generate_missing_witnesses(
  function storage_slots_are_sorted_when_set (line 1518) | fn storage_slots_are_sorted_when_set() {
  function given_a_storage_slot (line 1528) | fn given_a_storage_slot(key: u8) -> StorageSlot {
  function create_message_coin_signed_if_data_is_empty (line 1536) | fn create_message_coin_signed_if_data_is_empty() {
  function create_message_data_signed_if_data_is_not_empty (line 1544) | fn create_message_data_signed_if_data_is_not_empty() {
  function create_message_coin_predicate_if_data_is_empty (line 1552) | fn create_message_coin_predicate_if_data_is_empty() {
  function create_message_data_predicate_if_data_is_not_empty (line 1560) | fn create_message_data_predicate_if_data_is_not_empty() {
  function given_a_message (line 1567) | fn given_a_message(data: Vec<u8>) -> Message {
  function given_a_coin (line 1579) | fn given_a_coin(tx_id: [u8; 32], owner: [u8; 32], amount: u64) -> Coin {
  function given_inputs (line 1588) | fn given_inputs(num_inputs: u8) -> Vec<Input> {
  function given_witnesses (line 1597) | fn given_witnesses(num_witnesses: usize) -> Vec<Witness> {
  type MockDryRunner (line 1601) | struct MockDryRunner {
  method default (line 1606) | fn default() -> Self {
  method dry_run (line 1616) | async fn dry_run(&self, _: FuelTransaction) -> Result<DryRun> {
  method consensus_parameters (line 1624) | async fn consensus_parameters(&self) -> Result<ConsensusParameters> {
  method estimate_gas_price (line 1628) | async fn estimate_gas_price(&self, _block_horizon: u32) -> Result<u64> {
  method estimate_predicates (line 1632) | async fn estimate_predicates(
  function create_tx_builder_witness_indexes_set_correctly (line 1642) | async fn create_tx_builder_witness_indexes_set_correctly() -> Result<()> {
  function script_tx_builder_witness_indexes_set_correctly (line 1679) | async fn script_tx_builder_witness_indexes_set_correctly() -> Result<()> {
  function build_w_enable_burn (line 1716) | async fn build_w_enable_burn() -> Result<()> {
  function build_w_enable_burn_predicates (line 1722) | async fn build_w_enable_burn_predicates() -> Result<()> {
  function build_w_enable_burn_messages (line 1734) | async fn build_w_enable_burn_messages() -> Result<()> {
  function build_w_enable_burn_predicates_message (line 1741) | async fn build_w_enable_burn_predicates_message() -> Result<()> {
  function test_enable_burn (line 1752) | async fn test_enable_burn(input: Input) -> Result<()> {
  type MockSigner (line 1775) | struct MockSigner {
  method sign (line 1783) | async fn sign(&self, _message: fuel_crypto::Message) -> Result<Signature> {
  method address (line 1786) | fn address(&self) -> Address {
  function add_signer_called_multiple_times (line 1793) | async fn add_signer_called_multiple_times() {

FILE: packages/fuels-core/src/types/transaction_builders/blob.rs
  type Blob (line 31) | pub struct Blob {
    method from (line 38) | fn from(data: Vec<u8>) -> Self {
    method as_ref (line 44) | fn as_ref(&self) -> &[u8] {
    method new (line 50) | pub fn new(data: Vec<u8>) -> Self {
    method len (line 54) | pub fn len(&self) -> usize {
    method is_empty (line 58) | pub fn is_empty(&self) -> bool {
    method id (line 62) | pub fn id(&self) -> BlobId {
    method bytes (line 66) | pub fn bytes(&self) -> &[u8] {
    method as_blob_body (line 70) | fn as_blob_body(&self, witness_index: u16) -> fuel_tx::BlobBody {
  type BlobId (line 35) | pub type BlobId = [u8; 32];
  function from (line 79) | fn from(value: Blob) -> Self {
  function from (line 85) | fn from(blob: Blob) -> Self {
  type BlobTransactionBuilder (line 91) | pub struct BlobTransactionBuilder {
    method estimate_max_blob_size (line 127) | pub async fn estimate_max_blob_size(&self, provider: &impl DryRunner) ...
    method build (line 149) | pub async fn build(mut self, provider: impl DryRunner) -> Result<BlobT...
    method resolve_fuel_tx (line 170) | async fn resolve_fuel_tx(mut self, provider: &impl DryRunner) -> Resul...
    method with_blob (line 211) | pub fn with_blob(mut self, blob: Blob) -> Self {
    method with_max_fee_estimation_tolerance (line 216) | pub fn with_max_fee_estimation_tolerance(mut self, max_fee_estimation_...
  method default (line 106) | fn default() -> Self {
  type TxType (line 226) | type TxType = BlobTransaction;
  type Strategy (line 227) | type Strategy = Strategy;
  method with_build_strategy (line 229) | fn with_build_strategy(mut self, strategy: Self::Strategy) -> Self {
  method build (line 234) | async fn build(self, provider: impl DryRunner) -> Result<Self::TxType> {

FILE: packages/fuels-core/src/types/transaction_builders/script_tx_estimator.rs
  type ScriptTxEstimator (line 16) | pub(crate) struct ScriptTxEstimator<R> {
  function new (line 24) | pub fn new(
  function run (line 39) | pub async fn run(
  function prepare_for_estimation (line 50) | pub async fn prepare_for_estimation(
  function last_dry_run (line 66) | pub fn last_dry_run(&self) -> Option<DryRun> {
  function _run (line 70) | async fn _run(&mut self, tx: fuel_tx::Script) -> Result<DryRun> {
  function set_script_gas_limit_to_max (line 77) | fn set_script_gas_limit_to_max(
  function saturate_with_variable_outputs (line 86) | fn saturate_with_variable_outputs(
  function add_fake_witnesses (line 103) | fn add_fake_witnesses(&self, tx: &mut fuel_tx::Script) {
  function add_fake_coins (line 110) | fn add_fake_coins(&self, tx: &mut fuel_tx::Script, consensus_params: &Co...
  function needs_fake_base_input (line 122) | fn needs_fake_base_input(

FILE: packages/fuels-core/src/types/tx_response.rs
  type TxResponse (line 6) | pub struct TxResponse {

FILE: packages/fuels-core/src/types/tx_status.rs
  type Success (line 24) | pub struct Success {
  type SqueezedOut (line 31) | pub struct SqueezedOut {
  type Failure (line 36) | pub struct Failure {
  type TxStatus (line 45) | pub enum TxStatus {
    method check (line 55) | pub fn check(&self, log_decoder: Option<&LogDecoder>) -> Result<()> {
    method take_success_checked (line 75) | pub fn take_success_checked(self, log_decoder: Option<&LogDecoder>) ->...
    method total_gas (line 104) | pub fn total_gas(&self) -> u64 {
    method total_fee (line 112) | pub fn total_fee(&self) -> u64 {
    method map_revert_error (line 120) | fn map_revert_error(
    method take_receipts_checked (line 195) | pub fn take_receipts_checked(
    method take_receipts (line 203) | pub fn take_receipts(self) -> Arc<Vec<Receipt>> {
    method is_final (line 211) | pub fn is_final(&self) -> bool {
    method from (line 221) | fn from(client_status: ClientTransactionStatus) -> Self {
    method from (line 287) | fn from(value: TransactionExecutionStatus) -> Self {

FILE: packages/fuels-core/src/types/wrappers/block.rs
  type Header (line 10) | pub struct Header {
    method from (line 27) | fn from(client_header: ClientHeader) -> Self {
  type Block (line 49) | pub struct Block {
    method from (line 56) | fn from(client_block: ClientBlock) -> Self {

FILE: packages/fuels-core/src/types/wrappers/chain_info.rs
  type ChainInfo (line 9) | pub struct ChainInfo {
    method from (line 17) | fn from(client_chain_info: ClientChainInfo) -> Self {

FILE: packages/fuels-core/src/types/wrappers/coin.rs
  type Coin (line 12) | pub struct Coin {
    method from (line 20) | fn from(coin: ClientCoin) -> Self {
  method from (line 31) | fn from(coin: Coin) -> CoinConfig {

FILE: packages/fuels-core/src/types/wrappers/coin_type.rs
  type CoinType (line 8) | pub enum CoinType {
    method from (line 15) | fn from(client_resource: ClientCoinType) -> Self {
    method id (line 25) | pub fn id(&self) -> Option<CoinTypeId> {
    method amount (line 33) | pub fn amount(&self) -> u64 {
    method coin_asset_id (line 41) | pub fn coin_asset_id(&self) -> Option<AssetId> {
    method asset_id (line 49) | pub fn asset_id(&self, base_asset_id: AssetId) -> Option<AssetId> {
    method owner (line 57) | pub fn owner(&self) -> Option<&Address> {

FILE: packages/fuels-core/src/types/wrappers/coin_type_id.rs
  type CoinTypeId (line 5) | pub enum CoinTypeId {

FILE: packages/fuels-core/src/types/wrappers/input.rs
  type Input (line 11) | pub enum Input {
    method resource_signed (line 30) | pub const fn resource_signed(resource: CoinType) -> Self {
    method resource_predicate (line 34) | pub const fn resource_predicate(resource: CoinType, code: Vec<u8>, dat...
    method amount (line 42) | pub fn amount(&self) -> Option<u64> {
    method contains_data (line 51) | pub fn contains_data(&self) -> bool {
    method contract (line 65) | pub const fn contract(

FILE: packages/fuels-core/src/types/wrappers/message.rs
  type MessageStatus (line 10) | pub enum MessageStatus {
  type Message (line 17) | pub struct Message {
    method message_id (line 28) | pub fn message_id(&self) -> MessageId {
    method from (line 40) | fn from(message: ClientMessage) -> Self {
    method from (line 54) | fn from(message: ClientMessageCoin) -> Self {
  method from (line 68) | fn from(message: Message) -> MessageConfig {

FILE: packages/fuels-core/src/types/wrappers/message_proof.rs
  type MerkleProof (line 10) | pub struct MerkleProof {
    method from (line 18) | fn from(client_merkle_proof: ClientMerkleProof) -> Self {
  type MessageProof (line 27) | pub struct MessageProof {
    method from (line 46) | fn from(client_message_proof: ClientMessageProof) -> Self {

FILE: packages/fuels-core/src/types/wrappers/node_info.rs
  type NodeInfo (line 6) | pub struct NodeInfo {
    method from (line 15) | fn from(client_node_info: ClientNodeInfo) -> Self {

FILE: packages/fuels-core/src/types/wrappers/transaction.rs
  type Transactions (line 34) | pub struct Transactions {
    method new (line 39) | pub fn new() -> Self {
    method insert (line 43) | pub fn insert(mut self, tx: impl Into<FuelTransaction>) -> Self {
    method as_slice (line 49) | pub fn as_slice(&self) -> &[FuelTransaction] {
  type MintTransaction (line 55) | pub struct MintTransaction {
    method from (line 72) | fn from(tx: Mint) -> Self {
    method check_without_signatures (line 78) | pub fn check_without_signatures(
    method id (line 88) | pub fn id(&self, chain_id: ChainId) -> Bytes32 {
    method mint_asset_id (line 93) | pub fn mint_asset_id(&self) -> &AssetId {
    method mint_amount (line 98) | pub fn mint_amount(&self) -> u64 {
  method from (line 60) | fn from(mint: MintTransaction) -> Self {
  method from (line 66) | fn from(tx: MintTransaction) -> Self {
  type TxPolicies (line 105) | pub struct TxPolicies {
    method new (line 117) | pub fn new(
    method with_tip (line 137) | pub fn with_tip(mut self, tip: u64) -> Self {
    method tip (line 142) | pub fn tip(&self) -> Option<u64> {
    method with_witness_limit (line 146) | pub fn with_witness_limit(mut self, witness_limit: u64) -> Self {
    method witness_limit (line 151) | pub fn witness_limit(&self) -> Option<u64> {
    method with_maturity (line 155) | pub fn with_maturity(mut self, maturity: u64) -> Self {
    method maturity (line 160) | pub fn maturity(&self) -> Option<u64> {
    method with_expiration (line 164) | pub fn with_expiration(mut self, expiration: u64) -> Self {
    method expiration (line 169) | pub fn expiration(&self) -> Option<u64> {
    method with_max_fee (line 173) | pub fn with_max_fee(mut self, max_fee: u64) -> Self {
    method max_fee (line 178) | pub fn max_fee(&self) -> Option<u64> {
    method with_script_gas_limit (line 182) | pub fn with_script_gas_limit(mut self, script_gas_limit: u64) -> Self {
    method script_gas_limit (line 187) | pub fn script_gas_limit(&self) -> Option<u64> {
    method with_owner (line 191) | pub fn with_owner(mut self, owner: u64) -> Self {
    method owner (line 196) | pub fn owner(&self) -> Option<u64> {
  type TransactionType (line 206) | pub enum TransactionType {
  type EstimablePredicates (line 218) | pub trait EstimablePredicates: sealed::Sealed {
    method estimate_predicates (line 222) | async fn estimate_predicates(
    method estimate_predicates (line 567) | async fn estimate_predicates(
    method estimate_predicates (line 585) | async fn estimate_predicates(
    method estimate_predicates (line 605) | async fn estimate_predicates(
    method estimate_predicates (line 637) | async fn estimate_predicates(
    method estimate_predicates (line 655) | async fn estimate_predicates(
  type ValidatablePredicates (line 229) | pub trait ValidatablePredicates: sealed::Sealed {
    method validate_predicates (line 232) | fn validate_predicates(
  type Transaction (line 241) | pub trait Transaction:
    method fee_checked_from_tx (line 250) | fn fee_checked_from_tx(
    method max_gas (line 256) | fn max_gas(&self, consensus_parameters: &ConsensusParameters) -> u64;
    method check (line 261) | fn check(&self, block_height: u32, consensus_parameters: &ConsensusPar...
    method id (line 263) | fn id(&self, chain_id: ChainId) -> Bytes32;
    method maturity (line 265) | fn maturity(&self) -> Option<u64>;
    method expiration (line 267) | fn expiration(&self) -> Option<u64>;
    method owner (line 269) | fn owner(&self) -> Option<u64>;
    method metered_bytes_size (line 271) | fn metered_bytes_size(&self) -> usize;
    method inputs (line 273) | fn inputs(&self) -> &Vec<Input>;
    method outputs (line 275) | fn outputs(&self) -> &Vec<Output>;
    method witnesses (line 277) | fn witnesses(&self) -> &Vec<Witness>;
    method max_fee (line 279) | fn max_fee(&self) -> Option<u64>;
    method size (line 281) | fn size(&self) -> usize;
    method witness_limit (line 283) | fn witness_limit(&self) -> Option<u64>;
    method tip (line 285) | fn tip(&self) -> Option<u64>;
    method is_using_predicates (line 287) | fn is_using_predicates(&self) -> bool;
    method precompute (line 291) | fn precompute(&mut self, chain_id: &ChainId) -> Result<()>;
    method append_witness (line 294) | fn append_witness(&mut self, witness: Witness) -> Result<usize>;
    method used_coins (line 296) | fn used_coins(&self, base_asset_id: &AssetId) -> HashMap<(Address, Ass...
    method sign_with (line 298) | async fn sign_with(
  type Error (line 306) | type Error = Error;
  method try_from (line 307) | fn try_from(value: TransactionType) -> Result<Self> {
  function extract_coin_type_id (line 320) | fn extract_coin_type_id(input: &Input) -> Option<CoinTypeId> {
  function extract_owner_or_recipient (line 330) | pub fn extract_owner_or_recipient(input: &Input) -> Option<Address> {
  method salt (line 621) | pub fn salt(&self) -> &FuelSalt {
  method bytecode_witness_index (line 625) | pub fn bytecode_witness_index(&self) -> u16 {
  method storage_slots (line 629) | pub fn storage_slots(&self) -> &Vec<StorageSlot> {
  method script (line 671) | pub fn script(&self) -> &Vec<u8> {
  method script_data (line 675) | pub fn script_data(&self) -> &Vec<u8> {
  method gas_limit (line 679) | pub fn gas_limit(&self) -> u64 {
  method with_gas_limit (line 683) | pub fn with_gas_limit(mut self, gas_limit: u64) -> Self {
  function append_witnesses_returns_error_when_limit_exceeded (line 697) | fn append_witnesses_returns_error_when_limit_exceeded() {

FILE: packages/fuels-core/src/types/wrappers/transaction_response.rs
  type TransactionResponse (line 14) | pub struct TransactionResponse {
    method from (line 22) | fn from(client_response: ClientTransactionResponse) -> Self {

FILE: packages/fuels-core/src/utils.rs
  function checked_round_up_to_word_alignment (line 9) | pub fn checked_round_up_to_word_alignment(bytes_len: usize) -> Result<us...
  function calculate_witnesses_size (line 29) | pub(crate) fn calculate_witnesses_size<'a, I: IntoIterator<Item = &'a Wi...
  type Sealed (line 39) | pub trait Sealed {}
  function to_named (line 43) | pub(crate) fn to_named<'a, I: IntoIterator<Item = &'a crate::types::para...

FILE: packages/fuels-core/src/utils/constants.rs
  constant ENUM_DISCRIMINANT_BYTE_WIDTH (line 3) | pub const ENUM_DISCRIMINANT_BYTE_WIDTH: usize = 8;
  constant WORD_SIZE (line 4) | pub const WORD_SIZE: usize = core::mem::size_of::<Word>();
  constant DEFAULT_CALL_PARAMS_AMOUNT (line 7) | pub const DEFAULT_CALL_PARAMS_AMOUNT: u64 = 0;
  constant DEFAULT_GAS_ESTIMATION_TOLERANCE (line 10) | pub const DEFAULT_GAS_ESTIMATION_TOLERANCE: f64 = 0.2;
  constant DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON (line 11) | pub const DEFAULT_GAS_ESTIMATION_BLOCK_HORIZON: u32 = 5;
  constant WITNESS_STATIC_SIZE (line 14) | pub const WITNESS_STATIC_SIZE: usize = 8;
  constant SIGNATURE_SIZE (line 15) | const SIGNATURE_SIZE: usize = 64;
  constant SIGNATURE_WITNESS_SIZE (line 16) | pub const SIGNATURE_WITNESS_SIZE: usize = WITNESS_STATIC_SIZE + SIGNATUR...

FILE: packages/fuels-core/src/utils/offsets.rs
  function base_offset_script (line 9) | pub fn base_offset_script(consensus_parameters: &ConsensusParameters) ->...
  function call_script_data_offset (line 15) | pub fn call_script_data_offset(

FILE: packages/fuels-macros/src/abigen/parsing.rs
  function from (line 10) | fn from(targets: MacroAbigenTargets) -> Self {
  method from (line 16) | fn from(macro_target: MacroAbigenTarget) -> Self {
  type MacroAbigenTarget (line 28) | pub(crate) struct MacroAbigenTarget {
    method new (line 50) | pub fn new(command: Command) -> Result<Self> {
    method parse_inline_or_load_abi (line 67) | fn parse_inline_or_load_abi(abi_lit_str: &LitStr) -> Result<Abi> {
  type MacroAbigenTargets (line 34) | pub(crate) struct MacroAbigenTargets {
  method parse (line 39) | fn parse(input: ParseStream) -> Result<Self> {

FILE: packages/fuels-macros/src/derive/parameterize.rs
  function generate_parameterize_impl (line 10) | pub fn generate_parameterize_impl(input: DeriveInput) -> Result<TokenStr...
  function parameterize_for_struct (line 38) | fn parameterize_for_struct(
  function parameterize_generic_params (line 68) | fn parameterize_generic_params(
  function parameterize_for_enum (line 83) | fn parameterize_for_enum(

FILE: packages/fuels-macros/src/derive/tokenizable.rs
  function generate_tokenizable_impl (line 14) | pub fn generate_tokenizable_impl(input: DeriveInput) -> Result<TokenStre...
  function tokenizable_for_struct (line 42) | fn tokenizable_for_struct(
  function tokenizable_for_enum (line 106) | fn tokenizable_for_enum(

FILE: packages/fuels-macros/src/derive/try_from.rs
  function generate_try_from_impl (line 7) | pub fn generate_try_from_impl(input: DeriveInput) -> Result<TokenStream> {
  function impl_try_from (line 25) | fn impl_try_from(

FILE: packages/fuels-macros/src/derive/utils.rs
  function get_path_from_attr_or (line 8) | pub(crate) fn get_path_from_attr_or(
  function find_attr (line 40) | pub(crate) fn find_attr<'a>(name: &str, attrs: &'a [Attribute]) -> Optio...
  type VariantInfo (line 49) | pub(crate) struct VariantInfo {
  type ExtractedVariant (line 54) | pub(crate) enum ExtractedVariant {
  function extract_variants (line 64) | pub(crate) fn extract_variants(
  type ExtractedVariants (line 104) | pub(crate) struct ExtractedVariants {
    method variant_into_discriminant_and_token (line 110) | pub(crate) fn variant_into_discriminant_and_token(&self) -> TokenStream {
    method variant_from_discriminant_and_token (line 141) | pub(crate) fn variant_from_discriminant_and_token(&self, no_std: bool)...
  function validate_variant_type (line 173) | fn validate_variant_type(variant: &Variant) -> Result<()> {
  function std_lib_path (line 197) | pub(crate) fn std_lib_path(no_std: bool) -> TokenStream {

FILE: packages/fuels-macros/src/lib.rs
  function abigen (line 36) | pub fn abigen(input: TokenStream) -> TokenStream {
  function wasm_abigen (line 45) | pub fn wasm_abigen(input: TokenStream) -> TokenStream {
  function setup_program_test (line 57) | pub fn setup_program_test(input: TokenStream) -> TokenStream {
  function parameterize (line 66) | pub fn parameterize(stream: TokenStream) -> TokenStream {
  function tokenizable (line 75) | pub fn tokenizable(stream: TokenStream) -> TokenStream {
  function try_from (line 84) | pub fn try_from(stream: TokenStream) -> TokenStream {

FILE: packages/fuels-macros/src/parse_utils.rs
  type ErrorsExt (line 15) | pub(crate) trait ErrorsExt: Iterator<Item = Error> + Sized {
    method combine_errors (line 16) | fn combine_errors(self) -> Option<Self::Item>;
    method validate_no_errors (line 17) | fn validate_no_errors(self) -> Result<(), Self::Item>;
    method combine_errors (line 24) | fn combine_errors(self) -> Option<Self::Item> {
    method validate_no_errors (line 31) | fn validate_no_errors(self) -> Result<(), Self::Item> {
  function generate_duplicate_error (line 40) | fn generate_duplicate_error<T>(duplicates: &[&T]) -> Error
  function group_up_duplicates (line 57) | fn group_up_duplicates<T, K, KeyFn>(name_values: &[T], key: KeyFn) -> Ve...
  function validate_no_duplicates (line 75) | fn validate_no_duplicates<T, K, KeyFn>(elements: &[T], key_fn: KeyFn) ->...
  function validate_and_extract_generic_types (line 87) | pub fn validate_and_extract_generic_types(generics: &Generics) -> syn::R...
  type Member (line 104) | enum Member {
  type Members (line 109) | pub(crate) struct Members {
    method from_struct (line 115) | pub(crate) fn from_struct(
    method from_enum (line 151) | pub(crate) fn from_enum(data: DataEnum, fuels_core_path: TokenStream) ...
    method names (line 191) | pub(crate) fn names(&self) -> impl Iterator<Item = &Ident> + '_ {
    method names_as_strings (line 201) | pub(crate) fn names_as_strings(&self) -> impl Iterator<Item = TokenStr...
    method ignored_names (line 208) | pub(crate) fn ignored_names(&self) -> impl Iterator<Item = &Ident> + '_ {
    method param_type_calls (line 218) | pub(crate) fn param_type_calls(&self) -> impl Iterator<Item = TokenStr...
  function has_ignore_attr (line 229) | pub(crate) fn has_ignore_attr(attrs: &[Attribute]) -> bool {

FILE: packages/fuels-macros/src/parse_utils/command.rs
  type Command (line 11) | pub struct Command {
    method parse_multiple (line 17) | pub fn parse_multiple(input: ParseStream) -> syn::Result<Vec<Command>> {
    method new (line 25) | pub fn new(meta: Meta) -> syn::Result<Self> {
    method parse_nested_metas (line 46) | pub fn parse_nested_metas(self) -> syn::Result<Punctuated<Meta, Comma>> {
    method parse_multiple_from_token_stream (line 51) | pub(crate) fn parse_multiple_from_token_stream(
    method parse_single_from_token_stream (line 58) | pub(crate) fn parse_single_from_token_stream(
  function command_name_is_properly_extracted (line 73) | fn command_name_is_properly_extracted() -> syn::Result<()> {

FILE: packages/fuels-macros/src/parse_utils/unique_lit_strs.rs
  type UniqueLitStrs (line 9) | pub struct UniqueLitStrs {
    method new (line 15) | pub fn new(tokens: TokenStream) -> Result<Self> {
    method iter (line 26) | pub fn iter(&self) -> impl Iterator<Item = &LitStr> {
    method span (line 31) | pub fn span(&self) -> Span {
  type Item (line 37) | type Item = LitStr;
  type IntoIter (line 38) | type IntoIter = IntoIter<Self::Item>;
  method into_iter (line 40) | fn into_iter(self) -> Self::IntoIter {
  function correctly_reads_lit_strs (line 54) | fn correctly_reads_lit_strs() -> Result<()> {
  function doesnt_allow_duplicates (line 73) | fn doesnt_allow_duplicates() {
  function only_strings_allowed (line 86) | fn only_strings_allowed() {
  function parse_unique_lit_strs (line 94) | fn parse_unique_lit_strs(stream: TokenStream) -> Result<UniqueLitStrs> {

FILE: packages/fuels-macros/src/parse_utils/unique_name_values.rs
  type UniqueNameValues (line 14) | pub struct UniqueNameValues {
    method new (line 20) | pub fn new(tokens: TokenStream) -> syn::Result<Self> {
    method try_get (line 36) | pub fn try_get(&self, name: &str) -> Option<&Lit> {
    method validate_has_no_other_names (line 40) | pub fn validate_has_no_other_names(&self, allowed_names: &[&str]) -> s...
    method get_as_lit_str (line 58) | pub fn get_as_lit_str(&self, name: &str) -> syn::Result<&LitStr> {
    method extract_name_values (line 73) | fn extract_name_values<T: Iterator<Item = MetaNameValue>>(
  function name_values_correctly_parsed (line 110) | fn name_values_correctly_parsed() -> syn::Result<()> {
  function duplicates_cause_errors (line 134) | fn duplicates_cause_errors() {
  function attr_names_cannot_be_paths (line 147) | fn attr_names_cannot_be_paths() {
  function only_name_value_is_accepted (line 159) | fn only_name_value_is_accepted() {
  function validates_correct_names (line 168) | fn validates_correct_names() -> syn::Result<()> {
  function catches_incorrect_names (line 180) | fn catches_incorrect_names() -> syn::Result<()> {
  function can_get_lit_strs (line 197) | fn can_get_lit_strs() -> syn::Result<()> {
  function cannot_get_lit_str_if_type_is_wrong (line 208) | fn cannot_get_lit_str_if_type_is_wrong() -> syn::Result<()> {
  function lit_str_getter_complains_value_is_missing (line 224) | fn lit_str_getter_complains_value_is_missing() -> syn::Result<()> {
  function extract_name_values (line 236) | fn extract_name_values(stream: TokenStream) -> syn::Result<UniqueNameVal...

FILE: packages/fuels-macros/src/setup_program_test/code_gen.rs
  function generate_setup_program_test_code (line 16) | pub(crate) fn generate_setup_program_test_code(
  function generate_project_lookup (line 42) | fn generate_project_lookup(
  function abigen_code (line 58) | fn abigen_code(project_lookup: &HashMap<String, Project>) -> syn::Result...
  function parse_abigen_targets (line 64) | fn parse_abigen_targets(
  function wallet_initialization_code (line 82) | fn wallet_initialization_code(maybe_command: Option<InitializeWalletComm...
  function extract_wallet_names (line 109) | fn extract_wallet_names(command: &InitializeWalletCommand) -> Vec<Ident> {
  function contract_deploying_code (line 117) | fn contract_deploying_code(
  function script_loading_code (line 175) | fn script_loading_code(
  type Project (line 202) | struct Project {
    method new (line 210) | fn new(program_type: ProgramType, dir: &LitStr, profile: BuildProfile)...
    method compile_file_path (line 226) | fn compile_file_path(&self, suffix: &str, description: &str) -> String {
    method project_name (line 241) | fn project_name(&self) -> &str {
    method abi_path (line 249) | fn abi_path(&self) -> String {
    method bin_path (line 253) | fn bin_path(&self) -> String {

FILE: packages/fuels-macros/src/setup_program_test/parsing/commands.rs
  type TestProgramCommands (line 29) | pub(crate) struct TestProgramCommands {
  method parse (line 46) | fn parse(input: ParseStream) -> Result<Self> {

FILE: packages/fuels-macros/src/setup_program_test/parsing/commands/abigen.rs
  type TargetInfo (line 10) | pub(crate) struct TargetInfo {
    type Error (line 17) | type Error = Error;
    method try_from (line 19) | fn try_from(command: Command) -> Result<Self, Self::Error> {
  type AbigenCommand (line 37) | pub(crate) struct AbigenCommand {
    type Error (line 43) | type Error = Error;
    method try_from (line 45) | fn try_from(command: Command) -> Result<Self, Self::Error> {

FILE: packages/fuels-macros/src/setup_program_test/parsing/commands/deploy_contract.rs
  type DeployContractCommand (line 8) | pub struct DeployContractCommand {
    type Error (line 16) | type Error = Error;
    method try_from (line 18) | fn try_from(command: Command) -> Result<Self, Self::Error> {

FILE: packages/fuels-macros/src/setup_program_test/parsing/commands/initialize_wallet.rs
  type InitializeWalletCommand (line 9) | pub struct InitializeWalletCommand {
    type Error (line 15) | type Error = Error;
    method try_from (line 17) | fn try_from(command: Command) -> Result<Self, Self::Error> {

FILE: packages/fuels-macros/src/setup_program_test/parsing/commands/load_script.rs
  type LoadScriptCommand (line 8) | pub struct LoadScriptCommand {
    type Error (line 15) | type Error = Error;
    method try_from (line 17) | fn try_from(command: Command) -> Result<Self, Self::Error> {

FILE: packages/fuels-macros/src/setup_program_test/parsing/commands/set_options.rs
  type BuildProfile (line 8) | pub enum BuildProfile {
    method fmt (line 27) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Err (line 15) | type Err = &'static str;
  method from_str (line 17) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type SetOptionsCommand (line 40) | pub struct SetOptionsCommand {
    type Error (line 45) | type Error = Error;
    method try_from (line 47) | fn try_from(command: Command) -> Result<Self, Self::Error> {

FILE: packages/fuels-macros/src/setup_program_test/parsing/validations.rs
  function extract_the_abigen_command (line 14) | pub(crate) fn extract_the_abigen_command(
  function validate_all_contracts_are_known (line 32) | pub(crate) fn validate_all_contracts_are_known(
  function validate_all_scripts_are_known (line 56) | pub(crate) fn validate_all_scripts_are_known(
  function validate_zero_or_one_wallet_command_present (line 80) | pub(crate) fn validate_zero_or_one_wallet_command_present(
  function names_of_program_bindings (line 95) | fn names_of_program_bindings(
  function extract_contracts_to_deploy (line 106) | fn extract_contracts_to_deploy(commands: &[DeployContractCommand]) -> Ha...
  function extract_scripts_to_load (line 110) | fn extract_scripts_to_load(commands: &[LoadScriptCommand]) -> HashSet<&L...

FILE: packages/fuels-macros/tests/macro_usage.rs
  function ui (line 4) | fn ui() {

FILE: packages/fuels-macros/tests/ui/abigen/duplicate_attribute.rs
  function main (line 10) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/invalid_abi_path.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/invalid_abi_value.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/invalid_name_value.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/invalid_program_type.rs
  function main (line 8) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/malformed_abi.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/missing_abi_attribute.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/missing_name_attr.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/abigen/unrecognized_attribute.rs
  function main (line 9) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/parameterize/attribute_must_be_named_value.rs
  type SomeEnum (line 5) | enum SomeEnum {
  type SomeStruct (line 11) | struct SomeStruct {}
  function main (line 13) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/parameterize/only_generic_types_are_supported.rs
  type SomeEnum (line 4) | enum SomeEnum<const T: usize> {
  type AnotherEnum (line 9) | enum AnotherEnum<'a> {
  type SomeStruct (line 14) | struct SomeStruct<const T: usize> {}
  type AnotherStruct (line 17) | struct AnotherStruct<'a> {
  function main (line 21) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/parameterize/only_one_variant_element_supported.rs
  type SomeEnum (line 4) | enum SomeEnum {
  type AnotherEnum (line 10) | enum AnotherEnum {
  function main (line 14) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/parameterize/struct_like_enum_variants_not_supported.rs
  type SomeEnum (line 4) | enum SomeEnum {
  function main (line 9) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/parameterize/tuple_like_structs_not_supported.rs
  type SomeStruct (line 4) | struct SomeStruct(pub u64, pub String);
  function main (line 6) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/tokenizable/only_generic_types_are_supported.rs
  type SomeEnum (line 4) | enum SomeEnum<const T: usize> {
  type AnotherEnum (line 9) | enum AnotherEnum<'a> {
  type SomeStruct (line 14) | struct SomeStruct<const T: usize> {}
  type AnotherStruct (line 17) | struct AnotherStruct<'a> {
  function main (line 21) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/tokenizable/only_one_variant_element_supported.rs
  type SomeEnum (line 4) | enum SomeEnum {
  type AnotherEnum (line 10) | enum AnotherEnum {
  function main (line 14) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/tokenizable/struct_like_enum_variants_not_supported.rs
  type SomeEnum (line 4) | enum SomeEnum {
  function main (line 9) | fn main() {}

FILE: packages/fuels-macros/tests/ui/derive/tokenizable/tuple_like_structs_not_supported.rs
  type SomeStruct (line 4) | struct SomeStruct(pub u64, pub String);
  function main (line 6) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/abigen_command_is_missing.rs
  function main (line 9) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/duplicate_wallet_command.rs
  function main (line 9) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/duplicate_wallet_names.rs
  function main (line 8) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/invalid_path.rs
  function main (line 8) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/invalid_project_path.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/unknown_command.rs
  function main (line 13) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/unknown_contract.rs
  function main (line 12) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/unknown_options_key.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-macros/tests/ui/setup_program_test/unknown_options_value.rs
  function main (line 5) | fn main() {}

FILE: packages/fuels-programs/src/assembly/contract_call.rs
  type ContractCallInstructions (line 8) | pub struct ContractCallInstructions {
    method new (line 22) | pub fn new(opcode_params: CallOpcodeParamsOffset) -> Self {
    method into_bytes (line 29) | pub fn into_bytes(self) -> impl Iterator<Item = u8> {
    method generate_instructions (line 46) | fn generate_instructions(offsets: CallOpcodeParamsOffset) -> Vec<Instr...
    method extract_normal_variant (line 87) | fn extract_normal_variant(instructions: &[Instruction]) -> Option<&[In...
    method extract_gas_fwd_variant (line 97) | fn extract_gas_fwd_variant(instructions: &[Instruction]) -> Option<&[I...
    method extract_from (line 107) | pub fn extract_from(instructions: &[Instruction]) -> Option<Self> {
    method len (line 121) | pub fn len(&self) -> usize {
    method call_data_offset (line 125) | pub fn call_data_offset(&self) -> u32 {
    method is_gas_fwd_variant (line 133) | pub fn is_gas_fwd_variant(&self) -> bool {
    method extract_if_match (line 137) | fn extract_if_match<'a>(
  type Item (line 14) | type Item = Instruction;
  type IntoIter (line 15) | type IntoIter = std::vec::IntoIter<Instruction>;
  method into_iter (line 16) | fn into_iter(self) -> Self::IntoIter {
  type ContractCallData (line 154) | pub struct ContractCallData {
    method decode_fn_selector (line 164) | pub fn decode_fn_selector(&self) -> Result<String> {
    method encode (line 178) | pub fn encode(&self, memory_offset: usize, buffer: &mut Vec<u8>) -> Ca...
    method decode (line 216) | pub fn decode(data: &[u8], gas_fwd: bool) -> Result<Self> {
  type CallOpcodeParamsOffset (line 263) | pub struct CallOpcodeParamsOffset {
  function loader_contract_asm (line 271) | pub fn loader_contract_asm(blob_ids: &[[u8; 32]]) -> Result<Vec<u8>> {

FILE: packages/fuels-programs/src/assembly/cursor.rs
  type WasmFriendlyCursor (line 3) | pub struct WasmFriendlyCursor<'a> {
  function new (line 8) | pub fn new(data: &'a [u8]) -> Self {
  function consume (line 12) | pub fn consume(&mut self, amount: usize, ctx: &'static str) -> Result<&'...
  function consume_fixed (line 27) | pub fn consume_fixed<const AMOUNT: usize>(
  function consume_all (line 39) | pub fn consume_all(&mut self) -> &'a [u8] {
  function unconsumed (line 47) | pub fn unconsumed(&self) -> usize {

FILE: packages/fuels-programs/src/assembly/script_and_predicate_loader.rs
  type LoaderCode (line 16) | pub struct LoaderCode {
    method from_normal_binary (line 26) | pub fn from_normal_binary(binary: Vec<u8>) -> Result<Self> {
    method from_loader_binary (line 40) | pub fn from_loader_binary(binary: &[u8]) -> Result<Option<Self>> {
    method extract_blob (line 53) | pub fn extract_blob(binary: &[u8]) -> Result<fuels_core::types::transa...
    method as_bytes (line 58) | pub fn as_bytes(&self) -> &[u8] {
    method configurables_section_offset (line 62) | pub fn configurables_section_offset(&self) -> usize {
    method generate_loader_code (line 66) | fn generate_loader_code(blob_id: [u8; 32], split_section: &[u8]) -> (V...
    method blob_id (line 74) | pub fn blob_id(&self) -> [u8; 32] {
  function extract_blob_id_and_section_offset (line 79) | fn extract_blob_id_and_section_offset(binary: &[u8]) -> Result<Option<([...
  function consume_instructions (line 105) | fn consume_instructions<'a>(
  function generate_loader_wo_configurables (line 127) | fn generate_loader_wo_configurables(blob_id: [u8; 32]) -> (Vec<u8>, usiz...
  function generate_loader_w_configurables (line 141) | fn generate_loader_w_configurables(
  function loader_instructions_no_configurables (line 177) | fn loader_instructions_no_configurables() -> [Instruction; 8] {
  function loader_instructions_w_configurables (line 223) | pub fn loader_instructions_w_configurables() -> [Instruction; 12] {
  function extract_configurables_offset (line 289) | pub fn extract_configurables_offset(binary: &[u8]) -> Result<usize> {
  function split_at_configurables_offset (line 302) | pub fn split_at_configurables_offset(binary: &[u8]) -> Result<(&[u8], &[...
  function extract_data_offset (line 315) | pub fn extract_data_offset(binary: &[u8]) -> Result<usize> {
  function split_at_data_offset (line 328) | pub fn split_at_data_offset(binary: &[u8]) -> Result<(&[u8], &[u8])> {
  function split_for_loader (line 340) | pub fn split_for_loader(binary: &[u8]) -> Result<(&[u8], &[u8])> {
  function get_offset_for_section_containing_configurables (line 349) | pub fn get_offset_for_section_containing_configurables(binary: &[u8]) ->...
  function has_configurables_section_offset (line 357) | pub fn has_configurables_section_offset(binary: &[u8]) -> Result<bool> {

FILE: packages/fuels-programs/src/calls.rs
  type Execution (line 15) | pub struct Execution {
    method realistic (line 23) | pub fn realistic() -> Self {
    method state_read_only (line 31) | pub fn state_read_only() -> Self {
    method at_height (line 40) | pub fn at_height(mut self, height: impl Into<BlockHeight>) -> Self {
  method default (line 47) | fn default() -> Self {
  type ExecutionType (line 53) | pub(crate) enum ExecutionType {

FILE: packages/fuels-programs/src/calls/call_handler.rs
  type ContractDependency (line 33) | pub trait ContractDependency {
    method id (line 34) | fn id(&self) -> ContractId;
    method log_decoder (line 35) | fn log_decoder(&self) -> LogDecoder;
  type CallHandler (line 41) | pub struct CallHandler<A, C, T> {
  function with_tx_policies (line 61) | pub fn with_tx_policies(mut self, tx_policies: TxPolicies) -> Self {
  function with_decoder_config (line 66) | pub fn with_decoder_config(mut self, decoder_config: DecoderConfig) -> S...
  function with_variable_output_policy (line 79) | pub fn with_variable_output_policy(mut self, variable_outputs: VariableO...
  function add_signer (line 84) | pub fn add_signer(mut self, signer: impl Signer + Send + Sync + 'static)...
  function transaction_builder (line 96) | pub async fn transaction_builder(&self) -> Result<ScriptTransactionBuild...
  function transaction_builder_with_parameters (line 115) | pub fn transaction_builder_with_parameters(
  function build_tx (line 134) | pub async fn build_tx(&self) -> Result<ScriptTransaction> {
  function estimate_transaction_cost (line 141) | pub async fn estimate_transaction_cost(
  function with_contract_ids (line 174) | pub fn with_contract_ids(mut self, contract_ids: &[ContractId]) -> Self {
  function with_contracts (line 188) | pub fn with_contracts(mut self, contracts: &[&dyn ContractDependency]) -...
  function call (line 200) | pub async fn call(mut self) -> Result<CallResponse<T>> {
  function submit (line 213) | pub async fn submit(mut self) -> Result<SubmitResponse<A, C, T>> {
  function simulate (line 225) | pub async fn simulate(
  function get_response (line 252) | pub fn get_response(&self, tx_status: TxStatus) -> Result<CallResponse<T...
  function determine_missing_contracts (line 267) | pub async fn determine_missing_contracts(mut self) -> Result<Self> {
  function new_contract_call (line 289) | pub fn new_contract_call(
  function add_custom_asset (line 339) | pub fn add_custom_asset(mut self, asset_id: AssetId, amount: u64, to: Op...
  function is_payable (line 344) | pub fn is_payable(&self) -> bool {
  function call_params (line 355) | pub fn call_params(mut self, params: CallParameters) -> Result<Self> {
  function with_outputs (line 366) | pub fn with_outputs(mut self, outputs: Vec<Output>) -> Self {
  function with_inputs (line 373) | pub fn with_inputs(mut self, inputs: Vec<Input>) -> Self {
  function new_script_call (line 384) | pub fn new_script_call(
  function with_outputs (line 413) | pub fn with_outputs(mut self, outputs: Vec<Output>) -> Self {
  function with_inputs (line 420) | pub fn with_inputs(mut self, inputs: Vec<Input>) -> Self {
  function new_multi_call (line 430) | pub fn new_multi_call(account: A) -> Self {
  function append_external_contract (line 444) | fn append_external_contract(mut self, contract_id: ContractId) -> Result...
  function add_call (line 463) | pub fn add_call(
  function call (line 476) | pub async fn call<T: Tokenizable + Debug>(mut self) -> Result<CallRespon...
  function submit (line 490) | pub async fn submit(mut self) -> Result<SubmitResponse<A, Vec<ContractCa...
  function simulate (line 505) | pub async fn simulate<T: Tokenizable + Debug>(
  function simulate_without_decode (line 532) | async fn simulate_without_decode(&self) -> Result<()> {
  function get_response (line 542) | pub fn get_response<T: Tokenizable + Debug>(
  function determine_missing_contracts (line 567) | pub async fn determine_missing_contracts(mut self) -> Result<Self> {

FILE: packages/fuels-programs/src/calls/contract_call.rs
  type ContractCall (line 16) | pub struct ContractCall {
    method data (line 30) | pub(crate) fn data(&self, base_asset_id: AssetId) -> Result<ContractCa...
    method with_contract_id (line 47) | pub fn with_contract_id(self, contract_id: ContractId) -> Self {
    method with_call_parameters (line 54) | pub fn with_call_parameters(self, call_parameters: CallParameters) -> ...
    method add_custom_asset (line 61) | pub fn add_custom_asset(&mut self, asset_id: AssetId, amount: u64, to:...
    method with_outputs (line 66) | pub fn with_outputs(mut self, outputs: Vec<Output>) -> Self {
    method with_inputs (line 72) | pub fn with_inputs(mut self, inputs: Vec<Input>) -> Self {
  type CallParameters (line 81) | pub struct CallParameters {
    method new (line 88) | pub fn new(amount: u64, asset_id: AssetId, gas_forwarded: u64) -> Self {
    method with_amount (line 96) | pub fn with_amount(mut self, amount: u64) -> Self {
    method amount (line 101) | pub fn amount(&self) -> u64 {
    method with_asset_id (line 105) | pub fn with_asset_id(mut self, asset_id: AssetId) -> Self {
    method asset_id (line 110) | pub fn asset_id(&self) -> Option<AssetId> {
    method with_gas_forwarded (line 114) | pub fn with_gas_forwarded(mut self, gas_forwarded: u64) -> Self {
    method gas_forwarded (line 119) | pub fn gas_forwarded(&self) -> Option<u64> {
  method default (line 125) | fn default() -> Self {

FILE: packages/fuels-programs/src/calls/receipt_parser.rs
  type ReceiptParser (line 14) | pub struct ReceiptParser {
    method new (line 20) | pub fn new(receipts: &[Receipt], decoder_config: DecoderConfig) -> Self {
    method parse_call (line 35) | pub fn parse_call(
    method parse_script (line 47) | pub fn parse_script(self, output_param: &ParamType) -> Result<Token> {
    method missing_receipts_error (line 55) | fn missing_receipts_error(output_param: &ParamType) -> Error {
    method extract_contract_call_data (line 62) | pub fn extract_contract_call_data(&mut self, target_contract: Contract...
    method extract_script_data (line 92) | fn extract_script_data(&self) -> Option<Bytes> {
  constant RECEIPT_DATA (line 111) | const RECEIPT_DATA: &[u8; 3] = &[8, 8, 3];
  constant DECODED_DATA (line 112) | const DECODED_DATA: &[u8; 3] = &[8, 8, 3];
  function target_contract (line 114) | fn target_contract() -> ContractId {
  function get_return_data_receipt (line 118) | fn get_return_data_receipt(id: ContractId, data: &[u8]) -> Receipt {
  function get_call_receipt (line 130) | fn get_call_receipt(to: ContractId) -> Receipt {
  function get_relevant_receipts (line 144) | fn get_relevant_receipts() -> Vec<Receipt> {
  function receipt_parser_filters_receipts (line 153) | async fn receipt_parser_filters_receipts() -> Result<()> {
  function receipt_parser_empty_receipts (line 197) | async fn receipt_parser_empty_receipts() -> Result<()> {
  function receipt_parser_extract_return_data (line 212) | async fn receipt_parser_extract_return_data() -> Result<()> {
  function receipt_parser_extracts_top_level_call_receipts (line 227) | async fn receipt_parser_extracts_top_level_call_receipts() -> Result<()> {

FILE: packages/fuels-programs/src/calls/script_call.rs
  type ScriptCall (line 15) | pub struct ScriptCall {
    method with_outputs (line 25) | pub fn with_outputs(mut self, outputs: Vec<Output>) -> Self {
    method with_inputs (line 31) | pub fn with_inputs(mut self, inputs: Vec<Input>) -> Self {
    method prepare_inputs_outputs (line 36) | pub(crate) fn prepare_inputs_outputs(&self) -> Result<(Vec<Input>, Vec...
    method compute_script_data (line 59) | pub(crate) fn compute_script_data(&self) -> Result<Vec<u8>> {

FILE: packages/fuels-programs/src/calls/traits/contract_dep_configurator.rs
  type ContractDependencyConfigurator (line 5) | pub trait ContractDependencyConfigurator: sealed::Sealed {
    method append_external_contract (line 6) | fn append_external_contract(&mut self, contract_id: ContractId);
    method with_external_contracts (line 7) | fn with_external_contracts(self, external_contracts: Vec<ContractId>) ...
    method append_external_contract (line 11) | fn append_external_contract(&mut self, contract_id: ContractId) {
    method with_external_contracts (line 15) | fn with_external_contracts(self, external_contracts: Vec<ContractId>) ...
    method append_external_contract (line 24) | fn append_external_contract(&mut self, contract_id: ContractId) {
    method with_external_contracts (line 28) | fn with_external_contracts(self, external_contracts: Vec<ContractId>) ...

FILE: packages/fuels-programs/src/calls/traits/response_parser.rs
  type ResponseParser (line 9) | pub trait ResponseParser: sealed::Sealed {
    method parse_call (line 10) | fn parse_call(
    method parse_call (line 19) | fn parse_call(
    method parse_call (line 30) | fn parse_call(

FILE: packages/fuels-programs/src/calls/traits/transaction_tuner.rs
  type TransactionTuner (line 22) | pub trait TransactionTuner: sealed::Sealed {
    method required_assets (line 23) | fn required_assets(&self, base_asset_id: AssetId) -> Vec<(AssetId, u12...
    method transaction_builder (line 25) | fn transaction_builder<T: Account>(
    method build_tx (line 34) | async fn build_tx<T: Account>(
    method required_assets (line 43) | fn required_assets(&self, base_asset_id: AssetId) -> Vec<(AssetId, u12...
    method transaction_builder (line 47) | fn transaction_builder<T: Account>(
    method build_tx (line 65) | async fn build_tx<T: Account>(
    method required_assets (line 76) | fn required_assets(&self, _: AssetId) -> Vec<(AssetId, u128)> {
    method transaction_builder (line 80) | fn transaction_builder<T: Account>(
    method build_tx (line 101) | async fn build_tx<T: Account>(
    method required_assets (line 120) | fn required_assets(&self, base_asset_id: AssetId) -> Vec<(AssetId, u12...
    method transaction_builder (line 124) | fn transaction_builder<T: Account>(
    method build_tx (line 145) | async fn build_tx<T: Account>(
  function validate_contract_calls (line 156) | fn validate_contract_calls(calls: &[ContractCall]) -> Result<()> {

FILE: packages/fuels-programs/src/calls/utils.rs
  type Sealed (line 29) | pub trait Sealed {}
  function transaction_builder_from_contract_calls (line 33) | pub(crate) fn transaction_builder_from_contract_calls(
  function build_with_tb (line 72) | pub(crate) async fn build_with_tb(
  function compute_calls_instructions_len (line 97) | fn compute_calls_instructions_len(calls: &[ContractCall]) -> usize {
  function calculate_required_asset_amounts (line 117) | pub fn calculate_required_asset_amounts(
  function get_instructions (line 149) | pub(crate) fn get_instructions(offsets: Vec<CallOpcodeParamsOffset>) -> ...
  function build_script_data_from_contract_calls (line 157) | pub(crate) fn build_script_data_from_contract_calls(
  function get_transaction_inputs_outputs (line 178) | pub(crate) fn get_transaction_inputs_outputs(
  function generate_custom_outputs (line 215) | fn generate_custom_outputs(calls: &[ContractCall]) -> Vec<Output> {
  function extract_unique_asset_ids (line 233) | fn extract_unique_asset_ids(asset_inputs: &[Input], base_asset_id: Asset...
  function generate_asset_change_outputs (line 245) | fn generate_asset_change_outputs(
  function generate_contract_outputs (line 256) | pub(crate) fn generate_contract_outputs(
  function generate_contract_inputs (line 272) | pub(crate) fn generate_contract_inputs(
  function extract_unique_contract_ids (line 291) | fn extract_unique_contract_ids(calls: &[ContractCall]) -> HashSet<Contra...
  function is_missing_output_variables (line 303) | pub fn is_missing_output_variables(receipts: &[Receipt]) -> bool {
  function find_ids_of_missing_contracts (line 309) | pub fn find_ids_of_missing_contracts(receipts: &[Receipt]) -> Vec<Contra...
  function new_contract_call_with_random_id (line 338) | fn new_contract_call_with_random_id() -> ContractCall {
  function random_contract_id (line 353) | fn random_contract_id() -> ContractId {
  function contract_input_present (line 358) | fn contract_input_present() {
  function contract_input_is_not_duplicated (line 383) | fn contract_input_is_not_duplicated() {
  function contract_output_present (line 412) | fn contract_output_present() {
  function external_contract_input_present (line 431) | fn external_contract_input_present() {
  function external_contract_output_present (line 475) | fn external_contract_output_present() {
  function change_per_asset_id_added (line 500) | fn change_per_asset_id_added() {
  function will_collate_same_asset_ids (line 540) | fn will_collate_same_asset_ids() {
  constant BASE_INSTRUCTION_COUNT (line 577) | const BASE_INSTRUCTION_COUNT: usize = 5;
  constant GAS_OFFSET_INSTRUCTION_COUNT (line 579) | const GAS_OFFSET_INSTRUCTION_COUNT: usize = 2;
  function test_simple (line 582) | fn test_simple() {
  function test_with_gas_offset (line 589) | fn test_with_gas_offset() {
  function test_with_enum_with_only_non_heap_variants (line 600) | fn test_with_enum_with_only_non_heap_variants() {

FILE: packages/fuels-programs/src/contract.rs
  type Contract (line 14) | pub struct Contract<Code> {
  function salt (line 21) | pub fn salt(&self) -> Salt {
  function with_salt (line 25) | pub fn with_salt(mut self, salt: impl Into<Salt>) -> Self {
  function storage_slots (line 30) | pub fn storage_slots(&self) -> &[StorageSlot] {
  function with_storage_slots (line 34) | pub fn with_storage_slots(mut self, storage_slots: Vec<StorageSlot>) -> ...
  function compute_contract_id_and_state_root (line 49) | fn compute_contract_id_and_state_root(
  function autoload_storage_slots (line 77) | fn autoload_storage_slots() {
  function autoload_fails_if_file_missing (line 99) | fn autoload_fails_if_file_missing() {
  function save_slots (line 125) | fn save_slots(slots: &Vec<StorageSlot>, path: &Path) {
  function blob_size_must_be_greater_than_zero (line 134) | fn blob_size_must_be_greater_than_zero() {
  function contract_with_no_code_cannot_be_turned_into_a_loader (line 151) | fn contract_with_no_code_cannot_be_turned_into_a_loader() {
  function loader_needs_at_least_one_blob (line 168) | fn loader_needs_at_least_one_blob() {
  function loader_requires_all_except_the_last_blob_to_be_word_sized (line 184) | fn loader_requires_all_except_the_last_blob_to_be_word_sized() {
  function last_blob_in_loader_can_be_unaligned (line 200) | fn last_blob_in_loader_can_be_unaligned() {
  function can_load_regular_contract (line 212) | fn can_load_regular_contract() -> Result<()> {
  function can_manually_create_regular_contract (line 233) | fn can_manually_create_regular_contract() -> Result<()> {
  function regular_contract_has_expected_getters (line 257) | fn regular_contract_has_expected_getters() -> Result<()> {
  function regular_can_be_turned_into_loader_and_back (line 283) | fn regular_can_be_turned_into_loader_and_back() -> Result<()> {
  function unuploaded_loader_contract_has_expected_getters (line 298) | fn unuploaded_loader_contract_has_expected_getters() -> Result<()> {
  function unuploaded_loader_requires_at_least_one_blob (line 321) | fn unuploaded_loader_requires_at_least_one_blob() -> Result<()> {
  function uploaded_loader_has_expected_getters (line 338) | fn uploaded_loader_has_expected_getters() -> Result<()> {

FILE: packages/fuels-programs/src/contract/loader.rs
  type BlobsUploaded (line 18) | pub struct BlobsUploaded {
  type BlobsNotUploaded (line 23) | pub struct BlobsNotUploaded {
  type Loader (line 28) | pub struct Loader<Blobs> {
  function code (line 33) | pub fn code(&self) -> Vec<u8> {
  function contract_id (line 39) | pub fn contract_id(&self) -> ContractId {
  function code_root (line 43) | pub fn code_root(&self) -> Bytes32 {
  function state_root (line 47) | pub fn state_root(&self) -> Bytes32 {
  function compute_roots (line 51) | fn compute_roots(&self) -> (ContractId, Bytes32, Bytes32) {
  function loader_from_blobs (line 61) | pub fn loader_from_blobs(
  function blobs (line 99) | pub fn blobs(&self) -> &[Blob] {
  function blob_ids (line 103) | pub fn blob_ids(&self) -> Vec<BlobId> {
  function upload_blobs (line 114) | pub async fn upload_blobs(
  function deploy (line 159) | pub async fn deploy(
  function deploy_if_not_exists (line 172) | pub async fn deploy_if_not_exists(
  function revert_to_regular (line 183) | pub fn revert_to_regular(self) -> Contract<Regular> {
  function code (line 197) | pub fn code(&self) -> Vec<u8> {
  function contract_id (line 202) | pub fn contract_id(&self) -> ContractId {
  function code_root (line 206) | pub fn code_root(&self) -> Bytes32 {
  function state_root (line 210) | pub fn state_root(&self) -> Bytes32 {
  function compute_roots (line 214) | pub fn compute_roots(&self) -> (ContractId, Bytes32, Bytes32) {
  function loader_from_blob_ids (line 222) | pub fn loader_from_blob_ids(
  function blob_ids (line 243) | pub fn blob_ids(&self) -> &[BlobId] {
  function deploy (line 248) | pub async fn deploy(
  function deploy_if_not_exists (line 258) | pub async fn deploy_if_not_exists(

FILE: packages/fuels-programs/src/contract/regular.rs
  type DeployResponse (line 25) | pub struct DeployResponse {
  type Regular (line 37) | pub struct Regular {
    method new (line 43) | pub(crate) fn new(code: Vec<u8>, configurables: Configurables) -> Self {
    method with_code (line 50) | pub(crate) fn with_code(self, code: Vec<u8>) -> Self {
    method with_configurables (line 54) | pub(crate) fn with_configurables(self, configurables: Configurables) -...
    method code (line 61) | pub(crate) fn code(&self) -> Vec<u8> {
  function with_code (line 71) | pub fn with_code(self, code: Vec<u8>) -> Self {
  function with_configurables (line 79) | pub fn with_configurables(self, configurables: impl Into<Configurables>)...
  function code (line 86) | pub fn code(&self) -> Vec<u8> {
  function contract_id (line 90) | pub fn contract_id(&self) -> ContractId {
  function code_root (line 94) | pub fn code_root(&self) -> Bytes32 {
  function state_root (line 98) | pub fn state_root(&self) -> Bytes32 {
  function compute_roots (line 102) | fn compute_roots(&self) -> (ContractId, Bytes32, Bytes32) {
  function load_from (line 107) | pub fn load_from(
  function regular (line 131) | pub fn regular(
  function deploy (line 146) | pub async fn deploy(
  function deploy_if_not_exists (line 189) | pub async fn deploy_if_not_exists(
  function convert_to_loader (line 208) | pub fn convert_to_loader(
  function smart_deploy (line 225) | pub async fn smart_deploy(
  type LoadConfiguration (line 250) | pub struct LoadConfiguration {
    method new (line 257) | pub fn new(
    method with_storage_configuration (line 269) | pub fn with_storage_configuration(mut self, storage: StorageConfigurat...
    method with_configurables (line 274) | pub fn with_configurables(mut self, configurables: impl Into<Configura...
    method with_salt (line 279) | pub fn with_salt(mut self, salt: impl Into<Salt>) -> Self {

FILE: packages/fuels-programs/src/contract/storage.rs
  type StorageConfiguration (line 14) | pub struct StorageConfiguration {
    method new (line 29) | pub fn new(autoload_enabled: bool, slots: impl IntoIterator<Item = Sto...
    method with_autoload (line 40) | pub fn with_autoload(mut self, enabled: bool) -> Self {
    method autoload_enabled (line 45) | pub fn autoload_enabled(&self) -> bool {
    method add_slot_overrides (line 51) | pub fn add_slot_overrides(
    method add_slot_overrides_from_file (line 63) | pub fn add_slot_overrides_from_file(mut self, path: impl AsRef<Path>) ...
    method into_slots (line 69) | pub fn into_slots(self) -> impl Iterator<Item = StorageSlot> {
  method default (line 20) | fn default() -> Self {
  type StorageSlots (line 75) | pub(crate) struct StorageSlots {
    method from (line 80) | fn from(storage_slots: impl IntoIterator<Item = StorageSlot>) -> Self {
    method add_overrides (line 87) | pub(crate) fn add_overrides(
    method load_from_file (line 96) | pub(crate) fn load_from_file(storage_path: impl AsRef<Path>) -> Result...
    method into_iter (line 112) | pub(crate) fn into_iter(self) -> impl Iterator<Item = StorageSlot> {
  function determine_storage_slots (line 117) | pub(crate) fn determine_storage_slots(
  function autoload_storage_slots (line 134) | pub(crate) fn autoload_storage_slots(contract_binary: &Path) -> Result<S...
  function expected_storage_slots_filepath (line 143) | pub(crate) fn expected_storage_slots_filepath(contract_binary: &Path) ->...
  function validate_path_and_extension (line 150) | pub(crate) fn validate_path_and_extension(file_path: &Path, extension: &...
  function merging_overrides_storage_slots (line 176) | fn merging_overrides_storage_slots() {

FILE: packages/fuels-programs/src/debug.rs
  type ScriptCallData (line 16) | pub struct ScriptCallData {
    method data_section (line 25) | pub fn data_section(&self) -> Option<&[u8]> {
  type ScriptType (line 34) | pub enum ScriptType {
    method detect (line 138) | pub fn detect(script: &[u8], data: &[u8]) -> Result<Self> {
  function parse_script_call (line 43) | fn parse_script_call(script: &[u8], script_data: &[u8]) -> Result<Script...
  function parse_contract_calls (line 63) | fn parse_contract_calls(
  function extract_call_instructions (line 114) | fn extract_call_instructions(
  function parse_loader_script (line 153) | fn parse_loader_script(script: &[u8], data: &[u8]) -> Result<Option<(Scr...
  function can_handle_empty_scripts (line 185) | fn can_handle_empty_scripts() {
  function is_fine_with_malformed_scripts (line 204) | fn is_fine_with_malformed_scripts() {
  function example_contract_call_data (line 224) | fn example_contract_call_data(has_args: bool, gas_fwd: bool) -> Vec<u8> {
  function catches_missing_data (line 250) | fn catches_missing_data(amount_of_data_to_steal: usize, expected_msg: &s...
  function handles_invalid_utf8_fn_selector (line 280) | fn handles_invalid_utf8_fn_selector() {
  function loader_script_without_a_blob (line 318) | fn loader_script_without_a_blob() {
  function loader_script_with_almost_matching_instructions (line 339) | fn loader_script_with_almost_matching_instructions() {
  function extra_instructions_in_contract_calling_scripts_not_tolerated (line 367) | fn extra_instructions_in_contract_calling_scripts_not_tolerated() {
  function handles_invalid_call_data_offset (line 396) | fn handles_invalid_call_data_offset() {

FILE: packages/fuels-programs/src/executable.rs
  type Regular (line 21) | pub struct Regular {
    method new (line 27) | pub fn new(code: Vec<u8>, configurables: Configurables) -> Self {
  type Executable (line 39) | pub struct Executable<State> {
  function from_bytes (line 44) | pub fn from_bytes(code: Vec<u8>) -> Self {
  function load_from (line 59) | pub fn load_from(path: &str) -> Result<Executable<Regular>> {
  function with_configurables (line 67) | pub fn with_configurables(self, configurables: impl Into<Configurables>)...
  function data_offset_in_code (line 76) | pub fn data_offset_in_code(&self) -> Result<usize> {
  function configurables_offset_in_code (line 80) | pub fn configurables_offset_in_code(&self) -> Result<Option<usize>> {
  function code (line 93) | pub fn code(&self) -> Vec<u8> {
  function convert_to_loader (line 105) | pub fn convert_to_loader(self) -> Result<Executable<Loader>> {
  type Loader (line 120) | pub struct Loader {
  function with_configurables (line 126) | pub fn with_configurables(self, configurables: impl Into<Configurables>)...
  function data_offset_in_code (

[
  {
    "path": ".editorconfig",
    "chars": 46,
    "preview": "[*.toml]\nindent_style = space\nindent_size = 2\n"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 20,
    "preview": "* @FuelLabs/client \n"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 1060,
    "preview": "<!--\nList the issues this PR closes (if any) in a bullet list format, e.g.:\n- Closes #ABCD\n- Closes #EFGH\n-->\n\n# Release"
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 11409,
    "preview": "name: CI\n\non:\n  push:\n    branches:\n      - master\n  pull_request:\n  release:\n    types: [ published ]\n\nconcurrency:\n  g"
  },
  {
    "path": ".github/workflows/docs.yml",
    "chars": 411,
    "preview": "name: Docs\n\non:\n  push:\n    branches:\n      - master\n  pull_request:\n  release:\n    types: [published]\n\njobs:\n  test:\n  "
  },
  {
    "path": ".github/workflows/gh-pages.yml",
    "chars": 1867,
    "preview": "name: github pages\n\non:\n  push:\n    branches:\n      - master\n    tags:\n      - v*\n\njobs:\n  deploy:\n    runs-on: ubuntu-l"
  },
  {
    "path": ".github/workflows/repo-plan.toml",
    "chars": 224,
    "preview": "[current-repo]\nname = \"fuels-rs\"\nowner = \"FuelLabs\"\n\n[repo.fuels-rs.details]\nname = \"fuels-rs\"\nowner = \"FuelLabs\"\n\n[repo"
  },
  {
    "path": ".github/workflows/scripts/verify_tag.sh",
    "chars": 658,
    "preview": "#!/usr/bin/env bash\nset -e\n\nerr() {\n    echo -e \"\\e[31m\\e[1merror:\\e[0m $@\" 1>&2;\n}\n\nstatus() {\n    WIDTH=12\n    printf "
  },
  {
    "path": ".gitignore",
    "chars": 532,
    "preview": "# Generated by Cargo\n# will have compiled files and executables\ntarget/\n\n# Remove Cargo.lock from gitignore if creating "
  },
  {
    "path": ".markdownlint.yaml",
    "chars": 141,
    "preview": "\"default\": true # Default state for all rules\n\"MD013\": false # Disable rule for line length\n\"MD033\": false # Disable rul"
  },
  {
    "path": ".markdownlintignore",
    "chars": 28,
    "preview": "README.md\nscripts/check-docs"
  },
  {
    "path": "Cargo.toml",
    "chars": 5023,
    "preview": "[workspace]\n# Use the new resolver to prevent dev-deps and build-deps from enabling debugging or test features in produc"
  },
  {
    "path": "LICENSE",
    "chars": 11357,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "README.md",
    "chars": 3054,
    "preview": "# fuels-rs\n\n[![build](https://github.com/FuelLabs/fuels-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/FuelL"
  },
  {
    "path": "SECURITY.md",
    "chars": 1866,
    "preview": "# Fuel Security Policy\n\nThank you for helping make the Fuel ecosystem safe for everyone. The Fuel team take security bug"
  },
  {
    "path": "_typos.toml",
    "chars": 74,
    "preview": "[files]\nextend-exclude = [\"packages/fuels-accounts/src/schema/schema.sdl\"]"
  },
  {
    "path": "ci_checks.sh",
    "chars": 942,
    "preview": "#!/usr/bin/env bash\n\n# Requires installed:\n# The latest version of the `forc`,`forc-fmt` and `fuel-core`.\n# `cargo insta"
  },
  {
    "path": "docs/.spellcheck.yml",
    "chars": 811,
    "preview": "matrix:\n    - name: SPCheck\n      aspell:\n        lang: en\n      dictionary:\n        encoding: utf-8\n        wordlists:\n"
  },
  {
    "path": "docs/book.toml",
    "chars": 226,
    "preview": "[book]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nlanguage = \"en\"\nmultilingual = false\nsrc = \"src\"\ntitle = \"The Fuel Rust"
  },
  {
    "path": "docs/spell-check-custom-words.txt",
    "chars": 1831,
    "preview": "ABI\nABIs\nALU\nAPIs\nASM\nAST\nAssemblyScript\nBitwise\nBooleans\nBrowserStack\nCEI\nCLI\nCardinality\nChangelog\nCodec\nCollateralize"
  },
  {
    "path": "docs/src/SUMMARY.md",
    "chars": 4260,
    "preview": "# Summary\n\n[The Fuel Rust SDK](./index.md)\n\n- [Getting Started](./getting-started.md)\n- [Connecting to a Fuel node](./co"
  },
  {
    "path": "docs/src/abigen/index.md",
    "chars": 763,
    "preview": "# Generating bindings with abigen\n\nYou might have noticed this snippet in the previous sections:\n\n```rust,ignore\n{{#incl"
  },
  {
    "path": "docs/src/abigen/the-abigen-macro.md",
    "chars": 4139,
    "preview": "# abigen\n\n<!-- This section explain the `abigen!` macro -->\n<!-- abigen:example:start -->\n`abigen!` is a procedural macr"
  },
  {
    "path": "docs/src/abigen/the-json-abi-file.md",
    "chars": 1034,
    "preview": "# The JSON ABI file\n\n<!-- This section should talk about the importance of the ABI -->\n<!-- abi:example:start -->\nWhethe"
  },
  {
    "path": "docs/src/accounts.md",
    "chars": 1785,
    "preview": "# Accounts\n\nThe `ViewOnlyAccount` trait provides a common interface to query balances.\n\nThe `Account` trait, in addition"
  },
  {
    "path": "docs/src/calling-contracts/call-params.md",
    "chars": 2781,
    "preview": "# Call parameters\n\n<!-- This section should explain what the call params are and how to configure them -->\n<!-- call_par"
  },
  {
    "path": "docs/src/calling-contracts/call-response.md",
    "chars": 3000,
    "preview": "# Call response\n\n<!-- This section should why you have to chain `.call().await.unwrap()` so often -->\n<!-- chaining:exam"
  },
  {
    "path": "docs/src/calling-contracts/calls-with-different-wallets.md",
    "chars": 942,
    "preview": "# Calls with different wallets\n\n<!-- This section should explain how to call a contract with a certain wallet -->\n<!-- w"
  },
  {
    "path": "docs/src/calling-contracts/cost-estimation.md",
    "chars": 1005,
    "preview": "# Estimating contract call cost\n\nWith the function `estimate_transaction_cost(tolerance: Option<f64>, block_horizon: Opt"
  },
  {
    "path": "docs/src/calling-contracts/custom-asset-transfer.md",
    "chars": 448,
    "preview": "# Custom asset transfer\n\n<!-- This section should explain the `add_custom_asset()` method -->\n<!-- transfer:example:star"
  },
  {
    "path": "docs/src/calling-contracts/custom-inputs-outputs.md",
    "chars": 378,
    "preview": "# Custom inputs and outputs\n\nIf you need to add specific inputs and outputs to contract calls, you can use the `with_inp"
  },
  {
    "path": "docs/src/calling-contracts/index.md",
    "chars": 990,
    "preview": "# Calling contracts\n\nOnce you've deployed your contract, as seen in the previous sections, you'll likely want to:\n\n1. Ca"
  },
  {
    "path": "docs/src/calling-contracts/logs.md",
    "chars": 1151,
    "preview": "# Logs\n\nWhenever you log a value within a contract method, the resulting log entry is added to the log receipt and the v"
  },
  {
    "path": "docs/src/calling-contracts/low-level-calls.md",
    "chars": 1285,
    "preview": "# Low-level calls\n\n<!-- This section should explain what low-level calls are and how to do them -->\nWith low-level calls"
  },
  {
    "path": "docs/src/calling-contracts/multicalls.md",
    "chars": 1665,
    "preview": "# Multiple contract calls\n\nWith `CallHandler`, you can execute multiple contract calls within a single transaction. To a"
  },
  {
    "path": "docs/src/calling-contracts/other-contracts.md",
    "chars": 1082,
    "preview": "# Calling other contracts\n\nIf your contract method is calling other contracts you will have to add the appropriate `Inpu"
  },
  {
    "path": "docs/src/calling-contracts/simulation.md",
    "chars": 1307,
    "preview": "# Simulating calls\n\nSometimes you want to simulate a call to a contract without changing the state of the blockchain. Th"
  },
  {
    "path": "docs/src/calling-contracts/tx-dependency-estimation.md",
    "chars": 1533,
    "preview": "# Transaction dependency estimation\n\nPreviously, we mentioned that a contract call might require you to manually specify"
  },
  {
    "path": "docs/src/calling-contracts/tx-policies.md",
    "chars": 1793,
    "preview": "# Transaction policies\n\n<!-- This section should explain what tx policies are and how to configure them -->\n<!-- tx_poli"
  },
  {
    "path": "docs/src/calling-contracts/variable-outputs.md",
    "chars": 1576,
    "preview": "# Output variables\n\n<!-- This section should explain variable outputs  -->\n<!-- variable_outputs:example:start -->\nSomet"
  },
  {
    "path": "docs/src/cli/fuels-abi-cli.md",
    "chars": 3405,
    "preview": "# `fuels-abi-cli`\n\nSimple CLI program to encode Sway function calls and decode their output. The ABI being encoded and d"
  },
  {
    "path": "docs/src/cli/index.md",
    "chars": 186,
    "preview": "# `fuels-rs` Rust Workspaces\n\nThis section gives you a little overview of the role and function of every workspace in th"
  },
  {
    "path": "docs/src/codec/decoding.md",
    "chars": 2184,
    "preview": "# Decoding\n\nBe sure to read the [prerequisites](./index.md#prerequisites-for-decodingencoding) to decoding.\n\nDecoding is"
  },
  {
    "path": "docs/src/codec/encoding.md",
    "chars": 1197,
    "preview": "# Encoding\n\nBe sure to read the [prerequisites](./index.md#prerequisites-for-decodingencoding) to encoding.\n\nEncoding is"
  },
  {
    "path": "docs/src/codec/index.md",
    "chars": 3223,
    "preview": "# Codec\n\nEncoding and decoding are done as per [the fuel spec](https://docs.fuel.network/docs/specs/abi/argument-encodin"
  },
  {
    "path": "docs/src/connecting/external-node.md",
    "chars": 1279,
    "preview": "# Connecting to the Testnet or an external node\n\nWe can interact with the `Testnet` node by using the following example."
  },
  {
    "path": "docs/src/connecting/index.md",
    "chars": 972,
    "preview": "# Connecting to a Fuel node\n\n<!-- This section should explain at a high level the main ways to connect to a node with th"
  },
  {
    "path": "docs/src/connecting/querying.md",
    "chars": 1999,
    "preview": "# Querying the blockchain\n\nOnce you set up a provider, you can interact with the Fuel blockchain. Here are a few example"
  },
  {
    "path": "docs/src/connecting/retrying.md",
    "chars": 1377,
    "preview": "# Retrying requests\n\nThe [`Provider`](https://docs.rs/fuels/0.62.0/fuels/accounts/provider/struct.Provider.html) can be "
  },
  {
    "path": "docs/src/connecting/rocksdb.md",
    "chars": 522,
    "preview": "# RocksDB\n\nRocksDB enables the preservation of the blockchain's state locally, facilitating its future utilization.\n\nTo "
  },
  {
    "path": "docs/src/connecting/short-lived.md",
    "chars": 1312,
    "preview": "# Running a short-lived Fuel node with the SDK\n\nYou can use the SDK to spin up a local, ideally short-lived Fuel node. T"
  },
  {
    "path": "docs/src/contributing/CONTRIBUTING.md",
    "chars": 2822,
    "preview": "# Contributing to the Fuel Rust SDK\n\nThanks for your interest in contributing to the Fuel Rust SDK!\n\nThis document outli"
  },
  {
    "path": "docs/src/contributing/tests-structure.md",
    "chars": 1152,
    "preview": "# Integration tests structure in `fuels-rs`\n\nThe integration tests of `fuels-rs` cover almost all aspects of the SDK and"
  },
  {
    "path": "docs/src/cookbook/custom-chain.md",
    "chars": 886,
    "preview": "# Custom chain\n\nThis example demonstrates how to start a short-lived Fuel node with custom consensus parameters for the "
  },
  {
    "path": "docs/src/cookbook/deposit-and-withdraw.md",
    "chars": 2138,
    "preview": "# Deposit and withdraw\n\nConsider the following contract:\n\n```rust,ignore\n{{#include ../../../e2e/sway/contracts/liquidit"
  },
  {
    "path": "docs/src/cookbook/index.md",
    "chars": 329,
    "preview": "# Cookbook\n\nThis section covers more advanced use cases that can be satisfied by combining various features of the Rust "
  },
  {
    "path": "docs/src/cookbook/transfer-all-assets.md",
    "chars": 1598,
    "preview": "# Transfer all assets\n\nThe `transfer()` method lets you transfer a single asset, but what if you needed to move all of y"
  },
  {
    "path": "docs/src/custom-transactions/custom-calls.md",
    "chars": 722,
    "preview": "# Custom contract and script calls\n\nWhen preparing a contract call via `CallHandler`, the Rust SDK uses a transaction bu"
  },
  {
    "path": "docs/src/custom-transactions/index.md",
    "chars": 328,
    "preview": "# Custom transactions\n\nUntil now, we have used helpers to create transactions, send them with a provider, and parse the "
  },
  {
    "path": "docs/src/custom-transactions/transaction-builders.md",
    "chars": 6088,
    "preview": "# Transaction Builders\n\nThe Rust SDK simplifies the creation of **Create** and **Script** transactions through two handy"
  },
  {
    "path": "docs/src/debugging/decoding-script-transactions.md",
    "chars": 696,
    "preview": "# Decoding script transactions\n\nThe SDK offers some tools that can help you make fuel script transactions more\nhuman rea"
  },
  {
    "path": "docs/src/debugging/function-selector.md",
    "chars": 388,
    "preview": "# Function selector\n\nWhenever you call a contract method the SDK will generate a function selector according to the fuel"
  },
  {
    "path": "docs/src/debugging/index.md",
    "chars": 117,
    "preview": "# Debugging\n\n> **note** This section is still a work in progress.\n\n- [The Function Selector](./function-selector.md)\n"
  },
  {
    "path": "docs/src/deploying/configurable-constants.md",
    "chars": 685,
    "preview": "# Configurable constants\n\nIn Sway, you can define `configurable` constants which can be changed during the contract depl"
  },
  {
    "path": "docs/src/deploying/index.md",
    "chars": 2432,
    "preview": "# Deploying contracts\n\nThere are two main ways of working with contracts in the SDK: deploying a contract with SDK or us"
  },
  {
    "path": "docs/src/deploying/interacting-with-contracts.md",
    "chars": 397,
    "preview": "# Interacting with contracts\n\nIf you already have a deployed contract and want to call its methods using the SDK, but wi"
  },
  {
    "path": "docs/src/deploying/large_contracts.md",
    "chars": 2918,
    "preview": "# Deploying Large Contracts\n\nIf your contract exceeds the size limit for a single deployment:\n\n```rust,ignore\n{{#include"
  },
  {
    "path": "docs/src/deploying/storage-slots.md",
    "chars": 781,
    "preview": "# Overriding storage slots\n\nIf you use storage in your contract, the default storage values will be generated in a JSON "
  },
  {
    "path": "docs/src/deploying/the-fuelvm-binary-file.md",
    "chars": 1907,
    "preview": "# The FuelVM binary file\n\nThe command `forc build` compiles your Sway code and generates the bytecode: the binary code t"
  },
  {
    "path": "docs/src/getting-started.md",
    "chars": 3983,
    "preview": "# Getting Started\n\n## Installation Guide\n\nPlease visit the Fuel [installation guide](https://docs.fuel.network/guides/in"
  },
  {
    "path": "docs/src/glossary.md",
    "chars": 727,
    "preview": "# Glossary\n\n## Contract\n\n<!-- This section should define a contract -->\n<!-- rs_contract:example:start -->\n\nA contract, "
  },
  {
    "path": "docs/src/index.md",
    "chars": 692,
    "preview": "# The Fuel Rust SDK\n\n<!-- This section should explain what the Fuel Rust SDK can be used for -->\n<!-- fuels_rs:example:s"
  },
  {
    "path": "docs/src/predicates/index.md",
    "chars": 2991,
    "preview": "# Predicates\n\nPredicates, in Sway, are programs that return a Boolean value and do not have any side effects (they are p"
  },
  {
    "path": "docs/src/predicates/send-spend-predicate.md",
    "chars": 1950,
    "preview": "# Signatures in predicates example\n\nThis is a more involved example where the predicate accepts three signatures and mat"
  },
  {
    "path": "docs/src/preuploading-code.md",
    "chars": 1255,
    "preview": "# Pre-uploading code\n\nIf you have a script or predicate that is larger than normal or which you plan\non calling often, y"
  },
  {
    "path": "docs/src/reference.md",
    "chars": 294,
    "preview": "# API Reference\n\nFor a more in-depth look at the APIs provided by the Fuel Rust SDK, head over to the [official document"
  },
  {
    "path": "docs/src/running-scripts.md",
    "chars": 2547,
    "preview": "# Running scripts\n\nYou can run a script using its JSON-ABI and the path to its binary file. You can run the scripts with"
  },
  {
    "path": "docs/src/testing/basics.md",
    "chars": 4026,
    "preview": "# Testing Basics\n\nIf you're new to Rust, you'll want to review these important tools to help you build tests.\n\n## The `a"
  },
  {
    "path": "docs/src/testing/chains.md",
    "chars": 641,
    "preview": "# Increasing the block height\n\nYou can use `produce_blocks` to help achieve an arbitrary block height; this is useful wh"
  },
  {
    "path": "docs/src/testing/index.md",
    "chars": 216,
    "preview": "# `fuels-rs` Testing\n\n> **note** This section is still a work in progress.\n\n- [Testing Basics](./basics.md)\n- [`setup_pr"
  },
  {
    "path": "docs/src/testing/the-setup-program-test-macro.md",
    "chars": 3709,
    "preview": "# The setup_program_test! macro\n\nWhen deploying contracts with the `abigen!` macro, as shown in the previous sections, t"
  },
  {
    "path": "docs/src/types/B512.md",
    "chars": 368,
    "preview": "# `B512`\n\nIn the Rust SDK, the `B512` definition matches the Sway standard library type with the same name and will be c"
  },
  {
    "path": "docs/src/types/address.md",
    "chars": 345,
    "preview": "# `Address`\n\nLike `Bytes32`, `Address` is a wrapper on `[u8; 32]` with similar methods and implements the same traits (s"
  },
  {
    "path": "docs/src/types/asset-id.md",
    "chars": 346,
    "preview": "# `AssetId`\n\nLike `Bytes32`, `AssetId` is a wrapper on `[u8; 32]` with similar methods and implements the same traits (s"
  },
  {
    "path": "docs/src/types/bits256.md",
    "chars": 599,
    "preview": "# `Bits256`\n\nIn Fuel, a type called `b256` represents hashes and holds a 256-bit value. The Rust SDK represents `b256` a"
  },
  {
    "path": "docs/src/types/bytes.md",
    "chars": 500,
    "preview": "# `Bytes`\n\nIn Fuel, a type called `Bytes` represents a collection of tightly-packed bytes. The Rust SDK represents `Byte"
  },
  {
    "path": "docs/src/types/bytes32.md",
    "chars": 1095,
    "preview": "# `Bytes32`\n\nIn Sway and the FuelVM, `Bytes32` represents hashes. They hold a 256-bit (32-byte) value. `Bytes32` is a wr"
  },
  {
    "path": "docs/src/types/contract-id.md",
    "chars": 360,
    "preview": "# `ContractId`\n\nLike `Bytes32`, `ContractId` is a wrapper on `[u8; 32]` with similar methods and implements the same tra"
  },
  {
    "path": "docs/src/types/conversion.md",
    "chars": 4171,
    "preview": "# Converting Types\n\nBelow you can find examples for common type conversions:\n\n- [Convert Between Native Types](#convert-"
  },
  {
    "path": "docs/src/types/custom_types.md",
    "chars": 2991,
    "preview": "# Structs and enums\n\n<!-- This section should explain how to get the custom types from a Sway program -->\n<!-- custom_ty"
  },
  {
    "path": "docs/src/types/evm_address.md",
    "chars": 610,
    "preview": "# `EvmAddress`\n\nIn the Rust SDK, Ethereum Virtual Machine (EVM) addresses can be represented with the `EvmAddress` type."
  },
  {
    "path": "docs/src/types/index.md",
    "chars": 174,
    "preview": "# Types\n\nThe FuelVM and Sway have many internal types. These types have equivalents in the SDK. This section discusses t"
  },
  {
    "path": "docs/src/types/string.md",
    "chars": 986,
    "preview": "# `String`\n\nThe Rust SDK represents Fuel's `String`s as `SizedAsciiString<LEN>`, where the generic parameter `LEN` is th"
  },
  {
    "path": "docs/src/types/vectors.md",
    "chars": 849,
    "preview": "# Vectors\n\n## Passing in vectors\n\nYou can pass a Rust `std::vec::Vec` into your contract method transparently. The follo"
  },
  {
    "path": "docs/src/wallets/access.md",
    "chars": 1454,
    "preview": "# Wallet Access\n\nThe kinds of operations we can perform with a `Wallet` instance depend on\nwhether or not the wallet has"
  },
  {
    "path": "docs/src/wallets/checking-balances-and-coins.md",
    "chars": 1362,
    "preview": "# Checking balances and coins\n\n<!-- This section should explain getting the balance of a wallet -->\n<!-- balance:example"
  },
  {
    "path": "docs/src/wallets/fake_signer.md",
    "chars": 706,
    "preview": "# Fake signer (impersonating another account)\n\nTo facilitate account impersonation, the Rust SDK provides the `FakeSigne"
  },
  {
    "path": "docs/src/wallets/index.md",
    "chars": 1894,
    "preview": "# Wallets\n\nWallets serve as a centralized interface for all account-related behaviors. They allow you to:\n\n- **Inspect U"
  },
  {
    "path": "docs/src/wallets/keystore.md",
    "chars": 289,
    "preview": "# Encrypting and Storing Keys\n\nThe code below shows how to:\n\n- Encrypt and store your key using a master password.\n- Ens"
  },
  {
    "path": "docs/src/wallets/kms.md",
    "chars": 483,
    "preview": "# Using KMS Wallets\n\nKey Management Service (KMS) is a robust and secure solution for managing cryptographic keys for yo"
  },
  {
    "path": "docs/src/wallets/private_key_signer.md",
    "chars": 1409,
    "preview": "# Using private keys to create wallets\n\n## Directly from a private key\n\nAn example of how to create a wallet that uses a"
  },
  {
    "path": "docs/src/wallets/signing.md",
    "chars": 1395,
    "preview": "# Signing\n\nAn example of how you might sign a message using any of the SDK signers (or your\nown, custom ones, that imple"
  },
  {
    "path": "docs/src/wallets/test-wallets.md",
    "chars": 3149,
    "preview": "# Setting up test wallets\n\nYou'll often want to create one or more test wallets when testing your contracts. Here's how "
  },
  {
    "path": "docs/theme/highlight.js",
    "chars": 29018,
    "preview": "/*!\n  Highlight.js v11.3.1 (git: 2a972d8658)\n  (c) 2006-2022 Ivan Sagalaev and other contributors\n  License: BSD-3-Claus"
  },
  {
    "path": "e2e/Cargo.toml",
    "chars": 1518,
    "preview": "[package]\nname = \"e2e\"\nauthors = { workspace = true }\nedition = { workspace = true }\nhomepage = { workspace = true }\nrea"
  },
  {
    "path": "e2e/Forc.toml",
    "chars": 4500,
    "preview": "[workspace]\nmembers = [\n  'sway/bindings/sharing_types/contract_a',\n  'sway/bindings/sharing_types/contract_b',\n  'sway/"
  },
  {
    "path": "e2e/build.rs",
    "chars": 3250,
    "preview": "use std::{\n    io::Cursor,\n    path::{Path, PathBuf},\n};\n\nuse flate2::read::GzDecoder;\nuse fuels_accounts::provider::SUP"
  },
  {
    "path": "e2e/src/aws_kms.rs",
    "chars": 4461,
    "preview": "use fuels::{\n    accounts::signers::kms::aws::{\n        AwsKmsSigner,\n        aws_config::{BehaviorVersion, Region, defa"
  },
  {
    "path": "e2e/src/e2e_helpers.rs",
    "chars": 206,
    "preview": "use fuels::types::errors::Result;\n\nuse crate::aws_kms::{AwsKms, AwsKmsProcess};\n\npub async fn start_aws_kms(logs: bool) "
  },
  {
    "path": "e2e/src/lib.rs",
    "chars": 34,
    "preview": "mod aws_kms;\npub mod e2e_helpers;\n"
  },
  {
    "path": "e2e/sway/abi/simple_contract/Forc.toml",
    "chars": 118,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"simple_contract\"\n"
  },
  {
    "path": "e2e/sway/abi/simple_contract/src/main.sw",
    "chars": 191,
    "preview": "contract;\n\nabi SimpleContract {\n    fn takes_u32_returns_bool(arg: u32) -> bool;\n}\n\nimpl SimpleContract for Contract {\n "
  },
  {
    "path": "e2e/sway/abi/wasm_contract/Forc.toml",
    "chars": 116,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"wasm_contract\"\n"
  },
  {
    "path": "e2e/sway/abi/wasm_contract/src/main.sw",
    "chars": 282,
    "preview": "contract;\n\nenum SomeEnum<T> {\n    V1: (),\n    V2: T,\n}\n\n#[allow(dead_code)]\nstruct SomeStruct {\n    a: u32,\n    b: bool,"
  },
  {
    "path": "e2e/sway/abi/wasm_predicate/Forc.toml",
    "chars": 117,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"wasm_predicate\"\n"
  },
  {
    "path": "e2e/sway/abi/wasm_predicate/src/main.sw",
    "chars": 95,
    "preview": "predicate;\n\nconfigurable {\n    U64: u64 = 128,\n}\n\nfn main(val: u64) -> bool {\n    val == U64\n}\n"
  },
  {
    "path": "e2e/sway/bindings/sharing_types/contract_a/Forc.toml",
    "chars": 169,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_a\"\n\n[depen"
  },
  {
    "path": "e2e/sway/bindings/sharing_types/contract_a/src/main.sw",
    "chars": 1374,
    "preview": "contract;\nuse shared_lib::*;\n\nstruct UniqueStructToContractA<T> {\n    a: T,\n}\n\nstruct StructSameNameButDifferentInternal"
  },
  {
    "path": "e2e/sway/bindings/sharing_types/contract_b/Forc.toml",
    "chars": 169,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_b\"\n\n[depen"
  },
  {
    "path": "e2e/sway/bindings/sharing_types/contract_b/src/main.sw",
    "chars": 1384,
    "preview": "contract;\nuse shared_lib::*;\n\nstruct UniqueStructToContractB<T> {\n    a: T,\n}\n\nstruct StructSameNameButDifferentInternal"
  },
  {
    "path": "e2e/sway/bindings/sharing_types/shared_lib/Forc.toml",
    "chars": 112,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"lib.sw\"\nlicense = \"Apache-2.0\"\nname = \"shared_lib\"\n"
  },
  {
    "path": "e2e/sway/bindings/sharing_types/shared_lib/src/lib.sw",
    "chars": 207,
    "preview": "library;\n\npub struct SharedStruct1<T> {\n    a: T,\n}\n\npub struct SharedStruct2<K> {\n    a: u32,\n    b: SharedStruct1<K>,\n"
  },
  {
    "path": "e2e/sway/bindings/simple_contract/Forc.toml",
    "chars": 118,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"simple_contract\"\n"
  },
  {
    "path": "e2e/sway/bindings/simple_contract/src/main.sw",
    "chars": 190,
    "preview": "contract;\n\nabi MyContract {\n    fn takes_int_returns_bool(arg: u32) -> bool;\n}\n\nimpl MyContract for Contract {\n    fn ta"
  },
  {
    "path": "e2e/sway/bindings/type_paths/Forc.toml",
    "chars": 113,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"type_paths\"\n"
  },
  {
    "path": "e2e/sway/bindings/type_paths/src/another_lib.sw",
    "chars": 68,
    "preview": "library;\n\npub struct VeryCommonNameStruct {\n    pub field_a: u32,\n}\n"
  },
  {
    "path": "e2e/sway/bindings/type_paths/src/contract_a_types.sw",
    "chars": 128,
    "preview": "library;\n\npub struct VeryCommonNameStruct {\n    another_field: u32,\n}\n\npub struct AWrapper {\n    field: VeryCommonNameSt"
  },
  {
    "path": "e2e/sway/bindings/type_paths/src/main.sw",
    "chars": 354,
    "preview": "contract;\n\nmod contract_a_types;\nmod another_lib;\n\nuse contract_a_types::AWrapper;\nuse another_lib::VeryCommonNameStruct"
  },
  {
    "path": "e2e/sway/contracts/asserts/Forc.toml",
    "chars": 110,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"asserts\"\n"
  },
  {
    "path": "e2e/sway/contracts/asserts/src/main.sw",
    "chars": 1811,
    "preview": "contract;\n\nstruct TestStruct {\n    field_1: bool,\n    field_2: u64,\n}\n\n#[allow(dead_code)]\nenum TestEnum {\n    VariantOn"
  },
  {
    "path": "e2e/sway/contracts/auth_testing_abi/Forc.toml",
    "chars": 119,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"auth_testing_abi\"\n"
  },
  {
    "path": "e2e/sway/contracts/auth_testing_abi/src/main.sw",
    "chars": 122,
    "preview": "library;\n\nabi AuthTesting {\n    fn is_caller_external() -> bool;\n    fn check_msg_sender(expected_id: Address) -> bool;\n"
  },
  {
    "path": "e2e/sway/contracts/auth_testing_contract/Forc.toml",
    "chars": 192,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"auth_testing_contra"
  },
  {
    "path": "e2e/sway/contracts/auth_testing_contract/src/main.sw",
    "chars": 688,
    "preview": "contract;\n\nuse std::auth::{AuthError, caller_is_external, msg_sender};\nuse auth_testing_abi::*;\n\nimpl AuthTesting for Co"
  },
  {
    "path": "e2e/sway/contracts/block_timestamp/Forc.toml",
    "chars": 118,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"block_timestamp\"\n"
  },
  {
    "path": "e2e/sway/contracts/block_timestamp/src/main.sw",
    "chars": 187,
    "preview": "contract;\n\nuse std::block::timestamp;\n\nabi MyContract {\n    fn return_timestamp() -> u64;\n}\n\nimpl MyContract for Contrac"
  },
  {
    "path": "e2e/sway/contracts/configurables/Forc.toml",
    "chars": 116,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"configurables\"\n"
  },
  {
    "path": "e2e/sway/contracts/configurables/src/main.sw",
    "chars": 1276,
    "preview": "contract;\n\n#[allow(dead_code)]\nenum EnumWithGeneric<D> {\n    VariantOne: D,\n    VariantTwo: (),\n}\n\nstruct StructWithGene"
  },
  {
    "path": "e2e/sway/contracts/contract_test/Forc.toml",
    "chars": 203,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_test\"\n\n[de"
  },
  {
    "path": "e2e/sway/contracts/contract_test/src/main.sw",
    "chars": 2739,
    "preview": "contract;\n\nuse std::storage::storage_api::{read, write};\nuse std::context::msg_amount;\n\nstruct MyType {\n    x: u64,\n    "
  },
  {
    "path": "e2e/sway/contracts/huge_contract/Forc.toml",
    "chars": 132,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"huge_contract\"\n\n[de"
  },
  {
    "path": "e2e/sway/contracts/huge_contract/src/main.sw",
    "chars": 529,
    "preview": "contract;\n\nabi MyContract {\n    fn something() -> u64;\n    #[storage(write)]\n    fn write_some_u64(some: u64);\n    #[sto"
  },
  {
    "path": "e2e/sway/contracts/large_return_data/Forc.toml",
    "chars": 120,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"large_return_data\"\n"
  },
  {
    "path": "e2e/sway/contracts/large_return_data/src/main.sw",
    "chars": 1251,
    "preview": "contract;\n\npub struct SmallStruct {\n    foo: u32,\n}\n\npub struct LargeStruct {\n    foo: u8,\n    bar: u8,\n}\n\nabi TestContr"
  },
  {
    "path": "e2e/sway/contracts/lib_contract/Forc.toml",
    "chars": 214,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"lib_contract\"\n\n[dep"
  },
  {
    "path": "e2e/sway/contracts/lib_contract/src/main.sw",
    "chars": 240,
    "preview": "contract;\n\nuse lib_contract_abi::LibContract;\n\nimpl LibContract for Contract {\n    fn increment(value: u64) -> u64 {\n   "
  },
  {
    "path": "e2e/sway/contracts/lib_contract_abi/Forc.toml",
    "chars": 119,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"lib_contract_abi\"\n"
  },
  {
    "path": "e2e/sway/contracts/lib_contract_abi/src/main.sw",
    "chars": 85,
    "preview": "library;\n\nabi LibContract {\n    fn increment(value: u64) -> u64;\n    fn require();\n}\n"
  },
  {
    "path": "e2e/sway/contracts/lib_contract_caller/Forc.toml",
    "chars": 217,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"lib_contract_caller"
  },
  {
    "path": "e2e/sway/contracts/lib_contract_caller/src/main.sw",
    "chars": 1853,
    "preview": "contract;\n\nuse lib_contract::LibContract;\nuse std::asset::mint_to;\n\nabi ContractCaller {\n    fn increment_from_contract("
  },
  {
    "path": "e2e/sway/contracts/library_test/Forc.toml",
    "chars": 115,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"library_test\"\n"
  },
  {
    "path": "e2e/sway/contracts/library_test/src/main.sw",
    "chars": 185,
    "preview": "library;\n\nabi Incrementor {\n    fn initialize(gas: u64, amt: u64, coin: b256, initial_value: u64) -> u64;\n    fn increme"
  },
  {
    "path": "e2e/sway/contracts/liquidity_pool/Forc.toml",
    "chars": 117,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"liquidity_pool\"\n"
  },
  {
    "path": "e2e/sway/contracts/liquidity_pool/src/main.sw",
    "chars": 1007,
    "preview": "contract;\n\nuse std::{asset::{mint_to, transfer}, call_frames::msg_asset_id, context::msg_amount};\nabi LiquidityPool {\n  "
  },
  {
    "path": "e2e/sway/contracts/low_level_caller/Forc.toml",
    "chars": 119,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"low_level_caller\"\n"
  },
  {
    "path": "e2e/sway/contracts/low_level_caller/src/main.sw",
    "chars": 787,
    "preview": "contract;\n\nuse std::{\n    bytes::Bytes,\n    constants::ZERO_B256,\n    low_level_call::{\n        call_with_function_selec"
  },
  {
    "path": "e2e/sway/contracts/msg_methods/Forc.toml",
    "chars": 114,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"msg_methods\"\n"
  },
  {
    "path": "e2e/sway/contracts/msg_methods/src/main.sw",
    "chars": 229,
    "preview": "contract;\n\nuse std::auth::msg_sender;\n\nabi FuelTest {\n    #[payable]\n    fn message_sender() -> Identity;\n}\n\nimpl FuelTe"
  },
  {
    "path": "e2e/sway/contracts/multiple_read_calls/Forc.toml",
    "chars": 122,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"multiple_read_calls"
  },
  {
    "path": "e2e/sway/contracts/multiple_read_calls/src/main.sw",
    "chars": 484,
    "preview": "contract;\n\nuse std::storage::storage_api::{read, write};\n\nabi MyContract {\n    #[storage(write)]\n    fn store(input: u64"
  },
  {
    "path": "e2e/sway/contracts/needs_custom_decoder/Forc.toml",
    "chars": 139,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"needs_custom_decode"
  },
  {
    "path": "e2e/sway/contracts/needs_custom_decoder/src/main.sw",
    "chars": 580,
    "preview": "contract;\n\nimpl AbiEncode for [u8; 1000] {\n    fn abi_encode(self, buffer: Buffer) -> Buffer {\n        let mut buffer = "
  },
  {
    "path": "e2e/sway/contracts/payable_annotation/Forc.toml",
    "chars": 121,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"payable_annotation\""
  },
  {
    "path": "e2e/sway/contracts/payable_annotation/src/main.sw",
    "chars": 243,
    "preview": "contract;\n\nabi TestContract {\n    #[payable]\n    fn payable() -> u64;\n    fn non_payable() -> u64;\n}\n\nimpl TestContract "
  },
  {
    "path": "e2e/sway/contracts/proxy/Forc.toml",
    "chars": 124,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"proxy\"\n\n[dependenci"
  },
  {
    "path": "e2e/sway/contracts/proxy/src/main.sw",
    "chars": 1013,
    "preview": "contract;\n\nuse std::execution::run_external;\n\nabi Proxy {\n    #[storage(write)]\n    fn set_target_contract(id: ContractI"
  },
  {
    "path": "e2e/sway/contracts/revert_transaction_error/Forc.toml",
    "chars": 127,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"revert_transaction_"
  },
  {
    "path": "e2e/sway/contracts/revert_transaction_error/src/main.sw",
    "chars": 234,
    "preview": "contract;\n\nabi MyContract {\n    fn make_transaction_fail(fail: bool) -> u64;\n}\n\nimpl MyContract for Contract {\n    fn ma"
  },
  {
    "path": "e2e/sway/contracts/storage/Forc.toml",
    "chars": 110,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"storage\"\n"
  },
  {
    "path": "e2e/sway/contracts/storage/src/main.sw",
    "chars": 734,
    "preview": "contract;\n\nuse std::storage::storage_api::read;\n\nstorage {\n    x: u64 = 64,\n    y: b256 = 0x0101010101010101010101010101"
  },
  {
    "path": "e2e/sway/contracts/token_ops/Forc.toml",
    "chars": 112,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"token_ops\"\n"
  },
  {
    "path": "e2e/sway/contracts/token_ops/src/main.sw",
    "chars": 1551,
    "preview": "contract;\n\nuse std::{asset::*, bytes::Bytes, context::balance_of, context::msg_amount, message::send_message};\n\nabi Test"
  },
  {
    "path": "e2e/sway/contracts/transaction_block_height/Forc.toml",
    "chars": 127,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"transaction_block_h"
  },
  {
    "path": "e2e/sway/contracts/transaction_block_height/src/main.sw",
    "chars": 263,
    "preview": "contract;\n\nabi MyContract {\n    fn get_current_height() -> u32;\n    fn calling_this_will_produce_a_block();\n}\n\nimpl MyCo"
  },
  {
    "path": "e2e/sway/contracts/tx_input_output/Forc.toml",
    "chars": 118,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"tx_input_output\"\n"
  },
  {
    "path": "e2e/sway/contracts/tx_input_output/src/main.sw",
    "chars": 989,
    "preview": "contract;\n\nuse std::{inputs::*, outputs::*};\n\nconfigurable {\n    ASSET_ID: AssetId = AssetId::zero(),\n    OWNER: Address"
  },
  {
    "path": "e2e/sway/contracts/var_outputs/Forc.toml",
    "chars": 114,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"var_outputs\"\n"
  },
  {
    "path": "e2e/sway/contracts/var_outputs/src/main.sw",
    "chars": 321,
    "preview": "contract;\n\nabi MyContract {\n    fn mint(coins: u64, recipient: Identity);\n}\n\nimpl MyContract for Contract {\n    fn mint("
  },
  {
    "path": "e2e/sway/logs/contract_logs/Forc.toml",
    "chars": 218,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_logs\"\n\n[de"
  },
  {
    "path": "e2e/sway/logs/contract_logs/src/main.sw",
    "chars": 4436,
    "preview": "contract;\n\nuse std::{logging::log, string::String};\nuse contract_logs_abi::ContractLogs;\n\nstruct B {\n    id: u64,\n    va"
  },
  {
    "path": "e2e/sway/logs/contract_logs_abi/Forc.toml",
    "chars": 120,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_logs_abi\"\n"
  },
  {
    "path": "e2e/sway/logs/contract_logs_abi/src/main.sw",
    "chars": 460,
    "preview": "library;\n\nuse std::logging::log;\n\nabi ContractLogs {\n    fn produce_logs_values();\n    fn produce_logs_variables();\n    "
  },
  {
    "path": "e2e/sway/logs/contract_revert_logs/Forc.toml",
    "chars": 123,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_revert_log"
  },
  {
    "path": "e2e/sway/logs/contract_revert_logs/src/main.sw",
    "chars": 1945,
    "preview": "contract;\n\nuse std::logging::log;\n\n#[allow(dead_code)]\nenum EnumWithGeneric<D> {\n    VariantOne: D,\n    VariantTwo: (),\n"
  },
  {
    "path": "e2e/sway/logs/contract_with_contract_logs/Forc.toml",
    "chars": 222,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"contract_with_contr"
  },
  {
    "path": "e2e/sway/logs/contract_with_contract_logs/src/main.sw",
    "chars": 1094,
    "preview": "contract;\n\nuse std::logging::log;\nuse library::ContractLogs;\n\nabi ContractCaller {\n    fn logs_from_external_contract(co"
  },
  {
    "path": "e2e/sway/logs/script_heap_logs/Forc.toml",
    "chars": 119,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"script_heap_logs\"\n"
  },
  {
    "path": "e2e/sway/logs/script_heap_logs/src/main.sw",
    "chars": 813,
    "preview": "script;\n\nuse std::{logging::log, string::String};\n\n#[allow(dead_code)]\nenum EnumWithGeneric<D> {\n    VariantOne: D,\n    "
  },
  {
    "path": "e2e/sway/logs/script_logs/Forc.toml",
    "chars": 114,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"script_logs\"\n"
  },
  {
    "path": "e2e/sway/logs/script_logs/src/main.sw",
    "chars": 1655,
    "preview": "script;\n\nuse std::logging::log;\n\n#[allow(dead_code)]\nstruct TestStruct {\n    field_1: bool,\n    field_2: b256,\n    field"
  },
  {
    "path": "e2e/sway/logs/script_revert_logs/Forc.toml",
    "chars": 121,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"script_revert_logs\""
  },
  {
    "path": "e2e/sway/logs/script_revert_logs/src/main.sw",
    "chars": 2447,
    "preview": "script;\n\nuse std::logging::log;\n\n#[allow(dead_code)]\nenum EnumWithGeneric<D> {\n    VariantOne: D,\n    VariantTwo: (),\n}\n"
  },
  {
    "path": "e2e/sway/logs/script_with_contract_logs/Forc.toml",
    "chars": 220,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"script_with_contrac"
  },
  {
    "path": "e2e/sway/logs/script_with_contract_logs/src/main.sw",
    "chars": 827,
    "preview": "script;\n\nuse std::logging::log;\nuse library::ContractLogs;\n\n#[allow(dead_code)]\nenum MatchEnum {\n    Logs: (),\n    Panic"
  },
  {
    "path": "e2e/sway/predicates/basic_predicate/Forc.toml",
    "chars": 118,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"basic_predicate\"\n"
  },
  {
    "path": "e2e/sway/predicates/basic_predicate/src/main.sw",
    "chars": 68,
    "preview": "predicate;\n\nfn main(a: u32, b: u64) -> bool {\n    b == a.as_u64()\n}\n"
  },
  {
    "path": "e2e/sway/predicates/predicate_blobs/Forc.toml",
    "chars": 118,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"predicate_blobs\"\n"
  },
  {
    "path": "e2e/sway/predicates/predicate_blobs/src/main.sw",
    "chars": 155,
    "preview": "predicate;\n\nconfigurable {\n    SECRET_NUMBER: u64 = 9000,\n}\n\nfn main(arg1: u8, arg2: u8) -> bool {\n    arg1 == 1 && arg2"
  },
  {
    "path": "e2e/sway/predicates/predicate_configurables/Forc.toml",
    "chars": 126,
    "preview": "[project]\nauthors = [\"Fuel Labs <contact@fuel.sh>\"]\nentry = \"main.sw\"\nlicense = \"Apache-2.0\"\nname = \"predicate_configura"
  },
  {
    "path": "e2e/sway/predicates/predicate_configurables/src/main.sw",
    "chars": 1501,
    "preview": "predicate;\n\nimpl PartialEq for StructWithGeneric<u8> {\n    fn eq(self, other: Self) -> bool {\n        self.field_1 == ot"
  }
]

// ... and 441 more files (download for full content)