pezkuwichain/revive-differential-tests
1
0
Fork 0
mirror of https://github.com/pezkuwichain/revive-differential-tests.git synced 2026-06-13 22:11:04 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove address replacement

Browse Source
This commit is contained in:
Omar Abdulla
2025-07-22 14:34:22 +03:00
parent 6a9acea748
commit 52042dfff5
8 changed files with 55 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/format/src/input.rs
+2 -94
View File
@@ -13,7 +13,7 @@ use serde::Deserialize;
use revive_dt_node_interaction::EthereumNode;
use crate::metadata::{AddressReplacementMap, ContractInstance};
use crate::metadata::ContractInstance;
#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq)]
pub struct Input {
@@ -101,41 +101,6 @@ impl ExpectedOutput {
self.return_data = Some(calldata);
self
}
pub fn handle_address_replacement(
&mut self,
old_to_new_mapping: &AddressReplacementMap,
) -> anyhow::Result<()> {
if let Some(ref mut calldata) = self.return_data {
calldata.handle_address_replacement(old_to_new_mapping)?;
}
if let Some(ref mut events) = self.events {
for event in events.iter_mut() {
event.handle_address_replacement(old_to_new_mapping)?;
}
}
Ok(())
}
}
impl Event {
pub fn handle_address_replacement(
&mut self,
old_to_new_mapping: &AddressReplacementMap,
) -> anyhow::Result<()> {
if let Some(ref mut address) = self.address {
if let Some(new_address) = old_to_new_mapping.resolve(address.to_string().as_str()) {
*address = new_address
}
};
for topic in self.topics.iter_mut() {
if let Some(new_address) = old_to_new_mapping.resolve(topic.to_string().as_str()) {
*topic = new_address.to_string();
}
}
self.values.handle_address_replacement(old_to_new_mapping)?;
Ok(())
}
}
impl Default for Calldata {
@@ -155,23 +120,6 @@ impl Calldata {
}
}
pub fn handle_address_replacement(
&mut self,
old_to_new_mapping: &AddressReplacementMap,
) -> anyhow::Result<()> {
match self {
Calldata::Single(_) => {}
Calldata::Compound(items) => {
for item in items.iter_mut() {
if let Some(resolved) = old_to_new_mapping.resolve(item) {
*item = resolved.to_string()
}
}
}
}
Ok(())
}
pub fn calldata(
&self,
deployed_contracts: &HashMap<ContractInstance, (Address, JsonAbi)>,
@@ -217,27 +165,7 @@ impl Calldata {
}
}
impl Expected {
pub fn handle_address_replacement(
&mut self,
old_to_new_mapping: &AddressReplacementMap,
) -> anyhow::Result<()> {
match self {
Expected::Calldata(calldata) => {
calldata.handle_address_replacement(old_to_new_mapping)?;
}
Expected::Expected(expected_output) => {
expected_output.handle_address_replacement(old_to_new_mapping)?;
}
Expected::ExpectedMany(expected_outputs) => {
for expected_output in expected_outputs.iter_mut() {
expected_output.handle_address_replacement(old_to_new_mapping)?;
}
}
}
Ok(())
}
}
impl Expected {}
impl Input {
fn instance_to_address(
@@ -341,26 +269,6 @@ impl Input {
vec
}
pub fn handle_address_replacement(
&mut self,
old_to_new_mapping: &mut AddressReplacementMap,
) -> anyhow::Result<()> {
if self.caller != default_caller() {
self.caller = old_to_new_mapping.add(self.caller);
}
self.calldata
.handle_address_replacement(old_to_new_mapping)?;
if let Some(ref mut expected) = self.expected {
expected.handle_address_replacement(old_to_new_mapping)?;
}
if let Some(ref mut storage) = self.storage {
for calldata in storage.values_mut() {
calldata.handle_address_replacement(old_to_new_mapping)?;
}
}
Ok(())
}
}
fn default_instance() -> ContractInstance {
crates/format/src/metadata.rs
+1 -139
View File
@@ -1,5 +1,5 @@
use std::{
collections::{BTreeMap, HashMap},
collections::BTreeMap,
fmt::Display,
fs::{File, read_to_string},
ops::Deref,
@@ -7,15 +7,11 @@ use std::{
str::FromStr,
};
use alloy::signers::local::PrivateKeySigner;
use alloy_primitives::Address;
use revive_dt_node_interaction::EthereumNode;
use serde::{Deserialize, Serialize};
use crate::{
case::Case,
define_wrapper_type,
input::resolve_argument,
mode::{Mode, SolcMode},
};
@@ -214,17 +210,6 @@ impl Metadata {
}
}
}
pub fn handle_address_replacement(
&mut self,
old_to_new_mapping: &mut AddressReplacementMap,
) -> anyhow::Result<()> {
for case in self.cases.iter_mut() {
case.handle_address_replacement(old_to_new_mapping)?;
}
tracing::debug!(metadata = ?self, "Performed replacement on metadata");
Ok(())
}
}
define_wrapper_type!(
@@ -323,129 +308,6 @@ impl From<ContractPathAndIdentifier> for String {
}
}
#[derive(Clone, Debug, Default)]
pub struct AddressReplacementMap(HashMap<Address, (PrivateKeySigner, Address)>);
impl AddressReplacementMap {
pub fn new() -> Self {
Self(Default::default())
}
pub fn into_inner(self) -> HashMap<Address, (PrivateKeySigner, Address)> {
self.0
}
pub fn contains_key(&self, address: &Address) -> bool {
self.0.contains_key(address)
}
pub fn add(&mut self, address: Address) -> Address {
self.0
.entry(address)
.or_insert_with(|| {
let private_key = Self::new_random_private_key_signer();
let account = private_key.address();
tracing::debug!(
old_address = %address,
new_address = %account,
"Added a new address replacement"
);
(private_key, account)
})
.1
}
pub fn resolve(&self, value: &str) -> Option<Address> {
// We attempt to resolve the given string without any additional context of the deployed
// contracts or the node API as we do not need them. If the resolution fails then we know
// that this isn't an address and we skip it.
let Ok(resolved) = resolve_argument(value, &Default::default(), &UnimplementedEthereumNode)
else {
return None;
};
let resolved_bytes = resolved.to_be_bytes_trimmed_vec();
let Ok(address) = Address::try_from(resolved_bytes.as_slice()) else {
return None;
};
self.0.get(&address).map(|(_, address)| *address)
}
fn new_random_private_key_signer() -> PrivateKeySigner {
// TODO: Use a seedable RNG to allow for deterministic allocation of the private keys so
// that we get reproducible runs.
PrivateKeySigner::random()
}
}
impl AsRef<HashMap<Address, (PrivateKeySigner, Address)>> for AddressReplacementMap {
fn as_ref(&self) -> &HashMap<Address, (PrivateKeySigner, Address)> {
&self.0
}
}
struct UnimplementedEthereumNode;
impl EthereumNode for UnimplementedEthereumNode {
fn execute_transaction(
&self,
_: alloy::rpc::types::TransactionRequest,
) -> anyhow::Result<alloy::rpc::types::TransactionReceipt> {
anyhow::bail!("Unimplemented")
}
fn chain_id(&self) -> anyhow::Result<alloy_primitives::ChainId> {
anyhow::bail!("Unimplemented")
}
fn block_gas_limit(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<u128> {
anyhow::bail!("Unimplemented")
}
fn block_coinbase(&self, _: alloy::eips::BlockNumberOrTag) -> anyhow::Result<Address> {
anyhow::bail!("Unimplemented")
}
fn block_difficulty(
&self,
_: alloy::eips::BlockNumberOrTag,
) -> anyhow::Result<alloy_primitives::U256> {
anyhow::bail!("Unimplemented")
}
fn block_hash(
&self,
_: alloy::eips::BlockNumberOrTag,
) -> anyhow::Result<alloy_primitives::BlockHash> {
anyhow::bail!("Unimplemented")
}
fn block_timestamp(
&self,
_: alloy::eips::BlockNumberOrTag,
) -> anyhow::Result<alloy_primitives::BlockTimestamp> {
anyhow::bail!("Unimplemented")
}
fn last_block_number(&self) -> anyhow::Result<alloy_primitives::BlockNumber> {
anyhow::bail!("Unimplemented")
}
fn trace_transaction(
&self,
_: &alloy::rpc::types::TransactionReceipt,
_: alloy::rpc::types::trace::geth::GethDebugTracingOptions,
) -> anyhow::Result<alloy::rpc::types::trace::geth::GethTrace> {
anyhow::bail!("Unimplemented")
}
fn state_diff(
&self,
_: &alloy::rpc::types::TransactionReceipt,
) -> anyhow::Result<alloy::rpc::types::trace::geth::DiffMode> {
anyhow::bail!("Unimplemented")
}
}
#[cfg(test)]
mod test {
use super::*;