housekeeping: linter

.gitignore

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

IMPLEMENTATION.md

@@ -4,52 +4,6 @@ This document covers concrete technology choices and dependencies. For the archi
 
 ---
 
-## Client Connection Flow
-
-### New Client Approval
-
-When a client whose public key is not yet in the database connects, all connected user agents are asked to approve the connection. The first agent to respond determines the outcome; remaining requests are cancelled via a watch channel.
-
-```mermaid
-flowchart TD
-    A([Client connects]) --> B[Receive AuthChallengeRequest]
-    B --> C{pubkey in DB?}
-
-    C -- yes --> D[Read nonce\nIncrement nonce in DB]
-    D --> G
-
-    C -- no --> E[Ask all UserAgents:\nClientConnectionRequest]
-    E --> F{First response}
-    F -- denied --> Z([Reject connection])
-    F -- approved --> F2[Cancel remaining\nUserAgent requests]
-    F2 --> F3[INSERT client\nnonce = 1]
-    F3 --> G[Send AuthChallenge\nwith nonce]
-
-    G --> H[Receive AuthChallengeSolution]
-    H --> I{Signature valid?}
-    I -- no --> Z
-    I -- yes --> J([Session started])
-```
-
-### Known Issue: Concurrent Registration Race (TOCTOU)
-
-Two connections presenting the same previously-unknown public key can race through the approval flow simultaneously:
-
-1. Both check the DB → neither is registered.
-2. Both request approval from user agents → both receive approval.
-3. Both `INSERT` the client record → the second insert silently overwrites the first, resetting the nonce.
-
-This means the first connection's nonce is invalidated by the second, causing its challenge verification to fail. A fix requires either serialising new-client registration (e.g. an in-memory lock keyed on pubkey) or replacing the separate check + insert with an `INSERT OR IGNORE` / upsert guarded by a unique constraint on `public_key`.
-
-### Nonce Semantics
-
-The `program_client.nonce` column stores the **next usable nonce** — i.e. it is always one ahead of the nonce last issued in a challenge.
-
-- **New client:** inserted with `nonce = 1`; the first challenge is issued with `nonce = 0`.
-- **Existing client:** the current DB value is read and used as the challenge nonce, then immediately incremented within the same exclusive transaction, preventing replay.
-
----
-
 ## Cryptography
 
 ### Authentication
@@ -73,6 +27,82 @@ The `program_client.nonce` column stores the **next usable nonce** — i.e. it i
 
 ---
 
+## EVM Policy Engine
+
+### Overview
+
+The EVM engine classifies incoming transactions, enforces grant constraints, and records executions. It is the sole path through which a wallet key is used for signing.
+
+The central abstraction is the `Policy` trait. Each implementation handles one semantic transaction category and owns its own database tables for grant storage and transaction logging.
+
+### Transaction Evaluation Flow
+
+`Engine::evaluate_transaction` runs the following steps in order:
+
+1. **Classify** — Each registered policy's `analyze(context)` inspects the transaction fields (`chain`, `to`, `value`, `calldata`). The first one returning `Some(meaning)` wins. If none match, the transaction is rejected as `UnsupportedTransactionType`.
+2. **Find grant** — `Policy::try_find_grant` queries for a non-revoked grant covering this wallet, client, chain, and target address.
+3. **Check shared constraints** — `check_shared_constraints` runs in the engine before any policy-specific logic. It enforces the validity window, gas fee caps, and transaction count rate limit (see below).
+4. **Evaluate** — `Policy::evaluate` checks the decoded meaning against the grant's policy-specific constraints and returns any violations.
+5. **Record** — If `RunKind::Execution` and there are no violations, the engine writes to `evm_transaction_log` and calls `Policy::record_transaction` for any policy-specific logging (e.g., token transfer volume).
+
+### Policy Trait
+
+| Method | Purpose |
+|---|---|
+| `analyze` | Pure — classifies a transaction into a typed `Meaning`, or `None` if this policy doesn't apply |
+| `evaluate` | Checks the `Meaning` against a `Grant`; returns a list of `EvalViolation`s |
+| `create_grant` | Inserts policy-specific rows; returns the specific grant ID |
+| `try_find_grant` | Finds a matching non-revoked grant for the given `EvalContext` |
+| `find_all_grants` | Returns all non-revoked grants (used for listing) |
+| `record_transaction` | Persists policy-specific data after execution |
+
+`analyze` and `evaluate` are intentionally separate: classification is pure and cheap, while evaluation may involve DB queries (e.g., fetching past transfer volume).
+
+### Registered Policies
+
+**EtherTransfer** — plain ETH transfers (empty calldata)
+
+- Grant requires: allowlist of recipient addresses + one volumetric rate limit (max ETH over a time window)
+- Violations: recipient not in allowlist, cumulative ETH volume exceeded
+
+**TokenTransfer** — ERC-20 `transfer(address,uint256)` calls
+
+- Recognised by ABI-decoding the `transfer(address,uint256)` selector against a static registry of known token contracts (`arbiter_tokens_registry`)
+- Grant requires: token contract address, optional recipient restriction, zero or more volumetric rate limits
+- Violations: recipient mismatch, any volumetric limit exceeded
+
+### Grant Model
+
+Every grant has two layers:
+
+- **Shared (`evm_basic_grant`)** — wallet, chain, validity period, gas fee caps, transaction count rate limit. One row per grant regardless of type.
+- **Specific** — policy-owned tables (`evm_ether_transfer_grant`, `evm_token_transfer_grant`, etc.) holding type-specific configuration.
+
+`find_all_grants` uses a `#[diesel::auto_type]` base join between the specific and shared tables, then batch-loads related rows (targets, volume limits) in two additional queries to avoid N+1.
+
+The engine exposes `list_all_grants` which collects across all policy types into `Vec<Grant<SpecificGrant>>` via a blanket `From<Grant<S>> for Grant<SpecificGrant>` conversion.
+
+### Shared Constraints (enforced by the engine)
+
+These are checked centrally in `check_shared_constraints` before policy evaluation:
+
+| Constraint | Fields | Behaviour |
+|---|---|---|
+| Validity window | `valid_from`, `valid_until` | Emits `InvalidTime` if current time is outside the range |
+| Gas fee cap | `max_gas_fee_per_gas`, `max_priority_fee_per_gas` | Emits `GasLimitExceeded` if either cap is breached |
+| Tx count rate limit | `rate_limit` (`count` + `window`) | Counts rows in `evm_transaction_log` within the window; emits `RateLimitExceeded` if at or above the limit |
+
+---
+
+### Known Limitations
+
+- **Only EIP-1559 transactions are supported.** Legacy and EIP-2930 types are rejected outright.
+- **No opaque-calldata (unknown contract) grant type.** The architecture describes a category for unrecognised contracts, but no policy implements it yet. Any transaction that is not a plain ETH transfer or a known ERC-20 transfer is unconditionally rejected.
+- **Token registry is static.** Tokens are recognised only if they appear in the hard-coded `arbiter_tokens_registry` crate. There is no mechanism to register additional contracts at runtime.
+- **Nonce management is not implemented.** The architecture lists nonce deduplication as a core responsibility, but no nonce tracking or enforcement exists yet.
+
+---
+
 ## Memory Protection
 
 The unsealed root key must be held in a hardened memory cell resistant to dumps, page swaps, and hibernation.

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/client.proto

@@ -2,6 +2,8 @@ syntax = "proto3";
 
 package arbiter.client;
 
+import "evm.proto";
+
 message AuthChallengeRequest {
   bytes pubkey = 1;
 }
@@ -21,22 +23,16 @@ message ClientRequest {
   oneof payload {
     AuthChallengeRequest auth_challenge_request = 1;
     AuthChallengeSolution auth_challenge_solution = 2;
+    arbiter.evm.EvmSignTransactionRequest evm_sign_transaction = 3;
+    arbiter.evm.EvmAnalyzeTransactionRequest evm_analyze_transaction = 4;
   }
 }
 
-message ClientConnectError {
-  enum Code {
-    UNKNOWN = 0;
-    APPROVAL_DENIED = 1;
-    NO_USER_AGENTS_ONLINE = 2;
-  }
-  Code code = 1;
-}
-
 message ClientResponse {
   oneof payload {
     AuthChallenge auth_challenge = 1;
     AuthOk auth_ok = 2;
-    ClientConnectError client_connect_error = 5;
+    arbiter.evm.EvmSignTransactionResponse evm_sign_transaction = 3;
+    arbiter.evm.EvmAnalyzeTransactionResponse evm_analyze_transaction = 4;
   }
 }

protobufs/evm.proto

