tempo_xtask/

genesis_args.rs

use alloy::{
    genesis::{ChainConfig, Genesis, GenesisAccount},
    primitives::{Address, U256, address},
    signers::{local::MnemonicBuilder, utils::secret_key_to_address},
};
use alloy_primitives::{B256, Bytes};
use commonware_codec::Encode as _;
use commonware_consensus::types::Epoch;
use commonware_cryptography::{
    Signer as _,
    bls12381::{
        dkg::{self, Output},
        primitives::{sharing::Mode, variant::MinSig},
    },
    ed25519::PublicKey,
};
use commonware_math::algebra::Random as _;
use commonware_utils::{N3f1, TryFromIterator as _, ordered};
use eyre::{WrapErr as _, eyre};
use indicatif::{ParallelProgressIterator, ProgressIterator};
use itertools::Itertools;
use rand_08::SeedableRng as _;
use rayon::prelude::*;
use reth_evm::{
    Evm as _, EvmEnv, EvmFactory,
    revm::{
        DatabaseCommit,
        context_interface::JournalTr as _,
        database::{CacheDB, EmptyDB},
        inspector::JournalExt,
        state::{AccountInfo, Bytecode},
    },
};
use std::{
    collections::BTreeMap,
    iter::repeat_with,
    net::SocketAddr,
    path::{Path, PathBuf},
};
use tempo_chainspec::hardfork::TempoHardfork;
use tempo_commonware_node_config::{SigningKey, SigningShare};
use tempo_contracts::{
    ARACHNID_CREATE2_FACTORY_ADDRESS, CREATEX_ADDRESS, MULTICALL3_ADDRESS, PERMIT2_ADDRESS,
    PERMIT2_SALT, SAFE_DEPLOYER_ADDRESS,
    contracts::{ARACHNID_CREATE2_FACTORY_BYTECODE, CreateX, Multicall3, SafeDeployer},
    precompiles::{ITIP20Factory, IValidatorConfig, IValidatorConfigV2},
};
use tempo_dkg_onchain_artifacts::OnchainDkgOutcome;
use tempo_evm::evm::{TempoEvm, TempoEvmFactory};
use tempo_precompiles::{
    PATH_USD_ADDRESS,
    account_keychain::AccountKeychain,
    nonce::NonceManager,
    stablecoin_dex::StablecoinDEX,
    storage::{ContractStorage, StorageCtx},
    tip_fee_manager::{IFeeManager, TipFeeManager},
    tip20::{ISSUER_ROLE, ITIP20, TIP20Token},
    tip20_factory::TIP20Factory,
    tip403_registry::TIP403Registry,
    validator_config::ValidatorConfig,
    validator_config_v2::ValidatorConfigV2,
};

/// Generate genesis allocation file for testing
#[derive(Debug, clap::Args)]
pub(crate) struct GenesisArgs {
    /// Number of accounts to generate
    #[arg(short, long, default_value = "50000")]
    accounts: u32,

