chore: add method to get fn selector (#1686)

use can use it like this

```rs
abigen!(Contract(
        name = "MyContract",
        abi = "e2e/sway/contracts/contract_name/out/release/contract_name-abi.json"
    ));
    
fn main() {
    let methods = MyContract::METHODS;
    let burn_coins_fn_selector = methods.burn_coins().fn_selector();
}
   
```

the method descriptor is now known at compile time, the fn_selector and
name are generated with the macro

---------

Co-authored-by: Green Baneling <[email protected]>

Author: rymnc

e2e/tests/contracts.rs

@@ -2839,3 +2839,44 @@ async fn multicall_tx_input_output() -> Result<()> {
 
     Ok(())
 }
+
+#[tokio::test]
+async fn test_returned_method_descriptors_are_valid() -> Result<()> {
+    abigen!(Contract(
+        name = "MyContract",
+        abi = "e2e/sway/contracts/token_ops/out/release/token_ops-abi.json"
+    ));
+
+    assert_eq!(
+        MyContract::METHODS.burn_coins().fn_selector(),
+        encode_fn_selector("burn_coins")
+    );
+    assert_eq!(
+        MyContract::METHODS.get_balance().fn_selector(),
+        encode_fn_selector("get_balance")
+    );
+    assert_eq!(
+        MyContract::METHODS.get_msg_amount().fn_selector(),
+        encode_fn_selector("get_msg_amount")
+    );
+    assert_eq!(
+        MyContract::METHODS.mint_coins().fn_selector(),
+        encode_fn_selector("mint_coins")
+    );
+    assert_eq!(
+        MyContract::METHODS.mint_to_addresses().fn_selector(),
+        encode_fn_selector("mint_to_addresses")
+    );
+    assert_eq!(
+        MyContract::METHODS.send_message().fn_selector(),
+        encode_fn_selector("send_message")
+    );
+    assert_eq!(
+        MyContract::METHODS.transfer().fn_selector(),
+        encode_fn_selector("transfer")
+    );
+
+    assert_eq!(MyContract::METHODS.iter().len(), 7);
+
+    Ok(())
+}

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

@@ -32,22 +32,29 @@ pub(crate) fn contract_bindings(
     let error_codes = quote! {::std::collections::HashMap::from([#(#error_codes),*])};
 
     let methods_name = ident(&format!("{name}Methods"));
+    let contract_methods_name = ident(&format!("{name}MethodVariants"));
 
     let contract_functions = expand_functions(&abi.functions)?;
+    let constant_methods_code =
+        generate_constant_methods_pattern(&abi.functions, &contract_methods_name)?;
 
     let configuration_struct_name = ident(&format!("{name}Configurables"));
     let constant_configuration_code =
         generate_code_for_configurable_constants(&configuration_struct_name, &abi.configurables)?;
 
     let code = quote! {
         #[derive(Debug, Clone)]
-        pub struct #name<A> {
+        pub struct #name<A = ()> {
             contract_id: ::fuels::types::ContractId,
             account: A,
             log_decoder: ::fuels::core::codec::LogDecoder,
             encoder_config: ::fuels::core::codec::EncoderConfig,
         }
 
+        impl #name {
+            pub const METHODS: #contract_methods_name = #contract_methods_name;
+        }
+
         impl<A> #name<A>
         {
             pub fn new(
@@ -126,13 +133,20 @@ pub(crate) fn contract_bindings(
         }
 
         #constant_configuration_code
+
+        #constant_methods_code
     };
 
     // All publicly available types generated above should be listed here.
-    let type_paths = [name, &methods_name, &configuration_struct_name]
-        .map(|type_name| TypePath::new(type_name).expect("We know the given types are not empty"))
-        .into_iter()
-        .collect();
+    let type_paths = [
+        name,
+        &methods_name,
+        &configuration_struct_name,
+        &contract_methods_name,
+    ]
+    .map(|type_name| TypePath::new(type_name).expect("We know the given types are not empty"))
+    .into_iter()
+    .collect();
 
     Ok(GeneratedCode::new(code, type_paths, no_std))
 }
@@ -179,6 +193,49 @@ pub(crate) fn expand_fn(abi_fun: &FullABIFunction) -> Result<TokenStream> {
     Ok(generator.generate())
 }
 
+fn generate_constant_methods_pattern(
+    functions: &[FullABIFunction],
+    contract_methods_name: &Ident,
+) -> Result<TokenStream> {
+    let method_descriptors = functions.iter().map(|func| {
+        let method_name = ident(func.name());
+        let fn_name = func.name();
+        let fn_selector =
+            proc_macro2::Literal::byte_string(&crate::utils::encode_fn_selector(fn_name));
+
+        quote! {
+            pub const fn #method_name(&self) -> ::fuels::types::MethodDescriptor {
+                ::fuels::types::MethodDescriptor {
+                    name: #fn_name,
+                    fn_selector: #fn_selector,
+                }
+            }
+        }
+    });
+
+    let all_methods = functions.iter().map(|func| {
+        let method_name = ident(func.name());
+        quote! { Self.#method_name() }
+    });
+
+    let method_count = functions.len();
+
+    let code = quote! {
+        #[derive(Debug, Clone, Copy)]
+        pub struct #contract_methods_name;
+
+        impl #contract_methods_name {
+            #(#method_descriptors)*
+
+            pub const fn iter(&self) -> [::fuels::types::MethodDescriptor; #method_count] {
+                [#(#all_methods),*]
+            }
+        }
+    };
+
+    Ok(code)
+}
+
 #[cfg(test)]
 mod tests {
     use std::collections::HashMap;

packages/fuels-code-gen/src/utils.rs

@@ -1 +1,8 @@
 pub use fuel_abi_types::utils::{TypePath, ident, safe_ident};
+
+pub fn encode_fn_selector(name: &str) -> Vec<u8> {
+    let bytes = name.as_bytes().to_vec();
+    let len = bytes.len() as u64;
+
+    [len.to_be_bytes().to_vec(), bytes].concat()
+}

packages/fuels-core/Cargo.toml

@@ -14,6 +14,7 @@ async-trait = { workspace = true, default-features = false }
 chrono = { workspace = true }
 fuel-abi-types = { workspace = true }
 fuel-asm = { workspace = true }
+fuels-code-gen = { workspace = true }
 fuel-core-chain-config = { workspace = true }
 fuel-core-client = { workspace = true, optional = true }
 fuel-core-types = { workspace = true }

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

@@ -1,9 +1,4 @@
-pub fn encode_fn_selector(name: &str) -> Vec<u8> {
-    let bytes = name.as_bytes().to_vec();
-    let len = bytes.len() as u64;
-
-    [len.to_be_bytes().to_vec(), bytes].concat()
-}
+pub use fuels_code_gen::utils::encode_fn_selector;
 
 /// This uses the default `EncoderConfig` configuration.
 #[macro_export]

packages/fuels-core/src/types.rs

@@ -4,7 +4,7 @@ pub use fuel_types::{
     MessageId, Nonce, Salt, SubAssetId, Word,
 };
 
-pub use crate::types::{core::*, token::*, wrappers::*};
+pub use crate::types::{core::*, method_descriptor::*, token::*, wrappers::*};
 use crate::{error, types::errors::Result};
 
 mod core;
@@ -18,6 +18,7 @@ pub mod tx_status;
 mod wrappers;
 pub use dry_runner::*;
 pub mod checksum_address;
+pub mod method_descriptor;
 
 pub type ByteArray = [u8; 8];
 pub type Selector = Vec<u8>;

packages/fuels-core/src/types/method_descriptor.rs

@@ -0,0 +1,21 @@
+/// This type is used to specify the fn_selector and name
+/// of methods on contracts at compile time, exported by the abigen! macro
+#[derive(Debug, Clone, Copy)]
+pub struct MethodDescriptor {
+    /// The name of the method.
+    pub name: &'static str,
+    /// The function selector of the method.
+    pub fn_selector: &'static [u8],
+}
+
+impl MethodDescriptor {
+    /// Returns the function selector of the method.
+    pub const fn fn_selector(&self) -> &'static [u8] {
+        self.fn_selector
+    }
+
+    /// Returns the name of the method.
+    pub const fn name(&self) -> &'static str {
+        self.name
+    }
+}