@@ -0,0 +1,216 @@
+syntax = "proto3";
+
+package arbiter.evm;
+
+import "google/protobuf/empty.proto";
+import "google/protobuf/timestamp.proto";
+
+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;
+  }
+}
+
+// --- Grant types ---
+
+message TransactionRateLimit {
+  uint32 count = 1;
+  int64 window_secs = 2;
+}
+
+message VolumeRateLimit {
+  bytes max_volume = 1; // U256 as big-endian bytes
+  int64 window_secs = 2;
+}
+
+message SharedSettings {
+  int32 wallet_id = 1;
+  uint64 chain_id = 2;
+  optional google.protobuf.Timestamp valid_from = 3;
+  optional google.protobuf.Timestamp valid_until = 4;
+  optional bytes max_gas_fee_per_gas = 5; // U256 as big-endian bytes
+  optional bytes max_priority_fee_per_gas = 6; // U256 as big-endian bytes
+  optional TransactionRateLimit rate_limit = 7;
+}
+
+message EtherTransferSettings {
+  repeated bytes targets = 1; // list of 20-byte Ethereum addresses
+  VolumeRateLimit limit = 2;
+}
+
+message TokenTransferSettings {
+  bytes token_contract = 1; // 20-byte Ethereum address
+  optional bytes target = 2; // 20-byte Ethereum address; absent means any recipient allowed
+  repeated VolumeRateLimit volume_limits = 3;
+}
+
+message SpecificGrant {
+  oneof grant {
+    EtherTransferSettings ether_transfer = 1;
+    TokenTransferSettings token_transfer = 2;
+  }
+}
+
+message EtherTransferMeaning {
+  bytes to = 1; // 20-byte Ethereum address
+  bytes value = 2; // U256 as big-endian bytes
+}
+
+message TokenInfo {
+  string symbol = 1;
+  bytes address = 2; // 20-byte Ethereum address
+  uint64 chain_id = 3;
+}
+
+// Mirror of token_transfers::Meaning
+message TokenTransferMeaning {
+  TokenInfo token = 1;
+  bytes to = 2; // 20-byte Ethereum address
+  bytes value = 3; // U256 as big-endian bytes
+}
+
+// Mirror of policies::SpecificMeaning
+message SpecificMeaning {
+  oneof meaning {
+    EtherTransferMeaning ether_transfer = 1;
+    TokenTransferMeaning token_transfer = 2;
+  }
+}
+
+// --- Eval error types ---
+message GasLimitExceededViolation {
+  optional bytes max_gas_fee_per_gas = 1; // U256 as big-endian bytes
+  optional bytes max_priority_fee_per_gas = 2; // U256 as big-endian bytes
+}
+
+message EvalViolation {
+  oneof kind {
+    bytes invalid_target = 1; // 20-byte Ethereum address
+    GasLimitExceededViolation gas_limit_exceeded = 2;
+    google.protobuf.Empty rate_limit_exceeded = 3;
+    google.protobuf.Empty volumetric_limit_exceeded = 4;
+    google.protobuf.Empty invalid_time = 5;
+    google.protobuf.Empty invalid_transaction_type = 6;
+  }
+}
+
+// Transaction was classified but no grant covers it
+message NoMatchingGrantError {
+  SpecificMeaning meaning = 1;
+}
+
+// Transaction was classified and a grant was found, but constraints were violated
+message PolicyViolationsError {
+  SpecificMeaning meaning = 1;
+  repeated EvalViolation violations = 2;
+}
+
+// top-level error returned when transaction evaluation fails
+message TransactionEvalError {
+  oneof kind {
+    google.protobuf.Empty contract_creation_not_supported = 1;
+    google.protobuf.Empty unsupported_transaction_type = 2;
+    NoMatchingGrantError no_matching_grant = 3;
+    PolicyViolationsError policy_violations = 4;
+  }
+}
+
+// --- UserAgent grant management ---
+message EvmGrantCreateRequest {
+  int32 client_id = 1;
+  SharedSettings shared = 2;
+  SpecificGrant specific = 3;
+}
+
+message EvmGrantCreateResponse {
+  oneof result {
+    int32 grant_id = 1;
+    EvmError error = 2;
+  }
+}
+
+message EvmGrantDeleteRequest {
+  int32 grant_id = 1;
+}
+
+message EvmGrantDeleteResponse {
+  oneof result {
+    google.protobuf.Empty ok = 1;
+    EvmError error = 2;
+  }
+}
+
+// Basic grant info returned in grant listings
+message GrantEntry {
+  int32 id = 1;
+  int32 client_id = 2;
+  SharedSettings shared = 3;
+  SpecificGrant specific = 4;
+}
+
+message EvmGrantListRequest {
+  optional int32 wallet_id = 1;
+}
+
+message EvmGrantListResponse {
+  oneof result {
+    EvmGrantList grants = 1;
+    EvmError error = 2;
+  }
+}
+
+message EvmGrantList {
+  repeated GrantEntry grants = 1;
+}
+
+// --- Client transaction operations ---
+
+message EvmSignTransactionRequest {
+  bytes wallet_address = 1; // 20-byte Ethereum address
+  bytes rlp_transaction = 2; // RLP-encoded EIP-1559 transaction (unsigned)
+}
+
+// oneof because signing and evaluation happen atomically — a signing failure
+// is always either an eval error or an internal error, never a partial success
+message EvmSignTransactionResponse {
+  oneof result {
+    bytes signature = 1; // 65-byte signature: r[32] || s[32] || v[1]
+    TransactionEvalError eval_error = 2;
+    EvmError error = 3;
+  }
+}
+
+message EvmAnalyzeTransactionRequest {
+  bytes wallet_address = 1; // 20-byte Ethereum address
+  bytes rlp_transaction = 2; // RLP-encoded EIP-1559 transaction
+}
+
+message EvmAnalyzeTransactionResponse {
+  oneof result {
+    SpecificMeaning meaning = 1;
+    TransactionEvalError eval_error = 2;
+    EvmError error = 3;
+  }
+}

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;
@@ -48,16 +49,6 @@ enum VaultState {
   VAULT_STATE_ERROR = 4;
 }
 
-message ClientConnectionRequest {
-  bytes pubkey = 1;
-}
-
-message ClientConnectionResponse {
-  bool approved = 1;
-}
-
-message ClientConnectionCancel {}
-
 message UserAgentRequest {
   oneof payload {
     AuthChallengeRequest auth_challenge_request = 1;
@@ -65,7 +56,11 @@ message UserAgentRequest {
     UnsealStart unseal_start = 3;
     UnsealEncryptedKey unseal_encrypted_key = 4;
     google.protobuf.Empty query_vault_state = 5;
-    ClientConnectionResponse client_connection_response = 11;
+    google.protobuf.Empty evm_wallet_create = 6;
+    google.protobuf.Empty evm_wallet_list = 7;
+    arbiter.evm.EvmGrantCreateRequest evm_grant_create = 8;
+    arbiter.evm.EvmGrantDeleteRequest evm_grant_delete = 9;
+    arbiter.evm.EvmGrantListRequest evm_grant_list = 10;
   }
 }
 message UserAgentResponse {
@@ -75,7 +70,10 @@ message UserAgentResponse {
     UnsealStartResponse unseal_start_response = 3;
     UnsealResult unseal_result = 4;
     VaultState vault_state = 5;
-    ClientConnectionRequest client_connection_request = 11;
-    ClientConnectionCancel client_connection_cancel = 12;
+    arbiter.evm.WalletCreateResponse evm_wallet_create = 6;
+    arbiter.evm.WalletListResponse evm_wallet_list = 7;
+    arbiter.evm.EvmGrantCreateResponse evm_grant_create = 8;
+    arbiter.evm.EvmGrantDeleteResponse evm_grant_delete = 9;
+    arbiter.evm.EvmGrantListResponse evm_grant_list = 10;
   }
 }

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"] }
@@ -27,6 +29,7 @@ prost-types = { version = "0.14.3", features = ["chrono"] }
 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-proto/src/transport.rs

@@ -83,23 +83,6 @@ use async_trait::async_trait;
 pub enum Error {
     #[error("Transport channel is closed")]
     ChannelClosed,
-    #[error("Unexpected message received")]
-    UnexpectedMessage,
-}
-
-/// Receives one message from `transport` and extracts a value from it using
-/// `extractor`. Returns [`Error::ChannelClosed`] if the transport closes and
-/// [`Error::UnexpectedMessage`] if `extractor` returns `None`.
-pub async fn expect_message<T, Inbound, Outbound, Target, F>(
-    transport: &mut T,
-    extractor: F,
-) -> Result<Target, Error>
-where
-    T: Bi<Inbound, Outbound> + ?Sized,
-    F: FnOnce(Inbound) -> Option<Target>,
-{
-    let msg = transport.recv().await.ok_or(Error::ChannelClosed)?;
-    extractor(msg).ok_or(Error::UnexpectedMessage)
 }
 
 /// Minimal bidirectional transport abstraction used by protocol code.

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/client/auth.rs

@@ -1,251 +0,0 @@
-use arbiter_proto::{
-    format_challenge,
-    proto::client::{
-        AuthChallenge, AuthChallengeSolution, ClientConnectError, ClientRequest, ClientResponse,
-        client_connect_error::Code as ConnectErrorCode,
-        client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    },
-    transport::expect_message,
-};
-use diesel::{
-    ExpressionMethods as _, OptionalExtension as _, QueryDsl as _, dsl::insert_into, update,
-};
-use diesel_async::RunQueryDsl as _;
-use ed25519_dalek::VerifyingKey;
-use kameo::error::SendError;
-use tracing::error;
-
-use crate::{
-    actors::{client::ClientConnection, router::{self, RequestClientApproval}},
-    db::{self, schema::program_client},
-};
-
-use super::session::ClientSession;
-
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
-pub enum Error {
-    #[error("Unexpected message payload")]
-    UnexpectedMessagePayload,
-    #[error("Invalid client public key length")]
-    InvalidClientPubkeyLength,
-    #[error("Invalid client public key encoding")]
-    InvalidAuthPubkeyEncoding,
-    #[error("Database pool unavailable")]
-    DatabasePoolUnavailable,
-    #[error("Database operation failed")]
-    DatabaseOperationFailed,
-    #[error("Invalid challenge solution")]
-    InvalidChallengeSolution,
-    #[error("Client approval request failed")]
-    ApproveError(#[from] ApproveError),
-    #[error("Internal error")]
-    InternalError,
-    #[error("Transport error")]
-    Transport,
-}
-
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
-pub enum ApproveError {
-    #[error("Internal error")]
-    Internal,
-    #[error("Client connection denied by user agents")]
-    Denied,
-    #[error("Upstream error: {0}")]
-    Upstream(router::ApprovalError),
-}
-
-/// Atomically reads and increments the nonce for a known client.
-/// Returns `None` if the pubkey is not registered.
-async fn get_nonce(db: &db::DatabasePool, pubkey: &VerifyingKey) -> Result<Option<i32>, Error> {
-    let pubkey_bytes = pubkey.as_bytes().to_vec();
-
-    let mut conn = db.get().await.map_err(|e| {
-        error!(error = ?e, "Database pool error");
-        Error::DatabasePoolUnavailable
-    })?;
-
-    conn.exclusive_transaction(|conn| {
-        let pubkey_bytes = pubkey_bytes.clone();
-        Box::pin(async move {
-            let Some(current_nonce) = program_client::table
-                .filter(program_client::public_key.eq(&pubkey_bytes))
-                .select(program_client::nonce)
-                .first::<i32>(conn)
-                .await
-                .optional()?
-            else {
-                return Result::<_, diesel::result::Error>::Ok(None);
-            };
-
-            update(program_client::table)
-                .filter(program_client::public_key.eq(&pubkey_bytes))
-                .set(program_client::nonce.eq(current_nonce + 1))
-                .execute(conn)
-                .await?;
-
-            Ok(Some(current_nonce))
-        })
-    })
-    .await
-    .map_err(|e| {
-        error!(error = ?e, "Database error");
-        Error::DatabaseOperationFailed
-    })
-}
-
-async fn approve_new_client(
-    actors: &crate::actors::GlobalActors,
-    pubkey: VerifyingKey,
-) -> Result<(), Error> {
-    let result = actors
-        .router
-        .ask(RequestClientApproval { client_pubkey: pubkey })
-        .await;
-
-    match result {
-        Ok(true) => Ok(()),
-        Ok(false) => Err(Error::ApproveError(ApproveError::Denied)),
-        Err(SendError::HandlerError(e)) => {
-            error!(error = ?e, "Approval upstream error");
-            Err(Error::ApproveError(ApproveError::Upstream(e)))
-        }
-        Err(e) => {
-            error!(error = ?e, "Approval request to router failed");
-            Err(Error::ApproveError(ApproveError::Internal))
-        }
-    }
-}
-
-async fn insert_client(db: &db::DatabasePool, pubkey: &VerifyingKey) -> Result<(), Error> {
-    let now = std::time::SystemTime::now()
-        .duration_since(std::time::UNIX_EPOCH)
-        .unwrap_or_default()
-        .as_secs() as i32;
-
-    let mut conn = db.get().await.map_err(|e| {
-        error!(error = ?e, "Database pool error");
-        Error::DatabasePoolUnavailable
-    })?;
-
-    insert_into(program_client::table)
-        .values((
-            program_client::public_key.eq(pubkey.as_bytes().to_vec()),
-            program_client::nonce.eq(1), // pre-incremented; challenge uses 0
-            program_client::created_at.eq(now),
-            program_client::updated_at.eq(now),
-        ))
-        .execute(&mut conn)
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to insert new client");
-            Error::DatabaseOperationFailed
-        })?;
-
-    Ok(())
-}
-
-async fn challenge_client(
-    props: &mut ClientConnection,
-    pubkey: VerifyingKey,
-    nonce: i32,
-) -> Result<(), Error> {
-    let challenge = AuthChallenge {
-        pubkey: pubkey.as_bytes().to_vec(),
-        nonce,
-    };
-
-    props
-        .transport
-        .send(Ok(ClientResponse {
-            payload: Some(ClientResponsePayload::AuthChallenge(challenge.clone())),
-        }))
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to send auth challenge");
-            Error::Transport
-        })?;
-
-    let AuthChallengeSolution { signature } = expect_message(
-        &mut *props.transport,
-        |req: ClientRequest| match req.payload? {
-            ClientRequestPayload::AuthChallengeSolution(s) => Some(s),
-            _ => None,
-        },
-    )
-    .await
-    .map_err(|e| {
-        error!(error = ?e, "Failed to receive challenge solution");
-        Error::Transport
-    })?;
-
-    let formatted = format_challenge(nonce, &challenge.pubkey);
-    let sig = signature.as_slice().try_into().map_err(|_| {
-        error!("Invalid signature length");
-        Error::InvalidChallengeSolution
-    })?;
-
-    pubkey.verify_strict(&formatted, &sig).map_err(|_| {
-        error!("Challenge solution verification failed");
-        Error::InvalidChallengeSolution
-    })?;
-
-    Ok(())
-}
-
-fn connect_error_code(err: &Error) -> ConnectErrorCode {
-    match err {
-        Error::ApproveError(ApproveError::Denied) => ConnectErrorCode::ApprovalDenied,
-        Error::ApproveError(ApproveError::Upstream(router::ApprovalError::NoUserAgentsConnected)) => {
-            ConnectErrorCode::NoUserAgentsOnline
-        }
-        _ => ConnectErrorCode::Unknown,
-    }
-}
-
-async fn authenticate(props: &mut ClientConnection) -> Result<VerifyingKey, Error> {
-    let Some(ClientRequest {
-        payload: Some(ClientRequestPayload::AuthChallengeRequest(challenge)),
-    }) = props.transport.recv().await
-    else {
-        return Err(Error::Transport);
-    };
-
-    let pubkey_bytes = challenge
-        .pubkey
-        .as_array()
-        .ok_or(Error::InvalidClientPubkeyLength)?;
-    let pubkey =
-        VerifyingKey::from_bytes(pubkey_bytes).map_err(|_| Error::InvalidAuthPubkeyEncoding)?;
-
-    let nonce = match get_nonce(&props.db, &pubkey).await? {
-        Some(nonce) => nonce,
-        None => {
-            approve_new_client(&props.actors, pubkey).await?;
-            insert_client(&props.db, &pubkey).await?;
-            0
-        }
-    };
-
-    challenge_client(props, pubkey, nonce).await?;
-
-    Ok(pubkey)
-}
-
-pub async fn authenticate_and_create(mut props: ClientConnection) -> Result<ClientSession, Error> {
-    match authenticate(&mut props).await {
-        Ok(pubkey) => Ok(ClientSession::new(props, pubkey)),
-        Err(err) => {
-            let code = connect_error_code(&err);
-            let _ = props
-                .transport
-                .send(Ok(ClientResponse {
-                    payload: Some(ClientResponsePayload::ClientConnectError(
-                        ClientConnectError { code: code.into() },
-                    )),
-                }))
-                .await;
-            Err(err)
-        }
-    }
-}

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

