Feature/log id expose (#1699)

Example of usage:
https://github.com/FuelLabs/fuel-rust-indexer/blob/main/crates/indexer/processors/receipt_parser.rs#L17

<!--
List the issues this PR closes (if any) in a bullet list format, e.g.:
- Closes #ABCD
- Closes #EFGH
-->

# Release notes

<!--
Use this only if this PR requires a mention in the Release
Notes Summary. Valuable features and critical fixes are good
examples. For everything else, please delete the whole section.
-->

In this release, we:

- Did this and that <!-- edit this text only -->

# Summary

<!--
Please write a summary of your changes and why you made them.
Not all PRs will be complex or substantial enough to require this
section, so you can remove it if you think it's unnecessary.
-->

# Breaking Changes

<!--
If the PR has breaking changes, please detail them in this section
and remove this comment.

Remove this section if there are no breaking changes.
-->

# Checklist

- [ ] All **changes** are **covered** by **tests** (or not applicable)
- [ ] All **changes** are **documented** (or not applicable)
- [ ] I **reviewed** the **entire PR** myself (preferably, on GH UI)
- [ ] I **described** all **Breaking Changes** (or there's none)

Author: xgreenx

packages/fuels-code-gen/src/program_bindings/abigen.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashSet, path::PathBuf};
 
 pub use abigen_target::{Abi, AbigenTarget, ProgramType};
-use fuel_abi_types::abi::full_program::FullTypeDeclaration;
+use fuel_abi_types::abi::full_program::{FullLoggedType, FullTypeDeclaration};
 use inflector::Inflector;
 use itertools::Itertools;
 use proc_macro2::TokenStream;
@@ -69,8 +69,13 @@ impl Abigen {
         let custom_types = Self::filter_custom_types(&parsed_targets);
         let shared_types = Self::filter_shared_types(custom_types);
 
+        let logged_types = parsed_targets
+            .iter()
+            .flat_map(|abi| abi.source.abi.logged_types.clone())
+            .collect_vec();
         let bindings = Self::generate_all_bindings(parsed_targets, no_std, &shared_types)?;
-        let shared_types = Self::generate_shared_types(shared_types, no_std)?;
+
+        let shared_types = Self::generate_shared_types(shared_types, &logged_types, no_std)?;
 
         let mod_name = ident("abigen_bindings");
         Ok(shared_types.merge(bindings).wrap_in_mod(mod_name))
@@ -98,7 +103,12 @@ impl Abigen {
 
         let recompile_trigger =
             Self::generate_macro_recompile_trigger(target.source.path.as_ref(), no_std);
-        let types = generate_types(&target.source.abi.types, shared_types, no_std)?;
+        let types = generate_types(
+            &target.source.abi.types,
+            shared_types,
+            &target.source.abi.logged_types,
+            no_std,
+        )?;
         let bindings = generate_bindings(target, no_std)?;
         Ok(recompile_trigger
             .merge(types)
@@ -124,9 +134,10 @@ impl Abigen {
 
     fn generate_shared_types(
         shared_types: HashSet<FullTypeDeclaration>,
+        logged_types: &Vec<FullLoggedType>,
         no_std: bool,
     ) -> Result<GeneratedCode> {
-        let types = generate_types(&shared_types, &HashSet::default(), no_std)?;
+        let types = generate_types(&shared_types, &HashSet::default(), logged_types, no_std)?;
 
         if types.is_empty() {
             Ok(Default::default())

packages/fuels-code-gen/src/program_bindings/custom_types.rs

@@ -1,6 +1,6 @@
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
-use fuel_abi_types::abi::full_program::FullTypeDeclaration;
+use fuel_abi_types::abi::full_program::{FullLoggedType, FullTypeDeclaration};
 use itertools::Itertools;
 use quote::quote;
 
@@ -16,7 +16,7 @@ use crate::{
 
 mod enums;
 mod structs;
-mod utils;
+pub(crate) mod utils;
 
 /// Generates Rust code for each type inside `types` if:
 /// * the type is not present inside `shared_types`, and
@@ -29,21 +29,28 @@ mod utils;
 /// * `types`: Types you wish to generate Rust code for.
 /// * `shared_types`: Types that are shared between multiple
 ///   contracts/scripts/predicates and thus generated elsewhere.
-pub(crate) fn generate_types<'a, T: IntoIterator<Item = &'a FullTypeDeclaration>>(
-    types: T,
+pub(crate) fn generate_types<'a>(
+    types: impl IntoIterator<Item = &'a FullTypeDeclaration>,
     shared_types: &HashSet<FullTypeDeclaration>,
+    logged_types: impl IntoIterator<Item = &'a FullLoggedType>,
     no_std: bool,
 ) -> Result<GeneratedCode> {
+    let log_ids: HashMap<_, _> = logged_types
+        .into_iter()
+        .map(|l| (l.application.type_decl.type_field.clone(), l.log_id.clone()))
+        .collect();
+
     types
         .into_iter()
         .filter(|ttype| !should_skip_codegen(ttype))
         .map(|ttype: &FullTypeDeclaration| {
+            let log_id = log_ids.get(&ttype.type_field);
             if shared_types.contains(ttype) {
                 reexport_the_shared_type(ttype, no_std)
             } else if ttype.is_struct_type() {
-                expand_custom_struct(ttype, no_std)
+                expand_custom_struct(ttype, no_std, log_id)
             } else {
-                expand_custom_enum(ttype, no_std)
+                expand_custom_enum(ttype, no_std, log_id)
             }
         })
         .fold_ok(GeneratedCode::default(), |acc, generated_code| {
@@ -84,7 +91,7 @@ fn reexport_the_shared_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result
 // Others like 'std::vec::RawVec' are skipped because they are
 // implementation details of the contract's Vec type and are not directly
 // used in the SDK.
-fn should_skip_codegen(type_decl: &FullTypeDeclaration) -> bool {
+pub fn should_skip_codegen(type_decl: &FullTypeDeclaration) -> bool {
     if !type_decl.is_custom_type() {
         return true;
     }
@@ -165,7 +172,11 @@ mod tests {
         .into_iter()
         .collect::<HashMap<_, _>>();
 
-        let actual = expand_custom_enum(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let actual = expand_custom_enum(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            None,
+        )?;
 
         let expected = quote! {
             #[allow(clippy::enum_variant_names)]
@@ -198,8 +209,12 @@ mod tests {
         };
         let types = [(0, p.clone())].into_iter().collect::<HashMap<_, _>>();
 
-        expand_custom_enum(&FullTypeDeclaration::from_counterpart(&p, &types), false)
-            .expect_err("Was able to construct an enum without variants");
+        expand_custom_enum(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            None,
+        )
+        .expect_err("Was able to construct an enum without variants");
 
         Ok(())
     }
@@ -249,7 +264,11 @@ mod tests {
         .into_iter()
         .collect::<HashMap<_, _>>();
 
-        let actual = expand_custom_enum(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let actual = expand_custom_enum(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            None,
+        )?;
 
         let expected = quote! {
             #[allow(clippy::enum_variant_names)]
@@ -311,7 +330,11 @@ mod tests {
         .into_iter()
         .collect::<HashMap<_, _>>();
 
-        let actual = expand_custom_enum(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let actual = expand_custom_enum(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            None,
+        )?;
 
         let expected = quote! {
             #[allow(clippy::enum_variant_names)]
@@ -385,7 +408,12 @@ mod tests {
         .into_iter()
         .collect::<HashMap<_, _>>();
 
-        let actual = expand_custom_enum(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let log_id = "42".to_string();
+        let actual = expand_custom_enum(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            Some(&log_id),
+        )?;
 
         let expected = quote! {
             #[allow(clippy::enum_variant_names)]
@@ -401,6 +429,11 @@ mod tests {
             pub enum EnumLevel3 {
                 El2(self::EnumLevel2),
             }
+
+            impl ::fuels::core::codec::Log for EnumLevel3 {
+                const LOG_ID: &'static str = "42";
+                const LOG_ID_U64: u64 = 42u64;
+            }
         };
 
         assert_eq!(actual.code().to_string(), expected.to_string());
@@ -460,8 +493,11 @@ mod tests {
         .into_iter()
         .collect::<HashMap<_, _>>();
 
-        let actual =
-            expand_custom_struct(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let actual = expand_custom_struct(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            None,
+        )?;
 
         let expected = quote! {
             #[derive(
@@ -508,8 +544,11 @@ mod tests {
         };
         let types = [(0, p.clone())].into_iter().collect::<HashMap<_, _>>();
 
-        let actual =
-            expand_custom_struct(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let actual = expand_custom_struct(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            None,
+        )?;
 
         let expected = quote! {
             #[derive(
@@ -577,8 +616,12 @@ mod tests {
         .into_iter()
         .collect::<HashMap<_, _>>();
 
-        let actual =
-            expand_custom_struct(&FullTypeDeclaration::from_counterpart(&p, &types), false)?;
+        let log_id = "13".to_string();
+        let actual = expand_custom_struct(
+            &FullTypeDeclaration::from_counterpart(&p, &types),
+            false,
+            Some(&log_id),
+        )?;
 
         let expected = quote! {
             #[derive(
@@ -602,6 +645,11 @@ mod tests {
                     }
                 }
             }
+
+            impl ::fuels::core::codec::Log for Cocktail {
+                const LOG_ID: &'static str = "13";
+                const LOG_ID_U64: u64 = 13u64;
+            }
         };
 
         assert_eq!(actual.code().to_string(), expected.to_string());
@@ -620,7 +668,7 @@ mod tests {
         let shared_types = HashSet::from([type_decl.clone()]);
 
         // when
-        let generated_code = generate_types(&[type_decl], &shared_types, false).unwrap();
+        let generated_code = generate_types(&[type_decl], &shared_types, [], false).unwrap();
 
         // then
         let expected_code = quote! {

packages/fuels-code-gen/src/program_bindings/custom_types/enums.rs

@@ -20,6 +20,7 @@ use crate::{
 pub(crate) fn expand_custom_enum(
     type_decl: &FullTypeDeclaration,
     no_std: bool,
+    log_id: Option<&String>,
 ) -> Result<GeneratedCode> {
     let enum_type_path = type_decl.custom_type_path()?;
     let enum_ident = enum_type_path.ident().unwrap();
@@ -30,7 +31,7 @@ pub(crate) fn expand_custom_enum(
     }
     let generics = extract_generic_parameters(type_decl);
 
-    let code = enum_decl(enum_ident, &components, &generics, no_std);
+    let code = enum_decl(enum_ident, &components, &generics, no_std, log_id);
 
     let enum_code = GeneratedCode::new(code, HashSet::from([enum_ident.into()]), no_std);
 
@@ -70,14 +71,28 @@ fn enum_decl(
     components: &Components,
     generics: &[Ident],
     no_std: bool,
+    log_id: Option<&String>,
 ) -> TokenStream {
     let maybe_disable_std = no_std.then(|| quote! {#[NoStd]});
 
     let enum_variants = components.as_enum_variants();
     let unused_generics_variant = components.generate_variant_for_unused_generics(generics);
-    let (_, generics_w_bounds) = tokenize_generics(generics);
+    let (generics_wo_bounds, generics_w_bounds) = tokenize_generics(generics);
     let maybe_impl_error = maybe_impl_error(enum_ident, components);
 
+    let log_impl = log_id.map(|log_id| {
+        let log_id_u64: u64 = log_id
+            .parse::<u64>()
+            .expect("log id should be a valid u64 string");
+
+        quote! {
+            impl #generics_w_bounds ::fuels::core::codec::Log for #enum_ident #generics_wo_bounds {
+                const LOG_ID: &'static str = #log_id;
+                const LOG_ID_U64: u64 = #log_id_u64;
+            }
+        }
+    });
+
     quote! {
         #[allow(clippy::enum_variant_names)]
         #[derive(
@@ -95,5 +110,6 @@ fn enum_decl(
             #unused_generics_variant
         }
         #maybe_impl_error
+        #log_impl
     }
 }

packages/fuels-code-gen/src/program_bindings/custom_types/structs.rs

@@ -20,14 +20,21 @@ use crate::{
 pub(crate) fn expand_custom_struct(
     type_decl: &FullTypeDeclaration,
     no_std: bool,
+    log_id: Option<&String>,
 ) -> Result<GeneratedCode> {
     let struct_type_path = type_decl.custom_type_path()?;
     let struct_ident = struct_type_path.ident().unwrap();
 
     let components = Components::new(&type_decl.components, true, struct_type_path.parent())?;
     let generic_parameters = extract_generic_parameters(type_decl);
 
-    let code = struct_decl(struct_ident, &components, &generic_parameters, no_std);
+    let code = struct_decl(
+        struct_ident,
+        &components,
+        &generic_parameters,
+        no_std,
+        log_id,
+    );
 
     let struct_code = GeneratedCode::new(code, HashSet::from([struct_ident.into()]), no_std);
 
@@ -52,6 +59,7 @@ fn struct_decl(
     components: &Components,
     generics: &[Ident],
     no_std: bool,
+    log_id: Option<&String>,
 ) -> TokenStream {
     let derive_default = components
         .is_empty()
@@ -64,6 +72,17 @@ fn struct_decl(
     let (phantom_fields, phantom_types) =
         components.generate_parameters_for_unused_generics(generics);
 
+    let log_impl = log_id.map(|log_id| {
+        let log_id_u64: u64 = log_id.parse::<u64>().expect("log id should be a valid u64 string");
+
+        quote! {
+            impl #generics_w_bounds ::fuels::core::codec::Log for #struct_ident #generics_wo_bounds {
+                const LOG_ID: &'static str = #log_id;
+                const LOG_ID_U64: u64 = #log_id_u64;
+            }
+        }
+    });
+
     quote! {
         #[derive(
             Clone,
@@ -89,5 +108,7 @@ fn struct_decl(
                 }
             }
         }
+
+        #log_impl
     }
 }

packages/fuels-core/src/codec/logs.rs

@@ -5,6 +5,14 @@ use std::{
     iter::FilterMap,
 };
 
+/// Trait that represents a log with a unique identifier.
+pub trait Log {
+    /// Returns the unique identifier of the log as a string.
+    const LOG_ID: &'static str;
+    /// Returns the unique identifier of the log as a `u64`.
+    const LOG_ID_U64: u64;
+}
+
 #[derive(Debug, Clone)]
 pub struct ErrorDetails {
     pub(crate) pkg: String,