Add support for ABI alias types

tritao · tritao · commit bd37700a26cb · 2025-07-25T14:00:47.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -8,6 +8,7 @@ resolver = "2"
 members = [
   "e2e",
   "examples/codec",
+  "examples/codegen",
   "examples/contracts",
   "examples/cookbook",
   "examples/debugging",
@@ -52,7 +53,8 @@ cynic = { version = "3.1.0", default-features = false }
 test-case = { version = "3.3", default-features = false }
 eth-keystore = "0.5.0"
 flate2 = { version = "1.0", default-features = false }
-fuel-abi-types = "0.13.0"
+#fuel-abi-types = "0.13.0"
+fuel-abi-types = { path = "../fuel-abi-types", version = "0.13.0" }
 futures = "0.3.29"
 hex = { version = "0.4.3", default-features = false }
 itertools = "0.12.0"
diff --git a/e2e/sway/abi/contract_with_alias/Forc.toml b/e2e/sway/abi/contract_with_alias/Forc.toml
@@ -0,0 +1,5 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "contract_with_alias"
diff --git a/e2e/sway/abi/contract_with_alias/src/main.sw b/e2e/sway/abi/contract_with_alias/src/main.sw
@@ -0,0 +1,19 @@
+contract;
+
+pub type MyAlias = Vec<b256>;
+//pub type MyAliasGeneric<T> = Vec<T>;
+
+abi MyContract {
+    fn with_b256(b: b256) -> b256;
+    fn with_myalias_vec() -> MyAlias;
+}
+
+impl MyContract for Contract {
+    fn with_b256(b: b256) -> b256 {
+        b256::zero()
+    }
+
+    fn with_myalias_vec() -> MyAlias {
+        MyAlias::new()
+    }
+}
diff --git a/e2e/sway/contracts/alias/Forc.toml b/e2e/sway/contracts/alias/Forc.toml
@@ -0,0 +1,5 @@
+[project]
+authors = ["Fuel Labs <contact@fuel.sh>"]
+entry = "main.sw"
+license = "Apache-2.0"
+name = "alias"
diff --git a/e2e/sway/contracts/alias/src/main.sw b/e2e/sway/contracts/alias/src/main.sw
@@ -0,0 +1,13 @@
+contract;
+
+pub type MyAlias = b256;
+
+abi MyContract {
+    fn with_myalias(b: MyAlias) -> MyAlias;
+}
+
+impl MyContract for Contract {
+    fn with_myalias(b: MyAlias) -> MyAlias {
+        b256::zero()
+    }
+}
diff --git a/e2e/tests/alias.rs b/e2e/tests/alias.rs
@@ -0,0 +1,27 @@
+use fuels::prelude::*;
+
+#[tokio::test]
+async fn test_alias() -> Result<()> {
+    setup_program_test!(
+        Wallets("wallet"),
+        Abigen(Contract(
+            name = "MyContract",
+            project = "e2e/sway/contracts/alias"
+        )),
+        Deploy(
+            name = "contract_instance",
+            contract = "MyContract",
+            wallet = "wallet",
+            random_salt = false,
+        ),
+    );
+
+    // Make sure we can call the contract with multiple arguments
+    let contract_methods = contract_instance.methods();
+    use abigen_bindings::my_contract_mod::MyAlias;
+    let response = contract_methods.with_myalias(MyAlias::zeroed()).call().await?;
+
+    assert_eq!(response.value, MyAlias::zeroed());
+
+    Ok(())
+}
diff --git a/examples/codegen/Cargo.toml b/examples/codegen/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "fuels-example-codegen"
+version = { workspace = true }
+authors = { workspace = true }
+edition = { workspace = true }
+homepage = { workspace = true }
+license = { workspace = true }
+publish = false
+repository = { workspace = true }
+description = "Fuel Rust SDK codegen examples."
+
+[dev-dependencies]
+fuels = { workspace = true, features = ["default"] }
+fuels-code-gen = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
diff --git a/examples/codegen/src/lib.rs b/examples/codegen/src/lib.rs
@@ -0,0 +1,21 @@
+extern crate alloc;
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn example_alias() {
+        use fuels::code_gen::*;
+
+        let target = AbigenTarget::new(
+            "MyContract".into(),
+            Abi::load_from("/home/joao/dev/fuels-rs/e2e/sway/abi/contract_with_alias_0/out/release/contract_with_alias-abi.json")
+            //Abi::load_from("/home/joao/dev/fuels-rs/e2e/sway/abi/contract_with_alias/out/release/contract_with_alias-abi.json")
+            // Abi::load_from("/home/joao/dev/sway/_test_aliases_abi/out/debug/test-case-abi.json")
+                .unwrap(),
+            ProgramType::Contract,
+        );
+        let targets = vec![target];
+
+        let abigen = Abigen::generate(targets, false).expect("abigen generation failed");
+    }
+}
diff --git a/packages/fuels-code-gen/src/program_bindings/abigen.rs b/packages/fuels-code-gen/src/program_bindings/abigen.rs
@@ -34,8 +34,15 @@ impl Abigen {
     ///   for, and of what nature (Contract, Script or Predicate).
     /// * `no_std`: don't use the Rust std library.
     pub fn generate(targets: Vec<AbigenTarget>, no_std: bool) -> Result<TokenStream> {
+        // eprintln!("{:#?}", targets);
+
         let generated_code = Self::generate_code(no_std, targets)?;
 
+        // eprintln!(
+        //     "========================== CODE: \n {:#}",
+        //     generated_code.code()
+        // );
+
         let use_statements = generated_code.use_statements_for_uniquely_named_types();
 
         let code = if no_std {
@@ -69,8 +76,15 @@ impl Abigen {
         let custom_types = Self::filter_custom_types(&parsed_targets);
         let shared_types = Self::filter_shared_types(custom_types);
 
+        // TODO: Shared type handling.
+        let _alias_types = Self::filter_alias_types(&parsed_targets)
+            .cloned()
+            .collect::<Vec<_>>();
+
         let bindings = Self::generate_all_bindings(parsed_targets, no_std, &shared_types)?;
+        //eprintln!("bindings {:#}", bindings.code().to_string());
         let shared_types = Self::generate_shared_types(shared_types, no_std)?;
+        //eprintln!("shared_types {:#}", shared_types.code().to_string());
 
         let mod_name = ident("abigen_bindings");
         Ok(shared_types.merge(bindings).wrap_in_mod(mod_name))
@@ -94,11 +108,14 @@ impl Abigen {
         no_std: bool,
         shared_types: &HashSet<FullTypeDeclaration>,
     ) -> Result<GeneratedCode> {
+        //eprintln!("generate_bindings shared_types {:#?}", shared_types);
         let mod_name = ident(&format!("{}_mod", &target.name.to_snake_case()));
 
         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)?;
+        //eprintln!("generate_bindings types {:#?}", types);
+
         let bindings = generate_bindings(target, no_std)?;
         Ok(recompile_trigger
             .merge(types)
@@ -145,6 +162,15 @@ impl Abigen {
             .filter(|ttype| ttype.is_custom_type())
     }
 
+    fn filter_alias_types(
+        all_types: &[AbigenTarget],
+    ) -> impl Iterator<Item = &FullTypeDeclaration> {
+        all_types
+            .iter()
+            .flat_map(|target| &target.source.abi.types)
+            .filter(|ttype| ttype.is_alias_type())
+    }
+
     /// A type is considered "shared" if it appears at least twice in
     /// `all_custom_types`.
     ///
diff --git a/packages/fuels-code-gen/src/program_bindings/custom_types.rs b/packages/fuels-code-gen/src/program_bindings/custom_types.rs
@@ -2,14 +2,12 @@ use std::collections::HashSet;
 
 use fuel_abi_types::abi::full_program::FullTypeDeclaration;
 use itertools::Itertools;
-use quote::quote;
+use quote::{quote, ToTokens};
 
 use crate::{
     error::Result,
     program_bindings::{
-        custom_types::{enums::expand_custom_enum, structs::expand_custom_struct},
-        generated_code::GeneratedCode,
-        utils::sdk_provided_custom_types_lookup,
+        custom_types::{enums::expand_custom_enum, structs::expand_custom_struct}, generated_code::GeneratedCode, resolved_type::TypeResolver, utils::sdk_provided_custom_types_lookup
     },
     utils::TypePath,
 };
@@ -40,6 +38,8 @@ pub(crate) fn generate_types<'a, T: IntoIterator<Item = &'a FullTypeDeclaration>
         .map(|ttype: &FullTypeDeclaration| {
             if shared_types.contains(ttype) {
                 reexport_the_shared_type(ttype, no_std)
+            } else if ttype.is_alias_type() {
+                expand_alias_type(ttype, no_std)
             } else if ttype.is_struct_type() {
                 expand_custom_struct(ttype, no_std)
             } else {
@@ -51,13 +51,62 @@ pub(crate) fn generate_types<'a, T: IntoIterator<Item = &'a FullTypeDeclaration>
         })
 }
 
+fn expand_alias_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result<GeneratedCode> {
+    let type_path = ttype.alias_type_path().expect("This must be an alias type");
+    let type_path_ident = syn::Ident::new(
+        type_path.ident().unwrap().to_string().as_str(),
+        proc_macro2::Span::call_site(),
+    );
+
+    let alias_of = ttype.alias_of.as_ref().unwrap();
+    //eprintln!("alias_of: {:?}", alias_of);
+
+    // let mut raw_type_str = alias_of.name.as_str();
+
+    // if let Some(stripped) = raw_type_str.strip_prefix("struct ") {
+    //     raw_type_str = stripped;
+    // } else if let Some(stripped) = raw_type_str.strip_prefix("enum ") {
+    //     raw_type_str = stripped;
+    // }
+
+    let resolver = TypeResolver::default();
+    let resolved_alias = resolver.resolve(alias_of)?;
+    //eprintln!("resolved_alias: {:?}", resolved_alias);
+    // panic!();
+    
+    // let alias_of_path: syn::Type =
+    //     syn::parse_str(raw_type_str).expect("Failed to parse type");
+    
+    let alias_of_path = resolved_alias.to_token_stream();
+
+    // eprintln!("type_path: {:?}", type_path);
+    // panic!();
+
+    let type_mod = type_path.parent();
+
+    let top_lvl_mod = TypePath::default();
+    let from_current_mod_to_top_level = top_lvl_mod.relative_path_from(&type_mod);
+
+    let path = from_current_mod_to_top_level.append(type_path);
+
+    let the_reexport = quote! {pub type #type_path_ident = #alias_of_path;};
+
+    Ok(GeneratedCode::new(the_reexport, Default::default(), no_std).wrap_in_mod(type_mod))
+}
+
 /// Instead of generating bindings for `ttype` this fn will just generate a `pub use` pointing to
 /// the already generated equivalent shared type.
 fn reexport_the_shared_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result<GeneratedCode> {
     // e.g. some_library::another_mod::SomeStruct
-    let type_path = ttype
-        .custom_type_path()
-        .expect("This must be a custom type due to the previous filter step");
+    let type_path = if ttype.is_custom_type() {
+        ttype
+            .custom_type_path()
+            .expect("This must be a custom type due to the previous filter step")
+    } else if ttype.is_alias_type() {
+        ttype.alias_type_path().expect("This must be an alias type")
+    } else {
+        unreachable!()
+    };
 
     let type_mod = type_path.parent();
 
@@ -85,6 +134,10 @@ fn reexport_the_shared_type(ttype: &FullTypeDeclaration, no_std: bool) -> Result
 // implementation details of the contract's Vec type and are not directly
 // used in the SDK.
 fn should_skip_codegen(type_decl: &FullTypeDeclaration) -> bool {
+    if type_decl.is_alias_type() {
+        return false;
+    }
+
     if !type_decl.is_custom_type() {
         return true;
     }
diff --git a/packages/fuels-code-gen/src/program_bindings/resolved_type.rs b/packages/fuels-code-gen/src/program_bindings/resolved_type.rs
@@ -1,4 +1,7 @@
-use std::fmt::{Display, Formatter};
+use std::{
+    fmt::{Display, Formatter},
+    sync::Arc,
+};
 
 use fuel_abi_types::{
     abi::full_program::FullTypeApplication,
@@ -44,6 +47,10 @@ pub enum ResolvedType {
     Array(Box<ResolvedType>, usize),
     Tuple(Vec<ResolvedType>),
     Generic(GenericType),
+    Alias {
+        path: TypePath,
+        target: Arc<ResolvedType>,
+    },
 }
 
 impl ResolvedType {
@@ -57,6 +64,7 @@ impl ResolvedType {
             }
             ResolvedType::Array(el, _) => el.generics(),
             ResolvedType::Generic(inner) => vec![inner.clone()],
+            ResolvedType::Alias { target, .. } => target.generics(),
             _ => vec![],
         }
     }
@@ -82,6 +90,10 @@ impl ToTokens for ResolvedType {
                 quote! { (#(#elements,)*) }
             }
             ResolvedType::Generic(generic_type) => generic_type.into_token_stream(),
+            ResolvedType::Alias { path, .. } => {
+                path.to_token_stream()
+                // target.as_ref().into_token_stream()
+            }
         };
 
         tokens.extend(tokenized)
@@ -122,6 +134,7 @@ impl TypeResolver {
             Self::try_as_tuple,
             Self::try_as_raw_slice,
             Self::try_as_custom_type,
+            Self::try_as_alias_type,
         ];
 
         for resolver in resolvers {
@@ -302,6 +315,33 @@ impl TypeResolver {
             generics,
         }))
     }
+
+    fn try_as_alias_type(
+        &self,
+        type_application: &FullTypeApplication,
+    ) -> Result<Option<ResolvedType>> {
+        let type_decl = &type_application.type_decl;
+
+        if !type_decl.is_alias_type() {
+            return Ok(None);
+        }
+
+        let Some(alias_of) = &type_decl.alias_of else {
+            return Ok(None);
+        };
+
+        let target = Arc::new(self.resolve(alias_of)?);
+
+        let path = if let Ok(custom_type_path) = type_decl.custom_type_path() {
+            custom_type_path
+        } else {
+            type_decl.alias_type_path()?
+        };
+
+        let path = path.relative_path_from(&self.current_mod);
+
+        Ok(Some(ResolvedType::Alias { path, target }))
+    }
 }
 
 #[cfg(test)]
diff --git a/packages/fuels-macros/src/lib.rs b/packages/fuels-macros/src/lib.rs
diff --git a/packages/fuels/Cargo.toml b/packages/fuels/Cargo.toml
diff --git a/packages/fuels/src/lib.rs b/packages/fuels/src/lib.rs