@@ -0,0 +1,102 @@
+use arbiter_proto::proto::client::{
+    AuthChallengeRequest, AuthChallengeSolution, ClientRequest,
+    client_request::Payload as ClientRequestPayload,
+};
+use ed25519_dalek::VerifyingKey;
+use tracing::error;
+
+use crate::actors::client::{
+    ClientConnection,
+    auth::state::{AuthContext, AuthStateMachine},
+    session::ClientSession,
+};
+
+#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
+pub enum Error {
+    #[error("Unexpected message payload")]
+    UnexpectedMessagePayload,
+    #[error("Invalid client public key length")]
+    InvalidClientPubkeyLength,
+    #[error("Invalid client public key encoding")]
+    InvalidAuthPubkeyEncoding,
+    #[error("Database pool unavailable")]
+    DatabasePoolUnavailable,
+    #[error("Database operation failed")]
+    DatabaseOperationFailed,
+    #[error("Public key not registered")]
+    PublicKeyNotRegistered,
+    #[error("Invalid signature length")]
+    InvalidSignatureLength,
+    #[error("Invalid challenge solution")]
+    InvalidChallengeSolution,
+    #[error("Transport error")]
+    Transport,
+}
+
+mod state;
+use state::*;
+
+fn parse_auth_event(payload: ClientRequestPayload) -> Result<AuthEvents, Error> {
+    match payload {
+        ClientRequestPayload::AuthChallengeRequest(AuthChallengeRequest { pubkey }) => {
+            let pubkey_bytes = pubkey.as_array().ok_or(Error::InvalidClientPubkeyLength)?;
+            let pubkey = VerifyingKey::from_bytes(pubkey_bytes)
+                .map_err(|_| Error::InvalidAuthPubkeyEncoding)?;
+            Ok(AuthEvents::AuthRequest(ChallengeRequest {
+                pubkey: pubkey.into(),
+            }))
+        }
+        ClientRequestPayload::AuthChallengeSolution(AuthChallengeSolution { signature }) => {
+            Ok(AuthEvents::ReceivedSolution(ChallengeSolution {
+                solution: signature,
+            }))
+        }
+        _ => Err(Error::UnexpectedMessagePayload) ,
+    }
+}
+
+pub async fn authenticate(props: &mut ClientConnection) -> Result<VerifyingKey, Error> {
+    let mut state = AuthStateMachine::new(AuthContext::new(props));
+
+    loop {
+        let transport = state.context_mut().conn.transport.as_mut();
+        let Some(ClientRequest {
+            payload: Some(payload),
+        }) = transport.recv().await
+        else {
+            return Err(Error::Transport);
+        };
+
+        let event = parse_auth_event(payload)?;
+
+        match state.process_event(event).await {
+            Ok(AuthStates::AuthOk(key)) => return Ok(key.clone()),
+            Err(AuthError::ActionFailed(err)) => {
+                error!(?err, "State machine action failed");
+                return Err(err);
+            }
+            Err(AuthError::GuardFailed(err)) => {
+                error!(?err, "State machine guard failed");
+                return Err(err);
+            }
+            Err(AuthError::InvalidEvent) => {
+                error!("Invalid event for current state");
+                return Err(Error::InvalidChallengeSolution);
+            }
+            Err(AuthError::TransitionsFailed) => {
+                error!("Invalid state transition");
+                return Err(Error::InvalidChallengeSolution);
+            }
+
+            _ => (),
+        }
+    }
+}
+
+pub async fn authenticate_and_create(
+    mut props: ClientConnection,
+) -> Result<ClientSession, Error> {
+    let key = authenticate(&mut props).await?;
+    let session = ClientSession::new(props, key);
+    Ok(session)
+}

server/crates/arbiter-server/src/actors/client/auth/state.rs

@@ -0,0 +1,136 @@
+use arbiter_proto::proto::client::{
+    AuthChallenge, ClientResponse,
+    client_response::Payload as ClientResponsePayload,
+};
+use diesel::{ExpressionMethods as _, OptionalExtension as _, QueryDsl, update};
+use diesel_async::RunQueryDsl;
+use ed25519_dalek::VerifyingKey;
+use tracing::error;
+
+use super::Error;
+use crate::{actors::client::ClientConnection, db::schema};
+
+pub struct ChallengeRequest {
+    pub pubkey: VerifyingKey,
+}
+
+pub struct ChallengeContext {
+    pub challenge: AuthChallenge,
+    pub key: VerifyingKey,
+}
+
+pub struct ChallengeSolution {
+    pub solution: Vec<u8>,
+}
+
+smlang::statemachine!(
+    name: Auth,
+    custom_error: true,
+    transitions: {
+        *Init + AuthRequest(ChallengeRequest) / async prepare_challenge = SentChallenge(ChallengeContext),
+        SentChallenge(ChallengeContext) + ReceivedSolution(ChallengeSolution) [async verify_solution] / provide_key = AuthOk(VerifyingKey),
+    }
+);
+
+async fn create_nonce(db: &crate::db::DatabasePool, pubkey_bytes: &[u8]) -> Result<i32, Error> {
+    let mut db_conn = db.get().await.map_err(|e| {
+        error!(error = ?e, "Database pool error");
+        Error::DatabasePoolUnavailable
+    })?;
+    db_conn
+        .exclusive_transaction(|conn| {
+            Box::pin(async move {
+                let current_nonce = schema::program_client::table
+                    .filter(schema::program_client::public_key.eq(pubkey_bytes.to_vec()))
+                    .select(schema::program_client::nonce)
+                    .first::<i32>(conn)
+                    .await?;
+
+                update(schema::program_client::table)
+                    .filter(schema::program_client::public_key.eq(pubkey_bytes.to_vec()))
+                    .set(schema::program_client::nonce.eq(current_nonce + 1))
+                    .execute(conn)
+                    .await?;
+
+                Result::<_, diesel::result::Error>::Ok(current_nonce)
+            })
+        })
+        .await
+        .optional()
+        .map_err(|e| {
+            error!(error = ?e, "Database error");
+            Error::DatabaseOperationFailed
+        })?
+        .ok_or_else(|| {
+            error!(?pubkey_bytes, "Public key not found in database");
+            Error::PublicKeyNotRegistered
+        })
+}
+
+pub struct AuthContext<'a> {
+    pub(super) conn: &'a mut ClientConnection,
+}
+
+impl<'a> AuthContext<'a> {
+    pub fn new(conn: &'a mut ClientConnection) -> Self {
+        Self { conn }
+    }
+}
+
+impl AuthStateMachineContext for AuthContext<'_> {
+    type Error = Error;
+
+    async fn verify_solution(
+        &self,
+        ChallengeContext { challenge, key }: &ChallengeContext,
+        ChallengeSolution { solution }: &ChallengeSolution,
+    ) -> Result<bool, Self::Error> {
+        let formatted_challenge =
+            arbiter_proto::format_challenge(challenge.nonce, &challenge.pubkey);
+
+        let signature = solution.as_slice().try_into().map_err(|_| {
+            error!(?solution, "Invalid signature length");
+            Error::InvalidChallengeSolution
+        })?;
+
+        let valid = key.verify_strict(&formatted_challenge, &signature).is_ok();
+
+        Ok(valid)
+    }
+
+    async fn prepare_challenge(
+        &mut self,
+        ChallengeRequest { pubkey }: ChallengeRequest,
+    ) -> Result<ChallengeContext, Self::Error> {
+        let nonce = create_nonce(&self.conn.db, pubkey.as_bytes()).await?;
+
+        let challenge = AuthChallenge {
+            pubkey: pubkey.as_bytes().to_vec(),
+            nonce,
+        };
+
+        self.conn
+            .transport
+            .send(Ok(ClientResponse {
+                payload: Some(ClientResponsePayload::AuthChallenge(challenge.clone())),
+            }))
+            .await
+            .map_err(|e| {
+                error!(?e, "Failed to send auth challenge");
+                Error::Transport
+            })?;
+
+        Ok(ChallengeContext {
+            challenge,
+            key: pubkey,
+        })
+    }
+
+    fn provide_key(
+        &mut self,
+        state_data: &ChallengeContext,
+        _: ChallengeSolution,
+    ) -> Result<VerifyingKey, Self::Error> {
+        Ok(state_data.key)
+    }
+}

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/router/mod.rs

