Types Reference

#[derive(Debug, Deserialize, Clone)]
pub struct Config {
    pub server: ServerConfig,
    pub upstream: UpstreamConfig,
    pub firewall: FirewallConfig,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ServerConfig {
    pub port: u16,              // Default: 8545
    pub max_request_size: usize, // Default: 1MB
    pub request_timeout_ms: u64, // Default: 30000
}

#[derive(Debug, Deserialize, Clone)]
pub struct UpstreamConfig {
    pub url: String,
    pub chain_id: Option<u64>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct FirewallConfig {
    pub mode: FirewallMode,
    pub fail_on_decode_error: bool,
    pub global_limits: Option<GlobalLimits>,
    pub rules: Vec<ContractRule>,
}

#[derive(Debug, Deserialize, Clone, Default)]
#[serde(rename_all = "snake_case")]
pub enum FirewallMode {
    #[default]
    Strict,   // Block violations
    Monitor,  // Log only
}

#[derive(Debug, Deserialize, Clone, Default)]
pub struct GlobalLimits {
    pub max_value: Option<U256>,
    pub max_gas_price: Option<U256>,
    pub max_fee_per_gas: Option<U256>,
    pub max_priority_fee_per_gas: Option<U256>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ContractRule {
    pub name: String,
    pub contract: Address,
    pub allow_methods: Vec<String>,
    pub arg_constraints: Vec<ArgConstraint>,
}

#[derive(Debug, Deserialize, Clone)]
pub struct ArgConstraint {
    pub index: usize,
    pub max: U256,
}

#[derive(Debug, Serialize, Clone, PartialEq)]
pub enum Verdict {
    Allowed,
    Blocked { reason: String },
}
 
impl Verdict {
    pub fn blocked(reason: impl Into<String>) -> Self;
    pub fn is_blocked(&self) -> bool;
}

let verdict = Verdict::blocked("Contract not in allowlist");
assert!(verdict.is_blocked());
 
if let Verdict::Blocked { reason } = verdict {
    println!("Blocked: {}", reason);
}

#[derive(Debug, Serialize, Clone)]
pub struct Receipt {
    pub id: Uuid,
    pub timestamp: DateTime<Utc>,
    pub method: String,
    pub from: Option<Address>,
    pub to: Option<Address>,
    pub value: Option<U256>,
    pub selector: Option<[u8; 4]>,
    pub verdict: Verdict,
    pub tx_hash: Option<B256>,
    pub latency_us: u64,
}
 
impl Receipt {
    pub fn new(method: &str) -> Self;
}

#[derive(Debug, Deserialize)]
#[serde(untagged)]
pub enum RpcInput {
    Single(RpcRequest),
    Batch(Vec<RpcRequest>),
}

#[derive(Debug, Deserialize, Clone)]
pub struct RpcRequest {
    pub jsonrpc: String,
    pub method: String,
    pub params: Option<RpcParams>,
    pub id: Option<Value>,  // None = notification
}

#[derive(Debug, Deserialize, Clone)]
#[serde(untagged)]
pub enum RpcParams {
    Array(Vec<Value>),
    Object(serde_json::Map<String, Value>),
}

#[derive(Debug, Serialize)]
pub struct RpcResponse {
    pub jsonrpc: String,
    pub id: Value,
    pub result: Option<Value>,
    pub error: Option<RpcError>,
}
 
impl RpcResponse {
    pub fn success(id: Value, result: Value) -> Self;
    pub fn error(id: Value, code: i32, message: impl Into<String>) -> Self;
    pub fn policy_violation(id: Value, reason: &str) -> Self;
}

#[derive(Debug, Serialize)]
pub struct RpcError {
    pub code: i32,
    pub message: String,
}

pub struct RuntimePolicy {
    pub global_limits: GlobalLimits,
    pub fail_on_decode_error: bool,
    pub mode: FirewallMode,
    // Internal: routes map
}
 
impl RuntimePolicy {
    pub fn from_config(config: &FirewallConfig) -> Result<Self, PolicyError>;
}

pub struct CompiledRule {
    pub name: String,
    pub arg_constraints: Vec<ArgConstraint>,
    pub inputs: Vec<DynSolType>,
}

#[derive(Debug, Clone)]
pub struct ProxyEvent {
    pub receipt: Receipt,
}
 
pub type EventSender = mpsc::Sender<ProxyEvent>;
pub type EventReceiver = mpsc::Receiver<ProxyEvent>;

#[derive(Debug, Error)]
pub enum PolicyError {
    #[error("Invalid signature '{signature}': {reason}")]
    InvalidSignature { signature: String, reason: String },
 
    #[error("Invalid address: {address}")]
    InvalidAddress { address: String },
 
    #[error("Config parsing error: {0}")]
    ConfigParsing(#[from] toml::de::Error),
}

#[derive(Debug, Error)]
pub enum DecodeError {
    #[error("Invalid hex encoding")]
    InvalidHex,
 
    #[error("RLP decoding error: {0}")]
    RlpError(String),
 
    #[error("Unsupported transaction type")]
    UnsupportedTxType,
}

#[derive(Debug, Error)]
pub enum ProxyError {
    #[error("Failed to parse upstream URL: {0}")]
    InvalidUpstreamUrl(#[from] url::ParseError),
 
    #[error("HTTP client error: {0}")]
    HttpClient(#[from] reqwest::Error),
 
    #[error("Failed to bind server: {0}")]
    ServerBind(#[from] std::io::Error),
 
    #[error("Configuration error: {0}")]
    Config(String),
}

// From alloy-primitives
pub use alloy_primitives::{Address, B256, U256, Bytes};
 
// From chrono
pub use chrono::{DateTime, Utc};
 
// From uuid
pub use uuid::Uuid;