use serde::{Deserialize, Serialize};
use std::fmt;
use super::{
Address, BlockContext, ChainId, Data, FeeTerms, OperationContext, OperationValue,
PreparedTransaction, Quantity, ReadOperation, ReadState,
};
use crate::error::{Error, ValidationError};
fn invalid() -> Error {
ValidationError::InvalidEvmPreparation.into()
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionCallData {
pub chain_id: ChainId,
pub from: Address,
pub to: Option<Address>,
pub nonce: u64,
pub gas_limit: u64,
pub value: Quantity,
pub input: Data,
pub fees: FeeTerms,
}
#[derive(Clone, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionCallData", into = "TransactionCallData")]
pub struct TransactionCall(TransactionCallData);
impl TransactionCall {
pub fn new(data: TransactionCallData) -> Result<Self, Error> {
data.fees.validate()?;
if data.nonce == u64::MAX || data.gas_limit == 0 {
return Err(invalid());
}
Ok(Self(data))
}
#[must_use]
pub fn from_prepared(prepared: &PreparedTransaction) -> Self {
let request = prepared.request().data();
let unsigned = prepared.unsigned();
Self(TransactionCallData {
chain_id: request.chain_id,
from: request.sender,
to: Some(unsigned.to()),
nonce: request.nonce,
gas_limit: request.gas_limit,
value: unsigned.value(),
input: unsigned.input().clone(),
fees: request.fees.clone(),
})
}
#[must_use]
pub const fn data(&self) -> &TransactionCallData {
&self.0
}
}
impl TryFrom<TransactionCallData> for TransactionCall {
type Error = Error;
fn try_from(value: TransactionCallData) -> Result<Self, Error> {
Self::new(value)
}
}
impl From<TransactionCall> for TransactionCallData {
fn from(value: TransactionCall) -> Self {
value.0
}
}
impl fmt::Debug for TransactionCall {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("TransactionCall").finish_non_exhaustive()
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct AccountNonce {
pub chain_id: ChainId,
pub address: Address,
pub nonce: u64,
}
impl OperationValue for AccountNonce {
fn validate_context(&self, context: &OperationContext) -> Result<(), Error> {
canonical(context, self.chain_id, ReadOperation::AccountNonce)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CallResult {
pub call: TransactionCall,
pub output: Data,
}
impl OperationValue for CallResult {
fn validate_context(&self, context: &OperationContext) -> Result<(), Error> {
canonical(context, self.call.data().chain_id, ReadOperation::Call)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "GasEstimateFields")]
pub struct GasEstimate {
call: TransactionCall,
gas: u64,
}
impl GasEstimate {
pub fn new(call: TransactionCall, gas: u64) -> Result<Self, Error> {
if gas == 0 || gas > call.data().gas_limit {
return Err(invalid());
}
Ok(Self { call, gas })
}
#[must_use]
pub const fn call(&self) -> &TransactionCall {
&self.call
}
#[must_use]
pub const fn gas(&self) -> u64 {
self.gas
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct GasEstimateFields {
call: TransactionCall,
gas: u64,
}
impl TryFrom<GasEstimateFields> for GasEstimate {
type Error = Error;
fn try_from(value: GasEstimateFields) -> Result<Self, Error> {
Self::new(value.call, value.gas)
}
}
impl OperationValue for GasEstimate {
fn validate_context(&self, context: &OperationContext) -> Result<(), Error> {
canonical(
context,
self.call.data().chain_id,
ReadOperation::GasEstimate,
)
}
}
fn canonical(
context: &OperationContext,
chain: ChainId,
operation: ReadOperation,
) -> Result<(), Error> {
if context.network().chain_id() != chain
|| context.operation() != operation
|| !matches!(context.state(), ReadState::CanonicalHash { .. })
{
return Err(ValidationError::ObservationOperationMismatch.into());
}
Ok(())
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(
tag = "outcome",
content = "value",
rename_all = "snake_case",
deny_unknown_fields
)]
pub enum OptionalFeeSuggestion {
Available(Quantity),
Unsupported,
NullResult,
Unavailable,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BlockFee {
pub block: BlockContext,
pub base_fee_per_gas: Option<Quantity>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct FeeSuggestions {
pub chain_id: ChainId,
pub gas_price: Quantity,
pub max_priority_fee_per_gas: OptionalFeeSuggestion,
pub block_fee: BlockFee,
}
impl OperationValue for FeeSuggestions {
fn validate_context(&self, context: &OperationContext) -> Result<(), Error> {
if context.network().chain_id() != self.chain_id
|| context.operation() != ReadOperation::FeeSuggestions
|| context.state() != ReadState::Unanchored
{
return Err(ValidationError::ObservationOperationMismatch.into());
}
Ok(())
}
}