    /// Mnemonic to use for account generation
    #[arg(
        short,
        long,
        default_value = "test test test test test test test test test test test junk"
    )]
    mnemonic: String,

    /// Coinbase address
    #[arg(long, default_value = "0x0000000000000000000000000000000000000000")]
    coinbase: Address,

    /// Chain ID
    #[arg(long, short, default_value = "1337")]
    chain_id: u64,

    /// Genesis block gas limit
    #[arg(long, default_value_t = 500_000_000)]
    gas_limit: u64,

    /// The hard-coded length of an epoch in blocks.
    #[arg(long, default_value_t = 302_400)]
    epoch_length: u64,

    /// A comma-separated list of `<ip>:<port>`.
    #[arg(
        long,
        value_name = "<ip>:<port>",
        value_delimiter = ',',
        required_unless_present_all(["no_dkg_in_genesis"]),
    )]
    validators: Vec<SocketAddr>,

    /// Will not write the initial DKG outcome into the extra_data field of
    /// the genesis header.
    #[arg(long)]
    no_dkg_in_genesis: bool,

    /// A fixed seed to generate all signing keys and group shares. This is
    /// intended for use in development and testing. Use at your own peril.
    #[arg(long)]
    pub(crate) seed: Option<u64>,

    /// Custom admin address for pathUSD token.
    /// If not set, uses the first generated account.
    #[arg(long)]
    pathusd_admin: Option<Address>,

    #[arg(long, default_value_t = u64::MAX)]
    pathusd_amount: u64,

    /// Custom admin address for validator config.
    /// If not set, uses the first generated account.
    #[arg(long)]
    validator_admin: Option<Address>,

    /// Custom onchain addresses for validators.
    /// Must match the number of validators if provided.
    #[arg(long, value_delimiter = ',')]
    validator_addresses: Vec<Address>,

    /// Disable creating Alpha/Beta/ThetaUSD tokens.
    #[arg(long)]
    no_extra_tokens: bool,

    /// Enable creating deployment gas token.
    #[arg(long)]
    deployment_gas_token: bool,

    /// Custom admin address for deployment gas token.
    #[arg(long)]
    deployment_gas_token_admin: Option<Address>,

    /// Disable minting pairwise FeeAMM liquidity.
    #[arg(long)]
    no_pairwise_liquidity: bool,

    /// Timestamp for T0 hardfork activation (0 = genesis).
    #[arg(long, default_value = "0")]
    t0_time: u64,

    /// T1 hardfork activation time.
    #[arg(long, default_value = "0")]
    t1_time: u64,

    /// T1.A hardfork activation time.
    #[arg(long, default_value = "0")]
    t1a_time: u64,

    /// T1.B hardfork activation time.
    #[arg(long, default_value = "0")]
    t1b_time: u64,

    /// T1.C hardfork activation time.
    #[arg(long, default_value = "0")]
    t1c_time: u64,

    /// T2 hardfork activation time.
    #[arg(long, default_value = "0")]
    t2_time: u64,

    /// Whether to skip initializing validator config v1
    #[arg(long)]
    no_initialize_validator_config_v1: bool,
}

#[derive(Clone, Debug)]
pub(crate) struct ConsensusConfig {
    pub(crate) output: Output<MinSig, PublicKey>,
    pub(crate) validators: Vec<Validator>,
}
impl ConsensusConfig {
    pub(crate) fn to_genesis_dkg_outcome(&self) -> OnchainDkgOutcome {
        OnchainDkgOutcome {
            epoch: Epoch::zero(),
            output: self.output.clone(),
            next_players: ordered::Set::try_from_iter(
                self.validators.iter().map(Validator::public_key),
            )
            .unwrap(),
            is_next_full_dkg: false,
        }
    }
}

#[derive(Clone, Debug)]
pub(crate) struct Validator {
    pub(crate) addr: SocketAddr,
    pub(crate) signing_key: SigningKey,
    pub(crate) signing_share: SigningShare,
}

impl Validator {
    pub(crate) fn public_key(&self) -> PublicKey {
        self.signing_key.public_key()
    }

    pub(crate) fn dst_dir(&self, path: impl AsRef<Path>) -> PathBuf {
        path.as_ref().join(self.addr.to_string())
    }
    pub(crate) fn dst_signing_key(&self, path: impl AsRef<Path>) -> PathBuf {
        self.dst_dir(path).join("signing.key")
    }

    pub(crate) fn dst_signing_share(&self, path: impl AsRef<Path>) -> PathBuf {
        self.dst_dir(path).join("signing.share")
    }
}

