feat(evm): add grant management and transaction signing

.gitignore

@@ -1 +1,3 @@
 target/
+scripts/__pycache__/
+.DS_Store

mise.lock

@@ -55,6 +55,15 @@ backend = "aqua:protocolbuffers/protobuf/protoc"
 "platforms.macos-x64" = { checksum = "sha256:312f04713946921cc0187ef34df80241ddca1bab6f564c636885fd2cc90d3f88", url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-osx-x86_64.zip"}
 "platforms.windows-x64" = { checksum = "sha256:1ebd7c87baffb9f1c47169b640872bf5fb1e4408079c691af527be9561d8f6f7", url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-win64.zip"}
 
+[[tools.python]]
+version = "3.14.3"
+backend = "core:python"
+"platforms.linux-arm64" = { checksum = "sha256:be0f4dc2932f762292b27d46ea7d3e8e66ddf3969a5eb0254a229015ed402625", url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260303/cpython-3.14.3+20260303-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz"}
+"platforms.linux-x64" = { checksum = "sha256:0a73413f89efd417871876c9accaab28a9d1e3cd6358fbfff171a38ec99302f0", url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260303/cpython-3.14.3+20260303-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz"}
+"platforms.macos-arm64" = { checksum = "sha256:4703cdf18b26798fde7b49b6b66149674c25f97127be6a10dbcf29309bdcdcdb", url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260303/cpython-3.14.3+20260303-aarch64-apple-darwin-install_only_stripped.tar.gz"}
+"platforms.macos-x64" = { checksum = "sha256:76f1cc26e3d262eae8ca546a93e8bded10cf0323613f7e246fea2e10a8115eb7", url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260303/cpython-3.14.3+20260303-x86_64-apple-darwin-install_only_stripped.tar.gz"}
+"platforms.windows-x64" = { checksum = "sha256:950c5f21a015c1bdd1337f233456df2470fab71e4d794407d27a84cb8b9909a0", url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260303/cpython-3.14.3+20260303-x86_64-pc-windows-msvc-install_only_stripped.tar.gz"}
+
 [[tools.rust]]
 version = "1.93.0"
 backend = "core:rust"

mise.toml

@@ -9,3 +9,4 @@ protoc = "29.6"
 "cargo:cargo-nextest" = "0.9.126"
 "cargo:cargo-shear" = "latest"
 "cargo:cargo-insta" = "1.46.3"
+python = "3.14.3"

protobufs/evm.proto

@@ -0,0 +1,31 @@
+syntax = "proto3";
+
+package arbiter.evm;
+
+enum EvmError {
+  EVM_ERROR_UNSPECIFIED = 0;
+  EVM_ERROR_VAULT_SEALED = 1;
+  EVM_ERROR_INTERNAL = 2;
+}
+
+message WalletEntry {
+  bytes address = 1; // 20-byte Ethereum address
+}
+
+message WalletList {
+  repeated WalletEntry wallets = 1;
+}
+
+message WalletCreateResponse {
+  oneof result {
+    WalletEntry wallet = 1;
+    EvmError error = 2;
+  }
+}
+
+message WalletListResponse {
+  oneof result {
+    WalletList wallets = 1;
+    EvmError error = 2;
+  }
+}

protobufs/user_agent.proto

@@ -3,6 +3,7 @@ syntax = "proto3";
 package arbiter.user_agent;
 
 import "google/protobuf/empty.proto";
+import "evm.proto";
 
 message AuthChallengeRequest {
   bytes pubkey = 1;
@@ -55,6 +56,8 @@ message UserAgentRequest {
     UnsealStart unseal_start = 3;
     UnsealEncryptedKey unseal_encrypted_key = 4;
     google.protobuf.Empty query_vault_state = 5;
+    google.protobuf.Empty evm_wallet_create = 6;
+    google.protobuf.Empty evm_wallet_list = 7;
   }
 }
 message UserAgentResponse {
@@ -64,5 +67,7 @@ message UserAgentResponse {
     UnsealStartResponse unseal_start_response = 3;
     UnsealResult unseal_result = 4;
     VaultState vault_state = 5;
+    arbiter.evm.WalletCreateResponse evm_wallet_create = 6;
+    arbiter.evm.WalletListResponse evm_wallet_list = 7;
   }
 }

scripts/gen_erc20_registry.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+"""
+Fetch the Uniswap default token list and emit Rust `TokenInfo` statics.
+
+Usage:
+    python3 gen_erc20_registry.py                       # fetch from IPFS
+    python3 gen_erc20_registry.py tokens.json           # local file
+    python3 gen_erc20_registry.py tokens.json out.rs    # custom output file
+"""
+
+import json
+import re
+import sys
+import unicodedata
+import urllib.request
+
+UNISWAP_URL = "https://ipfs.io/ipns/tokens.uniswap.org"
+
+SOLANA_CHAIN_ID = 501000101
+IDENTIFIER_RE = re.compile(r"[^A-Za-z0-9]+")
+
+
+def load_tokens(source=None):
+    if source:
+        with open(source) as f:
+            return json.load(f)
+    req = urllib.request.Request(
+        UNISWAP_URL,
+        headers={"Accept": "application/json", "User-Agent": "gen_tokens/1.0"},
+    )
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        return json.loads(resp.read())
+
+
+def escape(s: str) -> str:
+    return s.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def to_screaming_case(name: str) -> str:
+    normalized = unicodedata.normalize("NFKD", name or "")
+    ascii_name = normalized.encode("ascii", "ignore").decode("ascii")
+    snake = IDENTIFIER_RE.sub("_", ascii_name).strip("_").upper()
+    if not snake:
+        snake = "TOKEN"
+    if snake[0].isdigit():
+        snake = f"TOKEN_{snake}"
+    return snake
+
+
+def static_name_for_token(token: dict, used_names: set[str]) -> str:
+    base = to_screaming_case(token.get("name", ""))
+    if base not in used_names:
+        used_names.add(base)
+        return base
+
+    address = token["address"]
+    suffix = f"{token['chainId']}_{address[2:].upper()[-8:]}"
+    candidate = f"{base}_{suffix}"
+
+    i = 2
+    while candidate in used_names:
+        candidate = f"{base}_{suffix}_{i}"
+        i += 1
+
+    used_names.add(candidate)
+    return candidate
+
+
+def main():
+    source = sys.argv[1] if len(sys.argv) > 1 else None
+    output = sys.argv[2] if len(sys.argv) > 2 else "generated_tokens.rs"
+    data = load_tokens(source)
+    tokens = data["tokens"]
+
+    # Deduplicate by (chainId, address)
+    seen = set()
+    unique = []
+    for t in tokens:
+        key = (t["chainId"], t["address"].lower())
+        if key not in seen:
+            seen.add(key)
+            unique.append(t)
+
+    unique.sort(key=lambda t: (t["chainId"], t.get("symbol", "").upper()))
+    evm_tokens = [t for t in unique if t["chainId"] != SOLANA_CHAIN_ID]
+
+    ver = data["version"]
+    lines = []
+    w = lines.append
+
+    w(
+        f"// Auto-generated from Uniswap token list v{ver['major']}.{ver['minor']}.{ver['patch']}"
+    )
+    w(f"// {len(evm_tokens)} tokens")
+    w("// DO NOT EDIT - regenerate with gen_erc20_registry.py")
+    w("")
+
+    used_static_names = set()
+    token_statics = []
+    for t in evm_tokens:
+        static_name = static_name_for_token(t, used_static_names)
+        token_statics.append((static_name, t))
+
+    for static_name, t in token_statics:
+        addr = t["address"]
+        name = escape(t.get("name", ""))
+        symbol = escape(t.get("symbol", ""))
+        decimals = t.get("decimals", 18)
+        logo = t.get("logoURI")
+        chain = t["chainId"]
+
+        logo_val = f'Some("{escape(logo)}")' if logo else "None"
+
+        w(f"pub static {static_name}: TokenInfo = TokenInfo {{")
+        w(f'    name: "{name}",')
+        w(f'    symbol: "{symbol}",')
+        w(f"    decimals: {decimals},")
+        w(f'    contract: address!("{addr}"),')
+        w(f"    chain: {chain},")
+        w(f"    logo_uri: {logo_val},")
+        w("};")
+        w("")
+
+    w("pub static TOKENS: &[&TokenInfo] = &[")
+    for static_name, _ in token_statics:
+        w(f"    &{static_name},")
+    w("];")
+    w("")
+    w("pub fn get_token(")
+    w("    chain_id: alloy::primitives::ChainId,")
+    w("    address: alloy::primitives::Address,")
+    w(") -> Option<&'static TokenInfo> {")
+    w("    match (chain_id, address) {")
+    for static_name, t in token_statics:
+        w(
+            f'        ({t["chainId"]}, addr) if addr == address!("{t["address"]}") => Some(&{static_name}),'
+        )
+    w("        _ => None,")
+    w("    }")
+    w("}")
+    w("")
+
+    with open(output, "w") as f:
+        f.write("\n".join(lines))
+
+    print(f"Wrote {len(token_statics)} tokens to {output}")
+
+
+if __name__ == "__main__":
+    main()

server/Cargo.toml

@@ -1,15 +1,17 @@
 [workspace]
 members = [
-    "crates/arbiter-client",
-    "crates/arbiter-proto",
-    "crates/arbiter-server",
-    "crates/arbiter-useragent",
+    "crates/*",
 ]
 resolver = "3"
 
 
 [workspace.dependencies]
-tonic = { version = "0.14.3", features = ["deflate", "gzip", "tls-connect-info", "zstd"] }
+tonic = { version = "0.14.3", features = [
+    "deflate",
+    "gzip",
+    "tls-connect-info",
+    "zstd",
+] }
 tracing = "0.1.44"
 tokio = { version = "1.49.0", features = ["full"] }
 ed25519-dalek = { version = "3.0.0-pre.6", features = ["rand_core"] }
@@ -26,6 +28,7 @@ kameo = "0.19.2"
 x25519-dalek = { version = "2.0.1", features = ["getrandom"] }
 rstest = "0.26.1"
 rustls-pki-types = "1.14.0"
+alloy = "1.7.3"
 rcgen = { version = "0.14.7", features = [
     "aws_lc_rs",
     "pem",

server/crates/arbiter-proto/build.rs

@@ -13,6 +13,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 format!("{}/arbiter.proto", PROTOBUF_DIR),
                 format!("{}/user_agent.proto", PROTOBUF_DIR),
                 format!("{}/client.proto", PROTOBUF_DIR),
+                format!("{}/evm.proto", PROTOBUF_DIR),
             ],
             &[PROTOBUF_DIR.to_string()],
         )

server/crates/arbiter-proto/src/lib.rs

@@ -13,6 +13,10 @@ pub mod proto {
     pub mod client {
         tonic::include_proto!("arbiter.client");
     }
+
+    pub mod evm {
+        tonic::include_proto!("arbiter.evm");
+    }
 }
 
 pub static BOOTSTRAP_PATH: &str = "bootstrap_token";

server/crates/arbiter-server/Cargo.toml

@@ -42,6 +42,9 @@ argon2 = { version = "0.5.3", features = ["zeroize"] }
 restructed = "0.2.2"
 strum = { version = "0.27.2", features = ["derive"] }
 pem = "3.0.6"
+k256 = "0.13.4"
+alloy.workspace = true
+arbiter-tokens-registry.path = "../arbiter-tokens-registry"
 
 [dev-dependencies]
 insta = "1.46.3"

server/crates/arbiter-server/migrations/2026-02-14-171124-0000_init/up.sql

@@ -57,3 +57,102 @@ create table if not exists program_client (
     created_at integer not null default(unixepoch ('now')),
     updated_at integer not null default(unixepoch ('now'))
 ) STRICT;
+
+create table if not exists evm_wallet (
+    id integer not null primary key,
+    address blob not null, -- 20-byte Ethereum address
+    aead_encrypted_id integer not null references aead_encrypted (id) on delete RESTRICT,
+    created_at integer not null default(unixepoch ('now'))
+) STRICT;
+
+create unique index if not exists uniq_evm_wallet_address on evm_wallet (address);
+create unique index if not exists uniq_evm_wallet_aead on evm_wallet (aead_encrypted_id);
+
+create table if not exists evm_ether_transfer_limit (
+    id integer not null primary key,
+    window_secs integer not null,           -- window duration in seconds
+    max_volume blob not null                -- big-endian 32-byte U256
+) STRICT;
+
+-- Shared grant properties: client scope, timeframe, fee caps, and rate limit
+create table if not exists evm_basic_grant (
+    id integer not null primary key,
+    wallet_id integer not null references evm_wallet(id) on delete restrict, 
+    client_id integer not null references program_client(id) on delete restrict,
+    chain_id integer not null,              -- EIP-155 chain ID
+    valid_from integer,                     -- unix timestamp (seconds), null = no lower bound
+    valid_until integer,                    -- unix timestamp (seconds), null = no upper bound
+    max_gas_fee_per_gas blob,               -- big-endian 32-byte U256, null = unlimited
+    max_priority_fee_per_gas blob,          -- big-endian 32-byte U256, null = unlimited
+    rate_limit_count integer,               -- max transactions in window, null = unlimited
+    rate_limit_window_secs integer,         -- window duration in seconds, null = unlimited
+    revoked_at integer,                     -- unix timestamp when revoked, null = still active
+    created_at integer not null default(unixepoch('now'))
+) STRICT;
+
+-- Shared transaction log for all EVM grants, used for rate limit tracking and auditing
+create table if not exists evm_transaction_log (
+    id integer not null primary key,
+    grant_id integer not null references evm_basic_grant(id) on delete restrict,
+    client_id integer not null references program_client(id) on delete restrict,
+    wallet_id integer not null references evm_wallet(id) on delete restrict,
+    chain_id integer not null,
+    eth_value blob not null,     -- always present on any EVM tx
+    signed_at integer not null default(unixepoch('now'))
+) STRICT;
+
+create index if not exists idx_evm_basic_grant_wallet_chain on evm_basic_grant(client_id, wallet_id, chain_id);
+
+-- ===============================
+-- ERC20 token transfer grant
+-- ===============================
+create table if not exists evm_token_transfer_grant (
+    id integer not null primary key,
+    basic_grant_id integer not null unique references evm_basic_grant(id) on delete cascade,
+    token_contract blob not null,            -- 20-byte ERC20 contract address
+    receiver blob                            -- 20-byte recipient address or null if every recipient allowed
+) STRICT;
+
+-- Per-window volume limits for token transfer grants
+create table if not exists evm_token_transfer_volume_limit (
+    id integer not null primary key,
+    grant_id integer not null references evm_token_transfer_grant(id) on delete cascade,
+    window_secs integer not null,           -- window duration in seconds
+    max_volume blob not null                -- big-endian 32-byte U256
+) STRICT;
+
+-- Log table for token transfer grant usage
+create table if not exists evm_token_transfer_log (
+    id integer not null primary key,
+    grant_id integer not null references evm_token_transfer_grant(id) on delete restrict,
+    log_id integer not null references evm_transaction_log(id) on delete restrict,
+    chain_id integer not null,              -- EIP-155 chain ID
+    token_contract blob not null,           -- 20-byte ERC20 contract address
+    recipient_address blob not null,        -- 20-byte recipient address
+    value blob not null,                    -- big-endian 32-byte U256
+    created_at integer not null default(unixepoch('now'))
+) STRICT;
+
+create index if not exists idx_token_transfer_log_grant on evm_token_transfer_log(grant_id);
+create index if not exists idx_token_transfer_log_log_id on evm_token_transfer_log(log_id);
+create index if not exists idx_token_transfer_log_chain on evm_token_transfer_log(chain_id);
+
+
+-- ===============================
+-- Ether transfer grant (uses base log)
+-- ===============================
+create table if not exists evm_ether_transfer_grant (
+    id integer not null primary key,
+    basic_grant_id integer not null unique references evm_basic_grant(id) on delete cascade,
+    limit_id integer not null references evm_ether_transfer_limit(id) on delete restrict
+) STRICT;
+
+-- Specific recipient addresses for an ether transfer grant
+create table if not exists evm_ether_transfer_grant_target (
+    id integer not null primary key,
+    grant_id integer not null references evm_ether_transfer_grant(id) on delete cascade,
+    address blob not null                   -- 20-byte recipient address
+) STRICT;
+
+create unique index if not exists uniq_ether_transfer_target on evm_ether_transfer_grant_target(grant_id, address);
+

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

@@ -0,0 +1,246 @@
+use alloy::{consensus::TxEip1559, network::TxSigner, primitives::Address, signers::Signature};
+use diesel::{ExpressionMethods, OptionalExtension as _, QueryDsl, SelectableHelper as _, dsl::insert_into};
+use diesel_async::RunQueryDsl;
+use kameo::{Actor, actor::ActorRef, messages};
+use memsafe::MemSafe;
+use rand::{SeedableRng, rng, rngs::StdRng};
+
+use crate::{
+    actors::keyholder::{CreateNew, Decrypt, KeyHolder},
+    db::{self, DatabasePool, models::{self, EvmBasicGrant, SqliteTimestamp}, schema},
+    evm::{
+        self, RunKind,
+        policies::{
+            FullGrant, SharedGrantSettings, SpecificGrant, SpecificMeaning,
+            ether_transfer::EtherTransfer,
+            token_transfers::TokenTransfer,
+        },
+    },
+};
+
+pub use crate::evm::safe_signer;
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum SignTransactionError {
+    #[error("Wallet not found")]
+    #[diagnostic(code(arbiter::evm::sign::wallet_not_found))]
+    WalletNotFound,
+
+    #[error("Database error: {0}")]
+    #[diagnostic(code(arbiter::evm::sign::database))]
+    Database(#[from] diesel::result::Error),
+
+    #[error("Database pool error: {0}")]
+    #[diagnostic(code(arbiter::evm::sign::pool))]
+    Pool(#[from] db::PoolError),
+
+    #[error("Keyholder error: {0}")]
+    #[diagnostic(code(arbiter::evm::sign::keyholder))]
+    Keyholder(#[from] crate::actors::keyholder::Error),
+
+    #[error("Keyholder mailbox error")]
+    #[diagnostic(code(arbiter::evm::sign::keyholder_send))]
+    KeyholderSend,
+
+    #[error("Signing error: {0}")]
+    #[diagnostic(code(arbiter::evm::sign::signing))]
+    Signing(#[from] alloy::signers::Error),
+
+    #[error("Policy error: {0}")]
+    #[diagnostic(code(arbiter::evm::sign::vet))]
+    Vet(#[from] evm::VetError),
+}
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum Error {
+    #[error("Keyholder error: {0}")]
+    #[diagnostic(code(arbiter::evm::keyholder))]
+    Keyholder(#[from] crate::actors::keyholder::Error),
+
+    #[error("Keyholder mailbox error")]
+    #[diagnostic(code(arbiter::evm::keyholder_send))]
+    KeyholderSend,
+
+    #[error("Database error: {0}")]
+    #[diagnostic(code(arbiter::evm::database))]
+    Database(#[from] diesel::result::Error),
+
+    #[error("Database pool error: {0}")]
+    #[diagnostic(code(arbiter::evm::database_pool))]
+    DatabasePool(#[from] db::PoolError),
+
+    #[error("Grant creation error: {0}")]
+    #[diagnostic(code(arbiter::evm::creation))]
+    Creation(#[from] evm::CreationError),
+}
+
+#[derive(Actor)]
+pub struct EvmActor {
+    pub keyholder: ActorRef<KeyHolder>,
+    pub db: DatabasePool,
+    pub rng: StdRng,
+    pub engine: evm::Engine,
+}
+
+impl EvmActor {
+    pub fn new(keyholder: ActorRef<KeyHolder>, db: DatabasePool) -> Self {
+        // is it safe to seed rng from system once?
+        // todo: audit
+        let rng = StdRng::from_rng(&mut rng());
+        let engine = evm::Engine::new(db.clone());
+        Self { keyholder, db, rng, engine }
+    }
+}
+
+#[messages]
+impl EvmActor {
+    #[message]
+    pub async fn generate(&mut self) -> Result<Address, Error> {
+        let (mut key_cell, address) = safe_signer::generate(&mut self.rng);
+
+        // Move raw key bytes into a Vec<u8> MemSafe for KeyHolder
+        let plaintext = {
+            let reader = key_cell.read().expect("MemSafe read");
+            MemSafe::new(reader.to_vec()).expect("MemSafe allocation")
+        };
+
+        let aead_id: i32 = self
+            .keyholder
+            .ask(CreateNew { plaintext })
+            .await
+            .map_err(|_| Error::KeyholderSend)?;
+
+        let mut conn = self.db.get().await?;
+        insert_into(schema::evm_wallet::table)
+            .values(&models::NewEvmWallet {
+                address: address.as_slice().to_vec(),
+                aead_encrypted_id: aead_id,
+            })
+            .execute(&mut conn)
+            .await?;
+
+        Ok(address)
+    }
+
+    #[message]
+    pub async fn list_wallets(&self) -> Result<Vec<Address>, Error> {
+        let mut conn = self.db.get().await?;
+        let rows: Vec<models::EvmWallet> = schema::evm_wallet::table
+            .select(models::EvmWallet::as_select())
+            .load(&mut conn)
+            .await?;
+
+        Ok(rows
+            .into_iter()
+            .map(|w| Address::from_slice(&w.address))
+            .collect())
+    }
+}
+
+#[messages]
+impl EvmActor {
+    #[message]
+    pub async fn useragent_create_grant(
+        &mut self,
+        client_id: i32,
+        basic: SharedGrantSettings,
+        grant: SpecificGrant,
+    ) -> Result<i32, evm::CreationError> {
+        match grant {
+            SpecificGrant::EtherTransfer(settings) => {
+                self.engine
+                    .create_grant::<EtherTransfer>(client_id, FullGrant { basic, specific: settings })
+                    .await
+            }
+            SpecificGrant::TokenTransfer(settings) => {
+                self.engine
+                    .create_grant::<TokenTransfer>(client_id, FullGrant { basic, specific: settings })
+                    .await
+            }
+        }
+    }
+
+    #[message]
+    pub async fn useragent_delete_grant(&mut self, grant_id: i32) -> Result<(), Error> {
+        let mut conn = self.db.get().await?;
+        diesel::update(schema::evm_basic_grant::table)
+            .filter(schema::evm_basic_grant::id.eq(grant_id))
+            .set(schema::evm_basic_grant::revoked_at.eq(SqliteTimestamp::now()))
+            .execute(&mut conn)
+            .await?;
+        Ok(())
+    }
+
+    #[message]
+    pub async fn useragent_list_grants(
+        &mut self,
+        wallet_id: Option<i32>,
+    ) -> Result<Vec<EvmBasicGrant>, Error> {
+        let mut conn = self.db.get().await?;
+        let mut query = schema::evm_basic_grant::table
+            .select(EvmBasicGrant::as_select())
+            .filter(schema::evm_basic_grant::revoked_at.is_null())
+            .into_boxed();
+        if let Some(wid) = wallet_id {
+            query = query.filter(schema::evm_basic_grant::wallet_id.eq(wid));
+        }
+        Ok(query.load(&mut conn).await?)
+    }
+
+    #[message]
+    pub async fn shared_analyze_transaction(
+        &mut self,
+        client_id: i32,
+        wallet_address: Address,
+        transaction: TxEip1559,
+    ) -> Result<SpecificMeaning, SignTransactionError> {
+        let mut conn = self.db.get().await?;
+        let wallet = schema::evm_wallet::table
+            .select(models::EvmWallet::as_select())
+            .filter(schema::evm_wallet::address.eq(wallet_address.as_slice()))
+            .first(&mut conn)
+            .await
+            .optional()?
+            .ok_or(SignTransactionError::WalletNotFound)?;
+        drop(conn);
+
+        let meaning = self.engine
+            .evaluate_transaction(wallet.id, client_id, transaction.clone(), RunKind::Execution)
+            .await?;
+
+        Ok(meaning)
+    }
+
+    #[message]
+    pub async fn client_sign_transaction(
+        &mut self,
+        client_id: i32,
+        wallet_address: Address,
+        mut transaction: TxEip1559,
+    ) -> Result<Signature, SignTransactionError> {
+        let mut conn = self.db.get().await?;
+        let wallet = schema::evm_wallet::table
+            .select(models::EvmWallet::as_select())
+            .filter(schema::evm_wallet::address.eq(wallet_address.as_slice()))
+            .first(&mut conn)
+            .await
+            .optional()?
+            .ok_or(SignTransactionError::WalletNotFound)?;
+        drop(conn);
+
+        let raw_key: MemSafe<Vec<u8>> = self
+            .keyholder
+            .ask(Decrypt { aead_id: wallet.aead_encrypted_id })
+            .await
+            .map_err(|_| SignTransactionError::KeyholderSend)?;
+
+        let signer = safe_signer::SafeSigner::from_memsafe(raw_key)?;
+
+        self.engine
+            .evaluate_transaction(wallet.id, client_id, transaction.clone(), RunKind::Execution)
+            .await?;
+
+        use alloy::network::TxSignerSync as _;
+        Ok(signer.sign_transaction_sync(&mut transaction)?)
+    }
+}

server/crates/arbiter-server/src/actors/keyholder/mod.rs

@@ -1,3 +1,4 @@
+use chrono::Utc;
 use diesel::{
     ExpressionMethods as _, OptionalExtension, QueryDsl, SelectableHelper,
     dsl::{insert_into, update},
@@ -312,7 +313,7 @@ impl KeyHolder {
                 current_nonce: nonce.to_vec(),
                 schema_version: 1,
                 associated_root_key_id: *root_key_history_id,
-                created_at: chrono::Utc::now().timestamp() as i32,
+                created_at: Utc::now().into()
             })
             .returning(schema::aead_encrypted::id)
             .get_result(&mut conn)

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

@@ -3,15 +3,16 @@ use miette::Diagnostic;
 use thiserror::Error;
 
 use crate::{
-    actors::{bootstrap::Bootstrapper, keyholder::KeyHolder, router::MessageRouter},
+    actors::{bootstrap::Bootstrapper, evm::EvmActor, keyholder::KeyHolder, router::MessageRouter},
     db,
 };
 
 pub mod bootstrap;
-pub mod router;
-pub mod keyholder;
-pub mod user_agent;
 pub mod client;
+mod evm;
+pub mod keyholder;
+pub mod router;
+pub mod user_agent;
 
 #[derive(Error, Debug, Diagnostic)]
 pub enum SpawnError {
@@ -30,13 +31,16 @@ pub struct GlobalActors {
     pub key_holder: ActorRef<KeyHolder>,
     pub bootstrapper: ActorRef<Bootstrapper>,
     pub router: ActorRef<MessageRouter>,
+    pub evm: ActorRef<EvmActor>,
 }
 
 impl GlobalActors {
     pub async fn spawn(db: db::DatabasePool) -> Result<Self, SpawnError> {
+        let key_holder = KeyHolder::spawn(KeyHolder::new(db.clone()).await?);
         Ok(Self {
             bootstrapper: Bootstrapper::spawn(Bootstrapper::new(&db).await?),
-            key_holder: KeyHolder::spawn(KeyHolder::new(db.clone()).await?),
+            evm: EvmActor::spawn(EvmActor::new(key_holder.clone(), db)),
+            key_holder,
             router: MessageRouter::spawn(MessageRouter::default()),
         })
     }

server/crates/arbiter-server/src/actors/user_agent/session.rs

@@ -1,19 +1,26 @@
 use std::{ops::DerefMut, sync::Mutex};
 
-use arbiter_proto::proto::user_agent::{
-    UnsealEncryptedKey, UnsealResult, UnsealStart, UnsealStartResponse, UserAgentRequest,
-    UserAgentResponse, user_agent_request::Payload as UserAgentRequestPayload,
-    user_agent_response::Payload as UserAgentResponsePayload,
+use arbiter_proto::proto::{
+    evm as evm_proto,
+    user_agent::{
+        UnsealEncryptedKey, UnsealResult, UnsealStart, UnsealStartResponse, UserAgentRequest,
+        UserAgentResponse, user_agent_request::Payload as UserAgentRequestPayload,
+        user_agent_response::Payload as UserAgentResponsePayload,
+    },
 };
 use chacha20poly1305::{AeadInPlace, XChaCha20Poly1305, XNonce, aead::KeyInit};
 use ed25519_dalek::VerifyingKey;
-use kameo::{Actor, error::SendError};
+use kameo::{
+    Actor,
+    error::SendError,
+};
 use memsafe::MemSafe;
 use tokio::select;
 use tracing::{error, info};
 use x25519_dalek::{EphemeralSecret, PublicKey};
 
 use crate::actors::{
+    evm::{Generate, ListWallets},
     keyholder::{self, TryUnseal},
     router::RegisterUserAgent,
     user_agent::{UserAgentConnection, UserAgentError},
@@ -58,6 +65,8 @@ impl UserAgentSession {
             UserAgentRequestPayload::UnsealEncryptedKey(unseal_encrypted_key) => {
                 self.handle_unseal_encrypted_key(unseal_encrypted_key).await
             }
+            UserAgentRequestPayload::EvmWalletCreate(_) => self.handle_evm_wallet_create().await,
+            UserAgentRequestPayload::EvmWalletList(_) => self.handle_evm_wallet_list().await,
             _ => Err(UserAgentError::UnexpectedRequestPayload),
         }
     }
@@ -178,6 +187,64 @@ impl UserAgentSession {
     }
 }
 
+impl UserAgentSession {
+    async fn handle_evm_wallet_create(&mut self) -> Output {
+        use evm_proto::wallet_create_response::Result as CreateResult;
+
+        let result = match self.props.actors.evm.ask(Generate {}).await {
+            Ok(address) => CreateResult::Wallet(evm_proto::WalletEntry {
+                address: address.as_slice().to_vec(),
+            }),
+            Err(err) => CreateResult::Error(map_evm_error("wallet create", err).into()),
+        };
+
+        Ok(response(UserAgentResponsePayload::EvmWalletCreate(
+            evm_proto::WalletCreateResponse {
+                result: Some(result),
+            },
+        )))
+    }
+
+    async fn handle_evm_wallet_list(&mut self) -> Output {
+        use evm_proto::wallet_list_response::Result as ListResult;
+
+        let result = match self.props.actors.evm.ask(ListWallets {}).await {
+            Ok(wallets) => ListResult::Wallets(evm_proto::WalletList {
+                wallets: wallets
+                    .into_iter()
+                    .map(|addr| evm_proto::WalletEntry {
+                        address: addr.as_slice().to_vec(),
+                    })
+                    .collect(),
+            }),
+            Err(err) => ListResult::Error(map_evm_error("wallet list", err).into()),
+        };
+
+        Ok(response(UserAgentResponsePayload::EvmWalletList(
+            evm_proto::WalletListResponse {
+                result: Some(result),
+            },
+        )))
+    }
+}
+
+fn map_evm_error<M>(op: &str, err: SendError<M, crate::actors::evm::Error>) -> evm_proto::EvmError {
+    use crate::actors::{evm::Error as EvmError, keyholder::Error as KhError};
+    match err {
+        SendError::HandlerError(EvmError::Keyholder(KhError::NotBootstrapped)) => {
+            evm_proto::EvmError::VaultSealed
+        }
+        SendError::HandlerError(err) => {
+            error!(?err, "EVM {op} failed");
+            evm_proto::EvmError::Internal
+        }
+        _ => {
+            error!("EVM actor unreachable during {op}");
+            evm_proto::EvmError::Internal
+        }
+    }
+}
+
 impl Actor for UserAgentSession {
     type Args = Self;
 

server/crates/arbiter-server/src/db/models.rs

@@ -1,14 +1,78 @@
 #![allow(unused)]
 #![allow(clippy::all)]
 
-use crate::db::schema::{self, aead_encrypted, arbiter_settings, root_key_history, tls_history};
+use crate::db::schema::{
+    self, aead_encrypted, arbiter_settings, evm_basic_grant, evm_ether_transfer_grant, evm_ether_transfer_grant_target, evm_ether_transfer_limit, evm_token_transfer_grant, evm_token_transfer_log, evm_token_transfer_volume_limit, evm_transaction_log, evm_wallet, root_key_history, tls_history
+};
+use chrono::{DateTime, Utc};
 use diesel::{prelude::*, sqlite::Sqlite};
 use restructed::Models;
 
 pub mod types {
+    use std::os::unix;
+
     use chrono::{DateTime, Utc};
-    pub struct SqliteTimestamp(DateTime<Utc>);
+    use diesel::{
+        deserialize::{FromSql, FromSqlRow},
+        expression::AsExpression,
+        serialize::{IsNull, ToSql},
+        sql_types::Integer,
+        sqlite::{Sqlite, SqliteType},
+    };
+
+    #[derive(Debug, FromSqlRow, AsExpression)]
+    #[sql_type = "Integer"]
+    #[repr(transparent)] // hint compiler to optimize the wrapper struct away
+    pub struct SqliteTimestamp(pub DateTime<Utc>);
+    impl SqliteTimestamp {
+        pub fn now() -> Self {
+            SqliteTimestamp(Utc::now())
+        }
+    }
+
+    impl From<chrono::DateTime<Utc>> for SqliteTimestamp {
+        fn from(dt: chrono::DateTime<Utc>) -> Self {
+            SqliteTimestamp(dt)
+        }
+    }
+    impl Into<chrono::DateTime<Utc>> for SqliteTimestamp {
+        fn into(self) -> chrono::DateTime<Utc> {
+            self.0
+        }
+    }
+
+    impl ToSql<Integer, Sqlite> for SqliteTimestamp {
+        fn to_sql<'b>(
+            &'b self,
+            out: &mut diesel::serialize::Output<'b, '_, Sqlite>,
+        ) -> diesel::serialize::Result {
+            let unix_timestamp = self.0.timestamp() as i32;
+            out.set_value(unix_timestamp);
+            Ok(IsNull::No)
+        }
+    }
+
+    impl FromSql<Integer, Sqlite> for SqliteTimestamp {
+        fn from_sql(
+            mut bytes: <Sqlite as diesel::backend::Backend>::RawValue<'_>,
+        ) -> diesel::deserialize::Result<Self> {
+            let Some(SqliteType::Integer) = bytes.value_type() else {
+                return Err(format!(
+                    "Expected Integer type for SqliteTimestamp, got {:?}",
+                    bytes.value_type()
+                )
+                .into());
+            };
+
+            let unix_timestamp = bytes.read_integer();
+            let datetime = DateTime::from_timestamp(unix_timestamp as i64, 0)
+                .ok_or("Timestamp is out of bounds")?;
+
+            Ok(SqliteTimestamp(datetime))
+        }
+    }
 }
+pub use types::*;
 
 #[derive(Models, Queryable, Debug, Insertable, Selectable)]
 #[view(
@@ -25,7 +89,7 @@ pub struct AeadEncrypted {
     pub current_nonce: Vec<u8>,
     pub schema_version: i32,
     pub associated_root_key_id: i32, // references root_key_history.id
-    pub created_at: i32,
+    pub created_at: SqliteTimestamp,
 }
 
 #[derive(Models, Queryable, Debug, Insertable, Selectable)]
@@ -58,9 +122,9 @@ pub struct TlsHistory {
     pub id: i32,
     pub cert: String,
     pub cert_key: String, // PEM Encoded private key
-    pub ca_cert: String, // PEM Encoded certificate for cert signing
-    pub ca_key: String, // PEM Encoded public key for cert signing
-    pub created_at: i32,
+    pub ca_cert: String,  // PEM Encoded certificate for cert signing
+    pub ca_key: String,   // PEM Encoded public key for cert signing
+    pub created_at: SqliteTimestamp,
 }
 
 #[derive(Queryable, Debug, Insertable, Selectable)]
@@ -68,25 +132,173 @@ pub struct TlsHistory {
 pub struct ArbiterSettings {
     pub id: i32,
     pub root_key_id: Option<i32>, // references root_key_history.id
-    pub tls_id: Option<i32>, // references tls_history.id
+    pub tls_id: Option<i32>,      // references tls_history.id
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_wallet, check_for_backend(Sqlite))]
+#[view(
+    NewEvmWallet,
+    derive(Insertable),
+    omit(id, created_at),
+    attributes_with = "deriveless"
+)]
+pub struct EvmWallet {
+    pub id: i32,
+    pub address: Vec<u8>,
+    pub aead_encrypted_id: i32,
+    pub created_at: SqliteTimestamp,
 }
 
 #[derive(Queryable, Debug)]
 #[diesel(table_name = schema::program_client, check_for_backend(Sqlite))]
 pub struct ProgramClient {
     pub id: i32,
-    pub public_key: Vec<u8>,
     pub nonce: i32,
-    pub created_at: i32,
-    pub updated_at: i32,
+    pub public_key: Vec<u8>,
+    pub created_at: SqliteTimestamp,
+    pub updated_at: SqliteTimestamp,
 }
 
 #[derive(Queryable, Debug)]
 #[diesel(table_name = schema::useragent_client, check_for_backend(Sqlite))]
 pub struct UseragentClient {
     pub id: i32,
-    pub public_key: Vec<u8>,
     pub nonce: i32,
-    pub created_at: i32,
-    pub updated_at: i32,
+    pub public_key: Vec<u8>,
+    pub created_at: SqliteTimestamp,
+    pub updated_at: SqliteTimestamp,
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_ether_transfer_limit, check_for_backend(Sqlite))]
+#[view(
+    NewEvmEtherTransferLimit,
+    derive(Insertable),
+    omit(id, created_at),
+    attributes_with = "deriveless"
+)]
+pub struct EvmEtherTransferLimit {
+    pub id: i32,
+    pub window_secs: i32,
+    pub max_volume: Vec<u8>,
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_basic_grant, check_for_backend(Sqlite))]
+#[view(
+    NewEvmBasicGrant,
+    derive(Insertable),
+    omit(id, created_at),
+    attributes_with = "deriveless"
+)]
+pub struct EvmBasicGrant {
+    pub id: i32,
+    pub wallet_id: i32, // references evm_wallet.id
+    pub client_id: i32, // references program_client.id
+    pub chain_id: i32,
+    pub valid_from: Option<SqliteTimestamp>,
+    pub valid_until: Option<SqliteTimestamp>,
+    pub max_gas_fee_per_gas: Option<Vec<u8>>,
+    pub max_priority_fee_per_gas: Option<Vec<u8>>,
+    pub rate_limit_count: Option<i32>,
+    pub rate_limit_window_secs: Option<i32>,
+    pub revoked_at: Option<SqliteTimestamp>,
+    pub created_at: SqliteTimestamp,
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_transaction_log, check_for_backend(Sqlite))]
+#[view(
+    NewEvmTransactionLog,
+    derive(Insertable),
+    omit(id),
+    attributes_with = "deriveless"
+)]
+pub struct EvmTransactionLog {
+    pub id: i32,
+    pub grant_id: i32,
+    pub client_id: i32,
+    pub wallet_id: i32,
+    pub chain_id: i32,
+    pub eth_value: Vec<u8>,
+    pub signed_at: SqliteTimestamp,
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_ether_transfer_grant, check_for_backend(Sqlite))]
+#[view(
+    NewEvmEtherTransferGrant,
+    derive(Insertable),
+    omit(id),
+    attributes_with = "deriveless"
+)]
+pub struct EvmEtherTransferGrant {
+    pub id: i32,
+    pub basic_grant_id: i32,
+    pub limit_id: i32, // references evm_ether_transfer_limit.id
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_ether_transfer_grant_target, check_for_backend(Sqlite))]
+#[view(
+    NewEvmEtherTransferGrantTarget,
+    derive(Insertable),
+    omit(id),
+    attributes_with = "deriveless"
+)]
+pub struct EvmEtherTransferGrantTarget {
+    pub id: i32,
+    pub grant_id: i32,
+    pub address: Vec<u8>,
+}
+
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_token_transfer_grant, check_for_backend(Sqlite))]
+#[view(
+    NewEvmTokenTransferGrant,
+    derive(Insertable),
+    omit(id),
+    attributes_with = "deriveless"
+)]
+pub struct EvmTokenTransferGrant {
+    pub id: i32,
+    pub basic_grant_id: i32,
+    pub token_contract: Vec<u8>,
+    pub receiver: Option<Vec<u8>>,
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_token_transfer_volume_limit, check_for_backend(Sqlite))]
+#[view(
+    NewEvmTokenTransferVolumeLimit,
+    derive(Insertable),
+    omit(id),
+    attributes_with = "deriveless"
+)]
+pub struct EvmTokenTransferVolumeLimit {
+    pub id: i32,
+    pub grant_id: i32,
+    pub window_secs: i32,
+    pub max_volume: Vec<u8>,
+}
+
+#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[diesel(table_name = evm_token_transfer_log, check_for_backend(Sqlite))]
+#[view(
+    NewEvmTokenTransferLog,
+    derive(Insertable),
+    omit(id, created_at),
+    attributes_with = "deriveless"
+)]
+pub struct EvmTokenTransferLog {
+    pub id: i32,
+    pub grant_id: i32,
+    pub log_id: i32,
+    pub chain_id: i32,
+    pub token_contract: Vec<u8>,
+    pub recipient_address: Vec<u8>,
+    pub value: Vec<u8>,
+    pub created_at: SqliteTimestamp,
 }

