Merge branch 'master' into master

Author: MujkicA

docs/src/SUMMARY.md

@@ -51,7 +51,6 @@
   - [`Address`](./types/address.md)
   - [`ContractId`](./types/contract-id.md)
   - [`AssetId`](./types/asset-id.md)
-  - [Converting native types](./types/conversion.md)
   - [`Bech32`](./types/bech32.md)
   - [Structs and enums](./types/custom_types.md)
   - [`String`](./types/string.md)
@@ -60,6 +59,7 @@
   - [`B512`](./types/B512.md)
   - [`EvmAddress`](./types/evm_address.md)
   - [Vectors](./types/vectors.md)
+  - [Converting types](./types/conversion.md)
 - [Codec](./codec/index.md)
   - [Encoding](./codec/encoding.md)
   - [Decoding](./codec/decoding.md)

docs/src/types/conversion.md

@@ -1,7 +1,214 @@
-# Converting native types
+# Converting Types
+
+Below you can find examples for common type conversions:
+
+- [Convert Between Native Types](#convert-between-native-types)
+- [Convert to `Bytes32`](#convert-to-bytes32)
+- [Convert to `Address`](#convert-to-address)
+- [Convert to `ContractId`](#convert-to-contractid)
+- [Convert to `Identity`](#convert-to-identity)
+- [Convert to `AssetId`](#convert-to-assetid)
+- [Convert to `Bech32`](#convert-to-bech32)
+- [Convert to `str`](#convert-to-str)
+- [Convert to `Bits256`](#convert-to-bits256)
+- [Convert to `Bytes`](#convert-to-bytes)
+- [Convert to `B512`](#convert-to-b512)
+- [Convert to `EvmAddress`](#convert-to-evmaddress)
+
+## Convert Between Native Types
 
 You might want to convert between the native types (`Bytes32`, `Address`, `ContractId`, and `AssetId`). Because these types are wrappers on `[u8; 32]`, converting is a matter of dereferencing one and instantiating the other using the dereferenced value. Here's an example:
 
 ```rust,ignore
 {{#include ../../../examples/types/src/lib.rs:type_conversion}}
 ```
+
+## Convert to `Bytes32`
+
+Convert a `[u8; 32]` array to `Bytes32`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:array_to_bytes32}}
+```
+
+Convert a hex string to `Bytes32`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:hex_string_to_bytes32}}
+```
+
+## Convert to `Address`
+
+Convert a `[u8; 32]` array to an `Address`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:array_to_address}}
+```
+
+Convert a `Bech32` address to an `Address`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:bech32_to_address}}
+```
+
+Convert a wallet to an `Address`:
+
+```rust,ignore
+{{#include ../../../examples/wallets/src/lib.rs:wallet_to_address}}
+```
+
+Convert a hex string to an `Address`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:hex_string_to_address}}
+```
+
+## Convert to `ContractId`
+
+Convert a `[u8; 32]` array to to `ContractId`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:array_to_contract_id}}
+```
+
+Convert a hex string to a `ContractId`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:string_to_contract_id}}
+```
+
+Convert a contract instance to a `ContractId`:
+
+```rust,ignore
+{{#include ../../../packages/fuels/tests/logs.rs:instance_to_contract_id}}
+```
+
+## Convert to `Identity`
+
+Convert an `Address` to an `Identity`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:address_to_identity}}
+```
+
+Convert a `ContractId` to an `Identity`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:contract_id_to_identity}}
+```
+
+## Convert to `AssetId`
+
+Convert a `[u8; 32]` array to an `AssetId`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:array_to_asset_id}}
+```
+
+Convert a hex string to an `AssetId`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:string_to_asset_id}}
+```
+
+## Convert to `Bech32`
+
+Convert a `[u8; 32]` array to a `Bech32` address:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:array_to_bech32}}
+```
+
+Convert `Bytes32` to a `Bech32` address:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:bytes32_to_bech32}}
+```
+
+Convert a string to a `Bech32` address:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:str_to_bech32}}
+```
+
+Convert an `Address` to a `Bech32` address:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:address_to_bech32}}
+```
+
+## Convert to `str`
+
+Convert a `ContractId` to a `str`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:contract_id_to_str}}
+```
+
+Convert an `Address` to a `str`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:address_to_str}}
+```
+
+Convert an `AssetId` to a `str`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:asset_id_to_str}}
+```
+
+Convert `Bytes32` to a `str`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:bytes32_to_str}}
+```
+
+## Convert to `Bits256`
+
+Convert a hex string to `Bits256`:
+
+```rust,ignore
+{{#include ../../../packages/fuels-core/src/types/core/bits.rs:hex_str_to_bits256}}
+```
+
+Convert a `ContractId` to `Bits256`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:contract_id_to_bits256}}
+```
+
+Convert an `Address` to `Bits256`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:address_to_bits256}}
+```
+
+Convert an `AssetId` to `Bits256`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:asset_id_to_bits256}}
+```
+
+## Convert to `Bytes`
+
+Convert a string to `Bytes`:
+
+```rust,ignore
+{{#include ../../../packages/fuels-core/src/types/core/bytes.rs:hex_string_to_bytes32}}
+```
+
+## Convert to `B512`
+
+Convert two hex strings to `B512`:
+
+```rust,ignore
+{{#include ../../../packages/fuels/tests/types_contracts.rs:b512_example}}
+```
+
+## Convert to `EvmAddress`
+
+Convert a `Bits256` address to an `EvmAddress`:
+
+```rust,ignore
+{{#include ../../../examples/types/src/lib.rs:b256_to_evm_address}}
+```

