feat(server): initial EVM functionality impl

server/crates/arbiter-server/src/evm/mod.rs

@@ -0,0 +1,132 @@
+pub mod safe_signer;
+
+use alloy::{
+    consensus::TxEip1559,
+    primitives::TxKind,
+};
+use diesel::insert_into;
+use diesel_async::{AsyncConnection, RunQueryDsl};
+
+use crate::{
+    db::{
+        self,
+        models::{EvmBasicGrant, NewEvmBasicGrant, SqliteTimestamp}, schema,
+    },
+    evm::policies::{
+        EvalContext, FullGrant, Policy, SpecificMeaning, ether_transfer::EtherTransfer
+    },
+};
+
+pub mod policies;
+mod utils;
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum AnalyzeError {
+    #[error("Engine doesn't support granting permissions for contract creation")]
+    #[diagnostic(code(arbiter_server::evm::analyze_error::contract_creation_not_supported))]
+    ContractCreationNotSupported,
+
+    #[error("Unsupported transaction type")]
+    #[diagnostic(code(arbiter_server::evm::analyze_error::unsupported_transaction_type))]
+    UnsupportedTransactionType,
+}
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum CreationError {
+    #[error("Database connection pool error")]
+    #[diagnostic(code(arbiter_server::evm::creation_error::database_error))]
+    Pool(#[from] db::PoolError),
+
+    #[error("Database returned error")]
+    #[diagnostic(code(arbiter_server::evm::creation_error::database_error))]
+    Database(#[from] diesel::result::Error),
+}
+
+// Supporting only EIP-1559 transactions for now, but we can easily extend this to support legacy transactions if needed
+pub struct Engine {
+    db: db::DatabasePool,
+}
+
+impl Engine {
+    pub fn new(db: db::DatabasePool) -> Self {
+        Self { db }
+    }
+
+    pub async fn create_grant<P: Policy>(
+        &self,
+        client_id: i32,
+        full_grant: FullGrant<P::Grant>,
+    ) -> Result<i32, CreationError> {
+        let mut conn = self.db.get().await?;
+
+        let id = conn.transaction(|conn| {
+            Box::pin(async move {
+                use schema::evm_basic_grant;
+
+                let basic_grant: EvmBasicGrant = insert_into(evm_basic_grant::table)
+                    .values(&NewEvmBasicGrant {
+                        wallet_id: full_grant.basic.wallet_id,
+                        chain_id: full_grant.basic.chain as i32,
+                        client_id: client_id,
+                        valid_from: full_grant.basic.valid_from.map(SqliteTimestamp),
+                        valid_until: full_grant.basic.valid_until.map(SqliteTimestamp),
+                        max_gas_fee_per_gas: full_grant
+                            .basic
+                            .max_gas_fee_per_gas
+                            .map(|fee| utils::u256_to_bytes(fee).to_vec()),
+                        max_priority_fee_per_gas: full_grant
+                            .basic
+                            .max_priority_fee_per_gas
+                            .map(|fee| utils::u256_to_bytes(fee).to_vec()),
+                        rate_limit_count: full_grant
+                            .basic
+                            .rate_limit
+                            .as_ref()
+                            .map(|rl| rl.count as i32),
+                        rate_limit_window_secs: full_grant
+                            .basic
+                            .rate_limit
+                            .as_ref()
+                            .map(|rl| rl.window.num_seconds() as i32),
+                        revoked_at: None,
+                    })
+                    .returning(evm_basic_grant::all_columns)
+                    .get_result(conn)
+                    .await?;
+
+                P::create_grant(&basic_grant, &full_grant.specific, conn).await
+            })
+        })
+        .await?;
+
+        Ok(id)
+    }
+
+    async fn perform_transaction<P: Policy>(&self, _context: EvalContext, _meaning: &P::Meaning) {
+    }
+
+    pub async fn analyze_transaction(
+        &self,
+        wallet_id: i32,
+        client_id: i32,
+        transaction: TxEip1559,
+    ) -> Result<SpecificMeaning, AnalyzeError> {
+        let TxKind::Call(to) = transaction.to else {
+            return Err(AnalyzeError::ContractCreationNotSupported);
+        };
+        let context = policies::EvalContext {
+            wallet_id,
+            client_id,
+            chain: transaction.chain_id,
+            to: to,
+            value: transaction.value,
+            calldata: transaction.input.clone(),
+        };
+
+       
+        if let Some(meaning) = EtherTransfer::analyze(&context) {
+            return Ok(SpecificMeaning::EtherTransfer(meaning));
+        }
+        Err(AnalyzeError::UnsupportedTransactionType)
+    }
+}