impl GenesisArgs {
    /// Generates a genesis json file.
    ///
    /// It creates a new genesis allocation for the configured accounts.
    /// And creates accounts for system contracts.
    pub(crate) async fn generate_genesis(self) -> eyre::Result<(Genesis, Option<ConsensusConfig>)> {
        println!("Generating {:?} accounts", self.accounts);

        let addresses: Vec<Address> = (0..self.accounts)
            .into_par_iter()
            .progress()
            .map(|worker_id| -> eyre::Result<Address> {
                let signer = MnemonicBuilder::from_phrase_nth(&self.mnemonic, worker_id);
                let address = secret_key_to_address(signer.credential());
                Ok(address)
            })
            .collect::<eyre::Result<Vec<Address>>>()?;

        // system contracts/precompiles must be initialized bottom up, if an init function (e.g. mint_pairwise_liquidity) uses another system contract/precompiles internally (tip403 registry), the registry must be initialized first.

        let pathusd_admin = self.pathusd_admin.unwrap_or_else(|| addresses[0]);
        let validator_admin = self.validator_admin.unwrap_or_else(|| addresses[0]);
        let mut evm = setup_tempo_evm(self.chain_id);

        deploy_arachnid_create2_factory(&mut evm);
        deploy_permit2(&mut evm)?;

        println!("Initializing registry");
        initialize_registry(&mut evm)?;

        // Initialize TIP20Factory once before creating any tokens
        println!("Initializing TIP20Factory");
        initialize_tip20_factory(&mut evm)?;

        println!("Creating pathUSD through factory");
        create_path_usd_token(pathusd_admin, &addresses, self.pathusd_amount, &mut evm)?;

        let (alpha_token_address, beta_token_address, theta_token_address) =
            if !self.no_extra_tokens {
                println!("Initializing TIP20 tokens");
                let alpha = create_and_mint_token(
                    "AlphaUSD",
                    "AlphaUSD",
                    "USD",
                    PATH_USD_ADDRESS,
                    pathusd_admin,
                    &addresses,
                    U256::from(u64::MAX),
                    SaltOrAddress::Address(address!("20C0000000000000000000000000000000000001")),
                    &mut evm,
                )?;

                let beta = create_and_mint_token(
                    "BetaUSD",
                    "BetaUSD",
                    "USD",
                    PATH_USD_ADDRESS,
                    pathusd_admin,
                    &addresses,
                    U256::from(u64::MAX),
                    SaltOrAddress::Address(address!("20C0000000000000000000000000000000000002")),
                    &mut evm,
                )?;

                let theta = create_and_mint_token(
                    "ThetaUSD",
                    "ThetaUSD",
                    "USD",
                    PATH_USD_ADDRESS,
                    pathusd_admin,
                    &addresses,
                    U256::from(u64::MAX),
                    SaltOrAddress::Address(address!("20C0000000000000000000000000000000000003")),
                    &mut evm,
                )?;

                (Some(alpha), Some(beta), Some(theta))
            } else {
                println!("Skipping extra token creation (--no-extra-tokens)");
                (None, None, None)
            };

        if self.deployment_gas_token && self.deployment_gas_token_admin.is_none() {
            eyre::bail!(
                "--deployment-gas-token-admin is required when --deployment-gas-token is set"
            );
        }

        let deployment_gas_token = {
            if self.deployment_gas_token {
                let mut rng = rand_08::rngs::StdRng::seed_from_u64(
                    self.seed.unwrap_or_else(rand_08::random::<u64>),
                );

                let mut salt_bytes = [0u8; 32];
                rand_08::Rng::fill(&mut rng, &mut salt_bytes);

                let address = create_and_mint_token(
                    "DONOTUSE",
                    "DONOTUSE",
                    "USD",
                    PATH_USD_ADDRESS,
                    self.deployment_gas_token_admin.expect(
                        "Deployment gas token admin is required if you want to deploy the token",
                    ),
                    &addresses,
                    U256::from(u64::MAX),
                    SaltOrAddress::Salt(B256::from(salt_bytes)),
                    &mut evm,
                )?;

                println!("Deployment gas token address: {address}");
                Some(address)
            } else {
                None
            }
        };

        println!(
            "generating consensus config for validators: {:?}",
            self.validators
        );
        let consensus_config =
            generate_consensus_config(&self.validators, self.seed, self.no_dkg_in_genesis);

        let validator_onchain_addresses = if self.validator_addresses.is_empty() {
            if addresses.len() < self.validators.len() + 1 {
                return Err(eyre!("not enough accounts created for validators"));
            }

            &addresses[1..self.validators.len() + 1]
        } else {
            if self.validator_addresses.len() < self.validators.len() {
                return Err(eyre!("not enough addresses provided for validators"));
            }

            &self.validator_addresses[0..self.validators.len()]
        };

        if self.t2_time == 0 {
            println!("Initializing validator config v2 (T2 active at genesis)");
            initialize_validator_config_v2(
                validator_admin,
                &mut evm,
                &consensus_config,
                validator_onchain_addresses,
                self.no_dkg_in_genesis,
                self.chain_id,
            )?;
        }

        if !self.no_initialize_validator_config_v1 {
            println!("Initializing validator config v1");
            initialize_validator_config(
                validator_admin,
                &mut evm,
                &consensus_config,
                validator_onchain_addresses,
                self.no_dkg_in_genesis,
            )?;
        } else {
            println!("flag specified; skipping initialization of validator config v1");
        }

        println!("Initializing fee manager");
        let default_user_fee_token = if let Some(address) = deployment_gas_token {
            address
        } else {
            alpha_token_address.unwrap_or(PATH_USD_ADDRESS)
        };

        let default_validator_fee_token = if let Some(address) = deployment_gas_token {
            address
        } else {
            PATH_USD_ADDRESS
        };

        initialize_fee_manager(
            default_validator_fee_token,
            default_user_fee_token,
            addresses.clone(),
            // TODO: also populate validators here, once the logic is back.
            vec![self.coinbase],
            &mut evm,
        );

        println!("Initializing stablecoin exchange");
        initialize_stablecoin_dex(&mut evm)?;

        println!("Initializing nonce manager");
        initialize_nonce_manager(&mut evm)?;

        println!("Initializing account keychain");
        initialize_account_keychain(&mut evm)?;

        if !self.no_pairwise_liquidity {
            if let (Some(alpha), Some(beta), Some(theta)) =
                (alpha_token_address, beta_token_address, theta_token_address)
            {
                println!("Minting pairwise FeeAMM liquidity");
                mint_pairwise_liquidity(
                    alpha,
                    vec![PATH_USD_ADDRESS, beta, theta],
                    U256::from(10u64.pow(10)),
                    pathusd_admin,
                    &mut evm,
                );
            } else {
                println!("Skipping pairwise liquidity (extra tokens not created)");
            }
        } else {
            println!("Skipping pairwise liquidity (--no-pairwise-liquidity)");
        }

        evm.ctx_mut()
            .journaled_state
            .load_account(ARACHNID_CREATE2_FACTORY_ADDRESS)?;
        evm.ctx_mut()
            .journaled_state
            .load_account(PERMIT2_ADDRESS)?;

        // Save EVM state to allocation
        println!("Saving EVM state to allocation");
        let evm_state = evm.ctx_mut().journaled_state.evm_state();
        let mut genesis_alloc: BTreeMap<Address, GenesisAccount> = evm_state
            .iter()
            .progress()
            .map(|(address, account)| {
                let storage = if !account.storage.is_empty() {
                    Some(
                        account
                            .storage
                            .iter()
                            .map(|(key, val)| ((*key).into(), val.present_value.into()))
                            .collect(),
                    )
                } else {
                    None
                };
                let genesis_account = GenesisAccount {
                    nonce: Some(account.info.nonce),
                    code: account.info.code.as_ref().map(|c| c.original_bytes()),
                    storage,
                    ..Default::default()
                };
                (*address, genesis_account)
            })
            .collect();

        genesis_alloc.insert(
            MULTICALL3_ADDRESS,
            GenesisAccount {
                code: Some(Bytes::from_static(&Multicall3::DEPLOYED_BYTECODE)),
                nonce: Some(1),
                ..Default::default()
            },
        );

        genesis_alloc.insert(
            CREATEX_ADDRESS,
            GenesisAccount {
                code: Some(Bytes::from_static(&CreateX::DEPLOYED_BYTECODE)),
                nonce: Some(1),
                ..Default::default()
            },
        );

        genesis_alloc.insert(
            SAFE_DEPLOYER_ADDRESS,
            GenesisAccount {
                code: Some(Bytes::from_static(&SafeDeployer::DEPLOYED_BYTECODE)),
                nonce: Some(1),
                ..Default::default()
            },
        );

        let mut chain_config = ChainConfig {
            chain_id: self.chain_id,
            homestead_block: Some(0),
            eip150_block: Some(0),
            eip155_block: Some(0),
            eip158_block: Some(0),
            byzantium_block: Some(0),
            constantinople_block: Some(0),
            petersburg_block: Some(0),
            istanbul_block: Some(0),
            berlin_block: Some(0),
            london_block: Some(0),
            merge_netsplit_block: Some(0),
            shanghai_time: Some(0),
            cancun_time: Some(0),
            prague_time: Some(0),
            osaka_time: Some(0),
            terminal_total_difficulty: Some(U256::from(0)),
            terminal_total_difficulty_passed: true,
            deposit_contract_address: Some(Address::ZERO),
            ..Default::default()
        };

        chain_config
            .extra_fields
            .insert_value("epochLength".to_string(), self.epoch_length)?;
        chain_config
            .extra_fields
            .insert_value("t0Time".to_string(), self.t0_time)?;
        chain_config
            .extra_fields
            .insert_value("t1Time".to_string(), self.t1_time)?;
        chain_config
            .extra_fields
            .insert_value("t1aTime".to_string(), self.t1a_time)?;
        chain_config
            .extra_fields
            .insert_value("t1bTime".to_string(), self.t1b_time)?;
        chain_config
            .extra_fields
            .insert_value("t1cTime".to_string(), self.t1c_time)?;
        chain_config
            .extra_fields
            .insert_value("t2Time".to_string(), self.t2_time)?;
        let mut extra_data = Bytes::from_static(b"tempo-genesis");

        if let Some(consensus_config) = &consensus_config {
            if self.no_dkg_in_genesis {
                println!("no-initial-dkg-in-genesis passed; not writing to header extra_data");
            } else {
                extra_data = consensus_config
                    .to_genesis_dkg_outcome()
                    .encode()
                    .to_vec()
                    .into();
            }
        }

        // Base fee determined by hardfork: T1 active at genesis (t1_time=0) uses T1 fee
        let base_fee: u128 = if self.t1_time == 0 {
            TempoHardfork::T1.base_fee().into()
        } else {
            TempoHardfork::T0.base_fee().into()
        };

        let mut genesis = Genesis::default()
            .with_gas_limit(self.gas_limit)
            .with_base_fee(Some(base_fee))
            .with_nonce(0x42)
            .with_extra_data(extra_data)
            .with_coinbase(self.coinbase);

        genesis.alloc = genesis_alloc;
        genesis.config = chain_config;

        Ok((genesis, consensus_config))
    }
}

