use super::{
Address, BlockHash, ChainId, Data, OperationContext, OperationValue, Quantity, ReadOperation,
ReadState, TransactionId, U256, Word,
};
use crate::error::{Error, ValidationError};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Inclusion {
block_hash: BlockHash,
block_number: u64,
transaction_index: u64,
}
impl Inclusion {
#[must_use]
pub const fn new(block_hash: BlockHash, block_number: u64, transaction_index: u64) -> Self {
Self {
block_hash,
block_number,
transaction_index,
}
}
#[must_use]
pub const fn block_hash(self) -> BlockHash {
self.block_hash
}
#[must_use]
pub const fn block_number(self) -> u64 {
self.block_number
}
#[must_use]
pub const fn transaction_index(self) -> u64 {
self.transaction_index
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AccessListEntry {
pub address: Address,
pub storage_keys: Vec<Word>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SignatureFields {
pub r: Quantity,
pub s: Quantity,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub v: Option<Quantity>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub y_parity: Option<bool>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Authorization {
pub chain_id: ChainId,
pub address: Address,
pub nonce: Quantity,
pub y_parity: bool,
pub r: Quantity,
pub s: Quantity,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum TransactionKind {
Legacy {
gas_price: Quantity,
},
AccessList {
gas_price: Quantity,
access_list: Vec<AccessListEntry>,
},
DynamicFee {
max_fee_per_gas: Quantity,
max_priority_fee_per_gas: Quantity,
access_list: Vec<AccessListEntry>,
},
Blob {
max_fee_per_gas: Quantity,
max_priority_fee_per_gas: Quantity,
max_fee_per_blob_gas: Quantity,
access_list: Vec<AccessListEntry>,
blob_versioned_hashes: Vec<Word>,
},
Authorization {
max_fee_per_gas: Quantity,
max_priority_fee_per_gas: Quantity,
access_list: Vec<AccessListEntry>,
authorization_list: Vec<Authorization>,
},
}
impl TransactionKind {
#[must_use]
pub const fn type_byte(&self) -> u8 {
match self {
Self::Legacy { .. } => 0,
Self::AccessList { .. } => 1,
Self::DynamicFee { .. } => 2,
Self::Blob { .. } => 3,
Self::Authorization { .. } => 4,
}
}
fn validate(&self) -> Result<(), Error> {
let (list, fees) = match self {
Self::Legacy { .. } => (None, None),
Self::AccessList { access_list, .. } => (Some(access_list), None),
Self::DynamicFee {
max_fee_per_gas,
max_priority_fee_per_gas,
access_list,
}
| Self::Blob {
max_fee_per_gas,
max_priority_fee_per_gas,
access_list,
..
}
| Self::Authorization {
max_fee_per_gas,
max_priority_fee_per_gas,
access_list,
..
} => (
Some(access_list),
Some((*max_fee_per_gas, *max_priority_fee_per_gas)),
),
};
if fees.is_some_and(|(max, tip)| max < tip) {
return Err(ValidationError::InvalidEvmRecord.into());
}
if let Some(list) = list
&& (list.len() > 1024
|| list
.iter()
.try_fold(0_usize, |n, e| n.checked_add(e.storage_keys.len()))
.is_none_or(|n| n > 4096))
{
return Err(ValidationError::InvalidEvmRecord.into());
}
match self {
Self::Blob {
blob_versioned_hashes,
..
} => {
if blob_versioned_hashes.is_empty()
|| blob_versioned_hashes.len() > 4096
|| blob_versioned_hashes.iter().any(|h| h.bytes()[0] != 1)
{
return Err(ValidationError::InvalidEvmRecord.into());
}
}
Self::Authorization {
authorization_list, ..
} => {
if authorization_list.is_empty()
|| authorization_list.len() > 1024
|| authorization_list
.iter()
.any(|a| a.nonce.value() >= U256::from(u64::MAX))
{
return Err(ValidationError::InvalidEvmRecord.into());
}
}
Self::Legacy { .. } | Self::AccessList { .. } | Self::DynamicFee { .. } => {}
}
Ok(())
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionData {
pub hash: TransactionId,
pub from: Address,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub to: Option<Address>,
pub nonce: Quantity,
pub gas_limit: Quantity,
pub value: Quantity,
pub input: Data,
pub kind: TransactionKind,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub reported_chain_id: Option<ChainId>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub reported_gas_price: Option<Quantity>,
pub signature: SignatureFields,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub inclusion: Option<Inclusion>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionFields")]
pub struct Transaction {
chain_id: ChainId,
data: TransactionData,
}
impl Transaction {
pub fn new(chain_id: ChainId, data: TransactionData) -> Result<Self, Error> {
data.kind.validate()?;
if data.reported_chain_id.is_some_and(|id| id != chain_id)
|| data.nonce.value() >= U256::from(u64::MAX)
|| data.gas_limit.value() == U256::ZERO
{
return Err(ValidationError::InvalidEvmRecord.into());
}
let sig = data.signature;
if data.kind.type_byte() == 0 {
let v = sig.v.ok_or(ValidationError::InvalidEvmRecord)?.value();
if v != U256::from(27)
&& v != U256::from(28)
&& (v < U256::from(35)
|| ChainId::new((v - U256::from(35)) / U256::from(2)) != chain_id)
{
return Err(ValidationError::InvalidEvmRecord.into());
}
if sig.y_parity.is_some() {
return Err(ValidationError::InvalidEvmRecord.into());
}
} else {
if data.reported_chain_id != Some(chain_id) || sig.v.is_none() && sig.y_parity.is_none()
{
return Err(ValidationError::InvalidEvmRecord.into());
}
if let Some(v) = sig.v
&& (v.value() > U256::from(1)
|| sig
.y_parity
.is_some_and(|p| p != (v.value() == U256::from(1))))
{
return Err(ValidationError::InvalidEvmRecord.into());
}
}
if matches!(
data.kind,
TransactionKind::Blob { .. } | TransactionKind::Authorization { .. }
) && data.to.is_none()
{
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(Self { chain_id, data })
}
#[must_use]
pub const fn chain_id(&self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn hash(&self) -> TransactionId {
self.data.hash
}
#[must_use]
pub const fn data(&self) -> &TransactionData {
&self.data
}
#[must_use]
pub const fn inclusion(&self) -> Option<Inclusion> {
self.data.inclusion
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionFields {
chain_id: ChainId,
data: TransactionData,
}
impl TryFrom<TransactionFields> for Transaction {
type Error = Error;
fn try_from(v: TransactionFields) -> Result<Self, Error> {
Self::new(v.chain_id, v.data)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "LogFields")]
pub struct Log {
transaction_hash: TransactionId,
inclusion: Inclusion,
#[serde(rename = "log_index")]
index: u64,
address: Address,
data: Data,
topics: Vec<Word>,
}
impl Log {
pub fn new(
transaction_hash: TransactionId,
inclusion: Inclusion,
log_index: u64,
address: Address,
data: Data,
topics: Vec<Word>,
) -> Result<Self, Error> {
if topics.len() > 4 {
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(Self {
transaction_hash,
inclusion,
index: log_index,
address,
data,
topics,
})
}
#[must_use]
pub const fn transaction_hash(&self) -> TransactionId {
self.transaction_hash
}
#[must_use]
pub const fn inclusion(&self) -> Inclusion {
self.inclusion
}
#[must_use]
pub const fn log_index(&self) -> u64 {
self.index
}
#[must_use]
pub const fn address(&self) -> Address {
self.address
}
#[must_use]
pub const fn data(&self) -> &Data {
&self.data
}
#[must_use]
pub fn topics(&self) -> &[Word] {
&self.topics
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct LogFields {
transaction_hash: TransactionId,
inclusion: Inclusion,
log_index: u64,
address: Address,
data: Data,
topics: Vec<Word>,
}
impl TryFrom<LogFields> for Log {
type Error = Error;
fn try_from(v: LogFields) -> Result<Self, Error> {
Self::new(
v.transaction_hash,
v.inclusion,
v.log_index,
v.address,
v.data,
v.topics,
)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "kind",
content = "state_root",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum ExecutionOutcome {
Succeeded,
Failed,
PreByzantium(Word),
Unknown,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ReceiptData {
pub transaction_hash: TransactionId,
pub inclusion: Inclusion,
pub from: Address,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub to: Option<Address>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub contract_address: Option<Address>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub transaction_type: Option<u8>,
pub execution: ExecutionOutcome,
pub gas_used: Quantity,
pub cumulative_gas_used: Quantity,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub effective_gas_price: Option<Quantity>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub blob_gas_used: Option<Quantity>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub blob_gas_price: Option<Quantity>,
pub logs_bloom: Data,
pub logs: Vec<Log>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ReceiptFields")]
pub struct Receipt {
chain_id: ChainId,
data: ReceiptData,
}
impl Receipt {
pub fn new(chain_id: ChainId, data: ReceiptData) -> Result<Self, Error> {
if data.gas_used > data.cumulative_gas_used
|| data.logs_bloom.bytes().len() != 256
|| data.logs.len() > 4096
|| data.to.is_some() && data.contract_address.is_some()
|| data.blob_gas_used.is_some() != data.blob_gas_price.is_some()
{
return Err(ValidationError::InvalidEvmRecord.into());
}
let mut indices = HashSet::with_capacity(data.logs.len());
for log in &data.logs {
if log.transaction_hash() != data.transaction_hash
|| log.inclusion() != data.inclusion
|| !indices.insert(log.log_index())
{
return Err(ValidationError::InvalidEvmRecord.into());
}
}
Ok(Self { chain_id, data })
}
#[must_use]
pub const fn chain_id(&self) -> ChainId {
self.chain_id
}
#[must_use]
pub const fn transaction_hash(&self) -> TransactionId {
self.data.transaction_hash
}
#[must_use]
pub const fn inclusion(&self) -> Inclusion {
self.data.inclusion
}
#[must_use]
pub const fn execution(&self) -> ExecutionOutcome {
self.data.execution
}
#[must_use]
pub const fn data(&self) -> &ReceiptData {
&self.data
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ReceiptFields {
chain_id: ChainId,
data: ReceiptData,
}
impl TryFrom<ReceiptFields> for Receipt {
type Error = Error;
fn try_from(v: ReceiptFields) -> Result<Self, Error> {
Self::new(v.chain_id, v.data)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionLookupFields")]
pub struct TransactionLookup {
chain_id: ChainId,
query: TransactionId,
transaction: Option<Transaction>,
}
impl TransactionLookup {
pub fn new(
chain_id: ChainId,
query: TransactionId,
transaction: Option<Transaction>,
) -> Result<Self, Error> {
if transaction
.as_ref()
.is_some_and(|t| t.hash() != query || t.chain_id() != chain_id)
{
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(Self {
chain_id,
query,
transaction,
})
}
#[must_use]
pub const fn query(&self) -> TransactionId {
self.query
}
#[must_use]
pub const fn transaction(&self) -> Option<&Transaction> {
self.transaction.as_ref()
}
#[must_use]
pub fn state(&self) -> ReadState {
self.transaction
.as_ref()
.map_or(ReadState::Unanchored, |t| {
t.inclusion()
.map_or(ReadState::Pending, |inclusion| ReadState::Included {
inclusion,
})
})
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionLookupFields {
chain_id: ChainId,
query: TransactionId,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
transaction: Option<Transaction>,
}
impl TryFrom<TransactionLookupFields> for TransactionLookup {
type Error = Error;
fn try_from(v: TransactionLookupFields) -> Result<Self, Error> {
Self::new(v.chain_id, v.query, v.transaction)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ReceiptLookupFields")]
pub struct ReceiptLookup {
chain_id: ChainId,
query: TransactionId,
receipt: Option<Receipt>,
}
impl ReceiptLookup {
pub fn new(
chain_id: ChainId,
query: TransactionId,
receipt: Option<Receipt>,
) -> Result<Self, Error> {
if receipt
.as_ref()
.is_some_and(|r| r.transaction_hash() != query || r.chain_id() != chain_id)
{
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(Self {
chain_id,
query,
receipt,
})
}
#[must_use]
pub const fn query(&self) -> TransactionId {
self.query
}
#[must_use]
pub const fn receipt(&self) -> Option<&Receipt> {
self.receipt.as_ref()
}
#[must_use]
pub fn state(&self) -> ReadState {
self.receipt
.as_ref()
.map_or(ReadState::Unanchored, |r| ReadState::Included {
inclusion: r.inclusion(),
})
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ReceiptLookupFields {
chain_id: ChainId,
query: TransactionId,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
receipt: Option<Receipt>,
}
impl TryFrom<ReceiptLookupFields> for ReceiptLookup {
type Error = Error;
fn try_from(v: ReceiptLookupFields) -> Result<Self, Error> {
Self::new(v.chain_id, v.query, v.receipt)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
pub enum TransactionState {
NotObserved,
Pending,
Included {
inclusion: Inclusion,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
execution: Option<ExecutionOutcome>,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "StatusFields")]
pub struct TransactionStatus {
transaction: TransactionLookup,
receipt: ReceiptLookup,
state: TransactionState,
}
impl TransactionStatus {
pub fn new(transaction: TransactionLookup, receipt: ReceiptLookup) -> Result<Self, Error> {
if transaction.chain_id != receipt.chain_id || transaction.query != receipt.query {
return Err(ValidationError::InvalidEvmRecord.into());
}
if let (Some(t), Some(r)) = (transaction.transaction(), receipt.receipt())
&& (t.inclusion().is_some_and(|i| i != r.inclusion())
|| t.data.from != r.data.from
|| t.data.to != r.data.to
|| r.data
.transaction_type
.is_some_and(|kind| kind != t.data.kind.type_byte())
|| r.data.gas_used > t.data.gas_limit)
{
return Err(ValidationError::InvalidEvmRecord.into());
}
let state = if let Some(r) = receipt.receipt() {
TransactionState::Included {
inclusion: r.inclusion(),
execution: Some(r.execution()),
}
} else if let Some(t) = transaction.transaction() {
t.inclusion()
.map_or(TransactionState::Pending, |inclusion| {
TransactionState::Included {
inclusion,
execution: None,
}
})
} else {
TransactionState::NotObserved
};
Ok(Self {
transaction,
receipt,
state,
})
}
#[must_use]
pub const fn query(&self) -> TransactionId {
self.transaction.query
}
#[must_use]
pub const fn transaction(&self) -> &TransactionLookup {
&self.transaction
}
#[must_use]
pub const fn receipt(&self) -> &ReceiptLookup {
&self.receipt
}
#[must_use]
pub const fn state(&self) -> TransactionState {
self.state
}
#[must_use]
pub const fn read_state(&self) -> ReadState {
match self.state {
TransactionState::NotObserved => ReadState::Unanchored,
TransactionState::Pending => ReadState::Pending,
TransactionState::Included { inclusion, .. } => ReadState::Included { inclusion },
}
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct StatusFields {
transaction: TransactionLookup,
receipt: ReceiptLookup,
state: TransactionState,
}
impl TryFrom<StatusFields> for TransactionStatus {
type Error = Error;
fn try_from(v: StatusFields) -> Result<Self, Error> {
let result = Self::new(v.transaction, v.receipt)?;
if result.state != v.state {
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(result)
}
}
fn validate_lookup(
chain: ChainId,
operation: ReadOperation,
state: ReadState,
c: &OperationContext,
) -> Result<(), Error> {
if c.operation() != operation {
return Err(ValidationError::ObservationOperationMismatch.into());
}
if c.network().chain_id() != chain {
return Err(ValidationError::NetworkMismatch.into());
}
if c.state() != state {
return Err(ValidationError::InvalidEvmRecord.into());
}
Ok(())
}
impl OperationValue for TransactionLookup {
fn validate_context(&self, c: &OperationContext) -> Result<(), Error> {
validate_lookup(self.chain_id, ReadOperation::Transaction, self.state(), c)
}
}
impl OperationValue for ReceiptLookup {
fn validate_context(&self, c: &OperationContext) -> Result<(), Error> {
validate_lookup(self.chain_id, ReadOperation::Receipt, self.state(), c)
}
}
impl OperationValue for TransactionStatus {
fn validate_context(&self, c: &OperationContext) -> Result<(), Error> {
validate_lookup(
self.transaction.chain_id,
ReadOperation::TransactionStatus,
self.read_state(),
c,
)
}
}