@@ -1,20 +1,17 @@
-use std::{collections::HashMap, ops::ControlFlow};
+use std::{
+    collections::{HashMap},
+    ops::ControlFlow,
+};
 
-use ed25519_dalek::VerifyingKey;
 use kameo::{
     Actor,
     actor::{ActorId, ActorRef},
     messages,
     prelude::{ActorStopReason, Context, WeakActorRef},
-    reply::DelegatedReply,
 };
-use tokio::{sync::watch, task::JoinSet};
-use tracing::{info, warn};
+use tracing::info;
 
-use crate::actors::{
-    client::session::ClientSession,
-    user_agent::session::{RequestNewClientApproval, UserAgentSession},
-};
+use crate::actors::{client::session::ClientSession, user_agent::session::UserAgentSession};
 
 #[derive(Default)]
 pub struct MessageRouter {
@@ -56,74 +53,6 @@ impl Actor for MessageRouter {
     }
 }
 
-#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq, Hash)]
-pub enum ApprovalError {
-    #[error("No user agents connected")]
-    NoUserAgentsConnected,
-}
-
-async fn request_client_approval(
-    user_agents: &[WeakActorRef<UserAgentSession>],
-    client_pubkey: VerifyingKey,
-) -> Result<bool, ApprovalError> {
-    if user_agents.is_empty() {
-        return Err(ApprovalError::NoUserAgentsConnected).into();
-    }
-
-    let mut pool = JoinSet::new();
-    let (cancel_tx, cancel_rx) = watch::channel(());
-
-    for weak_ref in user_agents {
-        match weak_ref.upgrade() {
-            Some(agent) => {
-                let client_pubkey = client_pubkey.clone();
-                let cancel_rx = cancel_rx.clone();
-                pool.spawn(async move {
-                    agent
-                        .ask(RequestNewClientApproval {
-                            client_pubkey,
-                            cancel_flag: cancel_rx.clone(),
-                        })
-                        .await
-                });
-            }
-            None => {
-                warn!(
-                    id = weak_ref.id().to_string(),
-                    actor = "MessageRouter",
-                    event = "useragent.disconnected_before_approval"
-                );
-            }
-        }
-    }
-
-    while let Some(result) = pool.join_next().await {
-        match result {
-            Ok(Ok(approved)) => {
-                // cancel other pending requests
-                let _ = cancel_tx.send(());
-                return Ok(approved);
-            }
-            Ok(Err(err)) => {
-                warn!(
-                    ?err,
-                    actor = "MessageRouter",
-                    event = "useragent.approval_error"
-                );
-            }
-            Err(err) => {
-                warn!(
-                    ?err,
-                    actor = "MessageRouter",
-                    event = "useragent.approval_task_failed"
-                );
-            }
-        }
-    }
-
-    Err(ApprovalError::NoUserAgentsConnected)
-}
-
 #[messages]
 impl MessageRouter {
     #[message(ctx)]
@@ -147,29 +76,4 @@ impl MessageRouter {
         ctx.actor_ref().link(&actor).await;
         self.clients.insert(actor.id(), actor);
     }
-
-    #[message(ctx)]
-    pub async fn request_client_approval(
-        &mut self,
-        client_pubkey: VerifyingKey,
-        ctx: &mut Context<Self, DelegatedReply<Result<bool, ApprovalError>>>,
-    ) -> DelegatedReply<Result<bool, ApprovalError>> {
-        let (reply, Some(reply_sender)) = ctx.reply_sender() else {
-            panic!("Exptected `request_client_approval` to have callback channel");
-        };
-
-        let weak_refs = self
-            .user_agents
-            .values()
-            .map(|agent| agent.downgrade())
-            .collect::<Vec<_>>();
-
-        // handle in subtask to not to lock the actor
-        tokio::task::spawn(async move {
-            let result = request_client_approval(&weak_refs, client_pubkey).await;
-            let _ = reply_sender.send(result);
-        });
-
-        reply
-    }
 }

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

@@ -11,7 +11,7 @@ use crate::{
 };
 
 #[derive(Debug, thiserror::Error, PartialEq)]