fn setup_tempo_evm(chain_id: u64) -> TempoEvm<CacheDB<EmptyDB>> {
    let db = CacheDB::default();
    // revm sets timestamp to 1 by default, override it to 0 for genesis initializations
    let mut env = EvmEnv::default().with_timestamp(U256::ZERO);
    env.cfg_env.chain_id = chain_id;

    let factory = TempoEvmFactory::default();
    factory.create_evm(db, env)
}

/// Deploys the Arachnid CREATE2 factory by directly inserting it into the EVM state.
fn deploy_arachnid_create2_factory(evm: &mut TempoEvm<CacheDB<EmptyDB>>) {
    println!("Deploying Arachnid CREATE2 factory at {ARACHNID_CREATE2_FACTORY_ADDRESS}");

    evm.db_mut().insert_account_info(
        ARACHNID_CREATE2_FACTORY_ADDRESS,
        AccountInfo {
            code: Some(Bytecode::new_raw(ARACHNID_CREATE2_FACTORY_BYTECODE)),
            nonce: 0,
            ..Default::default()
        },
    );
}

/// Deploys Permit2 contract via the Arachnid CREATE2 factory.
fn deploy_permit2(evm: &mut TempoEvm<CacheDB<EmptyDB>>) -> eyre::Result<()> {
    // Build calldata for Arachnid CREATE2 factory: salt (32 bytes) || creation bytecode
    let bytecode = &tempo_contracts::Permit2::BYTECODE;
    let calldata: Bytes = PERMIT2_SALT
        .as_slice()
        .iter()
        .chain(bytecode.iter())
        .copied()
        .collect();

    println!("Deploying Permit2 via CREATE2 to {PERMIT2_ADDRESS}");

    let result =
        evm.transact_system_call(Address::ZERO, ARACHNID_CREATE2_FACTORY_ADDRESS, calldata)?;

    if !result.result.is_success() {
        return Err(eyre!("Permit2 deployment failed: {:?}", result));
    }

    evm.db_mut().commit(result.state);

    println!("Permit2 deployed successfully at {PERMIT2_ADDRESS}");
    Ok(())
}