examples/debugging/src/lib.rs

@@ -5,9 +5,10 @@ mod tests {
     use fuel_abi_types::abi::program::ProgramABI;
     use fuels::{
         core::{
-            codec::{calldata, fn_selector, resolve_fn_selector},
+            codec::{calldata, fn_selector, resolve_fn_selector, ABIDecoder},
             traits::Parameterize,
         },
+        macros::abigen,
         types::{errors::Result, param_types::ParamType, SizedAsciiString},
     };
 
@@ -69,4 +70,103 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn decoded_debug_matches_rust_debug() -> Result<()> {
+        abigen!(Contract(
+            name = "MyContract",
+            abi = "packages/fuels/tests/types/contracts/generics/out/debug/generics-abi.json"
+        ));
+
+        let json_abi_file =
+            "../../packages/fuels/tests/types/contracts/generics/out/debug/generics-abi.json";
+        let abi_file_contents = std::fs::read_to_string(json_abi_file)?;
+
+        let parsed_abi: ProgramABI = serde_json::from_str(&abi_file_contents)?;
+
+        let type_lookup = parsed_abi
+            .types
+            .into_iter()
+            .map(|decl| (decl.type_id, decl))
+            .collect::<HashMap<_, _>>();
+
+        let get_first_fn_argument = |fn_name: &str| {
+            parsed_abi
+                .functions
+                .iter()
+                .find(|abi_fun| abi_fun.name == fn_name)
+                .expect("should be there")
+                .inputs
+                .first()
+                .expect("should be there")
+        };
+        let decoder = ABIDecoder::default();
+
+        {
+            // simple struct with a single generic parameter
+            let type_application = get_first_fn_argument("struct_w_generic");
+            let param_type = ParamType::try_from_type_application(type_application, &type_lookup)?;
+
+            let expected_struct = SimpleGeneric {
+                single_generic_param: 123u64,
+            };
+
+            assert_eq!(
+                format!("{expected_struct:?}"),
+                decoder.decode_as_debug_str(&param_type, &[0, 0, 0, 0, 0, 0, 0, 123])?
+            );
+        }
+        {
+            // struct that delegates the generic param internally
+            let type_application = get_first_fn_argument("struct_delegating_generic");
+            let param_type = ParamType::try_from_type_application(type_application, &type_lookup)?;
+
+            let expected_struct = PassTheGenericOn {
+                one: SimpleGeneric {
+                    single_generic_param: SizedAsciiString::<3>::try_from("abc")?,
+                },
+            };
+
+            assert_eq!(
+                format!("{expected_struct:?}"),
+                decoder.decode_as_debug_str(&param_type, &[97, 98, 99])?
+            );
+        }
+        {
+            // enum with generic in variant
+            let type_application = get_first_fn_argument("enum_w_generic");
+            let param_type = ParamType::try_from_type_application(type_application, &type_lookup)?;
+
+            let expected_enum = EnumWGeneric::B(10u64);
+
+            assert_eq!(
+                format!("{expected_enum:?}"),
+                decoder.decode_as_debug_str(
+                    &param_type,
+                    &[0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 10]
+                )?
+            );
+        }
+        {
+            // logged type
+            let logged_type = parsed_abi
+                .logged_types
+                .as_ref()
+                .expect("has logs")
+                .first()
+                .expect("has log");
+
+            let param_type =
+                ParamType::try_from_type_application(&logged_type.application, &type_lookup)?;
+
+            let expected_u8 = 1;
+
+            assert_eq!(
+                format!("{expected_u8}"),
+                decoder.decode_as_debug_str(&param_type, &[0, 0, 0, 0, 0, 0, 0, 1])?
+            );
+        }
+
+        Ok(())
+    }
 }