-pub enum TransportResponseError {
+pub enum UserAgentError {
     #[error("Expected message with payload")]
     MissingRequestPayload,
     #[error("Unexpected request payload")]
@@ -31,7 +31,7 @@ pub enum TransportResponseError {
 }
 
 pub type Transport =
-    Box<dyn Bi<UserAgentRequest, Result<UserAgentResponse, TransportResponseError>> + Send>;
+    Box<dyn Bi<UserAgentRequest, Result<UserAgentResponse, UserAgentError>> + Send>;
 
 pub struct UserAgentConnection {
     db: db::DatabasePool,

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

@@ -1,38 +1,34 @@
 use std::{ops::DerefMut, sync::Mutex};
 
-use arbiter_proto::proto::user_agent::{
-        ClientConnectionCancel, ClientConnectionRequest, UnsealEncryptedKey, UnsealResult,
-        UnsealStart, UnsealStartResponse, UserAgentRequest, UserAgentResponse,
-        user_agent_request::Payload as UserAgentRequestPayload,
+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, messages, prelude::Context};
+use kameo::{
+    Actor,
+    error::SendError,
+};
 use memsafe::MemSafe;
-use tokio::{select, sync::watch};
+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::{TransportResponseError, UserAgentConnection},
+    user_agent::{UserAgentConnection, UserAgentError},
 };
 
 mod state;
 use state::{DummyContext, UnsealContext, UserAgentEvents, UserAgentStateMachine, UserAgentStates};
 
-// Error for consumption by other actors
-#[derive(Debug, thiserror::Error, PartialEq)]
-pub enum Error {
-    #[error("User agent session ended due to connection loss")]
-    ConnectionLost,
-
-    #[error("User agent session ended due to unexpected message")]
-    UnexpectedMessage,
-}
-
 pub struct UserAgentSession {
     props: UserAgentConnection,
     key: VerifyingKey,
@@ -40,7 +36,7 @@ pub struct UserAgentSession {
 }
 
 impl UserAgentSession {
-     pub(crate) fn new(props: UserAgentConnection, key: VerifyingKey) -> Self {
+    pub(crate) fn new(props: UserAgentConnection, key: VerifyingKey) -> Self {
         Self {
             props,
             key,
@@ -48,118 +44,18 @@ impl UserAgentSession {
         }
     }
 
-    fn transition(&mut self, event: UserAgentEvents) -> Result<(), TransportResponseError> {
+    fn transition(&mut self, event: UserAgentEvents) -> Result<(), UserAgentError> {
         self.state.process_event(event).map_err(|e| {
             error!(?e, "State transition failed");
-            TransportResponseError::StateTransitionFailed
+            UserAgentError::StateTransitionFailed
         })?;
         Ok(())
     }
 
-    async fn send_msg<Reply: kameo::Reply>(
-        &mut self,
-        msg: UserAgentResponsePayload,
-        _ctx: &mut Context<Self, Reply>,
-    ) -> Result<(), Error> {
-        self.props
-            .transport
-            .send(Ok(response(msg)))
-            .await
-            .map_err(|_| {
-                error!(
-                    actor = "useragent",
-                    reason = "channel closed",
-                    "send.failed"
-                );
-                Error::ConnectionLost
-            })
-    }
-
-    async fn expect_msg<Extractor, Msg, Reply>(
-        &mut self,
-        extractor: Extractor,
-        ctx: &mut Context<Self, Reply>,
-    ) -> Result<Msg, Error>
-    where
-        Extractor: FnOnce(UserAgentRequestPayload) -> Option<Msg>,
-        Reply: kameo::Reply,
-    {
-        let msg = self.props.transport.recv().await.ok_or_else(|| {
-            error!(
-                actor = "useragent",
-                reason = "channel closed",
-                "recv.failed"
-            );
-            ctx.stop();
-            Error::ConnectionLost
-        })?;
-
-        msg.payload.and_then(extractor).ok_or_else(|| {
-            error!(
-                actor = "useragent",
-                reason = "unexpected message",
-                "recv.failed"
-            );
-            ctx.stop();
-            Error::UnexpectedMessage
-        })
-    }
-}
-
-#[messages]
-impl UserAgentSession {
-    // TODO: Think about refactoring it to state-machine based flow, as we already have one 
-    #[message(ctx)]
-    pub async fn request_new_client_approval(
-        &mut self,
-        client_pubkey: VerifyingKey,
-        mut cancel_flag: watch::Receiver<()>,
-        ctx: &mut Context<Self, Result<bool, Error>>,
-    ) -> Result<bool, Error> {
-        self.send_msg(
-            UserAgentResponsePayload::ClientConnectionRequest(
-                ClientConnectionRequest {
-                    pubkey: client_pubkey.as_bytes().to_vec(),
-                }
-                .into(),
-            ),
-            ctx,
-        )
-        .await?;
-
-        let extractor = |msg| {
-            if let UserAgentRequestPayload::ClientConnectionResponse(client_connection_response) =
-                msg
-            {
-                Some(client_connection_response)
-            } else {
-                None
-            }
-        };
-
-        tokio::select! {
-            _ = cancel_flag.changed() => {
-                info!(actor = "useragent", "client connection approval cancelled");
-                self.send_msg(
-                    UserAgentResponsePayload::ClientConnectionCancel(ClientConnectionCancel {}),
-                    ctx,
-                ).await?;
-                return Ok(false);
-            }
-            result = self.expect_msg(extractor, ctx) => {
-                let result = result?;
-                info!(actor = "useragent", "received client connection approval result: approved={}", result.approved);
-                return Ok(result.approved);
-            }
-        }
-    }
-}
-
-impl UserAgentSession {
     pub async fn process_transport_inbound(&mut self, req: UserAgentRequest) -> Output {
         let msg = req.payload.ok_or_else(|| {
             error!(actor = "useragent", "Received message with no payload");
-            TransportResponseError::MissingRequestPayload
+            UserAgentError::MissingRequestPayload
         })?;
 
         match msg {
@@ -169,12 +65,14 @@ impl UserAgentSession {
             UserAgentRequestPayload::UnsealEncryptedKey(unseal_encrypted_key) => {
                 self.handle_unseal_encrypted_key(unseal_encrypted_key).await
             }
-            _ => Err(TransportResponseError::UnexpectedRequestPayload),
+            UserAgentRequestPayload::EvmWalletCreate(_) => self.handle_evm_wallet_create().await,
+            UserAgentRequestPayload::EvmWalletList(_) => self.handle_evm_wallet_list().await,
+            _ => Err(UserAgentError::UnexpectedRequestPayload),
         }
     }
 }
 
-type Output = Result<UserAgentResponse, TransportResponseError>;
+type Output = Result<UserAgentResponse, UserAgentError>;
 
 fn response(payload: UserAgentResponsePayload) -> UserAgentResponse {
     UserAgentResponse {
@@ -190,7 +88,7 @@ impl UserAgentSession {
         let client_pubkey_bytes: [u8; 32] = req
             .client_pubkey
             .try_into()
-            .map_err(|_| TransportResponseError::InvalidClientPubkeyLength)?;
+            .map_err(|_| UserAgentError::InvalidClientPubkeyLength)?;
 
         let client_public_key = PublicKey::from(client_pubkey_bytes);
 
@@ -209,7 +107,7 @@ impl UserAgentSession {
     async fn handle_unseal_encrypted_key(&mut self, req: UnsealEncryptedKey) -> Output {
         let UserAgentStates::WaitingForUnsealKey(unseal_context) = self.state.state() else {
             error!("Received unseal encrypted key in invalid state");
-            return Err(TransportResponseError::InvalidStateForUnsealEncryptedKey);
+            return Err(UserAgentError::InvalidStateForUnsealEncryptedKey);
         };
         let ephemeral_secret = {
             let mut secret_lock = unseal_context.secret.lock().unwrap();
@@ -274,7 +172,7 @@ impl UserAgentSession {
                     Err(err) => {
                         error!(?err, "Failed to send unseal request to keyholder");
                         self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                        Err(TransportResponseError::KeyHolderActorUnreachable)
+                        Err(UserAgentError::KeyHolderActorUnreachable)
                     }
                 }
             }
@@ -289,10 +187,68 @@ 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;
 
-    type Error = TransportResponseError;
+    type Error = UserAgentError;
 
     async fn on_start(
         args: Self::Args,
@@ -307,7 +263,7 @@ impl Actor for UserAgentSession {
             .await
             .map_err(|err| {
                 error!(?err, "Failed to register user agent connection with router");
-                TransportResponseError::ConnectionRegistrationFailed
+                UserAgentError::ConnectionRegistrationFailed
             })?;
         Ok(args)
     }

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

@@ -1,15 +1,78 @@
 #![allow(unused)]
 #![allow(clippy::all)]
 
-use crate::db::{ schema::{self, aead_encrypted, arbiter_settings, root_key_history, tls_history}};
-use diesel::{prelude::*, sql_types::Bool, sqlite::Sqlite};
+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};
-    use diesel::{deserialize::FromSql, expression::AsExpression, serialize::{IsNull, ToSql}, sql_types::Integer, sqlite::Sqlite};
-    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)]
+    #[diesel(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::Long) = bytes.value_type() else {
+                return Err(format!(
+                    "Expected Integer type for SqliteTimestamp, got {:?}",
+                    bytes.value_type()
+                )
+                .into());
+            };
+
+            let unix_timestamp = bytes.read_long();
+            let datetime = DateTime::from_timestamp(unix_timestamp, 0)
+                .ok_or("Timestamp is out of bounds")?;
+
+            Ok(SqliteTimestamp(datetime))
+        }
+    }
 }
+pub use types::*;
 
 #[derive(Models, Queryable, Debug, Insertable, Selectable)]
 #[view(
@@ -26,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)]
@@ -61,7 +124,7 @@ pub struct TlsHistory {
     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 created_at: SqliteTimestamp,
 }
 
 #[derive(Queryable, Debug, Insertable, Selectable)]
@@ -72,22 +135,170 @@ pub struct ArbiterSettings {
     pub tls_id: Option<i32>,      // references tls_history.id
 }
 
-#[derive(Queryable, Debug, Insertable, Selectable)]
+#[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,339 @@
+pub mod abi;
+pub mod safe_signer;
+
+use alloy::{
+    consensus::TxEip1559,
+    primitives::{TxKind, U256},
+};
+use chrono::Utc;
+use diesel::{ExpressionMethods as _, QueryDsl, QueryResult, insert_into, sqlite::Sqlite};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+
+use crate::{
+    db::{
+        self,
+        models::{EvmBasicGrant, NewEvmBasicGrant, NewEvmTransactionLog, SqliteTimestamp},
+        schema::{self, evm_transaction_log},
+    },
+    evm::policies::{
+        DatabaseID, EvalContext, EvalViolation, FullGrant, Grant, Policy, SharedGrantSettings,
+        SpecificGrant, 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),
+}
+
+#[derive(Debug, thiserror::Error, miette::Diagnostic)]
+pub enum ListGrantsError {
+    #[error("Database connection pool error")]
+    #[diagnostic(code(arbiter_server::evm::list_grants_error::pool))]
+    Pool(#[from] db::PoolError),
+
+    #[error("Database returned error")]
+    #[diagnostic(code(arbiter_server::evm::list_grants_error::database))]
+    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,
+}
+
+async fn check_shared_constraints(
+    context: &EvalContext,
+    shared: &SharedGrantSettings,
+    shared_grant_id: DatabaseID,
+    conn: &mut impl AsyncConnection<Backend = Sqlite>,
+) -> QueryResult<Vec<EvalViolation>> {
+    let mut violations = Vec::new();
+    let now = Utc::now();
+
+    // Validity window
+    if shared.valid_from.map_or(false, |t| now < t) || shared.valid_until.map_or(false, |t| now > t)
+    {
+        violations.push(EvalViolation::InvalidTime);
+    }
+
+    // Gas fee caps
+    let fee_exceeded = shared
+        .max_gas_fee_per_gas
+        .map_or(false, |cap| U256::from(context.max_fee_per_gas) > cap);
+    let priority_exceeded = shared.max_priority_fee_per_gas.map_or(false, |cap| {
+        U256::from(context.max_priority_fee_per_gas) > cap
+    });
+    if fee_exceeded || priority_exceeded {
+        violations.push(EvalViolation::GasLimitExceeded {
+            max_gas_fee_per_gas: shared.max_gas_fee_per_gas,
+            max_priority_fee_per_gas: shared.max_priority_fee_per_gas,
+        });
+    }
+
+    // Transaction count rate limit
+    if let Some(rate_limit) = &shared.rate_limit {
+        let window_start = SqliteTimestamp(now - rate_limit.window);
+        let count: i64 = evm_transaction_log::table
+            .filter(evm_transaction_log::grant_id.eq(shared_grant_id))
+            .filter(evm_transaction_log::signed_at.ge(window_start))
+            .count()
+            .get_result(conn)
+            .await?;
+
+        if count >= rate_limit.count as i64 {
+            violations.push(EvalViolation::RateLimitExceeded);
+        }
+    }
+
+    Ok(violations)
+}
+
+// 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 mut violations =
+            check_shared_constraints(&context, &grant.shared, grant.shared_grant_id, &mut conn)
+                .await?;
+        violations.extend(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 list_all_grants(&self) -> Result<Vec<Grant<SpecificGrant>>, ListGrantsError> {
+        let mut conn = self.db.get().await?;
+
+        let mut grants: Vec<Grant<SpecificGrant>> = Vec::new();
+
+        grants.extend(
+            EtherTransfer::find_all_grants(&mut conn)
+                .await?
+                .into_iter()
+                .map(|g| Grant {
+                    id: g.id,
+                    shared_grant_id: g.shared_grant_id,
+                    shared: g.shared,
+                    settings: SpecificGrant::EtherTransfer(g.settings),
+                }),
+        );
+        grants.extend(
+            TokenTransfer::find_all_grants(&mut conn)
+                .await?
+                .into_iter()
+                .map(|g| Grant {
+                    id: g.id,
+                    shared_grant_id: g.shared_grant_id,
+                    shared: g.shared,
+                    settings: SpecificGrant::TokenTransfer(g.settings),
+                }),
+        );
+
+        Ok(grants)
+    }
+
+    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,
+            value: transaction.value,
+            calldata: transaction.input.clone(),
+            max_fee_per_gas: transaction.max_fee_per_gas,
+            max_priority_fee_per_gas: transaction.max_priority_fee_per_gas,
+        };
+
+        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,209 @@
+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;
+
+#[derive(Debug, Clone)]
+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,
+
+    // Gas pricing (EIP-1559)
+    pub max_fee_per_gas: u128,
+    pub max_priority_fee_per_gas: u128,
+}
+
+#[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;
+
+    // Return all non-revoked grants, eagerly loading policy-specific settings
+    fn find_all_grants(
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> impl Future<Output = QueryResult<Vec<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/mod.rs

@@ -0,0 +1,352 @@
+use std::collections::HashMap;
+use std::fmt::Display;
+
+use alloy::primitives::{Address, U256};
+use chrono::{DateTime, Duration, Utc};
+use diesel::dsl::{auto_type, 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_basic_grant, 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},
+};
+
+#[auto_type]
+fn grant_join() -> _ {
+    evm_ether_transfer_grant::table.inner_join(
+        evm_basic_grant::table.on(evm_ether_transfer_grant::basic_grant_id.eq(evm_basic_grant::id)),
+    )
+}
+
+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>>> {
+        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)
+            .inner_join(evm_ether_transfer_grant_target::table)
+            .filter(
+                evm_basic_grant::wallet_id
+                    .eq(context.wallet_id)
+                    .and(evm_basic_grant::client_id.eq(context.client_id))
+                    .and(evm_basic_grant::revoked_at.is_null())
+                    .and(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(())
+    }
+
+    async fn find_all_grants(
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<Vec<Grant<Self::Settings>>> {
+        let grants: Vec<(EvmBasicGrant, EvmEtherTransferGrant)> = grant_join()
+            .filter(evm_basic_grant::revoked_at.is_null())
+            .select((
+                EvmBasicGrant::as_select(),
+                EvmEtherTransferGrant::as_select(),
+            ))
+            .load(conn)
+            .await?;
+
+        if grants.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let grant_ids: Vec<i32> = grants.iter().map(|(_, g)| g.id).collect();
+        let limit_ids: Vec<i32> = grants.iter().map(|(_, g)| g.limit_id).collect();
+
+        let all_targets: Vec<EvmEtherTransferGrantTarget> = evm_ether_transfer_grant_target::table
+            .filter(evm_ether_transfer_grant_target::grant_id.eq_any(&grant_ids))
+            .select(EvmEtherTransferGrantTarget::as_select())
+            .load(conn)
+            .await?;
+
+        let all_limits: Vec<EvmEtherTransferLimit> = evm_ether_transfer_limit::table
+            .filter(evm_ether_transfer_limit::id.eq_any(&limit_ids))
+            .select(EvmEtherTransferLimit::as_select())
+            .load(conn)
+            .await?;
+
+        let mut targets_by_grant: HashMap<i32, Vec<EvmEtherTransferGrantTarget>> = HashMap::new();
+        for target in all_targets {
+            targets_by_grant
+                .entry(target.grant_id)
+                .or_default()
+                .push(target);
+        }
+
+        let limits_by_id: HashMap<i32, EvmEtherTransferLimit> =
+            all_limits.into_iter().map(|l| (l.id, l)).collect();
+
+        grants
+            .into_iter()
+            .map(|(basic, specific)| {
+                let targets: Vec<Address> = targets_by_grant
+                    .get(&specific.id)
+                    .map(|v| v.as_slice())
+                    .unwrap_or_default()
+                    .iter()
+                    .filter_map(|t| {
+                        let arr: [u8; 20] = t.address.clone().try_into().ok()?;
+                        Some(Address::from(arr))
+                    })
+                    .collect();
+
+                let limit = limits_by_id
+                    .get(&specific.limit_id)
+                    .ok_or(diesel::result::Error::NotFound)?;
+
+                Ok(Grant {
+                    id: specific.id,
+                    shared_grant_id: specific.basic_grant_id,
+                    shared: SharedGrantSettings::try_from_model(basic)?,
+                    settings: Settings {
+                        target: targets,
+                        limit: VolumeRateLimit {
+                            max_volume: utils::try_bytes_to_u256(&limit.max_volume).map_err(
+                                |e| diesel::result::Error::DeserializationError(Box::new(e)),
+                            )?,
+                            window: Duration::seconds(limit.window_secs as i64),
+                        },
+                    },
+                })
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests;

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

@@ -0,0 +1,387 @@
+use alloy::primitives::{Address, Bytes, U256, address};
+use chrono::{Duration, Utc};
+use diesel::{SelectableHelper, insert_into};
+use diesel_async::RunQueryDsl;
+
+use crate::db::{
+    self, DatabaseConnection,
+    models::{EvmBasicGrant, NewEvmBasicGrant, NewEvmTransactionLog, SqliteTimestamp},
+    schema::{evm_basic_grant, evm_transaction_log},
+};
+use crate::evm::{
+    policies::{
+        EvalContext, EvalViolation, Grant, Policy, SharedGrantSettings, VolumeRateLimit,
+    },
+    utils,
+};
+
+use super::{EtherTransfer, Settings};
+
+const WALLET_ID: i32 = 1;
+const CLIENT_ID: i32 = 2;
+const CHAIN_ID: u64 = 1;
+
+const ALLOWED: Address = address!("1111111111111111111111111111111111111111");
+const OTHER: Address = address!("2222222222222222222222222222222222222222");
+
+fn ctx(to: Address, value: U256) -> EvalContext {
+    EvalContext {
+        wallet_id: WALLET_ID,
+        client_id: CLIENT_ID,
+        chain: CHAIN_ID,
+        to,
+        value,
+        calldata: Bytes::new(),
+        max_fee_per_gas: 0,
+        max_priority_fee_per_gas: 0,
+    }
+}
+
+async fn insert_basic(conn: &mut DatabaseConnection, revoked: bool) -> EvmBasicGrant {
+    insert_into(evm_basic_grant::table)
+        .values(NewEvmBasicGrant {
+            wallet_id: WALLET_ID,
+            client_id: CLIENT_ID,
+            chain_id: CHAIN_ID as i32,
+            valid_from: None,
+            valid_until: None,
+            max_gas_fee_per_gas: None,
+            max_priority_fee_per_gas: None,
+            rate_limit_count: None,
+            rate_limit_window_secs: None,
+            revoked_at: revoked.then(|| SqliteTimestamp(Utc::now())),
+        })
+        .returning(EvmBasicGrant::as_select())
+        .get_result(conn)
+        .await
+        .unwrap()
+}
+
+fn make_settings(targets: Vec<Address>, max_volume: u64) -> Settings {
+    Settings {
+        target: targets,
+        limit: VolumeRateLimit {
+            max_volume: U256::from(max_volume),
+            window: Duration::hours(1),
+        },
+    }
+}
+
+fn shared() -> SharedGrantSettings {
+    SharedGrantSettings {
+        wallet_id: WALLET_ID,
+        chain: CHAIN_ID,
+        valid_from: None,
+        valid_until: None,
+        max_gas_fee_per_gas: None,
+        max_priority_fee_per_gas: None,
+        rate_limit: None,
+    }
+}
+
+// ── analyze ─────────────────────────────────────────────────────────────
+
+#[test]
+fn analyze_matches_empty_calldata() {
+    let m = EtherTransfer::analyze(&ctx(ALLOWED, U256::from(1_000u64))).unwrap();
+    assert_eq!(m.to, ALLOWED);
+    assert_eq!(m.value, U256::from(1_000u64));
+}
+
+#[test]
+fn analyze_rejects_nonempty_calldata() {
+    let context = EvalContext {
+        calldata: Bytes::from(vec![0xde, 0xad, 0xbe, 0xef]),
+        ..ctx(ALLOWED, U256::from(1u64))
+    };
+    assert!(EtherTransfer::analyze(&context).is_none());
+}
+
+// ── evaluate ────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn evaluate_passes_for_allowed_target() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(vec![ALLOWED], 1_000_000),
+    };
+    let context = ctx(ALLOWED, U256::from(100u64));
+    let m = EtherTransfer::analyze(&context).unwrap();
+    let v = EtherTransfer::evaluate(&context, &m, &grant, &mut *conn)
+        .await
+        .unwrap();
+    assert!(v.is_empty());
+}
+
+#[tokio::test]
+async fn evaluate_rejects_disallowed_target() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(vec![ALLOWED], 1_000_000),
+    };
+    let context = ctx(OTHER, U256::from(100u64));
+    let m = EtherTransfer::analyze(&context).unwrap();
+    let v = EtherTransfer::evaluate(&context, &m, &grant, &mut *conn)
+        .await
+        .unwrap();
+    assert!(
+        v.iter()
+            .any(|e| matches!(e, EvalViolation::InvalidTarget { .. }))
+    );
+}
+
+#[tokio::test]
+async fn evaluate_passes_when_volume_within_limit() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(vec![ALLOWED], 1_000);
+    let grant_id = EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    insert_into(evm_transaction_log::table)
+        .values(NewEvmTransactionLog {
+            grant_id,
+            client_id: CLIENT_ID,
+            wallet_id: WALLET_ID,
+            chain_id: CHAIN_ID as i32,
+            eth_value: utils::u256_to_bytes(U256::from(500u64)).to_vec(),
+            signed_at: SqliteTimestamp(Utc::now()),
+        })
+        .execute(&mut *conn)
+        .await
+        .unwrap();
+
+    let grant = Grant {
+        id: grant_id,
+        shared_grant_id: basic.id,
+        shared: shared(),
+        settings,
+    };
+    let context = ctx(ALLOWED, U256::from(100u64));
+    let m = EtherTransfer::analyze(&context).unwrap();
+    let v = EtherTransfer::evaluate(&context, &m, &grant, &mut *conn)
+        .await
+        .unwrap();
+    assert!(
+        !v.iter()
+            .any(|e| matches!(e, EvalViolation::VolumetricLimitExceeded))
+    );
+}
+
+#[tokio::test]
+async fn evaluate_rejects_volume_over_limit() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(vec![ALLOWED], 1_000);
+    let grant_id = EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    insert_into(evm_transaction_log::table)
+        .values(NewEvmTransactionLog {
+            grant_id,
+            client_id: CLIENT_ID,
+            wallet_id: WALLET_ID,
+            chain_id: CHAIN_ID as i32,
+            eth_value: utils::u256_to_bytes(U256::from(1_001u64)).to_vec(),
+            signed_at: SqliteTimestamp(Utc::now()),
+        })
+        .execute(&mut *conn)
+        .await
+        .unwrap();
+
+    let grant = Grant {
+        id: grant_id,
+        shared_grant_id: basic.id,
+        shared: shared(),
+        settings,
+    };
+    let context = ctx(ALLOWED, U256::from(100u64));
+    let m = EtherTransfer::analyze(&context).unwrap();
+    let v = EtherTransfer::evaluate(&context, &m, &grant, &mut *conn)
+        .await
+        .unwrap();
+    assert!(
+        v.iter()
+            .any(|e| matches!(e, EvalViolation::VolumetricLimitExceeded))
+    );
+}
+
+#[tokio::test]
+async fn evaluate_passes_at_exactly_volume_limit() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(vec![ALLOWED], 1_000);
+    let grant_id = EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    // Exactly at the limit — the check is `>`, so this should not violate
+    insert_into(evm_transaction_log::table)
+        .values(NewEvmTransactionLog {
+            grant_id,
+            client_id: CLIENT_ID,
+            wallet_id: WALLET_ID,
+            chain_id: CHAIN_ID as i32,
+            eth_value: utils::u256_to_bytes(U256::from(1_000u64)).to_vec(),
+            signed_at: SqliteTimestamp(Utc::now()),
+        })
+        .execute(&mut *conn)
+        .await
+        .unwrap();
+
+    let grant = Grant {
+        id: grant_id,
+        shared_grant_id: basic.id,
+        shared: shared(),
+        settings,
+    };
+    let context = ctx(ALLOWED, U256::from(100u64));
+    let m = EtherTransfer::analyze(&context).unwrap();
+    let v = EtherTransfer::evaluate(&context, &m, &grant, &mut *conn)
+        .await
+        .unwrap();
+    assert!(
+        !v.iter()
+            .any(|e| matches!(e, EvalViolation::VolumetricLimitExceeded))
+    );
+}
+
+// ── try_find_grant ───────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn try_find_grant_roundtrip() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(vec![ALLOWED], 1_000_000);
+    EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    let found = EtherTransfer::try_find_grant(&ctx(ALLOWED, U256::from(1u64)), &mut *conn)
+        .await
+        .unwrap();
+
+    assert!(found.is_some());
+    let g = found.unwrap();
+    assert_eq!(g.settings.target, vec![ALLOWED]);
+    assert_eq!(g.settings.limit.max_volume, U256::from(1_000_000u64));
+}
+
+#[tokio::test]
+async fn try_find_grant_revoked_returns_none() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, true).await;
+    let settings = make_settings(vec![ALLOWED], 1_000_000);
+    EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    let found = EtherTransfer::try_find_grant(&ctx(ALLOWED, U256::from(1u64)), &mut *conn)
+        .await
+        .unwrap();
+    assert!(found.is_none());
+}
+
+#[tokio::test]
+async fn try_find_grant_wrong_target_returns_none() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(vec![ALLOWED], 1_000_000);
+    EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    let found = EtherTransfer::try_find_grant(&ctx(OTHER, U256::from(1u64)), &mut *conn)
+        .await
+        .unwrap();
+    assert!(found.is_none());
+}
+
+// ── find_all_grants ──────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn find_all_grants_empty_db() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+    let all = EtherTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert!(all.is_empty());
+}
+
+#[tokio::test]
+async fn find_all_grants_excludes_revoked() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let settings = make_settings(vec![ALLOWED], 1_000_000);
+    let active = insert_basic(&mut conn, false).await;
+    EtherTransfer::create_grant(&active, &settings, &mut *conn)
+        .await
+        .unwrap();
+    let revoked = insert_basic(&mut conn, true).await;
+    EtherTransfer::create_grant(&revoked, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    let all = EtherTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert_eq!(all.len(), 1);
+    assert_eq!(all[0].settings.target, vec![ALLOWED]);
+}
+
+#[tokio::test]
+async fn find_all_grants_multiple_targets() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(vec![ALLOWED, OTHER], 1_000_000);
+    EtherTransfer::create_grant(&basic, &settings, &mut *conn)
+        .await
+        .unwrap();
+
+    let all = EtherTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert_eq!(all.len(), 1);
+    assert_eq!(all[0].settings.target.len(), 2);
+    assert_eq!(all[0].settings.limit.max_volume, U256::from(1_000_000u64));
+}
+
+#[tokio::test]
+async fn find_all_grants_multiple_grants() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic1 = insert_basic(&mut conn, false).await;
+    EtherTransfer::create_grant(&basic1, &make_settings(vec![ALLOWED], 500), &mut *conn)
+        .await
+        .unwrap();
+    let basic2 = insert_basic(&mut conn, false).await;
+    EtherTransfer::create_grant(&basic2, &make_settings(vec![OTHER], 1_000), &mut *conn)
+        .await
+        .unwrap();
+
+    let all = EtherTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert_eq!(all.len(), 2);
+}

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