/// Initializes the TIP20Factory contract (should be called once before creating any tokens)
fn initialize_tip20_factory(evm: &mut TempoEvm<CacheDB<EmptyDB>>) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || TIP20Factory::new().initialize(),
    )?;
    Ok(())
}

/// Creates pathUSD as the first TIP20 token at a reserved address.
/// pathUSD is not created via factory since it's at a reserved address.
fn create_path_usd_token(
    admin: Address,
    recipients: &[Address],
    amount_per_recipient: u64,
    evm: &mut TempoEvm<CacheDB<EmptyDB>>,
) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || {
            TIP20Factory::new().create_token_reserved_address(
                PATH_USD_ADDRESS,
                "pathUSD",
                "pathUSD",
                "USD",
                Address::ZERO,
                admin,
            )?;

            // Initialize pathUSD directly (not via factory) since it's at a reserved address.
            let mut token = TIP20Token::from_address(PATH_USD_ADDRESS)
                .expect("Could not create pathUSD token instance");
            token.grant_role_internal(admin, *ISSUER_ROLE)?;

            // Mint to all recipients
            for recipient in recipients.iter().progress() {
                token
                    .mint(
                        admin,
                        ITIP20::mintCall {
                            to: *recipient,
                            amount: U256::from(amount_per_recipient),
                        },
                    )
                    .expect("Could not mint pathUSD");
            }

            Ok(())
        },
    )
}

