Skip to main content

foundry_evm_core/
tempo.rs

1//! Tempo precompile and contract initialization for Foundry.
2//!
3//! This module provides the core initialization logic for Tempo-specific precompiles,
4//! fee tokens (PathUSD, AlphaUSD, BetaUSD, ThetaUSD), and standard contracts.
5//!
6//! It includes the shared genesis initialization function used by both anvil and forge.
7
8use alloy_primitives::{Address, Bytes, U256};
9use tempo_contracts::{
10    ARACHNID_CREATE2_FACTORY_ADDRESS, CREATEX_ADDRESS, CreateX, MULTICALL3_ADDRESS, Multicall3,
11    PERMIT2_ADDRESS, Permit2, SAFE_DEPLOYER_ADDRESS, SafeDeployer,
12    contracts::ARACHNID_CREATE2_FACTORY_BYTECODE, precompiles::VALIDATOR_CONFIG_ADDRESS,
13};
14use tempo_hardfork::TempoHardfork;
15use tempo_precompiles::{
16    error::TempoPrecompileError,
17    storage::StorageCtx,
18    tip20::{ITIP20, TIP20Token},
19    tip20_factory::TIP20Factory,
20    validator_config,
21};
22
23use crate::constants::SYSTEM_PRECOMPILE_STUB;
24
25pub use foundry_common::tempo::{
26    ALPHA_USD_ADDRESS, BETA_USD_ADDRESS, PATH_USD_ADDRESS, THETA_USD_ADDRESS,
27};
28pub use foundry_evm_networks::{
29    TEMPO_PRECOMPILE_ADDRESSES, active_tempo_precompile_addresses, is_tempo_precompile_active_at,
30};
31pub use tempo_contracts::precompiles::{
32    ACCOUNT_KEYCHAIN_ADDRESS, ADDRESS_REGISTRY_ADDRESS, IAccountKeychain, IAddressRegistry,
33    IFeeManager, IReceivePolicyGuard, ISignatureVerifier, IStablecoinDEX, ITIP20ChannelReserve,
34    ITIP403Registry, RECEIVE_POLICY_GUARD_ADDRESS, SIGNATURE_VERIFIER_ADDRESS,
35    STABLECOIN_DEX_ADDRESS, TIP_FEE_MANAGER_ADDRESS, TIP20_CHANNEL_RESERVE_ADDRESS,
36    TIP20_FACTORY_ADDRESS, TIP403_REGISTRY_ADDRESS,
37};
38pub use tempo_precompiles::{
39    address_registry::{AddressRegistry, IMPLICIT_APPROVAL_LIST, is_implicitly_approved},
40    signature_verifier::SignatureVerifier,
41    stablecoin_dex::StablecoinDEX,
42    tip_fee_manager::TipFeeManager,
43    tip20::is_tip20_prefix,
44    tip20_channel_reserve::TIP20ChannelReserve,
45};
46
47/// All well-known TIP20 fee token addresses on Tempo networks.
48pub const TEMPO_TIP20_TOKENS: &[Address] = &[PATH_USD_ADDRESS];
49
50/// Inner genesis initialization logic. Must be called within a [`StorageCtx`] scope
51/// (either via [`StorageCtx::enter`] or [`StorageCtx::enter_evm`]).
52/// Returns whether genesis code was installed rather than already initialized.
53pub fn initialize_tempo_genesis_inner(
54    admin: Address,
55    recipient: Address,
56    hardfork: TempoHardfork,
57) -> Result<bool, TempoPrecompileError> {
58    initialize_tempo_genesis_inner_with_precompiles(
59        admin,
60        recipient,
61        active_tempo_precompile_addresses(hardfork),
62    )
63}
64
65/// Inner genesis initialization for Forge's local test EVM.
66///
67/// Forge tests use sentinel bytecode to identify well-known Tempo precompile accounts, even when
68/// the current setup spec is earlier than the precompile's activation hardfork. This does not
69/// affect hardfork-aware execution, which remains handled by the precompile lookup.
70pub fn initialize_tempo_test_genesis_inner(
71    admin: Address,
72    recipient: Address,
73) -> Result<(), TempoPrecompileError> {
74    initialize_tempo_genesis_inner_with_precompiles(
75        admin,
76        recipient,
77        TEMPO_PRECOMPILE_ADDRESSES.iter().copied(),
78    )
79    .map(|_| ())
80}
81
82fn initialize_tempo_genesis_inner_with_precompiles(
83    admin: Address,
84    recipient: Address,
85    precompiles: impl IntoIterator<Item = Address>,
86) -> Result<bool, TempoPrecompileError> {
87    // Idempotent: PATH_USD is the first token created during genesis; if it already exists, skip.
88    if TIP20Factory::new().is_tip20(PATH_USD_ADDRESS)? {
89        return Ok(false);
90    }
91
92    let mut ctx = StorageCtx;
93
94    // Set sentinel bytecode for precompile addresses
95    for precompile in precompiles {
96        ctx.set_code(precompile, Bytes::from_static(SYSTEM_PRECOMPILE_STUB))?;
97    }
98
99    // Create PathUSD token: 0x20C0000000000000000000000000000000000000
100    let path_usd_token_address = create_and_mint_token(
101        PATH_USD_ADDRESS,
102        "PathUSD",
103        "PathUSD",
104        "USD",
105        Address::ZERO,
106        admin,
107        recipient,
108        U256::from(u64::MAX),
109    )?;
110
111    // Create AlphaUSD token: 0x20C0000000000000000000000000000000000001
112    let _alpha_usd_token_address = create_and_mint_token(
113        ALPHA_USD_ADDRESS,
114        "AlphaUSD",
115        "AlphaUSD",
116        "USD",
117        path_usd_token_address,
118        admin,
119        recipient,
120        U256::from(u64::MAX),
121    )?;
122
123    // Create BetaUSD token: 0x20C0000000000000000000000000000000000002
124    let _beta_usd_token_address = create_and_mint_token(
125        BETA_USD_ADDRESS,
126        "BetaUSD",
127        "BetaUSD",
128        "USD",
129        path_usd_token_address,
130        admin,
131        recipient,
132        U256::from(u64::MAX),
133    )?;
134
135    // Create ThetaUSD token: 0x20C0000000000000000000000000000000000003
136    let _theta_usd_token_address = create_and_mint_token(
137        THETA_USD_ADDRESS,
138        "ThetaUSD",
139        "ThetaUSD",
140        "USD",
141        path_usd_token_address,
142        admin,
143        recipient,
144        U256::from(u64::MAX),
145    )?;
146
147    // Initialize ValidatorConfig with admin as owner
148    ctx.sstore(VALIDATOR_CONFIG_ADDRESS, validator_config::slots::OWNER, admin.into_word().into())?;
149
150    // Set bytecode for standard contracts.
151    for (address, code) in tempo_genesis_contracts() {
152        ctx.set_code(address, code)?;
153    }
154
155    Ok(true)
156}
157
158/// Helper function to create and mint a TIP20 token.
159#[allow(clippy::too_many_arguments)]
160fn create_and_mint_token(
161    address: Address,
162    symbol: &str,
163    name: &str,
164    currency: &str,
165    quote_token: Address,
166    admin: Address,
167    recipient: Address,
168    mint_amount: U256,
169) -> Result<Address, TempoPrecompileError> {
170    let mut tip20_factory = TIP20Factory::new();
171
172    let token_address = tip20_factory.create_token_reserved_address(
173        address,
174        name,
175        symbol,
176        currency,
177        quote_token,
178        admin,
179    )?;
180
181    let mut token = TIP20Token::from_address(token_address)?;
182    token.grant_role_internal(admin, TIP20Token::issuer_role())?;
183    token.mint(admin, ITIP20::mintCall { to: recipient, amount: mint_amount })?;
184    if admin != recipient {
185        token.mint(admin, ITIP20::mintCall { to: admin, amount: mint_amount })?;
186    }
187
188    Ok(token_address)
189}
190
191/// Standard contracts and their runtime bytecode installed by Tempo genesis initialization.
192pub fn tempo_genesis_contracts() -> impl Iterator<Item = (Address, Bytes)> {
193    [
194        (MULTICALL3_ADDRESS, Multicall3::DEPLOYED_BYTECODE.clone()),
195        (CREATEX_ADDRESS, CreateX::DEPLOYED_BYTECODE.clone()),
196        (SAFE_DEPLOYER_ADDRESS, SafeDeployer::DEPLOYED_BYTECODE.clone()),
197        (PERMIT2_ADDRESS, Permit2::DEPLOYED_BYTECODE.clone()),
198        (ARACHNID_CREATE2_FACTORY_ADDRESS, ARACHNID_CREATE2_FACTORY_BYTECODE),
199    ]
200    .into_iter()
201}