@@ -0,0 +1,385 @@
+use std::collections::HashMap;
+
+use alloy::{
+    primitives::{Address, U256},
+    sol_types::SolCall,
+};
+use arbiter_tokens_registry::evm::nonfungible::{self, TokenInfo};
+use chrono::{DateTime, Duration, Utc};
+use diesel::dsl::{auto_type, 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_basic_grant, 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};
+
+#[auto_type]
+fn grant_join() -> _ {
+    evm_token_transfer_grant::table.inner_join(
+        evm_basic_grant::table.on(evm_token_transfer_grant::basic_grant_id.eq(evm_basic_grant::id)),
+    )
+}
+
+#[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>>> {
+        let token_contract_bytes = context.to.to_vec();
+
+        let grant: Option<(EvmBasicGrant, EvmTokenTransferGrant)> = grant_join()
+            .filter(evm_basic_grant::revoked_at.is_null())
+            .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(())
+    }
+
+    async fn find_all_grants(
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> QueryResult<Vec<Grant<Self::Settings>>> {
+        let grants: Vec<(EvmBasicGrant, EvmTokenTransferGrant)> = grant_join()
+            .filter(evm_basic_grant::revoked_at.is_null())
+            .select((
+                EvmBasicGrant::as_select(),
+                EvmTokenTransferGrant::as_select(),
+            ))
+            .load(conn)
+            .await?;
+
+        if grants.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let grant_ids: Vec<i32> = grants.iter().map(|(_, g)| g.id).collect();
+
+        let all_volume_limits: Vec<EvmTokenTransferVolumeLimit> =
+            evm_token_transfer_volume_limit::table
+                .filter(evm_token_transfer_volume_limit::grant_id.eq_any(&grant_ids))
+                .select(EvmTokenTransferVolumeLimit::as_select())
+                .load(conn)
+                .await?;
+
+        let mut limits_by_grant: HashMap<i32, Vec<EvmTokenTransferVolumeLimit>> = HashMap::new();
+        for limit in all_volume_limits {
+            limits_by_grant
+                .entry(limit.grant_id)
+                .or_default()
+                .push(limit);
+        }
+
+        grants
+            .into_iter()
+            .map(|(basic, specific)| {
+                let volume_limits: Vec<VolumeRateLimit> = limits_by_grant
+                    .get(&specific.id)
+                    .map(|v| v.as_slice())
+                    .unwrap_or_default()
+                    .iter()
+                    .map(|row| {
+                        Ok(VolumeRateLimit {
+                            max_volume: utils::try_bytes_to_u256(&row.max_volume).map_err(|e| {
+                                diesel::result::Error::DeserializationError(Box::new(e))
+                            })?,
+                            window: Duration::seconds(row.window_secs as i64),
+                        })
+                    })
+                    .collect::<QueryResult<Vec<_>>>()?;
+
+                let token_contract: [u8; 20] =
+                    specific.token_contract.clone().try_into().map_err(|_| {
+                        diesel::result::Error::DeserializationError(
+                            "Invalid token contract address length".into(),
+                        )
+                    })?;
+
+                let target: Option<Address> = match &specific.receiver {
+                    None => None,
+                    Some(bytes) => {
+                        let arr: [u8; 20] = bytes.clone().try_into().map_err(|_| {
+                            diesel::result::Error::DeserializationError(
+                                "Invalid receiver address length".into(),
+                            )
+                        })?;
+                        Some(Address::from(arr))
+                    }
+                };
+
+                Ok(Grant {
+                    id: specific.id,
+                    shared_grant_id: specific.basic_grant_id,
+                    shared: SharedGrantSettings::try_from_model(basic)?,
+                    settings: Settings {
+                        token_contract: Address::from(token_contract),
+                        target,
+                        volume_limits,
+                    },
+                })
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests;

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

@@ -0,0 +1,397 @@
+use alloy::primitives::{Address, Bytes, U256, address};
+use alloy::sol_types::SolCall;
+use chrono::{Duration, Utc};
+use diesel::{SelectableHelper, insert_into};
+use diesel_async::RunQueryDsl;
+
+use crate::db::{
+    self, DatabaseConnection,
+    models::{EvmBasicGrant, NewEvmBasicGrant, SqliteTimestamp},
+    schema::evm_basic_grant,
+};
+use crate::evm::{
+    abi::IERC20::transferCall,
+    policies::{EvalContext, EvalViolation, Grant, Policy, SharedGrantSettings, VolumeRateLimit},
+    utils,
+};
+
+use super::{Settings, TokenTransfer};
+
+// DAI on Ethereum mainnet — present in the static token registry
+const CHAIN_ID: u64 = 1;
+const DAI: Address = address!("6B175474E89094C44Da98b954EedeAC495271d0F");
+
+const WALLET_ID: i32 = 1;
+const CLIENT_ID: i32 = 2;
+
+const RECIPIENT: Address = address!("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+const OTHER: Address = address!("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+const UNKNOWN_TOKEN: Address = address!("cccccccccccccccccccccccccccccccccccccccc");
+
+/// Encode `transfer(to, value)` raw params (no 4-byte selector).
+/// `abi_decode_raw_validate` expects exactly this format.
+fn transfer_calldata(to: Address, value: U256) -> Bytes {
+    let mut raw = Vec::new();
+    transferCall { to, value }.abi_encode_raw(&mut raw);
+    Bytes::from(raw)
+}
+
+fn ctx(to: Address, calldata: Bytes) -> EvalContext {
+    EvalContext {
+        wallet_id: WALLET_ID,
+        client_id: CLIENT_ID,
+        chain: CHAIN_ID,
+        to,
+        value: U256::ZERO,
+        calldata,
+        max_fee_per_gas: 0,
+        max_priority_fee_per_gas: 0,
+    }
+}
+
+async fn insert_basic(conn: &mut DatabaseConnection, revoked: bool) -> EvmBasicGrant {
+    insert_into(evm_basic_grant::table)
+        .values(NewEvmBasicGrant {
+            wallet_id: WALLET_ID,
+            client_id: CLIENT_ID,
+            chain_id: CHAIN_ID as i32,
+            valid_from: None,
+            valid_until: None,
+            max_gas_fee_per_gas: None,
+            max_priority_fee_per_gas: None,
+            rate_limit_count: None,
+            rate_limit_window_secs: None,
+            revoked_at: revoked.then(|| SqliteTimestamp(Utc::now())),
+        })
+        .returning(EvmBasicGrant::as_select())
+        .get_result(conn)
+        .await
+        .unwrap()
+}
+
+fn make_settings(target: Option<Address>, max_volume: Option<u64>) -> Settings {
+    Settings {
+        token_contract: DAI,
+        target,
+        volume_limits: max_volume
+            .map(|v| {
+                vec![VolumeRateLimit {
+                    max_volume: U256::from(v),
+                    window: Duration::hours(1),
+                }]
+            })
+            .unwrap_or_default(),
+    }
+}
+
+fn shared() -> SharedGrantSettings {
+    SharedGrantSettings {
+        wallet_id: WALLET_ID,
+        chain: CHAIN_ID,
+        valid_from: None,
+        valid_until: None,
+        max_gas_fee_per_gas: None,
+        max_priority_fee_per_gas: None,
+        rate_limit: None,
+    }
+}
+
+// ── analyze ─────────────────────────────────────────────────────────────
+
+#[test]
+fn analyze_known_token_valid_calldata() {
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let m = TokenTransfer::analyze(&ctx(DAI, calldata)).unwrap();
+    assert_eq!(m.to, RECIPIENT);
+    assert_eq!(m.value, U256::from(100u64));
+}
+
+#[test]
+fn analyze_unknown_token_returns_none() {
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    assert!(TokenTransfer::analyze(&ctx(UNKNOWN_TOKEN, calldata)).is_none());
+}
+
+#[test]
+fn analyze_invalid_calldata_returns_none() {
+    let calldata = Bytes::from(vec![0xde, 0xad, 0xbe, 0xef]);
+    assert!(TokenTransfer::analyze(&ctx(DAI, calldata)).is_none());
+}
+
+#[test]
+fn analyze_empty_calldata_returns_none() {
+    assert!(TokenTransfer::analyze(&ctx(DAI, Bytes::new())).is_none());
+}
+
+// ── evaluate ────────────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn evaluate_rejects_nonzero_eth_value() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(None, None),
+    };
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let mut context = ctx(DAI, calldata);
+    context.value = U256::from(1u64); // ETH attached to an ERC-20 call
+
+    let m = TokenTransfer::analyze(&EvalContext { value: U256::ZERO, ..context.clone() })
+        .unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(v.iter().any(|e| matches!(e, EvalViolation::InvalidTransactionType)));
+}
+
+#[tokio::test]
+async fn evaluate_passes_any_recipient_when_no_restriction() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(None, None),
+    };
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let context = ctx(DAI, calldata);
+    let m = TokenTransfer::analyze(&context).unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(v.is_empty());
+}
+
+#[tokio::test]
+async fn evaluate_passes_matching_restricted_recipient() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(Some(RECIPIENT), None),
+    };
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let context = ctx(DAI, calldata);
+    let m = TokenTransfer::analyze(&context).unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(v.is_empty());
+}
+
+#[tokio::test]
+async fn evaluate_rejects_wrong_restricted_recipient() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(Some(RECIPIENT), None),
+    };
+    let calldata = transfer_calldata(OTHER, U256::from(100u64));
+    let context = ctx(DAI, calldata);
+    let m = TokenTransfer::analyze(&context).unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(v.iter().any(|e| matches!(e, EvalViolation::InvalidTarget { .. })));
+}
+
+#[tokio::test]
+async fn evaluate_passes_volume_within_limit() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(None, Some(1_000));
+    let grant_id = TokenTransfer::create_grant(&basic, &settings, &mut *conn).await.unwrap();
+
+    // Record a past transfer of 500 (within 1000 limit)
+    use crate::db::{models::NewEvmTokenTransferLog, schema::evm_token_transfer_log};
+    insert_into(evm_token_transfer_log::table)
+        .values(NewEvmTokenTransferLog {
+            grant_id,
+            log_id: 0,
+            chain_id: CHAIN_ID as i32,
+            token_contract: DAI.to_vec(),
+            recipient_address: RECIPIENT.to_vec(),
+            value: utils::u256_to_bytes(U256::from(500u64)).to_vec(),
+        })
+        .execute(&mut *conn)
+        .await
+        .unwrap();
+
+    let grant = Grant { id: grant_id, shared_grant_id: basic.id, shared: shared(), settings };
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let context = ctx(DAI, calldata);
+    let m = TokenTransfer::analyze(&context).unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(!v.iter().any(|e| matches!(e, EvalViolation::VolumetricLimitExceeded)));
+}
+
+#[tokio::test]
+async fn evaluate_rejects_volume_over_limit() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(None, Some(1_000));
+    let grant_id = TokenTransfer::create_grant(&basic, &settings, &mut *conn).await.unwrap();
+
+    use crate::db::{models::NewEvmTokenTransferLog, schema::evm_token_transfer_log};
+    insert_into(evm_token_transfer_log::table)
+        .values(NewEvmTokenTransferLog {
+            grant_id,
+            log_id: 0,
+            chain_id: CHAIN_ID as i32,
+            token_contract: DAI.to_vec(),
+            recipient_address: RECIPIENT.to_vec(),
+            value: utils::u256_to_bytes(U256::from(1_001u64)).to_vec(),
+        })
+        .execute(&mut *conn)
+        .await
+        .unwrap();
+
+    let grant = Grant { id: grant_id, shared_grant_id: basic.id, shared: shared(), settings };
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let context = ctx(DAI, calldata);
+    let m = TokenTransfer::analyze(&context).unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(v.iter().any(|e| matches!(e, EvalViolation::VolumetricLimitExceeded)));
+}
+
+#[tokio::test]
+async fn evaluate_no_volume_limits_always_passes() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let grant = Grant {
+        id: 999,
+        shared_grant_id: 999,
+        shared: shared(),
+        settings: make_settings(None, None), // no volume limits
+    };
+    let calldata = transfer_calldata(RECIPIENT, U256::from(u64::MAX));
+    let context = ctx(DAI, calldata);
+    let m = TokenTransfer::analyze(&context).unwrap();
+    let v = TokenTransfer::evaluate(&context, &m, &grant, &mut *conn).await.unwrap();
+    assert!(!v.iter().any(|e| matches!(e, EvalViolation::VolumetricLimitExceeded)));
+}
+
+// ── try_find_grant ───────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn try_find_grant_roundtrip() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(Some(RECIPIENT), Some(5_000));
+    TokenTransfer::create_grant(&basic, &settings, &mut *conn).await.unwrap();
+
+    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
+    let found = TokenTransfer::try_find_grant(&ctx(DAI, calldata), &mut *conn)
+        .await
+        .unwrap();
+
+    assert!(found.is_some());
+    let g = found.unwrap();
+    assert_eq!(g.settings.token_contract, DAI);
+    assert_eq!(g.settings.target, Some(RECIPIENT));
+    assert_eq!(g.settings.volume_limits.len(), 1);
+    assert_eq!(g.settings.volume_limits[0].max_volume, U256::from(5_000u64));
+}
+
+#[tokio::test]
+async fn try_find_grant_revoked_returns_none() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, true).await;
+    let settings = make_settings(None, None);
+    TokenTransfer::create_grant(&basic, &settings, &mut *conn).await.unwrap();
+
+    let calldata = transfer_calldata(RECIPIENT, U256::from(1u64));
+    let found = TokenTransfer::try_find_grant(&ctx(DAI, calldata), &mut *conn)
+        .await
+        .unwrap();
+    assert!(found.is_none());
+}
+
+#[tokio::test]
+async fn try_find_grant_unknown_token_returns_none() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(None, None);
+    TokenTransfer::create_grant(&basic, &settings, &mut *conn).await.unwrap();
+
+    // Query with a different token contract
+    let calldata = transfer_calldata(RECIPIENT, U256::from(1u64));
+    let found = TokenTransfer::try_find_grant(&ctx(UNKNOWN_TOKEN, calldata), &mut *conn)
+        .await
+        .unwrap();
+    assert!(found.is_none());
+}
+
+// ── find_all_grants ──────────────────────────────────────────────────────
+
+#[tokio::test]
+async fn find_all_grants_empty_db() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+    let all = TokenTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert!(all.is_empty());
+}
+
+#[tokio::test]
+async fn find_all_grants_excludes_revoked() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let settings = make_settings(None, Some(1_000));
+    let active = insert_basic(&mut conn, false).await;
+    TokenTransfer::create_grant(&active, &settings, &mut *conn).await.unwrap();
+    let revoked = insert_basic(&mut conn, true).await;
+    TokenTransfer::create_grant(&revoked, &settings, &mut *conn).await.unwrap();
+
+    let all = TokenTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert_eq!(all.len(), 1);
+}
+
+#[tokio::test]
+async fn find_all_grants_loads_volume_limits() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let basic = insert_basic(&mut conn, false).await;
+    let settings = make_settings(None, Some(9_999));
+    TokenTransfer::create_grant(&basic, &settings, &mut *conn).await.unwrap();
+
+    let all = TokenTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert_eq!(all.len(), 1);
+    assert_eq!(all[0].settings.volume_limits.len(), 1);
+    assert_eq!(all[0].settings.volume_limits[0].max_volume, U256::from(9_999u64));
+}
+
+#[tokio::test]
+async fn find_all_grants_multiple_grants_batch_loaded() {
+    let db = db::create_test_pool().await;
+    let mut conn = db.get().await.unwrap();
+
+    let b1 = insert_basic(&mut conn, false).await;
+    TokenTransfer::create_grant(&b1, &make_settings(None, Some(1_000)), &mut *conn)
+        .await
+        .unwrap();
+    let b2 = insert_basic(&mut conn, false).await;
+    TokenTransfer::create_grant(&b2, &make_settings(Some(RECIPIENT), Some(2_000)), &mut *conn)
+        .await
+        .unwrap();
+
+    let all = TokenTransfer::find_all_grants(&mut *conn).await.unwrap();
+    assert_eq!(all.len(), 2);
+}

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