enum SaltOrAddress {
    Salt(B256),
    Address(Address),
}

/// Creates a TIP20 token through the factory (factory must already be initialized)
#[expect(clippy::too_many_arguments)]
fn create_and_mint_token(
    symbol: &str,
    name: &str,
    currency: &str,
    quote_token: Address,
    admin: Address,
    recipients: &[Address],
    mint_amount: U256,
    salt_or_address: SaltOrAddress,
    evm: &mut TempoEvm<CacheDB<EmptyDB>>,
) -> eyre::Result<Address> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || {
            let mut factory = TIP20Factory::new();
            assert!(
                factory
                    .is_initialized()
                    .expect("Could not check factory initialization"),
                "TIP20Factory must be initialized before creating tokens"
            );

            let token_address = match salt_or_address {
                SaltOrAddress::Salt(salt) => factory
                    .create_token(
                        admin,
                        ITIP20Factory::createTokenCall {
                            name: name.into(),
                            symbol: symbol.into(),
                            currency: currency.into(),
                            quoteToken: quote_token,
                            salt,
                            admin,
                        },
                    )
                    .expect("Could not create token"),
                SaltOrAddress::Address(address) => factory
                    .create_token_reserved_address(
                        address,
                        name,
                        symbol,
                        currency,
                        quote_token,
                        admin,
                    )
                    .expect("Could not create token"),
            };

            let mut token =
                TIP20Token::from_address(token_address).expect("Could not create token instance");
            token.grant_role_internal(admin, *ISSUER_ROLE)?;

            let result = token.set_supply_cap(
                admin,
                ITIP20::setSupplyCapCall {
                    newSupplyCap: U256::from(u128::MAX),
                },
            );
            assert!(result.is_ok());

            token
                .mint(
                    admin,
                    ITIP20::mintCall {
                        to: admin,
                        amount: mint_amount,
                    },
                )
                .expect("Token minting failed");

            for address in recipients.iter().progress() {
                token
                    .mint(
                        admin,
                        ITIP20::mintCall {
                            to: *address,
                            amount: U256::from(u64::MAX),
                        },
                    )
                    .expect("Could not mint fee token");
            }

            Ok(token.address())
        },
    )
}

fn initialize_fee_manager(
    validator_fee_token_address: Address,
    user_fee_token_address: Address,
    initial_accounts: Vec<Address>,
    validators: Vec<Address>,
    evm: &mut TempoEvm<CacheDB<EmptyDB>>,
) {
    // Update the beneficiary since the validator can't set the validator fee token for themselves
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || {
            let mut fee_manager = TipFeeManager::new();
            fee_manager
                .initialize()
                .expect("Could not init fee manager");
            println!(
                "Setting user fee token {user_fee_token_address} for {} accounts",
                initial_accounts.len()
            );
            for address in initial_accounts.iter().progress() {
                fee_manager
                    .set_user_token(
                        *address,
                        IFeeManager::setUserTokenCall {
                            token: user_fee_token_address,
                        },
                    )
                    .expect("Could not set fee token");
            }

            // Set validator fee tokens to pathUSD
            for validator in validators {
                println!("Setting user token for {validator} {validator_fee_token_address}");
                fee_manager
                    .set_validator_token(
                        validator,
                        IFeeManager::setValidatorTokenCall {
                            token: validator_fee_token_address,
                        },
                        // use random address to avoid `CannotChangeWithinBlock` error
                        Address::random(),
                    )
                    .expect("Could not set validator fee token");
            }
        },
    );
}

