Method generate_code

contracts/src/codegen.rs:268–346

Generate the Rust code for this contract's bindings.

(&self, artifacts_dir: &Path)

    /// Generate the Rust code for this contract's bindings.
    fn generate_code(&self, artifacts_dir: &Path) -> Result<TokenStream> {
        let bindings_path = self.artifacts_path(artifacts_dir);
        let mut macrogen = SolMacroGen::new(bindings_path, self.name.clone());
        generate_binding(&mut macrogen, true)?;
        let mut expansion = macrogen
            .expansion
            .expect("if the expansion failed, it should have errored earlier");

        let module_name_ident = format_ident!("{}", self.name);
        let instance_name_ident = format_ident!("{}Instance", self.name);
        let instance = quote::quote! {
            pub type Instance = #module_name_ident :: #instance_name_ident<::alloy_provider::DynProvider>;
        };
        expansion.extend(instance);

        if !self.networks.is_empty() {
            let mut networks: Vec<_> = self
                .networks
                .iter()
                .map(|(&chain_id, info)| NetworkArm(chain_id, (info.0.clone(), info.1)))
                .collect();
            // Sorting is required to keep generation stable and changes to a minimum
            networks.sort_by_key(|arm| arm.0);
            let deployment_info = quote::quote! {
                use {
                    std::{
                        sync::LazyLock,
                        collections::HashMap
                    },
                    anyhow::{Result, Context},
                    alloy_primitives::{address, Address},
                    alloy_provider::{Provider, DynProvider},
                };

                pub const fn deployment_info(chain_id: u64) -> Option<(Address, Option<u64>)> {
                    match chain_id {
                        #( #networks ,)*
                        _ => None
                    }
                }

                pub const fn deployment_address(chain_id: &u64) -> Option<::alloy_primitives::Address> {
                    match deployment_info(*chain_id) {
                        Some((address, _)) => Some(address),
                        None => None,
                    }
                }

                pub const fn deployment_block(chain_id: &u64) -> Option<u64> {
                    match deployment_info(*chain_id) {
                        Some((_, block)) => block,
                        None => None,
                    }
                }

                impl Instance {
                    pub fn deployed(provider: &DynProvider) -> impl Future<Output = Result<Self>> + Send {
                        async move {