Skip to main content

foundry_evm/inspectors/
tempo_labels.rs

1use alloy_primitives::{U256, keccak256, map::AddressMap};
2use evm2::{
3    EvmTypes, Inspector,
4    interpreter::{Interpreter, Message, MessageResult},
5};
6use tempo_primitives::TempoAddressExt;
7
8// Limit labels to 256 bytes so long names require at most eight additional storage reads.
9const MAX_NAME_BYTES: usize = 256;
10
11/// Inspector that labels TIP20 token precompile addresses with their on-chain names.
12///
13/// During execution, when a call targets a TIP20 address, this inspector reads the token's
14/// name from storage and records the `address -> name` mapping. These labels are later merged
15/// into trace output for better readability.
16#[derive(Default, Clone, Debug)]
17pub struct TempoLabels {
18    pub(crate) labels: AddressMap<String>,
19}
20
21impl<T: EvmTypes> Inspector<T> for TempoLabels {
22    fn call(
23        &mut self,
24        interp: &mut Interpreter<'_, '_, T>,
25        message: &mut Message<T>,
26    ) -> Option<MessageResult<T>> {
27        let address = message.destination;
28        if address.is_tip20() && !self.labels.contains_key(&address) {
29            let state = interp.host().state_mut();
30            let name = 'decode: {
31                let slot = tempo_precompiles::tip20::slots::NAME;
32                let Ok(value) = state.storage_slot_untracked(&address, &slot) else {
33                    break 'decode None;
34                };
35                let bytes = value.to_be_bytes::<32>();
36                if bytes[31] & 1 == 0 {
37                    let len = usize::from(bytes[31] / 2);
38                    break 'decode (1..=31)
39                        .contains(&len)
40                        .then(|| String::from_utf8_lossy(&bytes[..len]).into_owned());
41                }
42
43                // Long strings store length * 2 + 1 in the base slot and data at keccak256(slot).
44                let len = value >> 1usize;
45                if len < U256::from(32) || len > U256::from(MAX_NAME_BYTES) {
46                    break 'decode None;
47                }
48                let len = len.to::<usize>();
49                let start = Into::<U256>::into(keccak256(slot.to_be_bytes::<32>()));
50                let mut data = Vec::with_capacity(len);
51                for i in 0..len.div_ceil(32) {
52                    let Ok(chunk) =
53                        state.storage_slot_untracked(&address, &(start + U256::from(i)))
54                    else {
55                        break 'decode None;
56                    };
57                    let chunk = chunk.to_be_bytes::<32>();
58                    data.extend_from_slice(&chunk[..(len - data.len()).min(32)]);
59                }
60                Some(String::from_utf8_lossy(&data).into_owned())
61            }
62            .unwrap_or_else(|| "TIP20".to_string());
63            self.labels.insert(address, name);
64        }
65
66        None
67    }
68}