/// Initializes the [`TIP403Registry`] contract.
fn initialize_registry(evm: &mut TempoEvm<CacheDB<EmptyDB>>) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || TIP403Registry::new().initialize(),
    )?;

    Ok(())
}

fn initialize_stablecoin_dex(evm: &mut TempoEvm<CacheDB<EmptyDB>>) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || StablecoinDEX::new().initialize(),
    )?;

    Ok(())
}

fn initialize_nonce_manager(evm: &mut TempoEvm<CacheDB<EmptyDB>>) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || NonceManager::new().initialize(),
    )?;

    Ok(())
}

/// Initializes the [`AccountKeychain`] contract.
fn initialize_account_keychain(evm: &mut TempoEvm<CacheDB<EmptyDB>>) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || AccountKeychain::new().initialize(),
    )?;

    Ok(())
}

/// Initializes the initial validator config smart contract.
///
/// NOTE: Does not populate it at all because consensus does not read the
/// validators at genesis.
fn initialize_validator_config(
    admin: Address,
    evm: &mut TempoEvm<CacheDB<EmptyDB>>,
    consensus_config: &Option<ConsensusConfig>,
    onchain_validator_addresses: &[Address],
    no_dkg_in_genesis: bool,
) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || {
            let mut validator_config = ValidatorConfig::new();
            validator_config
                .initialize(admin)
                .wrap_err("failed to initialize validator config contract")?;

            if no_dkg_in_genesis {
                println!("no-dkg-in-genesis passed; not writing validators to genesis block");
                return Ok(());
            }

            if let Some(consensus_config) = consensus_config.clone() {
                let num_validators = consensus_config.validators.len();

                if onchain_validator_addresses.len() < num_validators {
                    return Err(eyre!(
                        "need {} addresses for all validators, but only {} were provided",
                        num_validators,
                        onchain_validator_addresses.len()
                    ));
                }

                println!("writing {num_validators} validators into contract");
                for (i, validator) in consensus_config.validators.iter().enumerate() {
                    #[expect(non_snake_case, reason = "field of a snakeCase smart contract call")]
                    let newValidatorAddress = onchain_validator_addresses[i];
                    let public_key = validator.public_key();
                    let addr = validator.addr;
                    validator_config
                        .add_validator(
                            admin,
                            IValidatorConfig::addValidatorCall {
                                newValidatorAddress,
                                publicKey: public_key.encode().as_ref().try_into().unwrap(),
                                active: true,
                                inboundAddress: addr.to_string(),
                                outboundAddress: addr.to_string(),
                            },
                        )
                        .wrap_err(
                            "failed to execute smart contract call to add validator to evm state",
                        )?;
                    println!(
                        "added validator\
                \n\tpublic key: {public_key}\
                \n\tonchain address: {newValidatorAddress}\
                \n\tnet address: {addr}"
                    );
                }
            } else {
                println!("no consensus config passed; no validators to write to contract");
            }

            Ok(())
        },
    )
}

