feat(anvil): use Alloy otterscan types (#8318)

* deprecate src/eth/otterscan/types.rs

* fmt

* Revert "fmt"

This reverts commit bf1969f.

* (less) fmt

* requested changes

* CallType into String

* clippy + comment

---------

Co-authored-by: drun <[email protected]>
Co-authored-by: DaniPopes <[email protected]>
Co-authored-by: Matthias Seitz <[email protected]>

Author: 4 people

crates/anvil/core/src/eth/transaction/mod.rs

@@ -10,8 +10,8 @@ use alloy_eips::eip2718::{Decodable2718, Eip2718Error, Encodable2718};
 use alloy_primitives::{Address, Bloom, Bytes, Log, Signature, TxHash, TxKind, B256, U256, U64};
 use alloy_rlp::{length_of_length, Decodable, Encodable, Header};
 use alloy_rpc_types::{
-    request::TransactionRequest, AccessList, AnyTransactionReceipt, ConversionError,
-    Signature as RpcSignature, Transaction as RpcTransaction, TransactionReceipt,
+    request::TransactionRequest, trace::otterscan::OtsReceipt, AccessList, AnyTransactionReceipt,
+    ConversionError, Signature as RpcSignature, Transaction as RpcTransaction, TransactionReceipt,
 };
 use alloy_serde::{OtherFields, WithOtherFields};
 use bytes::BufMut;
@@ -70,7 +70,7 @@ pub fn transaction_request_to_typed(
             gas_limit: gas.unwrap_or_default(),
             is_system_tx: other.get_deserialized::<bool>("isSystemTx")?.ok()?,
             input: input.into_input().unwrap_or_default(),
-        }))
+        }));
     }
 
     match (
@@ -198,7 +198,7 @@ impl MaybeImpersonatedTransaction {
     #[cfg(feature = "impersonated-tx")]
     pub fn recover(&self) -> Result<Address, alloy_primitives::SignatureError> {
         if let Some(sender) = self.impersonated_sender {
-            return Ok(sender)
+            return Ok(sender);
         }
         self.transaction.recover()
     }
@@ -211,7 +211,7 @@ impl MaybeImpersonatedTransaction {
     pub fn hash(&self) -> B256 {
         if self.transaction.is_impersonated() {
             if let Some(sender) = self.impersonated_sender {
-                return self.transaction.impersonated_hash(sender)
+                return self.transaction.impersonated_hash(sender);
             }
         }
         self.transaction.hash()
@@ -1016,7 +1016,7 @@ impl Decodable for TypedTransaction {
 
         // Legacy TX
         if header.list {
-            return Ok(TxEnvelope::decode(buf)?.into())
+            return Ok(TxEnvelope::decode(buf)?.into());
         }
 
         // Check byte after header
@@ -1062,7 +1062,7 @@ impl Encodable2718 for TypedTransaction {
 impl Decodable2718 for TypedTransaction {
     fn typed_decode(ty: u8, buf: &mut &[u8]) -> Result<Self, Eip2718Error> {
         if ty == 0x7E {
-            return Ok(Self::Deposit(DepositTransaction::decode(buf)?))
+            return Ok(Self::Deposit(DepositTransaction::decode(buf)?));
         }
         match TxEnvelope::typed_decode(ty, buf)? {
             TxEnvelope::Eip2930(tx) => Ok(Self::EIP2930(tx)),
@@ -1245,6 +1245,37 @@ impl<T> TypedReceipt<T> {
     }
 }
 
+impl<T> From<TypedReceipt<T>> for ReceiptWithBloom<T> {
+    fn from(value: TypedReceipt<T>) -> Self {
+        match value {
+            TypedReceipt::Legacy(r) |
+            TypedReceipt::EIP1559(r) |
+            TypedReceipt::EIP2930(r) |
+            TypedReceipt::EIP4844(r) => r,
+            TypedReceipt::Deposit(r) => r.inner,
+        }
+    }
+}
+
+impl From<TypedReceipt<alloy_rpc_types::Log>> for OtsReceipt {
+    fn from(value: TypedReceipt<alloy_rpc_types::Log>) -> Self {
+        let r#type = match value {
+            TypedReceipt::Legacy(_) => 0x00,
+            TypedReceipt::EIP2930(_) => 0x01,
+            TypedReceipt::EIP1559(_) => 0x02,
+            TypedReceipt::EIP4844(_) => 0x03,
+            TypedReceipt::Deposit(_) => 0x7E,
+        } as u8;
+        let receipt = ReceiptWithBloom::<alloy_rpc_types::Log>::from(value);
+        let status = receipt.status();
+        let cumulative_gas_used = receipt.cumulative_gas_used() as u64;
+        let logs = receipt.receipt.logs.into_iter().map(|x| x.inner).collect();
+        let logs_bloom = receipt.logs_bloom;
+
+        Self { status, cumulative_gas_used, logs: Some(logs), logs_bloom: Some(logs_bloom), r#type }
+    }
+}
+
 impl TypedReceipt {
     pub fn cumulative_gas_used(&self) -> u128 {
         self.as_receipt_with_bloom().cumulative_gas_used()
@@ -1395,7 +1426,7 @@ impl Encodable2718 for TypedReceipt {
 impl Decodable2718 for TypedReceipt {
     fn typed_decode(ty: u8, buf: &mut &[u8]) -> Result<Self, Eip2718Error> {
         if ty == 0x7E {
-            return Ok(Self::Deposit(DepositReceipt::decode(buf)?))
+            return Ok(Self::Deposit(DepositReceipt::decode(buf)?));
         }
         match ReceiptEnvelope::typed_decode(ty, buf)? {
             ReceiptEnvelope::Eip2930(tx) => Ok(Self::EIP2930(tx)),

crates/anvil/src/eth/backend/mem/storage.rs

@@ -14,6 +14,7 @@ use alloy_rpc_types::{
             FourByteFrame, GethDebugBuiltInTracerType, GethDebugTracerType,
             GethDebugTracingOptions, GethTrace, NoopFrame,
         },
+        otterscan::{InternalOperation, OperationType},
         parity::LocalizedTransactionTrace,
     },
     BlockId, BlockNumberOrTag, TransactionInfo as RethTransactionInfo,
@@ -25,7 +26,9 @@ use anvil_core::eth::{
 use anvil_rpc::error::RpcError;
 use foundry_evm::{
     revm::primitives::Env,
-    traces::{FourByteInspector, GethTraceBuilder, ParityTraceBuilder, TracingInspectorConfig},
+    traces::{
+        CallKind, FourByteInspector, GethTraceBuilder, ParityTraceBuilder, TracingInspectorConfig,
+    },
 };
 use parking_lot::RwLock;
 use std::{
@@ -164,7 +167,7 @@ impl InMemoryBlockStates {
             if let Some(state) = self.on_disk_states.get_mut(hash) {
                 if let Some(cached) = self.disk_cache.read(*hash) {
                     state.init_from_snapshot(cached);
-                    return Some(state)
+                    return Some(state);
                 }
             }
             None
@@ -426,6 +429,31 @@ impl MinedTransaction {
         })
     }
 
+    pub fn ots_internal_operations(&self) -> Vec<InternalOperation> {
+        self.info
+            .traces
+            .iter()
+            .filter_map(|node| {
+                let r#type = match node.trace.kind {
+                    _ if node.is_selfdestruct() => OperationType::OpSelfDestruct,
+                    CallKind::Call if !node.trace.value.is_zero() => OperationType::OpTransfer,
+                    CallKind::Create => OperationType::OpCreate,
+                    CallKind::Create2 => OperationType::OpCreate2,
+                    _ => return None,
+                };
+                let mut from = node.trace.caller;
+                let mut to = node.trace.address;
+                let mut value = node.trace.value;
+                if node.is_selfdestruct() {
+                    from = node.trace.address;
+                    to = node.trace.selfdestruct_refund_target.unwrap_or_default();
+                    value = node.trace.selfdestruct_transferred_value.unwrap_or_default();
+                }
+                Some(InternalOperation { r#type, from, to, value })
+            })
+            .collect()
+    }
+
     pub fn geth_trace(&self, opts: GethDebugTracingOptions) -> Result<GethTrace, BlockchainError> {
         let GethDebugTracingOptions { config, tracer, tracer_config, .. } = opts;
 
@@ -434,7 +462,7 @@ impl MinedTransaction {
                 GethDebugTracerType::BuiltInTracer(tracer) => match tracer {
                     GethDebugBuiltInTracerType::FourByteTracer => {
                         let inspector = FourByteInspector::default();
-                        return Ok(FourByteFrame::from(inspector).into())
+                        return Ok(FourByteFrame::from(inspector).into());
                     }
                     GethDebugBuiltInTracerType::CallTracer => {
                         return match tracer_config.into_call_config() {