@@ -16,7 +16,7 @@ use tracing::info;
 use crate::{
     actors::{
         client::{self, ClientError, ClientConnection as ClientConnectionProps, connect_client},
-        user_agent::{self, UserAgentConnection, TransportResponseError, connect_user_agent},
+        user_agent::{self, UserAgentConnection, UserAgentError, connect_user_agent},
     },
     context::ServerContext,
 };
@@ -24,13 +24,14 @@ use crate::{
 pub mod actors;
 pub mod context;
 pub mod db;
+pub mod evm;
 
 const DEFAULT_CHANNEL_SIZE: usize = 1000;
 
 struct UserAgentGrpcSender;
 
 impl SendConverter for UserAgentGrpcSender {
-    type Input = Result<UserAgentResponse, TransportResponseError>;
+    type Input = Result<UserAgentResponse, UserAgentError>;
     type Output = Result<UserAgentResponse, Status>;
 
     fn convert(&self, item: Self::Input) -> Self::Output {
@@ -77,30 +78,31 @@ fn client_auth_error_status(value: &client::auth::Error) -> Status {
         Error::InvalidAuthPubkeyEncoding => {
             Status::invalid_argument("Failed to convert pubkey to VerifyingKey")
         }
-        Error::InvalidChallengeSolution => Status::unauthenticated(value.to_string()),
-        Error::ApproveError(_) => Status::permission_denied(value.to_string()),
+        Error::InvalidSignatureLength => Status::invalid_argument("Invalid signature length"),
+        Error::PublicKeyNotRegistered | Error::InvalidChallengeSolution => {
+            Status::unauthenticated(value.to_string())
+        }
         Error::Transport => Status::internal("Transport error"),
         Error::DatabasePoolUnavailable => Status::internal("Database pool error"),
         Error::DatabaseOperationFailed => Status::internal("Database error"),
-        Error::InternalError => Status::internal("Internal error"),
     }
 }
 
-fn user_agent_error_status(value: TransportResponseError) -> Status {
+fn user_agent_error_status(value: UserAgentError) -> Status {
     match value {
-        TransportResponseError::MissingRequestPayload | TransportResponseError::UnexpectedRequestPayload => {
+        UserAgentError::MissingRequestPayload | UserAgentError::UnexpectedRequestPayload => {
             Status::invalid_argument("Expected message with payload")
         }
-        TransportResponseError::InvalidStateForUnsealEncryptedKey => {
+        UserAgentError::InvalidStateForUnsealEncryptedKey => {
             Status::failed_precondition("Invalid state for unseal encrypted key")
         }
-        TransportResponseError::InvalidClientPubkeyLength => {
+        UserAgentError::InvalidClientPubkeyLength => {
             Status::invalid_argument("client_pubkey must be 32 bytes")
         }
-        TransportResponseError::StateTransitionFailed => Status::internal("State machine error"),
-        TransportResponseError::KeyHolderActorUnreachable => Status::internal("Vault is not available"),
-        TransportResponseError::Auth(ref err) => auth_error_status(err),
-        TransportResponseError::ConnectionRegistrationFailed => {
+        UserAgentError::StateTransitionFailed => Status::internal("State machine error"),
+        UserAgentError::KeyHolderActorUnreachable => Status::internal("Vault is not available"),
+        UserAgentError::Auth(ref err) => auth_error_status(err),
+        UserAgentError::ConnectionRegistrationFailed => {
             Status::internal("Failed registering connection")
         }
     }

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;