server/crates/arbiter-server/src/db/schema.rs

@@ -20,6 +20,99 @@ diesel::table! {
     }
 }
 
+diesel::table! {
+    evm_basic_grant (id) {
+        id -> Integer,
+        wallet_id -> Integer,
+        client_id -> Integer,
+        chain_id -> Integer,
+        valid_from -> Nullable<Integer>,
+        valid_until -> Nullable<Integer>,
+        max_gas_fee_per_gas -> Nullable<Binary>,
+        max_priority_fee_per_gas -> Nullable<Binary>,
+        rate_limit_count -> Nullable<Integer>,
+        rate_limit_window_secs -> Nullable<Integer>,
+        revoked_at -> Nullable<Integer>,
+        created_at -> Integer,
+    }
+}
+
+diesel::table! {
+    evm_ether_transfer_grant (id) {
+        id -> Integer,
+        basic_grant_id -> Integer,
+        limit_id -> Integer,
+    }
+}
+
+diesel::table! {
+    evm_ether_transfer_grant_target (id) {
+        id -> Integer,
+        grant_id -> Integer,
+        address -> Binary,
+    }
+}
+
+diesel::table! {
+    evm_ether_transfer_limit (id) {
+        id -> Integer,
+        window_secs -> Integer,
+        max_volume -> Binary,
+    }
+}
+
+diesel::table! {
+    evm_token_transfer_grant (id) {
+        id -> Integer,
+        basic_grant_id -> Integer,
+        token_contract -> Binary,
+        receiver -> Nullable<Binary>,
+    }
+}
+
+diesel::table! {
+    evm_token_transfer_log (id) {
+        id -> Integer,
+        grant_id -> Integer,
+        log_id -> Integer,
+        chain_id -> Integer,
+        token_contract -> Binary,
+        recipient_address -> Binary,
+        value -> Binary,
+        created_at -> Integer,
+    }
+}
+
+diesel::table! {
+    evm_token_transfer_volume_limit (id) {
+        id -> Integer,
+        grant_id -> Integer,
+        window_secs -> Integer,
+        max_volume -> Binary,
+    }
+}
+
+diesel::table! {
+    evm_transaction_log (id) {
+        id -> Integer,
+        grant_id -> Integer,
+        client_id -> Integer,
+        wallet_id -> Integer,
+        chain_id -> Integer,
+        eth_value -> Binary,
+        signed_at -> Integer,
+    }
+}
+
+diesel::table! {
+    evm_wallet (id) {
+        id -> Integer,
+        address -> Binary,
+        aead_encrypted_id -> Integer,
+        created_at -> Integer,
+    }
+}
+
 diesel::table! {
     program_client (id) {
         id -> Integer,
@@ -66,10 +159,29 @@ diesel::table! {
 diesel::joinable!(aead_encrypted -> root_key_history (associated_root_key_id));
 diesel::joinable!(arbiter_settings -> root_key_history (root_key_id));
 diesel::joinable!(arbiter_settings -> tls_history (tls_id));
+diesel::joinable!(evm_basic_grant -> evm_wallet (wallet_id));
+diesel::joinable!(evm_basic_grant -> program_client (client_id));
+diesel::joinable!(evm_ether_transfer_grant -> evm_basic_grant (basic_grant_id));
+diesel::joinable!(evm_ether_transfer_grant -> evm_ether_transfer_limit (limit_id));
+diesel::joinable!(evm_ether_transfer_grant_target -> evm_ether_transfer_grant (grant_id));
+diesel::joinable!(evm_token_transfer_grant -> evm_basic_grant (basic_grant_id));
+diesel::joinable!(evm_token_transfer_log -> evm_token_transfer_grant (grant_id));
+diesel::joinable!(evm_token_transfer_log -> evm_transaction_log (log_id));
+diesel::joinable!(evm_token_transfer_volume_limit -> evm_token_transfer_grant (grant_id));
+diesel::joinable!(evm_wallet -> aead_encrypted (aead_encrypted_id));
 
 diesel::allow_tables_to_appear_in_same_query!(
     aead_encrypted,
     arbiter_settings,
+    evm_basic_grant,
+    evm_ether_transfer_grant,
+    evm_ether_transfer_grant_target,
+    evm_ether_transfer_limit,
+    evm_token_transfer_grant,
+    evm_token_transfer_log,
+    evm_token_transfer_volume_limit,
+    evm_transaction_log,
+    evm_wallet,
     program_client,
     root_key_history,
     tls_history,

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

@@ -0,0 +1,84 @@
+use alloy::sol;
+
+sol! {
+    interface IERC20 {
+        event Transfer(address indexed from, address indexed to, uint256 value);
+        event Approval(address indexed owner, address indexed spender, uint256 value);
+
+        function totalSupply() external view returns (uint256);
+        function balanceOf(address account) external view returns (uint256);
+        function transfer(address to, uint256 value) external returns (bool);
+        function allowance(address owner, address spender) external view returns (uint256);
+        function approve(address spender, uint256 value) external returns (bool);
+        function transferFrom(address from, address to, uint256 value) external returns (bool);
+    }
+}
+
+sol! {
+    /// ERC-721: Non-Fungible Token Standard.
+    #[derive(Debug)]
+    interface IERC721 {
+        event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+        event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+        event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+        function balanceOf(address owner) external view returns (uint256 balance);
+        function ownerOf(uint256 tokenId) external view returns (address owner);
+        function safeTransferFrom(address from, address to, uint256 tokenId) external;
+        function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
+        function transferFrom(address from, address to, uint256 tokenId) external;
+        function approve(address to, uint256 tokenId) external;
+        function setApprovalForAll(address operator, bool approved) external;
+        function getApproved(uint256 tokenId) external view returns (address operator);
+        function isApprovedForAll(address owner, address operator) external view returns (bool);
+    }
+}
+
+sol! {
+    /// Wrapped Ether — the only functions beyond ERC-20 that matter.
+    #[derive(Debug)]
+    interface IWETH {
+        function deposit() external payable;
+        function withdraw(uint256 wad) external;
+    }
+}
+
+sol! {
+    /// Permit2 — Uniswap's canonical token approval manager.
+    /// Replaces per-contract ERC-20 approve() with a single approval hub.
+    #[derive(Debug)]
+    interface IPermit2 {
+        struct TokenPermissions {
+            address token;
+            uint256 amount;
+        }
+
+        struct PermitSingle {
+            TokenPermissions details;
+            address spender;
+            uint256 sigDeadline;
+        }
+
+        struct PermitBatch {
+            TokenPermissions[] details;
+            address spender;
+            uint256 sigDeadline;
+        }
+
+        struct AllowanceTransferDetails {
+            address from;
+            address to;
+            uint160 amount;
+            address token;
+        }
+
+        function approve(address token, address spender, uint160 amount, uint48 expiration) external;
+        function permit(address owner, PermitSingle calldata permitSingle, bytes calldata signature) external;
+        function permit(address owner, PermitBatch calldata permitBatch, bytes calldata signature) external;
+        function transferFrom(address from, address to, uint160 amount, address token) external;
+        function transferFrom(AllowanceTransferDetails[] calldata transferDetails) external;
+
+        function allowance(address user, address token, address spender)
+            external view returns (uint160 amount, uint48 expiration, uint48 nonce);
+    }
+}

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

@@ -0,0 +1,244 @@
+pub mod abi;
+pub mod safe_signer;
+
+use alloy::{consensus::TxEip1559, primitives::TxKind, signers::Signature};
+use chrono::Utc;
+use diesel::{QueryResult, insert_into};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+
+use crate::{
+    db::{
+        self,
+        models::{
+            EvmBasicGrant, EvmTransactionLog, NewEvmBasicGrant, NewEvmTransactionLog,
+            SqliteTimestamp,
+        },
+        schema::{self, evm_transaction_log},
+    },
+    evm::policies::{
+        EvalContext, EvalViolation, FullGrant, Policy, SpecificMeaning,
+        ether_transfer::EtherTransfer, token_transfers::TokenTransfer,
+    },
+};
+
+pub mod policies;
+mod utils;
+
+/// Errors that can only occur once the transaction meaning is known (during policy evaluation)
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum PolicyError {
+    #[error("Database connection pool error")]
+    #[diagnostic(code(arbiter_server::evm::policy_error::pool))]
+    Pool(#[from] db::PoolError),
+    #[error("Database returned error")]
+    #[diagnostic(code(arbiter_server::evm::policy_error::database))]
+    Database(#[from] diesel::result::Error),
+    #[error("Transaction violates policy: {0:?}")]
+    #[diagnostic(code(arbiter_server::evm::policy_error::violation))]
+    Violations(Vec<EvalViolation>),
+    #[error("No matching grant found")]
+    #[diagnostic(code(arbiter_server::evm::policy_error::no_matching_grant))]
+    NoMatchingGrant,
+}
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum VetError {
+    #[error("Contract creation transactions are not supported")]
+    #[diagnostic(code(arbiter_server::evm::vet_error::contract_creation_unsupported))]
+    ContractCreationNotSupported,
+    #[error("Engine can't classify this transaction")]
+    #[diagnostic(code(arbiter_server::evm::vet_error::unsupported))]
+    UnsupportedTransactionType,
+    #[error("Policy evaluation failed: {1}")]
+    #[diagnostic(code(arbiter_server::evm::vet_error::evaluated))]
+    Evaluated(SpecificMeaning, #[source] PolicyError),
+}
+
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum SignError {
+    #[error("Database connection pool error")]
+    #[diagnostic(code(arbiter_server::evm::database_error))]
+    Pool(#[from] db::PoolError),
+    #[error("Database returned error")]
+    #[diagnostic(code(arbiter_server::evm::database_error))]
+    Database(#[from] diesel::result::Error),
+}
+
+#[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),
+}
+
+/// Controls whether a transaction should be executed or only validated
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum RunKind {
+    /// Validate and record the transaction
+    Execution,
+    /// Validate only, do not record
+    CheckOnly,
+}
+
+// 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 {
+    async fn vet_transaction<P: Policy>(
+        &self,
+        context: EvalContext,
+        meaning: &P::Meaning,
+        run_kind: RunKind,
+    ) -> Result<(), PolicyError> {
+        let mut conn = self.db.get().await?;
+
+        let grant = P::try_find_grant(&context, &mut conn)
+            .await?
+            .ok_or(PolicyError::NoMatchingGrant)?;
+
+        let violations = P::evaluate(&context, meaning, &grant, &mut conn).await?;
+        if !violations.is_empty() {
+            return Err(PolicyError::Violations(violations));
+        } else if run_kind == RunKind::Execution {
+            conn.transaction(|conn| {
+                Box::pin(async move {
+                    let log_id: i32 = insert_into(evm_transaction_log::table)
+                        .values(&NewEvmTransactionLog {
+                            grant_id: grant.shared_grant_id,
+                            client_id: context.client_id,
+                            wallet_id: context.wallet_id,
+                            chain_id: context.chain as i32,
+                            eth_value: utils::u256_to_bytes(context.value).to_vec(),
+                            signed_at: Utc::now().into(),
+                        })
+                        .returning(evm_transaction_log::id)
+                        .get_result(conn)
+                        .await?;
+
+                    P::record_transaction(&context, meaning, log_id, &grant, conn).await?;
+
+                    QueryResult::Ok(())
+                })
+            })
+            .await?;
+        }
+
+        Ok(())
+    }
+}
+
+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::Settings>,
+    ) -> 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)
+    }
+
+    pub async fn evaluate_transaction(
+        &self,
+        wallet_id: i32,
+        client_id: i32,
+        transaction: TxEip1559,
+        run_kind: RunKind,
+    ) -> Result<SpecificMeaning, VetError> {
+        let TxKind::Call(to) = transaction.to else {
+            return Err(VetError::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 match self
+                .vet_transaction::<EtherTransfer>(context, &meaning, run_kind)
+                .await
+            {
+                Ok(()) => Ok(meaning.into()),
+                Err(e) => Err(VetError::Evaluated(meaning.into(), e)),
+            };
+        }
+        if let Some(meaning) = TokenTransfer::analyze(&context) {
+            return match self
+                .vet_transaction::<TokenTransfer>(context, &meaning, run_kind)
+                .await
+            {
+                Ok(()) => Ok(meaning.into()),
+                Err(e) => Err(VetError::Evaluated(meaning.into(), e)),
+            };
+        }
+
+        Err(VetError::UnsupportedTransactionType)
+    }
+}

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

@@ -0,0 +1,198 @@
+use std::fmt::Display;
+
+use alloy::primitives::{Address, Bytes, ChainId, U256};
+use chrono::{DateTime, Duration, Utc};
+use diesel::{
+    ExpressionMethods as _, QueryDsl, SelectableHelper, result::QueryResult, sqlite::Sqlite,
+};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+use miette::Diagnostic;
+use thiserror::Error;
+
+use crate::{
+    db::models::{self, EvmBasicGrant},
+    evm::utils,
+};
+
+pub mod ether_transfer;
+pub mod token_transfers;
+
+pub struct EvalContext {
+    // Which wallet is this transaction for
+    pub client_id: i32,
+    pub wallet_id: i32,
+
+    // The transaction data
+    pub chain: ChainId,
+    pub to: Address,
+    pub value: U256,
+    pub calldata: Bytes,
+}
+
+#[derive(Debug, Error, Diagnostic)]
+pub enum EvalViolation {
+    #[error("This grant doesn't allow transactions to the target address {target}")]
+    #[diagnostic(code(arbiter_server::evm::eval_violation::invalid_target))]
+    InvalidTarget { target: Address },
+
+    #[error("Gas limit exceeded for this grant")]
+    #[diagnostic(code(arbiter_server::evm::eval_violation::gas_limit_exceeded))]
+    GasLimitExceeded {
+        max_gas_fee_per_gas: Option<U256>,
+        max_priority_fee_per_gas: Option<U256>,
+    },
+
+    #[error("Rate limit exceeded for this grant")]
+    #[diagnostic(code(arbiter_server::evm::eval_violation::rate_limit_exceeded))]
+    RateLimitExceeded,
+
+    #[error("Transaction exceeds volumetric limits of the grant")]
+    #[diagnostic(code(arbiter_server::evm::eval_violation::volumetric_limit_exceeded))]
+    VolumetricLimitExceeded,
+
+    #[error("Transaction is outside of the grant's validity period")]
+    #[diagnostic(code(arbiter_server::evm::eval_violation::invalid_time))]
+    InvalidTime,
+
+    #[error("Transaction type is not allowed by this grant")]
+    #[diagnostic(code(arbiter_server::evm::eval_violation::invalid_transaction_type))]
+    InvalidTransactionType,
+}
+
+pub type DatabaseID = i32;
+
+pub struct Grant<PolicySettings> {
+    pub id: DatabaseID,
+    pub shared_grant_id: DatabaseID, // ID of the basic grant for shared-logic checks like rate limits and validity periods
+    pub shared: SharedGrantSettings,
+    pub settings: PolicySettings,
+}
+
+pub trait Policy: Sized {
+    type Settings: Send + Sync + 'static + Into<SpecificGrant>;
+    type Meaning: Display + std::fmt::Debug + Send + Sync + 'static + Into<SpecificMeaning>;
+
+    fn analyze(context: &EvalContext) -> Option<Self::Meaning>;
+
+    // Evaluate whether a transaction with the given meaning complies with the provided grant, and return any violations if not
+    // Empty vector means transaction is compliant with the grant
+    fn evaluate(
+        context: &EvalContext,
+        meaning: &Self::Meaning,
+        grant: &Grant<Self::Settings>,
+        db: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> impl Future<Output = QueryResult<Vec<EvalViolation>>> + Send;
+
+    // Create a new grant in the database based on the provided grant details, and return its ID
+    fn create_grant(
+        basic: &models::EvmBasicGrant,
+        grant: &Self::Settings,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> impl std::future::Future<Output = QueryResult<DatabaseID>> + Send;
+
+    // Try to find an existing grant that matches the transaction context, and return its details if found
+    // Additionally, return ID of basic grant for shared-logic checks like rate limits and validity periods
+    fn try_find_grant(
+        context: &EvalContext,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> impl Future<Output = QueryResult<Option<Grant<Self::Settings>>>> + Send;
+
+    // Records, updates or deletes rate limits
+    // In other words, records grant-specific things after transaction is executed
+    fn record_transaction(
+        context: &EvalContext,
+        meaning: &Self::Meaning,
+        log_id: i32,
+        grant: &Grant<Self::Settings>,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> impl Future<Output = QueryResult<()>> + Send;
+}
+
+pub enum ReceiverTarget {
+    Specific(Vec<Address>), // only allow transfers to these addresses
+    Any,                    // allow transfers to any address
+}
+
+// Classification of what transaction does
+#[derive(Debug)]
+pub enum SpecificMeaning {
+    EtherTransfer(ether_transfer::Meaning),
+    TokenTransfer(token_transfers::Meaning),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct TransactionRateLimit {
+    pub count: u32,
+    pub window: Duration,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct VolumeRateLimit {
+    pub max_volume: U256,
+    pub window: Duration,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct SharedGrantSettings {
+    pub wallet_id: i32,
+    pub chain: ChainId,
+
+    pub valid_from: Option<DateTime<Utc>>,
+    pub valid_until: Option<DateTime<Utc>>,
+
+    pub max_gas_fee_per_gas: Option<U256>,
+    pub max_priority_fee_per_gas: Option<U256>,
+
+    pub rate_limit: Option<TransactionRateLimit>,
+}
+
+impl SharedGrantSettings {
+    fn try_from_model(model: EvmBasicGrant) -> QueryResult<Self> {
+        Ok(Self {
+            wallet_id: model.wallet_id,
+            chain: model.chain_id as u64, // safe because chain_id is stored as i32 but is guaranteed to be a valid ChainId by the API when creating grants
+            valid_from: model.valid_from.map(Into::into),
+            valid_until: model.valid_until.map(Into::into),
+            max_gas_fee_per_gas: model
+                .max_gas_fee_per_gas
+                .map(|b| utils::try_bytes_to_u256(&b))
+                .transpose()?,
+            max_priority_fee_per_gas: model
+                .max_priority_fee_per_gas
+                .map(|b| utils::try_bytes_to_u256(&b))
+                .transpose()?,
+            rate_limit: match (model.rate_limit_count, model.rate_limit_window_secs) {
+                (Some(count), Some(window_secs)) => Some(TransactionRateLimit {
+                    count: count as u32,
+                    window: Duration::seconds(window_secs as i64),
+                }),
+                _ => None,
+            },
+        })
+    }
+
+    pub async fn query_by_id(
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+        id: i32,
+    ) -> diesel::result::QueryResult<Self> {
+        use crate::db::schema::evm_basic_grant;
+
+        let basic_grant: EvmBasicGrant = evm_basic_grant::table
+            .select(EvmBasicGrant::as_select())
+            .filter(evm_basic_grant::id.eq(id))
+            .first::<EvmBasicGrant>(conn)
+            .await?;
+
+        Self::try_from_model(basic_grant)
+    }
+}
+
+pub enum SpecificGrant {
+    EtherTransfer(ether_transfer::Settings),
+    TokenTransfer(token_transfers::Settings),
+}
+
+pub struct FullGrant<PolicyGrant> {
+    pub basic: SharedGrantSettings,
+    pub specific: PolicyGrant,
+}

server/crates/arbiter-server/src/evm/policies/ether_transfer.rs

@@ -0,0 +1,269 @@
+use std::fmt::Display;
+
+use alloy::primitives::{Address, U256};
+use chrono::{DateTime, Duration, Utc};
+use diesel::dsl::insert_into;
+use diesel::sqlite::Sqlite;
+use diesel::{ExpressionMethods, JoinOnDsl, prelude::*};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+
+use crate::db::models::{
+    EvmBasicGrant, EvmEtherTransferGrant, EvmEtherTransferGrantTarget, EvmEtherTransferLimit,
+    NewEvmEtherTransferLimit, SqliteTimestamp,
+};
+use crate::db::schema::{evm_ether_transfer_limit, evm_transaction_log};
+use crate::evm::policies::{
+    Grant, SharedGrantSettings, SpecificGrant, SpecificMeaning, VolumeRateLimit,
+};
+use crate::{
+    db::{
+        models::{self, NewEvmEtherTransferGrant, NewEvmEtherTransferGrantTarget},
+        schema::{evm_ether_transfer_grant, evm_ether_transfer_grant_target},
+    },
+    evm::{policies::Policy, utils},
+};
+
+use super::{DatabaseID, EvalContext, EvalViolation};
+
+// Plain ether transfer
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Meaning {
+    to: Address,
+    value: U256,
+}
+impl Display for Meaning {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Ether transfer of {} to {}",
+            self.value,
+            self.to.to_string()
+        )
+    }
+}
+impl Into<SpecificMeaning> for Meaning {
+    fn into(self) -> SpecificMeaning {
+        SpecificMeaning::EtherTransfer(self)
+    }
+}
+
+// A grant for ether transfers, which can be scoped to specific target addresses and volume limits
+pub struct Settings {
+    target: Vec<Address>,
+    limit: VolumeRateLimit,
+}
+
+impl Into<SpecificGrant> for Settings {
+    fn into(self) -> SpecificGrant {
+        SpecificGrant::EtherTransfer(self)
+    }
+}
+
+async fn query_relevant_past_transaction(
+    grant_id: i32,
+    longest_window: Duration,
+    db: &mut impl AsyncConnection<Backend = Sqlite>,
+) -> QueryResult<Vec<(U256, DateTime<Utc>)>> {
+    let past_transactions: Vec<(Vec<u8>, SqliteTimestamp)> = evm_transaction_log::table
+        .filter(evm_transaction_log::grant_id.eq(grant_id))
+        .filter(
+            evm_transaction_log::signed_at.ge(SqliteTimestamp(chrono::Utc::now() - longest_window)),
+        )
+        .select((
+            evm_transaction_log::eth_value,
+            evm_transaction_log::signed_at,
+        ))
+        .load(db)
+        .await?;
+    let past_transaction: Vec<(U256, DateTime<Utc>)> = past_transactions
+        .into_iter()
+        .filter_map(|(value_bytes, timestamp)| {
+            let value = utils::bytes_to_u256(&value_bytes)?;
+            Some((value, timestamp.0))
+        })
+        .collect();
+    Ok(past_transaction)
+}
+
+async fn check_rate_limits(
+    grant: &Grant<Settings>,
+    db: &mut impl AsyncConnection<Backend = Sqlite>,
+) -> QueryResult<Vec<EvalViolation>> {
+    let mut violations = Vec::new();
+    let window = grant.settings.limit.window;
+
+    let past_transaction = query_relevant_past_transaction(grant.id, window, db).await?;
+
+    let window_start = chrono::Utc::now() - grant.settings.limit.window;
+    let cumulative_volume: U256 = past_transaction
+        .iter()
+        .filter(|(_, timestamp)| timestamp >= &window_start)
+        .fold(U256::default(), |acc, (value, _)| acc + *value);
+
+    if cumulative_volume > grant.settings.limit.max_volume {
+        violations.push(EvalViolation::VolumetricLimitExceeded);
+    }
+
+    Ok(violations)
+}
+
+pub struct EtherTransfer;
+impl Policy for EtherTransfer {
+    type Settings = Settings;
+
+    type Meaning = Meaning;
+
+    fn analyze(context: &EvalContext) -> Option<Self::Meaning> {
+        if !context.calldata.is_empty() {
+            return None;
+        }
+
+        Some(Meaning {
+            to: context.to,
+            value: context.value,
+        })
+    }
+
+    async fn evaluate(
+        _: &EvalContext,
+        meaning: &Self::Meaning,
+        grant: &Grant<Self::Settings>,
+        db: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<Vec<EvalViolation>> {
+        let mut violations = Vec::new();
+
+        // Check if the target address is within the grant's allowed targets
+        if !grant.settings.target.contains(&meaning.to) {
+            violations.push(EvalViolation::InvalidTarget { target: meaning.to });
+        }
+
+        let rate_violations = check_rate_limits(grant, db).await?;
+        violations.extend(rate_violations);
+
+        Ok(violations)
+    }
+
+    async fn create_grant(
+        basic: &models::EvmBasicGrant,
+        grant: &Self::Settings,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> diesel::result::QueryResult<DatabaseID> {
+        let limit_id: i32 = insert_into(evm_ether_transfer_limit::table)
+            .values(NewEvmEtherTransferLimit {
+                window_secs: grant.limit.window.num_seconds() as i32,
+                max_volume: utils::u256_to_bytes(grant.limit.max_volume).to_vec(),
+            })
+            .returning(evm_ether_transfer_limit::id)
+            .get_result(conn)
+            .await?;
+
+        let grant_id: i32 = insert_into(evm_ether_transfer_grant::table)
+            .values(&NewEvmEtherTransferGrant {
+                basic_grant_id: basic.id,
+                limit_id,
+            })
+            .returning(evm_ether_transfer_grant::id)
+            .get_result(conn)
+            .await?;
+
+        for target in &grant.target {
+            insert_into(evm_ether_transfer_grant_target::table)
+                .values(NewEvmEtherTransferGrantTarget {
+                    grant_id,
+                    address: target.to_vec(),
+                })
+                .execute(conn)
+                .await?;
+        }
+
+        Ok(grant_id)
+    }
+
+    async fn try_find_grant(
+        context: &EvalContext,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> diesel::result::QueryResult<Option<Grant<Self::Settings>>> {
+        use crate::db::schema::{
+            evm_basic_grant, evm_ether_transfer_grant, evm_ether_transfer_grant_target,
+        };
+
+        let target_bytes = context.to.to_vec();
+
+        // Find a grant where:
+        // 1. The basic grant's wallet_id and client_id match the context
+        // 2. Any of the grant's targets match the context's `to` address
+        let grant: Option<(EvmBasicGrant, EvmEtherTransferGrant)> = evm_ether_transfer_grant::table
+            .inner_join(
+                evm_basic_grant::table
+                    .on(evm_ether_transfer_grant::basic_grant_id.eq(evm_basic_grant::id)),
+            )
+            .inner_join(
+                evm_ether_transfer_grant_target::table
+                    .on(evm_ether_transfer_grant::id.eq(evm_ether_transfer_grant_target::grant_id)),
+            )
+            .filter(evm_basic_grant::wallet_id.eq(context.wallet_id))
+            .filter(evm_basic_grant::client_id.eq(context.client_id))
+            .filter(evm_ether_transfer_grant_target::address.eq(&target_bytes))
+            .select((
+                EvmBasicGrant::as_select(),
+                EvmEtherTransferGrant::as_select(),
+            ))
+            .first(conn)
+            .await
+            .optional()?;
+
+        let Some((basic_grant, grant)) = grant else {
+            return Ok(None);
+        };
+
+        let target_bytes: Vec<EvmEtherTransferGrantTarget> = evm_ether_transfer_grant_target::table
+            .select(EvmEtherTransferGrantTarget::as_select())
+            .filter(evm_ether_transfer_grant_target::grant_id.eq(grant.id))
+            .load(conn)
+            .await?;
+
+        let limit: EvmEtherTransferLimit = evm_ether_transfer_limit::table
+            .filter(evm_ether_transfer_limit::id.eq(grant.limit_id))
+            .select(EvmEtherTransferLimit::as_select())
+            .first::<EvmEtherTransferLimit>(conn)
+            .await?;
+
+        // Convert bytes back to Address
+        let targets: Vec<Address> = target_bytes
+            .into_iter()
+            .filter_map(|target| {
+                // TODO: Handle invalid addresses more gracefully
+                let arr: [u8; 20] = target.address.try_into().ok()?;
+                Some(Address::from(arr))
+            })
+            .collect();
+
+        let settings = Settings {
+            target: targets,
+            limit: VolumeRateLimit {
+                max_volume: utils::try_bytes_to_u256(&limit.max_volume)
+                    .map_err(|err| diesel::result::Error::DeserializationError(Box::new(err)))?,
+                window: chrono::Duration::seconds(limit.window_secs as i64),
+            },
+        };
+
+        Ok(Some(Grant {
+            id: grant.id,
+            shared_grant_id: grant.basic_grant_id,
+            shared: SharedGrantSettings::try_from_model(basic_grant)?,
+            settings,
+        }))
+    }
+
+    async fn record_transaction(
+        _context: &EvalContext,
+        _: &Self::Meaning,
+        _log_id: i32,
+        _grant: &Grant<Self::Settings>,
+        _conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> diesel::result::QueryResult<()> {
+        // Basic log is sufficient
+
+        Ok(())
+    }
+}

server/crates/arbiter-server/src/evm/policies/token_transfers.rs

@@ -0,0 +1,291 @@
+use alloy::{
+    primitives::{Address, U256},
+    sol_types::SolCall,
+};
+use arbiter_tokens_registry::evm::nonfungible::{self, TokenInfo};
+use chrono::{DateTime, Duration, Utc};
+use diesel::dsl::insert_into;
+use diesel::sqlite::Sqlite;
+use diesel::{ExpressionMethods, prelude::*};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+
+use crate::db::models::{
+    EvmBasicGrant, EvmTokenTransferGrant, EvmTokenTransferVolumeLimit, NewEvmTokenTransferGrant,
+    NewEvmTokenTransferLog, NewEvmTokenTransferVolumeLimit, SqliteTimestamp,
+};
+use crate::db::schema::{
+    evm_token_transfer_grant, evm_token_transfer_log, evm_token_transfer_volume_limit,
+};
+use crate::evm::{
+    abi::IERC20::transferCall,
+    policies::{Grant, Policy, SharedGrantSettings, SpecificGrant, SpecificMeaning, VolumeRateLimit},
+    utils,
+};
+
+use super::{DatabaseID, EvalContext, EvalViolation};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Meaning {
+    token: &'static TokenInfo,
+    to: Address,
+    value: U256,
+}
+impl std::fmt::Display for Meaning {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Transfer of {} {} to {}",
+            self.value, self.token.symbol, self.to
+        )
+    }
+}
+impl Into<SpecificMeaning> for Meaning {
+    fn into(self) -> SpecificMeaning {
+        SpecificMeaning::TokenTransfer(self)
+    }
+}
+
+// A grant for token transfers, which can be scoped to specific target addresses and volume limits
+pub struct Settings {
+    token_contract: Address,
+    target: Option<Address>,
+    volume_limits: Vec<VolumeRateLimit>,
+}
+impl Into<SpecificGrant> for Settings {
+    fn into(self) -> SpecificGrant {
+        SpecificGrant::TokenTransfer(self)
+    }
+}
+
+async fn query_relevant_past_transfers(
+    grant_id: i32,
+    longest_window: Duration,
+    db: &mut impl AsyncConnection<Backend = Sqlite>,
+) -> QueryResult<Vec<(U256, DateTime<Utc>)>> {
+    let past_logs: Vec<(Vec<u8>, SqliteTimestamp)> = evm_token_transfer_log::table
+        .filter(evm_token_transfer_log::grant_id.eq(grant_id))
+        .filter(
+            evm_token_transfer_log::created_at
+                .ge(SqliteTimestamp(chrono::Utc::now() - longest_window)),
+        )
+        .select((
+            evm_token_transfer_log::value,
+            evm_token_transfer_log::created_at,
+        ))
+        .load(db)
+        .await?;
+
+    let past_transfers: Vec<(U256, DateTime<Utc>)> = past_logs
+        .into_iter()
+        .filter_map(|(value_bytes, timestamp)| {
+            let value = utils::bytes_to_u256(&value_bytes)?;
+            Some((value, timestamp.0))
+        })
+        .collect();
+
+    Ok(past_transfers)
+}
+
+async fn check_volume_rate_limits(
+    grant: &Grant<Settings>,
+    db: &mut impl AsyncConnection<Backend = Sqlite>,
+) -> QueryResult<Vec<EvalViolation>> {
+    let mut violations = Vec::new();
+
+    let Some(longest_window) = grant.settings.volume_limits.iter().map(|l| l.window).max() else {
+        return Ok(violations);
+    };
+
+    let past_transfers = query_relevant_past_transfers(grant.id, longest_window, db).await?;
+
+    for limit in &grant.settings.volume_limits {
+        let window_start = chrono::Utc::now() - limit.window;
+        let cumulative_volume: U256 = past_transfers
+            .iter()
+            .filter(|(_, timestamp)| timestamp >= &window_start)
+            .fold(U256::default(), |acc, (value, _)| acc + *value);
+
+        if cumulative_volume > limit.max_volume {
+            violations.push(EvalViolation::VolumetricLimitExceeded);
+            break;
+        }
+    }
+
+    Ok(violations)
+}
+
+pub struct TokenTransfer;
+impl Policy for TokenTransfer {
+    type Settings = Settings;
+    type Meaning = Meaning;
+
+    fn analyze(context: &EvalContext) -> Option<Self::Meaning> {
+        let token = nonfungible::get_token(context.chain, context.to)?;
+        let decoded = transferCall::abi_decode_raw_validate(&context.calldata).ok()?;
+
+        Some(Meaning {
+            token,
+            to: decoded.to,
+            value: decoded.value,
+        })
+    }
+
+    async fn evaluate(
+        context: &EvalContext,
+        meaning: &Self::Meaning,
+        grant: &Grant<Self::Settings>,
+        db: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<Vec<EvalViolation>> {
+        let mut violations = Vec::new();
+
+        // erc20 transfer shouldn't carry eth value
+        if !context.value.is_zero() {
+            violations.push(EvalViolation::InvalidTransactionType);
+            return Ok(violations);
+        }
+
+        if let Some(allowed) = grant.settings.target {
+            if allowed != meaning.to {
+                violations.push(EvalViolation::InvalidTarget { target: meaning.to });
+            }
+        }
+
+        let rate_violations = check_volume_rate_limits(grant, db).await?;
+        violations.extend(rate_violations);
+
+        Ok(violations)
+    }
+
+    async fn create_grant(
+        basic: &EvmBasicGrant,
+        grant: &Self::Settings,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<DatabaseID> {
+        // Store the specific receiver as bytes (None means any receiver is allowed)
+        let receiver: Option<Vec<u8>> = grant.target.map(|addr| addr.to_vec());
+
+        let grant_id: i32 = insert_into(evm_token_transfer_grant::table)
+            .values(NewEvmTokenTransferGrant {
+                basic_grant_id: basic.id,
+                token_contract: grant.token_contract.to_vec(),
+                receiver,
+            })
+            .returning(evm_token_transfer_grant::id)
+            .get_result(conn)
+            .await?;
+
+        for limit in &grant.volume_limits {
+            insert_into(evm_token_transfer_volume_limit::table)
+                .values(NewEvmTokenTransferVolumeLimit {
+                    grant_id,
+                    window_secs: limit.window.num_seconds() as i32,
+                    max_volume: utils::u256_to_bytes(limit.max_volume).to_vec(),
+                })
+                .execute(conn)
+                .await?;
+        }
+
+        Ok(grant_id)
+    }
+
+    async fn try_find_grant(
+        context: &EvalContext,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<Option<Grant<Self::Settings>>> {
+        use crate::db::schema::{evm_basic_grant, evm_token_transfer_grant};
+
+        let token_contract_bytes = context.to.to_vec();
+
+        let grant: Option<(EvmBasicGrant, EvmTokenTransferGrant)> = evm_token_transfer_grant::table
+            .inner_join(
+                evm_basic_grant::table
+                    .on(evm_token_transfer_grant::basic_grant_id.eq(evm_basic_grant::id)),
+            )
+            .filter(evm_basic_grant::wallet_id.eq(context.wallet_id))
+            .filter(evm_basic_grant::client_id.eq(context.client_id))
+            .filter(evm_token_transfer_grant::token_contract.eq(&token_contract_bytes))
+            .select((
+                EvmBasicGrant::as_select(),
+                EvmTokenTransferGrant::as_select(),
+            ))
+            .first(conn)
+            .await
+            .optional()?;
+
+        let Some((basic_grant, token_grant)) = grant else {
+            return Ok(None);
+        };
+
+        let volume_limits_db: Vec<EvmTokenTransferVolumeLimit> =
+            evm_token_transfer_volume_limit::table
+                .filter(evm_token_transfer_volume_limit::grant_id.eq(token_grant.id))
+                .select(EvmTokenTransferVolumeLimit::as_select())
+                .load(conn)
+                .await?;
+
+        let volume_limits: Vec<VolumeRateLimit> = volume_limits_db
+            .into_iter()
+            .map(|row| {
+                Ok(VolumeRateLimit {
+                    max_volume: utils::try_bytes_to_u256(&row.max_volume).map_err(|err| {
+                        diesel::result::Error::DeserializationError(Box::new(err))
+                    })?,
+                    window: Duration::seconds(row.window_secs as i64),
+                })
+            })
+            .collect::<QueryResult<Vec<_>>>()?;
+
+        let token_contract: [u8; 20] = token_grant.token_contract.try_into().map_err(|_| {
+            diesel::result::Error::DeserializationError(
+                "Invalid token contract address length".into(),
+            )
+        })?;
+
+        let target: Option<Address> = match token_grant.receiver {
+            None => None,
+            Some(bytes) => {
+                let arr: [u8; 20] = bytes.try_into().map_err(|_| {
+                    diesel::result::Error::DeserializationError(
+                        "Invalid receiver address length".into(),
+                    )
+                })?;
+                Some(Address::from(arr))
+            }
+        };
+
+        let settings = Settings {
+            token_contract: Address::from(token_contract),
+            target,
+            volume_limits,
+        };
+
+        Ok(Some(Grant {
+            id: token_grant.id,
+            shared_grant_id: token_grant.basic_grant_id,
+            shared: SharedGrantSettings::try_from_model(basic_grant)?,
+            settings,
+        }))
+    }
+
+    async fn record_transaction(
+        context: &EvalContext,
+        meaning: &Self::Meaning,
+        log_id: i32,
+        grant: &Grant<Self::Settings>,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<()> {
+        insert_into(evm_token_transfer_log::table)
+            .values(NewEvmTokenTransferLog {
+                grant_id: grant.id,
+                log_id,
+                chain_id: context.chain as i32,
+                token_contract: context.to.to_vec(),
+                recipient_address: meaning.to.to_vec(),
+                value: utils::u256_to_bytes(meaning.value).to_vec(),
+            })
+            .execute(conn)
+            .await?;
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,196 @@
+use std::sync::Mutex;
+
+use alloy::{
+    consensus::SignableTransaction,
+    network::{TxSigner, TxSignerSync},
+    primitives::{Address, ChainId, Signature, B256},
+    signers::{Error, Result, Signer, SignerSync, utils::secret_key_to_address},
+};
+use async_trait::async_trait;
+use k256::ecdsa::{self, signature::hazmat::PrehashSigner, RecoveryId, SigningKey};
+use memsafe::MemSafe;
+
+/// An Ethereum signer that stores its secp256k1 secret key inside a
+/// hardware-protected [`MemSafe`] cell.
+///
+/// The underlying memory page is kept non-readable/non-writable at rest.
+/// Access is temporarily elevated only for the duration of each signing
+/// operation, then immediately revoked.
+///
+/// Because [`MemSafe::read`] requires `&mut self` while the [`Signer`] trait
+/// requires `&self`, the cell is wrapped in a [`Mutex`].
+pub struct SafeSigner {
+    key: Mutex<MemSafe<SigningKey>>,
+    address: Address,
+    chain_id: Option<ChainId>,
+}
+
+impl std::fmt::Debug for SafeSigner {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SafeSigner")
+            .field("address", &self.address)
+            .field("chain_id", &self.chain_id)
+            .finish()
+    }
+}
+
+/// Generates a secp256k1 secret key directly inside a [`MemSafe`] cell.
+///
+/// Random bytes are written in-place into protected memory, then validated
+/// as a legal scalar on the secp256k1 curve (the scalar must be in
+/// `[1, n)` where `n` is the curve order — roughly 1-in-2^128 chance of
+/// rejection, but we retry to be correct).
+///
+/// Returns the protected key bytes and the derived Ethereum address.
+pub fn generate(rng: &mut impl rand::Rng) -> (MemSafe<[u8; 32]>, Address) {
+    loop {
+        let mut cell = MemSafe::new([0u8; 32]).expect("MemSafe allocation");
+        {
+            let mut w = cell.write().expect("MemSafe write");
+            rng.fill_bytes(w.as_mut());
+        }
+        let reader = cell.read().expect("MemSafe read");
+        if let Ok(sk) = SigningKey::from_slice(reader.as_ref()) {
+            let address = secret_key_to_address(&sk);
+            drop(reader);
+            return (cell, address);
+        }
+    }
+}
+
+impl SafeSigner {
+    /// Reconstructs a `SafeSigner` from key material held in a [`MemSafe`] buffer.
+    ///
+    /// The key bytes are read from protected memory, parsed as a secp256k1
+    /// scalar, and immediately moved into a new [`MemSafe`] cell. The raw
+    /// bytes are never exposed outside this function.
+    pub fn from_memsafe(mut cell: MemSafe<Vec<u8>>) -> Result<Self> {
+        let reader = cell.read().map_err(Error::other)?;
+        let sk = SigningKey::from_slice(reader.as_slice()).map_err(Error::other)?;
+        drop(reader);
+        Self::new(sk)
+    }
+
+    /// Creates a new `SafeSigner` by moving the signing key into a protected
+    /// memory region.
+    pub fn new(key: SigningKey) -> Result<Self> {
+        let address = secret_key_to_address(&key);
+        let cell = MemSafe::new(key).map_err(Error::other)?;
+        Ok(Self {
+            key: Mutex::new(cell),
+            address,
+            chain_id: None,
+        })
+    }
+
+    fn sign_hash_inner(&self, hash: &B256) -> Result<Signature> {
+        let mut cell = self.key.lock().expect("SafeSigner mutex poisoned");
+        let reader = cell.read().map_err(Error::other)?;
+        let sig: (ecdsa::Signature, RecoveryId) = reader.sign_prehash(hash.as_ref())?;
+        Ok(sig.into())
+    }
+
+    fn sign_tx_inner(
+        &self,
+        tx: &mut dyn SignableTransaction<Signature>,
+    ) -> Result<Signature> {
+        if let Some(chain_id) = self.chain_id {
+            if !tx.set_chain_id_checked(chain_id) {
+                return Err(Error::TransactionChainIdMismatch {
+                    signer: chain_id,
+                    tx: tx.chain_id().unwrap(),
+                });
+            }
+        }
+        self.sign_hash_inner(&tx.signature_hash()).map_err(Error::other)
+    }
+}
+
+#[async_trait]
+impl Signer for SafeSigner {
+    #[inline]
+    async fn sign_hash(&self, hash: &B256) -> Result<Signature> {
+        self.sign_hash_inner(hash)
+    }
+
+    #[inline]
+    fn address(&self) -> Address {
+        self.address
+    }
+
+    #[inline]
+    fn chain_id(&self) -> Option<ChainId> {
+        self.chain_id
+    }
+
+    #[inline]
+    fn set_chain_id(&mut self, chain_id: Option<ChainId>) {
+        self.chain_id = chain_id;
+    }
+}
+
+impl SignerSync for SafeSigner {
+    #[inline]
+    fn sign_hash_sync(&self, hash: &B256) -> Result<Signature> {
+        self.sign_hash_inner(hash)
+    }
+
+    #[inline]
+    fn chain_id_sync(&self) -> Option<ChainId> {
+        self.chain_id
+    }
+}
+
+#[async_trait]
+impl TxSigner<Signature> for SafeSigner {
+    fn address(&self) -> Address {
+        self.address
+    }
+
+    async fn sign_transaction(
+        &self,
+        tx: &mut dyn SignableTransaction<Signature>,
+    ) -> Result<Signature> {
+        self.sign_tx_inner(tx)
+    }
+}
+
+impl TxSignerSync<Signature> for SafeSigner {
+    fn address(&self) -> Address {
+        self.address
+    }
+
+    fn sign_transaction_sync(
+        &self,
+        tx: &mut dyn SignableTransaction<Signature>,
+    ) -> Result<Signature> {
+        self.sign_tx_inner(tx)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use alloy::signers::local::PrivateKeySigner;
+
+    #[test]
+    fn sign_and_recover() {
+        let pk = PrivateKeySigner::random();
+        let key = pk.into_credential();
+        let signer = SafeSigner::new(key).unwrap();
+        let message = b"hello arbiter";
+        let sig = signer.sign_message_sync(message).unwrap();
+        let recovered = sig.recover_address_from_msg(message).unwrap();
+        assert_eq!(recovered, Signer::address(&signer));
+    }
+
+    #[test]
+    fn chain_id_roundtrip() {
+        let pk = PrivateKeySigner::random();
+        let key = pk.into_credential();
+        let mut signer = SafeSigner::new(key).unwrap();
+        assert_eq!(Signer::chain_id(&signer), None);
+        signer.set_chain_id(Some(1337));
+        assert_eq!(Signer::chain_id(&signer), Some(1337));
+    }
+}

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

@@ -0,0 +1,26 @@
+use alloy::primitives::U256;
+
+#[derive(thiserror::Error, Debug)]
+#[error("Expected {expected} bytes but got {actual} bytes")]
+pub struct LengthError {
+    pub expected: usize,
+    pub actual: usize,
+}
+
+pub fn u256_to_bytes(value: U256) -> [u8; 32] {
+    value.to_le_bytes()
+}
+pub fn bytes_to_u256(bytes: &[u8]) -> Option<U256> {
+    let bytes: [u8; 32] = bytes.try_into().ok()?;
+    Some(U256::from_le_bytes(bytes))
+}
+
+pub fn try_bytes_to_u256(bytes: &[u8]) -> diesel::result::QueryResult<U256> {
+    let bytes: [u8; 32] = bytes.try_into().map_err(|_| {
+        diesel::result::Error::DeserializationError(Box::new(LengthError {
+            expected: 32,
+            actual: bytes.len(),
+        }))
+    })?;
+    Ok(U256::from_le_bytes(bytes))
+}

server/crates/arbiter-server/src/lib.rs

@@ -24,6 +24,7 @@ use crate::{
 pub mod actors;
 pub mod context;
 pub mod db;
+pub mod evm;
 
 const DEFAULT_CHANNEL_SIZE: usize = 1000;
 

server/crates/arbiter-tokens-registry/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "arbiter-tokens-registry"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+alloy.workspace = true

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

@@ -0,0 +1 @@
+pub mod nonfungible;

server/crates/arbiter-tokens-registry/src/evm/nonfungible.rs

@@ -0,0 +1,13 @@
+use alloy::primitives::{Address, ChainId, address};
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct TokenInfo {
+    pub name: &'static str,
+    pub symbol: &'static str,
+    pub decimals: u32,
+    pub contract: Address,
+    pub chain: ChainId,
+    pub logo_uri: Option<&'static str>,
+}
+
+include!("tokens.rs");

server/crates/arbiter-tokens-registry/src/lib.rs

@@ -0,0 +1 @@
+pub mod evm;