/// Initializes the [`ValidatorConfigV2`] contract at genesis (T2 active at genesis).
///
/// Populates validators directly into V2 with `needs_migration = false`.
/// Each `add_validator` call requires an Ed25519 signature from the validator's signing key.
fn initialize_validator_config_v2(
    admin: Address,
    evm: &mut TempoEvm<CacheDB<EmptyDB>>,
    consensus_config: &Option<ConsensusConfig>,
    onchain_validator_addresses: &[Address],
    no_dkg_in_genesis: bool,
    chain_id: u64,
) -> eyre::Result<()> {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || {
            let mut v2 = ValidatorConfigV2::new();
            v2.initialize(admin)
                .wrap_err("failed to initialize validator config v2")?;

            if no_dkg_in_genesis {
                println!("no-dkg-in-genesis passed; not writing validators to genesis block");
                return Ok(());
            }

            let Some(consensus_config) = consensus_config.clone() else {
                println!("no consensus config passed; no validators to write to contract");
                return Ok(());
            };

            let num_validators = consensus_config.validators.len();
            if onchain_validator_addresses.len() < num_validators {
                return Err(eyre!(
                    "need {} addresses for all validators, but only {} were provided",
                    num_validators,
                    onchain_validator_addresses.len()
                ));
            }

            println!("writing {num_validators} validators into v2 contract");
            for (i, validator) in consensus_config.validators.iter().enumerate() {
                let validator_address = onchain_validator_addresses[i];
                let public_key = validator.public_key();
                let pubkey: B256 = public_key.encode().as_ref().try_into().unwrap();
                let addr = validator.addr;

                let config = tempo_validator_config::ValidatorConfig {
                    chain_id,
                    validator_address,
                    public_key: pubkey,
                    ingress: addr,
                    egress: addr.ip(),
                };

                let message = config.add_validator_message_hash(validator_address);
                let private_key = validator.signing_key.clone().into_inner();
                let signature = private_key.sign(
                    tempo_precompiles::validator_config_v2::VALIDATOR_NS_ADD,
                    message.as_slice(),
                );

                v2.add_validator(
                    admin,
                    IValidatorConfigV2::addValidatorCall {
                        validatorAddress: validator_address,
                        publicKey: pubkey,
                        ingress: config.ingress.to_string(),
                        egress: config.egress.to_string(),
                        feeRecipient: validator_address,
                        signature: signature.encode().to_vec().into(),
                    },
                )
                .wrap_err("failed to add validator to V2")?;

                println!(
                    "added validator (v2)\
                    \n\tpublic key: {public_key}\
                    \n\tonchain address: {validator_address}\
                    \n\tnet address: {addr}"
                );
            }
            Ok(())
        },
    )
}

/// Generates the consensus configs of the validators.
fn generate_consensus_config(
    validators: &[SocketAddr],
    seed: Option<u64>,
    no_dkg_in_genesis: bool,
) -> Option<ConsensusConfig> {
    use commonware_cryptography::ed25519::PrivateKey;

    match (validators.is_empty(), no_dkg_in_genesis) {
        (_, true) => {
            println!(
                "no-dkg-in-genesis passed; not generating any consensus config because I can't write it to the genesis block"
            );
            return None;
        }
        (true, false) => {
            panic!("no validators provided and no-dkg-in-genesis not set");
        }
        _ => {}
    }

    let mut rng = rand_08::rngs::StdRng::seed_from_u64(seed.unwrap_or_else(rand_08::random::<u64>));

    let mut signer_keys = repeat_with(|| PrivateKey::random(&mut rng))
        .take(validators.len())
        .collect::<Vec<_>>();
    signer_keys.sort_by_key(|key| key.public_key());

    let (output, shares) = dkg::deal::<_, _, N3f1>(
        &mut rng,
        Mode::NonZeroCounter,
        ordered::Set::try_from_iter(signer_keys.iter().map(|key| key.public_key())).unwrap(),
    )
    .unwrap();

    let validators = validators
        .iter()
        .copied()
        .zip_eq(signer_keys)
        .zip_eq(shares)
        .map(|((addr, signing_key), (verifying_key, signing_share))| {
            assert_eq!(signing_key.public_key(), verifying_key);
            Validator {
                addr,
                signing_key: SigningKey::from(signing_key),
                signing_share: SigningShare::from(signing_share),
            }
        })
        .collect();

    Some(ConsensusConfig { output, validators })
}

fn mint_pairwise_liquidity(
    a_token: Address,
    b_tokens: Vec<Address>,
    amount: U256,
    admin: Address,
    evm: &mut TempoEvm<CacheDB<EmptyDB>>,
) {
    let ctx = evm.ctx_mut();
    StorageCtx::enter_evm(
        &mut ctx.journaled_state,
        &ctx.block,
        &ctx.cfg,
        &ctx.tx,
        || {
            let mut fee_manager = TipFeeManager::new();

            for b_token_address in b_tokens {
                fee_manager
                    .mint(admin, a_token, b_token_address, amount, admin)
                    .expect("Could not mint A -> B Liquidity pool");
            }
        },
    );
}