feat(transport): add domain error type to GrpcTransportActor

.claude/memory/feedback_widget_decomposition.md

@@ -1,11 +0,0 @@
----
-name: Widget decomposition and provider subscriptions
-description: Prefer splitting screens into multiple focused files/widgets; each widget subscribes to its own relevant providers
-type: feedback
----
-
-Split screens into multiple smaller widgets across multiple files. Each widget should subscribe only to the providers it needs (`ref.watch` at lowest possible level), rather than having one large screen widget that watches everything and passes data down as parameters.
-
-**Why:** Reduces unnecessary rebuilds; improves readability; each file has one clear responsibility.
-
-**How to apply:** When building a new screen, identify which sub-widgets need their own provider subscriptions and extract them into separate files (e.g., `widgets/grant_card.dart` watches enrichment providers itself, rather than the screen doing it and passing resolved strings down).

.gitignore

@@ -1,6 +1 @@
-target/
+target/
-scripts/__pycache__/
-.DS_Store
-.cargo/config.toml
-.vscode/
-docs/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "git.enabled": false
+}

.woodpecker/server-lint.yaml

@@ -22,4 +22,4 @@ steps:
       - apt-get update && apt-get install -y pkg-config
       - mise install rust 
       - mise install protoc
-      - mise exec rust -- cargo clippy --all -- -D warnings
+      - mise exec rust -- cargo clippy --all-targets --all-features -- -D warnings

.woodpecker/useragent-analyze.yaml

@@ -1,18 +0,0 @@
-when:
-  - event: pull_request
-    path:
-      include: ['.woodpecker/useragent-*.yaml', 'useragent/**']
-  - event: push
-    branch: main
-    path:
-      include: ['.woodpecker/useragent-*.yaml', 'useragent/**']
-
-steps:
-  - name: analyze
-    image: jdxcode/mise:latest
-    commands:
-      - mise install flutter 
-      - mise install protoc
-      # Reruns codegen to catch protocol drift
-      - mise codegen 
-      - cd useragent/ && flutter analyze

AGENTS.md

@@ -1,128 +0,0 @@
-# AGENTS.md
-
-This file provides guidance to Codex (Codex.ai/code) when working with code in this repository.
-
-## Project Overview
-
-Arbiter is a **permissioned signing service** for cryptocurrency wallets. It consists of:
-- **`server/`** — Rust gRPC daemon that holds encrypted keys and enforces policies
-- **`useragent/`** — Flutter desktop app (macOS/Windows) with a Rust backend via Rinf
-- **`protobufs/`** — Protocol Buffer definitions shared between server and client
-
-The vault never exposes key material; it only produces signatures when requests satisfy configured policies.
-
-## Toolchain Setup
-
-Tools are managed via [mise](https://mise.jdx.dev/). Install all required tools:
-```sh
-mise install
-```
-
-Key versions: Rust 1.93.0 (with clippy), Flutter 3.38.9-stable, protoc 29.6, diesel_cli 2.3.6 (sqlite).
-
-## Server (Rust workspace at `server/`)
-
-### Crates
-
-| Crate | Purpose |
-|---|---|
-| `arbiter-proto` | Generated gRPC stubs + protobuf types; compiled from `protobufs/*.proto` via `tonic-prost-build` |
-| `arbiter-server` | Main daemon — actors, DB, EVM policy engine, gRPC service implementation |
-| `arbiter-useragent` | Rust client library for the user agent side of the gRPC protocol |
-| `arbiter-client` | Rust client library for SDK clients |
-
-### Common Commands
-
-```sh
-cd server
-
-# Build
-cargo build
-
-# Run the server daemon
-cargo run -p arbiter-server
-
-# Run all tests (preferred over cargo test)
-cargo nextest run
-
-# Run a single test
-cargo nextest run <test_name>
-
-# Lint
-cargo clippy
-
-# Security audit
-cargo audit
-
-# Check unused dependencies
-cargo shear
-
-# Run snapshot tests and update snapshots
-cargo insta review
-```
-
-### Architecture
-
-The server is actor-based using the **kameo** crate. All long-lived state lives in `GlobalActors`:
-
-- **`Bootstrapper`** — Manages the one-time bootstrap token written to `~/.arbiter/bootstrap_token` on first run.
-- **`KeyHolder`** — Holds the encrypted root key and manages the Sealed/Unsealed vault state machine. On unseal, decrypts the root key into a `memsafe` hardened memory cell.
-- **`FlowCoordinator`** — Coordinates cross-connection flow between user agents and SDK clients.
-- **`EvmActor`** — Handles EVM transaction policy enforcement and signing.
-
-Per-connection actors live under `actors/user_agent/` and `actors/client/`, each with `auth` (challenge-response authentication) and `session` (post-auth operations) sub-modules.
-
-**Database:** SQLite via `diesel-async` + `bb8` connection pool. Schema managed by embedded Diesel migrations in `crates/arbiter-server/migrations/`. DB file lives at `~/.arbiter/arbiter.sqlite`. Tests use a temp-file DB via `db::create_test_pool()`.
-
-**Cryptography:**
-- Authentication: ed25519 (challenge-response, nonce-tracked per peer)
-- Encryption at rest: XChaCha20-Poly1305 (versioned via `scheme` field for transparent migration on unseal)
-- Password KDF: Argon2
-- Unseal transport: X25519 ephemeral key exchange
-- TLS: self-signed certificate (aws-lc-rs backend), fingerprint distributed via `ArbiterUrl`
-
-**Protocol:** gRPC with Protocol Buffers. The `ArbiterUrl` type encodes host, port, CA cert, and bootstrap token into a single shareable string (printed to console on first run).
-
-### Proto Regeneration
-
-When `.proto` files in `protobufs/` change, rebuild to regenerate:
-```sh
-cd server && cargo build -p arbiter-proto
-```
-
-### Database Migrations
-
-```sh
-# Create a new migration
-diesel migration generate <name> --migration-dir crates/arbiter-server/migrations
-
-# Run migrations manually (server also runs them on startup)
-diesel migration run --migration-dir crates/arbiter-server/migrations
-```
-
-## User Agent (Flutter + Rinf at `useragent/`)
-
-The Flutter app uses [Rinf](https://rinf.cunarist.org) to call Rust code. The Rust logic lives in `useragent/native/hub/` as a separate crate that uses `arbiter-useragent` for the gRPC client.
-
-Communication between Dart and Rust uses typed **signals** defined in `useragent/native/hub/src/signals/`. After modifying signal structs, regenerate Dart bindings:
-
-```sh
-cd useragent && rinf gen
-```
-
-### Common Commands
-
-```sh
-cd useragent
-
-# Run the app (macOS or Windows)
-flutter run
-
-# Regenerate Rust↔Dart signal bindings
-rinf gen
-
-# Analyze Dart code
-flutter analyze
-```
-
-The Rinf Rust entry point is `useragent/native/hub/src/lib.rs`. It spawns actors defined in `useragent/native/hub/src/actors/` which handle Dart↔server communication via signals.

CLAUDE.md

@@ -1,128 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-Arbiter is a **permissioned signing service** for cryptocurrency wallets. It consists of:
-- **`server/`** — Rust gRPC daemon that holds encrypted keys and enforces policies
-- **`useragent/`** — Flutter desktop app (macOS/Windows) with a Rust backend via Rinf
-- **`protobufs/`** — Protocol Buffer definitions shared between server and client
-
-The vault never exposes key material; it only produces signatures when requests satisfy configured policies.
-
-## Toolchain Setup
-
-Tools are managed via [mise](https://mise.jdx.dev/). Install all required tools:
-```sh
-mise install
-```
-
-Key versions: Rust 1.93.0 (with clippy), Flutter 3.38.9-stable, protoc 29.6, diesel_cli 2.3.6 (sqlite).
-
-## Server (Rust workspace at `server/`)
-
-### Crates
-
-| Crate | Purpose |
-|---|---|
-| `arbiter-proto` | Generated gRPC stubs + protobuf types; compiled from `protobufs/*.proto` via `tonic-prost-build` |
-| `arbiter-server` | Main daemon — actors, DB, EVM policy engine, gRPC service implementation |
-| `arbiter-useragent` | Rust client library for the user agent side of the gRPC protocol |
-| `arbiter-client` | Rust client library for SDK clients |
-
-### Common Commands
-
-```sh
-cd server
-
-# Build
-cargo build
-
-# Run the server daemon
-cargo run -p arbiter-server
-
-# Run all tests (preferred over cargo test)
-cargo nextest run
-
-# Run a single test
-cargo nextest run <test_name>
-
-# Lint
-cargo clippy
-
-# Security audit
-cargo audit
-
-# Check unused dependencies
-cargo shear
-
-# Run snapshot tests and update snapshots
-cargo insta review
-```
-
-### Architecture
-
-The server is actor-based using the **kameo** crate. All long-lived state lives in `GlobalActors`:
-
-- **`Bootstrapper`** — Manages the one-time bootstrap token written to `~/.arbiter/bootstrap_token` on first run.
-- **`KeyHolder`** — Holds the encrypted root key and manages the Sealed/Unsealed vault state machine. On unseal, decrypts the root key into a `memsafe` hardened memory cell.
-- **`FlowCoordinator`** — Coordinates cross-connection flow between user agents and SDK clients.
-- **`EvmActor`** — Handles EVM transaction policy enforcement and signing.
-
-Per-connection actors live under `actors/user_agent/` and `actors/client/`, each with `auth` (challenge-response authentication) and `session` (post-auth operations) sub-modules.
-
-**Database:** SQLite via `diesel-async` + `bb8` connection pool. Schema managed by embedded Diesel migrations in `crates/arbiter-server/migrations/`. DB file lives at `~/.arbiter/arbiter.sqlite`. Tests use a temp-file DB via `db::create_test_pool()`.
-
-**Cryptography:**
-- Authentication: ed25519 (challenge-response, nonce-tracked per peer)
-- Encryption at rest: XChaCha20-Poly1305 (versioned via `scheme` field for transparent migration on unseal)
-- Password KDF: Argon2
-- Unseal transport: X25519 ephemeral key exchange
-- TLS: self-signed certificate (aws-lc-rs backend), fingerprint distributed via `ArbiterUrl`
-
-**Protocol:** gRPC with Protocol Buffers. The `ArbiterUrl` type encodes host, port, CA cert, and bootstrap token into a single shareable string (printed to console on first run).
-
-### Proto Regeneration
-
-When `.proto` files in `protobufs/` change, rebuild to regenerate:
-```sh
-cd server && cargo build -p arbiter-proto
-```
-
-### Database Migrations
-
-```sh
-# Create a new migration
-diesel migration generate <name> --migration-dir crates/arbiter-server/migrations
-
-# Run migrations manually (server also runs them on startup)
-diesel migration run --migration-dir crates/arbiter-server/migrations
-```
-
-## User Agent (Flutter + Rinf at `useragent/`)
-
-The Flutter app uses [Rinf](https://rinf.cunarist.org) to call Rust code. The Rust logic lives in `useragent/native/hub/` as a separate crate that uses `arbiter-useragent` for the gRPC client.
-
-Communication between Dart and Rust uses typed **signals** defined in `useragent/native/hub/src/signals/`. After modifying signal structs, regenerate Dart bindings:
-
-```sh
-cd useragent && rinf gen
-```
-
-### Common Commands
-
-```sh
-cd useragent
-
-# Run the app (macOS or Windows)
-flutter run
-
-# Regenerate Rust↔Dart signal bindings
-rinf gen
-
-# Analyze Dart code
-flutter analyze
-```
-
-The Rinf Rust entry point is `useragent/native/hub/src/lib.rs`. It spawns actors defined in `useragent/native/hub/src/actors/` which handle Dart↔server communication via signals.

IMPLEMENTATION.md

@@ -4,66 +4,6 @@ This document covers concrete technology choices and dependencies. For the archi
 
 ---
 
-## Client Connection Flow
-
-### Authentication Result Semantics
-
-Authentication no longer uses an implicit success-only response shape. Both `client` and `user-agent` return explicit auth status enums over the wire.
-
-- **Client:** `AuthResult` may return `SUCCESS`, `INVALID_KEY`, `INVALID_SIGNATURE`, `APPROVAL_DENIED`, `NO_USER_AGENTS_ONLINE`, or `INTERNAL`
-- **User-agent:** `AuthResult` may return `SUCCESS`, `INVALID_KEY`, `INVALID_SIGNATURE`, `BOOTSTRAP_REQUIRED`, `TOKEN_INVALID`, or `INTERNAL`
-
-This makes transport-level failures and actor/domain-level auth failures distinct:
-
-- **Transport/protocol failures** are surfaced as stream/status errors
-- **Authentication failures** are surfaced as successful protocol responses carrying an explicit auth status
-
-Clients are expected to handle these status codes directly and present the concrete failure reason to the user.
-
-### 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
@@ -82,97 +22,9 @@ The `program_client.nonce` column stores the **next usable nonce** — i.e. it i
 ## Communication
 
 - **Protocol:** gRPC with Protocol Buffers
-- **Request/response matching:** multiplexed over a single bidirectional stream using per-connection request IDs
 - **Server identity distribution:** `ServerInfo` protobuf struct containing the TLS public key fingerprint
 - **Future consideration:** grpc-web lacks bidirectional stream support, so a browser-based wallet may require protojson over WebSocket
 
-### Request Multiplexing
-
-Both `client` and `user-agent` connections support multiple in-flight requests over one gRPC bidi stream.
-
-- Every request carries a monotonically increasing request ID
-- Every normal response echoes the request ID it corresponds to
-- Out-of-band server messages omit the response ID entirely
-- The server rejects already-seen request IDs at the transport adapter boundary before business logic sees the message
-
-This keeps request correlation entirely in transport/client connection code while leaving actor and domain handlers unaware of request IDs.
-
----
-
-## 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

app/.dart_tool/extension_discovery/README.md

@@ -1,31 +0,0 @@
-Extension Discovery Cache
-=========================
-
-This folder is used by `package:extension_discovery` to cache lists of
-packages that contains extensions for other packages.
-
-DO NOT USE THIS FOLDER
-----------------------
-
- * Do not read (or rely) the contents of this folder.
- * Do write to this folder.
-
-If you're interested in the lists of extensions stored in this folder use the
-API offered by package `extension_discovery` to get this information.
-
-If this package doesn't work for your use-case, then don't try to read the
-contents of this folder. It may change, and will not remain stable.
-
-Use package `extension_discovery`
----------------------------------
-
-If you want to access information from this folder.
-
-Feel free to delete this folder
--------------------------------
-
-Files in this folder act as a cache, and the cache is discarded if the files
-are older than the modification time of `.dart_tool/package_config.json`.
-
-Hence, it should never be necessary to clear this cache manually, if you find a
-need to do please file a bug.

app/.dart_tool/extension_discovery/vs_code.json

@@ -1 +0,0 @@
-{"version":2,"entries":[{"package":"app","rootUri":"../","packageUri":"lib/"}]}

docs/superpowers/plans/2026-03-28-grant-grid-view.md

@@ -1,821 +0,0 @@
-# Grant Grid View Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Add an "EVM Grants" dashboard tab that displays all grants as enriched cards (type, chain, wallet address, client name) with per-card revoke support.
-
-**Architecture:** A new `walletAccessListProvider` fetches wallet accesses with their DB row IDs. The screen (`grants.dart`) watches only `evmGrantsProvider` for top-level state. Each `GrantCard` widget (its own file) watches enrichment providers (`walletAccessListProvider`, `evmProvider`, `sdkClientsProvider`) and the revoke mutation directly — keeping rebuilds scoped to the card. The screen is registered as a dashboard tab in `AdaptiveScaffold`.
-
-**Tech Stack:** Flutter, Riverpod (`riverpod_annotation` + `build_runner` codegen), `sizer` (adaptive sizing), `auto_route`, Protocol Buffers (Dart), `Palette` design tokens.
-
----
-
-## File Map
-
-| File | Action | Responsibility |
-|---|---|---|
-| `useragent/lib/theme/palette.dart` | Modify | Add `Palette.token` (indigo accent for token-transfer cards) |
-| `useragent/lib/features/connection/evm/wallet_access.dart` | Modify | Add `listAllWalletAccesses()` function |
-| `useragent/lib/providers/sdk_clients/wallet_access_list.dart` | Create | `WalletAccessListProvider` — fetches full wallet access list with IDs |
-| `useragent/lib/screens/dashboard/evm/grants/widgets/grant_card.dart` | Create | `GrantCard` widget — watches enrichment providers + revoke mutation; one card per grant |
-| `useragent/lib/screens/dashboard/evm/grants/grants.dart` | Create | `EvmGrantsScreen` — watches `evmGrantsProvider`; handles loading/error/empty/data states; renders `GrantCard` list |
-| `useragent/lib/router.dart` | Modify | Register `EvmGrantsRoute` in dashboard children |
-| `useragent/lib/screens/dashboard.dart` | Modify | Add Grants entry to `routes` list and `NavigationDestination` list |
-
----
-
-## Task 1: Add `Palette.token`
-
-**Files:**
-- Modify: `useragent/lib/theme/palette.dart`
-
-- [ ] **Step 1: Add the color**
-
-Replace the contents of `useragent/lib/theme/palette.dart` with:
-
-```dart
-import 'package:flutter/material.dart';
-
-class Palette {
-  static const ink = Color(0xFF15263C);
-  static const coral = Color(0xFFE26254);
-  static const cream = Color(0xFFFFFAF4);
-  static const line = Color(0x1A15263C);
-  static const token = Color(0xFF5C6BC0);
-}
-```
-
-- [ ] **Step 2: Verify**
-
-```sh
-cd useragent && flutter analyze lib/theme/palette.dart
-```
-
-Expected: no issues.
-
-- [ ] **Step 3: Commit**
-
-```sh
-jj describe -m "feat(theme): add Palette.token for token-transfer grant cards"
-jj new
-```
-
----
-
-## Task 2: Add `listAllWalletAccesses` feature function
-
-**Files:**
-- Modify: `useragent/lib/features/connection/evm/wallet_access.dart`
-
-`readClientWalletAccess` (existing) filters the list to one client's wallet IDs and returns `Set<int>`. This new function returns the complete unfiltered list with row IDs so the grant cards can resolve wallet_access_id → wallet + client.
-
-- [ ] **Step 1: Append function**
-
-Add at the bottom of `useragent/lib/features/connection/evm/wallet_access.dart`:
-
-```dart
-Future<List<SdkClientWalletAccess>> listAllWalletAccesses(
-  Connection connection,
-) async {
-  final response = await connection.ask(
-    UserAgentRequest(listWalletAccess: Empty()),
-  );
-  if (!response.hasListWalletAccessResponse()) {
-    throw Exception(
-      'Expected list wallet access response, got ${response.whichPayload()}',
-    );
-  }
-  return response.listWalletAccessResponse.accesses.toList(growable: false);
-}
-```
-
-Each returned `SdkClientWalletAccess` has:
-- `.id` — the `evm_wallet_access` row ID (same value as `wallet_access_id` in a `GrantEntry`)
-- `.access.walletId` — the EVM wallet DB ID
-- `.access.sdkClientId` — the SDK client DB ID
-
-- [ ] **Step 2: Verify**
-
-```sh
-cd useragent && flutter analyze lib/features/connection/evm/wallet_access.dart
-```
-
-Expected: no issues.
-
-- [ ] **Step 3: Commit**
-
-```sh
-jj describe -m "feat(evm): add listAllWalletAccesses feature function"
-jj new
-```
-
----
-
-## Task 3: Create `WalletAccessListProvider`
-
-**Files:**
-- Create: `useragent/lib/providers/sdk_clients/wallet_access_list.dart`
-- Generated: `useragent/lib/providers/sdk_clients/wallet_access_list.g.dart`
-
-Mirrors the structure of `EvmGrants` in `providers/evm/evm_grants.dart` — class-based `@riverpod` with a `refresh()` method.
-
-- [ ] **Step 1: Write the provider**
-
-Create `useragent/lib/providers/sdk_clients/wallet_access_list.dart`:
-
-```dart
-import 'package:arbiter/features/connection/evm/wallet_access.dart';
-import 'package:arbiter/proto/user_agent.pb.dart';
-import 'package:arbiter/providers/connection/connection_manager.dart';
-import 'package:mtcore/markettakers.dart';
-import 'package:riverpod_annotation/riverpod_annotation.dart';
-
-part 'wallet_access_list.g.dart';
-
-@riverpod
-class WalletAccessList extends _$WalletAccessList {
-  @override
-  Future<List<SdkClientWalletAccess>?> build() async {
-    final connection = await ref.watch(connectionManagerProvider.future);
-    if (connection == null) {
-      return null;
-    }
-
-    try {
-      return await listAllWalletAccesses(connection);
-    } catch (e, st) {
-      talker.handle(e, st);
-      rethrow;
-    }
-  }
-
-  Future<void> refresh() async {
-    final connection = await ref.read(connectionManagerProvider.future);
-    if (connection == null) {
-      state = const AsyncData(null);
-      return;
-    }
-
-    state = const AsyncLoading();
-    state = await AsyncValue.guard(() => listAllWalletAccesses(connection));
-  }
-}
-```
-
-- [ ] **Step 2: Run code generation**
-
-```sh
-cd useragent && dart run build_runner build --delete-conflicting-outputs
-```
-
-Expected: `useragent/lib/providers/sdk_clients/wallet_access_list.g.dart` created. No errors.
-
-- [ ] **Step 3: Verify**
-
-```sh
-cd useragent && flutter analyze lib/providers/sdk_clients/
-```
-
-Expected: no issues.
-
-- [ ] **Step 4: Commit**
-
-```sh
-jj describe -m "feat(providers): add WalletAccessListProvider"
-jj new
-```
-
----
-
-## Task 4: Create `GrantCard` widget
-
-**Files:**
-- Create: `useragent/lib/screens/dashboard/evm/grants/widgets/grant_card.dart`
-
-This widget owns all per-card logic: enrichment lookups, revoke action, and rebuild scope. The screen only passes it a `GrantEntry` — the card fetches everything else itself.
-
-**Key types:**
-- `GrantEntry` (from `proto/evm.pb.dart`): `.id`, `.shared.walletAccessId`, `.shared.chainId`, `.specific.whichGrant()`
-- `SpecificGrant_Grant.etherTransfer` / `.tokenTransfer` — enum values for the oneof
-- `SdkClientWalletAccess` (from `proto/user_agent.pb.dart`): `.id`, `.access.walletId`, `.access.sdkClientId`
-- `WalletEntry` (from `proto/evm.pb.dart`): `.id`, `.address` (List<int>)
-- `SdkClientEntry` (from `proto/user_agent.pb.dart`): `.id`, `.info.name`
-- `revokeEvmGrantMutation` — `Mutation<void>` (global; all revoke buttons disable together while any revoke is in flight)
-- `executeRevokeEvmGrant(ref, grantId: int)` — `Future<void>`
-
-- [ ] **Step 1: Write the widget**
-
-Create `useragent/lib/screens/dashboard/evm/grants/widgets/grant_card.dart`:
-
-```dart
-import 'package:arbiter/proto/evm.pb.dart';
-import 'package:arbiter/proto/user_agent.pb.dart';
-import 'package:arbiter/providers/evm/evm.dart';
-import 'package:arbiter/providers/evm/evm_grants.dart';
-import 'package:arbiter/providers/sdk_clients/list.dart';
-import 'package:arbiter/providers/sdk_clients/wallet_access_list.dart';
-import 'package:arbiter/theme/palette.dart';
-import 'package:flutter/material.dart';
-import 'package:hooks_riverpod/experimental/mutation.dart';
-import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:sizer/sizer.dart';
-
-String _shortAddress(List<int> bytes) {
-  final hex = bytes.map((b) => b.toRadixString(16).padLeft(2, '0')).join();
-  return '0x${hex.substring(0, 6)}...${hex.substring(hex.length - 4)}';
-}
-
-String _formatError(Object error) {
-  final message = error.toString();
-  if (message.startsWith('Exception: ')) {
-    return message.substring('Exception: '.length);
-  }
-  return message;
-}
-
-class GrantCard extends ConsumerWidget {
-  const GrantCard({super.key, required this.grant});
-
-  final GrantEntry grant;
-
-  @override
-  Widget build(BuildContext context, WidgetRef ref) {
-    // Enrichment lookups — each watch scopes rebuilds to this card only
-    final walletAccesses =
-        ref.watch(walletAccessListProvider).asData?.value ?? const [];
-    final wallets = ref.watch(evmProvider).asData?.value ?? const [];
-    final clients = ref.watch(sdkClientsProvider).asData?.value ?? const [];
-    final revoking = ref.watch(revokeEvmGrantMutation) is MutationPending;
-
-    final isEther =
-        grant.specific.whichGrant() == SpecificGrant_Grant.etherTransfer;
-    final accent = isEther ? Palette.coral : Palette.token;
-    final typeLabel = isEther ? 'Ether' : 'Token';
-    final theme = Theme.of(context);
-    final muted = Palette.ink.withValues(alpha: 0.62);
-
-    // Resolve wallet_access_id → wallet address + client name
-    final accessById = <int, SdkClientWalletAccess>{
-      for (final a in walletAccesses) a.id: a,
-    };
-    final walletById = <int, WalletEntry>{
-      for (final w in wallets) w.id: w,
-    };
-    final clientNameById = <int, String>{
-      for (final c in clients) c.id: c.info.name,
-    };
-
-    final accessId = grant.shared.walletAccessId;
-    final access = accessById[accessId];
-    final wallet = access != null ? walletById[access.access.walletId] : null;
-
-    final walletLabel = wallet != null
-        ? _shortAddress(wallet.address)
-        : 'Access #$accessId';
-
-    final clientLabel = () {
-      if (access == null) return '';
-      final name = clientNameById[access.access.sdkClientId] ?? '';
-      return name.isEmpty ? 'Client #${access.access.sdkClientId}' : name;
-    }();
-
-    void showError(String message) {
-      if (!context.mounted) return;
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(content: Text(message), behavior: SnackBarBehavior.floating),
-      );
-    }
-
-    Future<void> revoke() async {
-      try {
-        await executeRevokeEvmGrant(ref, grantId: grant.id);
-      } catch (e) {
-        showError(_formatError(e));
-      }
-    }
-
-    return Container(
-      decoration: BoxDecoration(
-        borderRadius: BorderRadius.circular(24),
-        color: Palette.cream.withValues(alpha: 0.92),
-        border: Border.all(color: Palette.line),
-      ),
-      child: IntrinsicHeight(
-        child: Row(
-          crossAxisAlignment: CrossAxisAlignment.stretch,
-          children: [
-            // Accent strip
-            Container(
-              width: 0.8.w,
-              decoration: BoxDecoration(
-                color: accent,
-                borderRadius: const BorderRadius.horizontal(
-                  left: Radius.circular(24),
-                ),
-              ),
-            ),
-            // Card body
-            Expanded(
-              child: Padding(
-                padding: EdgeInsets.symmetric(
-                  horizontal: 1.6.w,
-                  vertical: 1.4.h,
-                ),
-                child: Column(
-                  crossAxisAlignment: CrossAxisAlignment.start,
-                  children: [
-                    // Row 1: type badge · chain · spacer · revoke button
-                    Row(
-                      children: [
-                        Container(
-                          padding: EdgeInsets.symmetric(
-                            horizontal: 1.w,
-                            vertical: 0.4.h,
-                          ),
-                          decoration: BoxDecoration(
-                            color: accent.withValues(alpha: 0.15),
-                            borderRadius: BorderRadius.circular(8),
-                          ),
-                          child: Text(
-                            typeLabel,
-                            style: theme.textTheme.labelSmall?.copyWith(
-                              color: accent,
-                              fontWeight: FontWeight.w800,
-                            ),
-                          ),
-                        ),
-                        SizedBox(width: 1.w),
-                        Container(
-                          padding: EdgeInsets.symmetric(
-                            horizontal: 1.w,
-                            vertical: 0.4.h,
-                          ),
-                          decoration: BoxDecoration(
-                            color: Palette.ink.withValues(alpha: 0.06),
-                            borderRadius: BorderRadius.circular(8),
-                          ),
-                          child: Text(
-                            'Chain ${grant.shared.chainId}',
-                            style: theme.textTheme.labelSmall?.copyWith(
-                              color: muted,
-                              fontWeight: FontWeight.w700,
-                            ),
-                          ),
-                        ),
-                        const Spacer(),
-                        if (revoking)
-                          SizedBox(
-                            width: 1.8.h,
-                            height: 1.8.h,
-                            child: CircularProgressIndicator(
-                              strokeWidth: 2,
-                              color: Palette.coral,
-                            ),
-                          )
-                        else
-                          OutlinedButton.icon(
-                            onPressed: revoke,
-                            style: OutlinedButton.styleFrom(
-                              foregroundColor: Palette.coral,
-                              side: BorderSide(
-                                color: Palette.coral.withValues(alpha: 0.4),
-                              ),
-                              padding: EdgeInsets.symmetric(
-                                horizontal: 1.w,
-                                vertical: 0.6.h,
-                              ),
-                              shape: RoundedRectangleBorder(
-                                borderRadius: BorderRadius.circular(10),
-                              ),
-                            ),
-                            icon: const Icon(Icons.block_rounded, size: 16),
-                            label: const Text('Revoke'),
-                          ),
-                      ],
-                    ),
-                    SizedBox(height: 0.8.h),
-                    // Row 2: wallet address · client name
-                    Row(
-                      children: [
-                        Text(
-                          walletLabel,
-                          style: theme.textTheme.bodySmall?.copyWith(
-                            color: Palette.ink,
-                            fontFamily: 'monospace',
-                          ),
-                        ),
-                        Padding(
-                          padding: EdgeInsets.symmetric(horizontal: 0.8.w),
-                          child: Text(
-                            '·',
-                            style: theme.textTheme.bodySmall
-                                ?.copyWith(color: muted),
-                          ),
-                        ),
-                        Expanded(
-                          child: Text(
-                            clientLabel,
-                            maxLines: 1,
-                            overflow: TextOverflow.ellipsis,
-                            style: theme.textTheme.bodySmall
-                                ?.copyWith(color: muted),
-                          ),
-                        ),
-                      ],
-                    ),
-                  ],
-                ),
-              ),
-            ),
-          ],
-        ),
-      ),
-    );
-  }
-}
-```
-
-- [ ] **Step 2: Verify**
-
-```sh
-cd useragent && flutter analyze lib/screens/dashboard/evm/grants/widgets/grant_card.dart
-```
-
-Expected: no issues.
-
-- [ ] **Step 3: Commit**
-
-```sh
-jj describe -m "feat(grants): add GrantCard widget with self-contained enrichment"
-jj new
-```
-
----
-
-## Task 5: Create `EvmGrantsScreen`
-
-**Files:**
-- Create: `useragent/lib/screens/dashboard/evm/grants/grants.dart`
-
-The screen watches only `evmGrantsProvider` for top-level state (loading / error / no connection / empty / data). When there is data it renders a list of `GrantCard` widgets — each card manages its own enrichment subscriptions.
-
-- [ ] **Step 1: Write the screen**
-
-Create `useragent/lib/screens/dashboard/evm/grants/grants.dart`:
-
-```dart
-import 'package:arbiter/proto/evm.pb.dart';
-import 'package:arbiter/providers/evm/evm_grants.dart';
-import 'package:arbiter/providers/sdk_clients/wallet_access_list.dart';
-import 'package:arbiter/router.gr.dart';
-import 'package:arbiter/screens/dashboard/evm/grants/widgets/grant_card.dart';
-import 'package:arbiter/theme/palette.dart';
-import 'package:arbiter/widgets/page_header.dart';
-import 'package:auto_route/auto_route.dart';
-import 'package:flutter/material.dart';
-import 'package:hooks_riverpod/hooks_riverpod.dart';
-import 'package:sizer/sizer.dart';
-
-String _formatError(Object error) {
-  final message = error.toString();
-  if (message.startsWith('Exception: ')) {
-    return message.substring('Exception: '.length);
-  }
-  return message;
-}
-
-// ─── State panel ──────────────────────────────────────────────────────────────
-
-class _StatePanel extends StatelessWidget {
-  const _StatePanel({
-    required this.icon,
-    required this.title,
-    required this.body,
-    this.actionLabel,
-    this.onAction,
-    this.busy = false,
-  });
-
-  final IconData icon;
-  final String title;
-  final String body;
-  final String? actionLabel;
-  final Future<void> Function()? onAction;
-  final bool busy;
-
-  @override
-  Widget build(BuildContext context) {
-    final theme = Theme.of(context);
-
-    return Container(
-      decoration: BoxDecoration(
-        borderRadius: BorderRadius.circular(24),
-        color: Palette.cream.withValues(alpha: 0.92),
-        border: Border.all(color: Palette.line),
-      ),
-      child: Padding(
-        padding: EdgeInsets.all(2.8.h),
-        child: Column(
-          crossAxisAlignment: CrossAxisAlignment.start,
-          children: [
-            if (busy)
-              SizedBox(
-                width: 2.8.h,
-                height: 2.8.h,
-                child: const CircularProgressIndicator(strokeWidth: 2.5),
-              )
-            else
-              Icon(icon, size: 34, color: Palette.coral),
-            SizedBox(height: 1.8.h),
-            Text(
-              title,
-              style: theme.textTheme.headlineSmall?.copyWith(
-                color: Palette.ink,
-                fontWeight: FontWeight.w800,
-              ),
-            ),
-            SizedBox(height: 1.h),
-            Text(
-              body,
-              style: theme.textTheme.bodyLarge?.copyWith(
-                color: Palette.ink.withValues(alpha: 0.72),
-                height: 1.5,
-              ),
-            ),
-            if (actionLabel != null && onAction != null) ...[
-              SizedBox(height: 2.h),
-              OutlinedButton.icon(
-                onPressed: () => onAction!(),
-                icon: const Icon(Icons.refresh),
-                label: Text(actionLabel!),
-              ),
-            ],
-          ],
-        ),
-      ),
-    );
-  }
-}
-
-// ─── Grant list ───────────────────────────────────────────────────────────────
-
-class _GrantList extends StatelessWidget {
-  const _GrantList({required this.grants});
-
-  final List<GrantEntry> grants;
-
-  @override
-  Widget build(BuildContext context) {
-    return Column(
-      children: [
-        for (var i = 0; i < grants.length; i++)
-          Padding(
-            padding: EdgeInsets.only(
-              bottom: i == grants.length - 1 ? 0 : 1.8.h,
-            ),
-            child: GrantCard(grant: grants[i]),
-          ),
-      ],
-    );
-  }
-}
-
-// ─── Screen ───────────────────────────────────────────────────────────────────
-
-@RoutePage()
-class EvmGrantsScreen extends ConsumerWidget {
-  const EvmGrantsScreen({super.key});
-
-  @override
-  Widget build(BuildContext context, WidgetRef ref) {
-    // Screen watches only the grant list for top-level state decisions
-    final grantsAsync = ref.watch(evmGrantsProvider);
-
-    Future<void> refresh() async {
-      await Future.wait([
-        ref.read(evmGrantsProvider.notifier).refresh(),
-        ref.read(walletAccessListProvider.notifier).refresh(),
-      ]);
-    }
-
-    void showMessage(String message) {
-      if (!context.mounted) return;
-      ScaffoldMessenger.of(context).showSnackBar(
-        SnackBar(content: Text(message), behavior: SnackBarBehavior.floating),
-      );
-    }
-
-    Future<void> safeRefresh() async {
-      try {
-        await refresh();
-      } catch (e) {
-        showMessage(_formatError(e));
-      }
-    }
-
-    final grantsState = grantsAsync.asData?.value;
-    final grants = grantsState?.grants;
-
-    final content = switch (grantsAsync) {
-      AsyncLoading() when grantsState == null => const _StatePanel(
-        icon: Icons.hourglass_top,
-        title: 'Loading grants',
-        body: 'Pulling grant registry from Arbiter.',
-        busy: true,
-      ),
-      AsyncError(:final error) => _StatePanel(
-        icon: Icons.sync_problem,
-        title: 'Grant registry unavailable',
-        body: _formatError(error),
-        actionLabel: 'Retry',
-        onAction: safeRefresh,
-      ),
-      AsyncData(:final value) when value == null => _StatePanel(
-        icon: Icons.portable_wifi_off,
-        title: 'No active server connection',
-        body: 'Reconnect to Arbiter to list EVM grants.',
-        actionLabel: 'Refresh',
-        onAction: safeRefresh,
-      ),
-      _ when grants != null && grants.isEmpty => _StatePanel(
-        icon: Icons.policy_outlined,
-        title: 'No grants yet',
-        body: 'Create a grant to allow SDK clients to sign transactions.',
-        actionLabel: 'Create grant',
-        onAction: () => context.router.push(const CreateEvmGrantRoute()),
-      ),
-      _ => _GrantList(grants: grants ?? const []),
-    };
-
-    return Scaffold(
-      body: SafeArea(
-        child: RefreshIndicator.adaptive(
-          color: Palette.ink,
-          backgroundColor: Colors.white,
-          onRefresh: safeRefresh,
-          child: ListView(
-            physics: const BouncingScrollPhysics(
-              parent: AlwaysScrollableScrollPhysics(),
-            ),
-            padding: EdgeInsets.fromLTRB(2.4.w, 2.4.h, 2.4.w, 3.2.h),
-            children: [
-              PageHeader(
-                title: 'EVM Grants',
-                isBusy: grantsAsync.isLoading,
-                actions: [
-                  FilledButton.icon(
-                    onPressed: () =>
-                        context.router.push(const CreateEvmGrantRoute()),
-                    icon: const Icon(Icons.add_rounded),
-                    label: const Text('Create grant'),
-                  ),
-                  SizedBox(width: 1.w),
-                  OutlinedButton.icon(
-                    onPressed: safeRefresh,
-                    style: OutlinedButton.styleFrom(
-                      foregroundColor: Palette.ink,
-                      side: BorderSide(color: Palette.line),
-                      padding: EdgeInsets.symmetric(
-                        horizontal: 1.4.w,
-                        vertical: 1.2.h,
-                      ),
-                      shape: RoundedRectangleBorder(
-                        borderRadius: BorderRadius.circular(14),
-                      ),
-                    ),
-                    icon: const Icon(Icons.refresh, size: 18),
-                    label: const Text('Refresh'),
-                  ),
-                ],
-              ),
-              SizedBox(height: 1.8.h),
-              content,
-            ],
-          ),
-        ),
-      ),
-    );
-  }
-}
-```
-
-- [ ] **Step 2: Verify**
-
-```sh
-cd useragent && flutter analyze lib/screens/dashboard/evm/grants/
-```
-
-Expected: no issues.
-
-- [ ] **Step 3: Commit**
-
-```sh
-jj describe -m "feat(grants): add EvmGrantsScreen"
-jj new
-```
-
----
-
-## Task 6: Wire router and dashboard tab
-
-**Files:**
-- Modify: `useragent/lib/router.dart`
-- Modify: `useragent/lib/screens/dashboard.dart`
-- Regenerated: `useragent/lib/router.gr.dart`
-
-- [ ] **Step 1: Add route to `router.dart`**
-
-Replace the contents of `useragent/lib/router.dart` with:
-
-```dart
-import 'package:auto_route/auto_route.dart';
-
-import 'router.gr.dart';
-
-@AutoRouterConfig(generateForDir: ['lib/screens'])
-class Router extends RootStackRouter {
-  @override
-  List<AutoRoute> get routes => [
-    AutoRoute(page: Bootstrap.page, path: '/bootstrap', initial: true),
-    AutoRoute(page: ServerInfoSetupRoute.page, path: '/server-info'),
-    AutoRoute(page: ServerConnectionRoute.page, path: '/server-connection'),
-    AutoRoute(page: VaultSetupRoute.page, path: '/vault'),
-    AutoRoute(page: ClientDetailsRoute.page, path: '/clients/:clientId'),
-    AutoRoute(page: CreateEvmGrantRoute.page, path: '/evm-grants/create'),
-
-    AutoRoute(
-      page: DashboardRouter.page,
-      path: '/dashboard',
-      children: [
-        AutoRoute(page: EvmRoute.page, path: 'evm'),
-        AutoRoute(page: ClientsRoute.page, path: 'clients'),
-        AutoRoute(page: EvmGrantsRoute.page, path: 'grants'),
-        AutoRoute(page: AboutRoute.page, path: 'about'),
-      ],
-    ),
-  ];
-}
-```
-
-- [ ] **Step 2: Update `dashboard.dart`**
-
-In `useragent/lib/screens/dashboard.dart`, replace the `routes` constant:
-
-```dart
-final routes = [
-  const EvmRoute(),
-  const ClientsRoute(),
-  const EvmGrantsRoute(),
-  const AboutRoute(),
-];
-```
-
-And replace the `destinations` list inside `AdaptiveScaffold`:
-
-```dart
-destinations: const [
-  NavigationDestination(
-    icon: Icon(Icons.account_balance_wallet_outlined),
-    selectedIcon: Icon(Icons.account_balance_wallet),
-    label: 'Wallets',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.devices_other_outlined),
-    selectedIcon: Icon(Icons.devices_other),
-    label: 'Clients',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.policy_outlined),
-    selectedIcon: Icon(Icons.policy),
-    label: 'Grants',
-  ),
-  NavigationDestination(
-    icon: Icon(Icons.info_outline),
-    selectedIcon: Icon(Icons.info),
-    label: 'About',
-  ),
-],
-```
-
-- [ ] **Step 3: Regenerate router**
-
-```sh
-cd useragent && dart run build_runner build --delete-conflicting-outputs
-```
-
-Expected: `lib/router.gr.dart` updated, `EvmGrantsRoute` now available, no errors.
-
-- [ ] **Step 4: Full project verify**
-
-```sh
-cd useragent && flutter analyze
-```
-
-Expected: no issues.
-
-- [ ] **Step 5: Commit**
-
-```sh
-jj describe -m "feat(nav): add Grants dashboard tab"
-jj new
-```

docs/superpowers/specs/2026-03-28-grant-grid-view-design.md

@@ -1,170 +0,0 @@
-# Grant Grid View — Design Spec
-
-**Date:** 2026-03-28
-
-## Overview
-
-Add a "Grants" dashboard tab to the Flutter user-agent app that displays all EVM grants as a card-based grid. Each card shows a compact summary (type, chain, wallet address, client name) with a revoke action. The tab integrates into the existing `AdaptiveScaffold` navigation alongside Wallets, Clients, and About.
-
-## Scope
-
-- New `walletAccessListProvider` for fetching wallet access entries with their DB row IDs
-- New `EvmGrantsScreen` as a dashboard tab
-- Grant card widget with enriched display (type, chain, wallet, client)
-- Revoke action wired to existing `executeRevokeEvmGrant` mutation
-- Dashboard tab bar and router updated
-- New token-transfer accent color added to `Palette`
-
-**Out of scope:** Fixing grant creation (separate task).
-
----
-
-## Data Layer
-
-### `walletAccessListProvider`
-
-**File:** `useragent/lib/providers/sdk_clients/wallet_access_list.dart`
-
-- `@riverpod` class, watches `connectionManagerProvider.future`
-- Returns `List<SdkClientWalletAccess>?` (null when not connected)
-- Each entry: `.id` (wallet_access_id), `.access.walletId`, `.access.sdkClientId`
-- Exposes a `refresh()` method following the same pattern as `EvmGrants.refresh()`
-
-### Enrichment at render time (Approach A)
-
-The `EvmGrantsScreen` watches four providers:
-1. `evmGrantsProvider` — the grant list
-2. `walletAccessListProvider` — to resolve wallet_access_id → (wallet_id, sdk_client_id)
-3. `evmProvider` — to resolve wallet_id → wallet address
-4. `sdkClientsProvider` — to resolve sdk_client_id → client name
-
-All lookups are in-memory Maps built inside the build method; no extra model class needed.
-
-Fallbacks:
-- Wallet address not found → `"Access #N"` where N is the wallet_access_id
-- Client name not found → `"Client #N"` where N is the sdk_client_id
-
----
-
-## Route Structure
-
-```
-/dashboard
-  /evm          ← existing (Wallets tab)
-  /clients      ← existing (Clients tab)
-  /grants       ← NEW (Grants tab)
-  /about        ← existing
-
-/evm-grants/create  ← existing push route (unchanged)
-```
-
-### Changes to `router.dart`
-
-Add inside dashboard children:
-```dart
-AutoRoute(page: EvmGrantsRoute.page, path: 'grants'),
-```
-
-### Changes to `dashboard.dart`
-
-Add to `routes` list:
-```dart
-const EvmGrantsRoute()
-```
-
-Add `NavigationDestination`:
-```dart
-NavigationDestination(
-  icon: Icon(Icons.policy_outlined),
-  selectedIcon: Icon(Icons.policy),
-  label: 'Grants',
-),
-```
-
----
-
-## Screen: `EvmGrantsScreen`
-
-**File:** `useragent/lib/screens/dashboard/evm/grants/grants.dart`
-
-```
-Scaffold
-└─ SafeArea
-   └─ RefreshIndicator.adaptive (refreshes evmGrantsProvider + walletAccessListProvider)
-      └─ ListView (BouncingScrollPhysics + AlwaysScrollableScrollPhysics)
-         ├─ PageHeader
-         │    title: 'EVM Grants'
-         │    isBusy: evmGrantsProvider.isLoading
-         │    actions: [CreateGrantButton, RefreshButton]
-         ├─ SizedBox(height: 1.8.h)
-         └─ <content>
-```
-
-### State handling
-
-Matches the pattern from `EvmScreen` and `ClientsScreen`:
-
-| State | Display |
-|---|---|
-| Loading (no data yet) | `_StatePanel` with spinner, "Loading grants" |
-| Error | `_StatePanel` with coral icon, error message, Retry button |
-| No connection | `_StatePanel`, "No active server connection" |
-| Empty list | `_StatePanel`, "No grants yet", with Create Grant shortcut |
-| Data | Column of `_GrantCard` widgets |
-
-### Header actions
-
-**CreateGrantButton:** `FilledButton.icon` with `Icons.add_rounded`, pushes `CreateEvmGrantRoute()` via `context.router.push(...)`.
-
-**RefreshButton:** `OutlinedButton.icon` with `Icons.refresh`, calls `ref.read(evmGrantsProvider.notifier).refresh()`.
-
----
-
-## Grant Card: `_GrantCard`
-
-**Layout:**
-
-```
-Container (rounded 24, Palette.cream bg, Palette.line border)
-└─ IntrinsicHeight > Row
-   ├─ Accent strip (0.8.w wide, full height, rounded left)
-   └─ Padding > Column
-        ├─ Row 1: TypeBadge + ChainChip + Spacer + RevokeButton
-        └─ Row 2: WalletText + "·" + ClientText
-```
-
-**Accent color by grant type:**
-- Ether transfer → `Palette.coral`
-- Token transfer → `Palette.token` (new entry in `Palette` — indigo, e.g. `Color(0xFF5C6BC0)`)
-
-**TypeBadge:** Small pill container with accent color background at 15% opacity, accent-colored text. Label: `'Ether'` or `'Token'`.
-
-**ChainChip:** Small container: `'Chain ${grant.shared.chainId}'`, muted ink color.
-
-**WalletText:** Short hex address (`0xabc...def`) from wallet lookup, `bodySmall`, monospace font family.
-
-**ClientText:** Client name from `sdkClientsProvider` lookup, or fallback string. `bodySmall`, muted ink.
-
-**RevokeButton:**
-- `OutlinedButton` with `Icons.block_rounded` icon, label `'Revoke'`
-- `foregroundColor: Palette.coral`, `side: BorderSide(color: Palette.coral.withValues(alpha: 0.4))`
-- Disabled (replaced with `CircularProgressIndicator`) while `revokeEvmGrantMutation` is pending — note: this is a single global mutation, so all revoke buttons disable while any revoke is in flight
-- On press: calls `executeRevokeEvmGrant(ref, grantId: grant.id)`; shows `SnackBar` on error
-
----
-
-## Adaptive Sizing
-
-All sizing uses `sizer` units (`1.h`, `1.w`, etc.). No hardcoded pixel values.
-
----
-
-## Files to Create / Modify
-
-| File | Action |
-|---|---|
-| `lib/theme/palette.dart` | Modify — add `Palette.token` color |
-| `lib/providers/sdk_clients/wallet_access_list.dart` | Create |
-| `lib/screens/dashboard/evm/grants/grants.dart` | Create |
-| `lib/router.dart` | Modify — add grants route to dashboard children |
-| `lib/screens/dashboard.dart` | Modify — add tab to routes list and NavigationDestinations |

mise.lock

@@ -1,44 +1,10 @@
-# @generated - this file is auto-generated by `mise lock` https://mise.jdx.dev/dev-tools/mise-lock.html
-
-[[tools.ast-grep]]
-version = "0.42.0"
-backend = "aqua:ast-grep/ast-grep"
-
-[tools.ast-grep."platforms.linux-arm64"]
-checksum = "sha256:5c830eae8456569e2f7212434ed9c238f58dca412d76045418ed6d394a755836"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-aarch64-unknown-linux-gnu.zip"
-
-[tools.ast-grep."platforms.linux-arm64-musl"]
-checksum = "sha256:5c830eae8456569e2f7212434ed9c238f58dca412d76045418ed6d394a755836"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-aarch64-unknown-linux-gnu.zip"
-
-[tools.ast-grep."platforms.linux-x64"]
-checksum = "sha256:e825a05603f0bcc4cd9076c4cc8c9abd6d008b7cd07d9aa3cc323ba4b8606651"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-x86_64-unknown-linux-gnu.zip"
-
-[tools.ast-grep."platforms.linux-x64-musl"]
-checksum = "sha256:e825a05603f0bcc4cd9076c4cc8c9abd6d008b7cd07d9aa3cc323ba4b8606651"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-x86_64-unknown-linux-gnu.zip"
-
-[tools.ast-grep."platforms.macos-arm64"]
-checksum = "sha256:fc300d5293b1c770a5aece03a8a193b92e71e87cec726c28096990691a582620"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-aarch64-apple-darwin.zip"
-
-[tools.ast-grep."platforms.macos-x64"]
-checksum = "sha256:979ffe611327056f4730a1ae71b0209b3b830f58b22c6ed194cda34f55400db2"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-x86_64-apple-darwin.zip"
-
-[tools.ast-grep."platforms.windows-x64"]
-checksum = "sha256:55836fa1b2c65dc7d61615a4d9368622a0d2371a76d28b9a165e5a3ab6ae32a4"
-url = "https://github.com/ast-grep/ast-grep/releases/download/0.42.0/app-x86_64-pc-windows-msvc.zip"
-
 [[tools."cargo:cargo-audit"]]
 version = "0.22.1"
 backend = "cargo:cargo-audit"
 
-[[tools."cargo:cargo-edit"]]
+[[tools."cargo:cargo-features"]]
-version = "0.13.9"
+version = "1.0.0"
-backend = "cargo:cargo-edit"
+backend = "cargo:cargo-features"
 
 [[tools."cargo:cargo-features-manager"]]
 version = "0.11.1"
@@ -53,13 +19,21 @@ version = "0.9.126"
 backend = "cargo:cargo-nextest"
 
 [[tools."cargo:cargo-shear"]]
-version = "1.11.2"
+version = "1.9.1"
 backend = "cargo:cargo-shear"
 
 [[tools."cargo:cargo-vet"]]
 version = "0.10.2"
 backend = "cargo:cargo-vet"
 
+[[tools."cargo:diesel-cli"]]
+version = "2.3.6"
+backend = "cargo:diesel-cli"
+
+[tools."cargo:diesel-cli".options]
+default-features = "false"
+features = "sqlite,sqlite-bundled"
+
 [[tools."cargo:diesel_cli"]]
 version = "2.3.6"
 backend = "cargo:diesel_cli"
@@ -75,66 +49,11 @@ backend = "asdf:flutter"
 [[tools.protoc]]
 version = "29.6"
 backend = "aqua:protocolbuffers/protobuf/protoc"
-
+"platforms.linux-arm64" = { checksum = "sha256:2594ff4fcae8cb57310d394d0961b236190ad9c5efbfdf1f597ea471d424fe79", url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-linux-aarch_64.zip"}
-[tools.protoc."platforms.linux-arm64"]
+"platforms.linux-x64" = { checksum = "sha256:48785a926e73ffa3f68e2f22b14e7b849620c7a1d36809ac9249a5495e280323", url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-linux-x86_64.zip"}
-checksum = "sha256:2594ff4fcae8cb57310d394d0961b236190ad9c5efbfdf1f597ea471d424fe79"
+"platforms.macos-arm64" = { checksum = "sha256:b9576b5fa1a1ef3fe13a8c91d9d8204b46545759bea5ae155cd6ba2ea4cdaeed", url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-osx-aarch_64.zip"}
-url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-linux-aarch_64.zip"
+"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.protoc."platforms.linux-arm64-musl"]
-checksum = "sha256:2594ff4fcae8cb57310d394d0961b236190ad9c5efbfdf1f597ea471d424fe79"
-url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-linux-aarch_64.zip"
-
-[tools.protoc."platforms.linux-x64"]
-checksum = "sha256:48785a926e73ffa3f68e2f22b14e7b849620c7a1d36809ac9249a5495e280323"
-url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-linux-x86_64.zip"
-
-[tools.protoc."platforms.linux-x64-musl"]
-checksum = "sha256:48785a926e73ffa3f68e2f22b14e7b849620c7a1d36809ac9249a5495e280323"
-url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-linux-x86_64.zip"
-
-[tools.protoc."platforms.macos-arm64"]
-checksum = "sha256:b9576b5fa1a1ef3fe13a8c91d9d8204b46545759bea5ae155cd6ba2ea4cdaeed"
-url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-osx-aarch_64.zip"
-
-[tools.protoc."platforms.macos-x64"]
-checksum = "sha256:312f04713946921cc0187ef34df80241ddca1bab6f564c636885fd2cc90d3f88"
-url = "https://github.com/protocolbuffers/protobuf/releases/download/v29.6/protoc-29.6-osx-x86_64.zip"
-
-[tools.protoc."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"
-
-[tools.python."platforms.linux-arm64"]
-checksum = "sha256:53700338695e402a1a1fe22be4a41fbdacc70e22bb308a48eca8ed67cb7992be"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz"
-
-[tools.python."platforms.linux-arm64-musl"]
-checksum = "sha256:53700338695e402a1a1fe22be4a41fbdacc70e22bb308a48eca8ed67cb7992be"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz"
-
-[tools.python."platforms.linux-x64"]
-checksum = "sha256:d7a9f970914bb4c88756fe3bdcc186d4feb90e9500e54f1db47dae4dc9687e39"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz"
-
-[tools.python."platforms.linux-x64-musl"]
-checksum = "sha256:d7a9f970914bb4c88756fe3bdcc186d4feb90e9500e54f1db47dae4dc9687e39"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz"
-
-[tools.python."platforms.macos-arm64"]
-checksum = "sha256:c43aecde4a663aebff99b9b83da0efec506479f1c3f98331442f33d2c43501f9"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-aarch64-apple-darwin-install_only_stripped.tar.gz"
-
-[tools.python."platforms.macos-x64"]
-checksum = "sha256:9ab41dbc2f100a2a45d1833b9c11165f51051c558b5213eda9a9731d5948a0c0"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-x86_64-apple-darwin-install_only_stripped.tar.gz"
-
-[tools.python."platforms.windows-x64"]
-checksum = "sha256:bbe19034b35b0267176a7442575ae7dc6343480fd4d35598cb7700173d431e09"
-url = "https://github.com/astral-sh/python-build-standalone/releases/download/20260324/cpython-3.14.3+20260324-x86_64-pc-windows-msvc-install_only_stripped.tar.gz"
 
 [[tools.rust]]
 version = "1.93.0"

mise.toml

@@ -9,14 +9,3 @@ protoc = "29.6"
 "cargo:cargo-nextest" = "0.9.126"
 "cargo:cargo-shear" = "latest"
 "cargo:cargo-insta" = "1.46.3"
-python = "3.14.3"
-ast-grep = "0.42.0"
-"cargo:cargo-edit" = "0.13.9"
-
-[tasks.codegen]
-sources = ['protobufs/*.proto', 'protobufs/**/*.proto']
-outputs = ['useragent/lib/proto/**']
-run = '''
-dart pub global activate protoc_plugin && \
-protoc --dart_out=grpc:useragent/lib/proto --proto_path=protobufs/ $(find protobufs -name '*.proto' | sort)
-'''

protobufs/arbiter.proto

@@ -2,6 +2,7 @@ syntax = "proto3";
 
 package arbiter;
 
+import "auth.proto";
 import "client.proto";
 import "user_agent.proto";
 
@@ -11,6 +12,6 @@ message ServerInfo {
 }
 
 service ArbiterService {
-  rpc Client(stream arbiter.client.ClientRequest) returns (stream arbiter.client.ClientResponse);
+  rpc Client(stream ClientRequest) returns (stream ClientResponse);
-  rpc UserAgent(stream arbiter.user_agent.UserAgentRequest) returns (stream arbiter.user_agent.UserAgentResponse);
+  rpc UserAgent(stream UserAgentRequest) returns (stream UserAgentResponse);
 }

protobufs/auth.proto

@@ -0,0 +1,35 @@
+syntax = "proto3";
+
+package arbiter.auth;
+
+import "google/protobuf/timestamp.proto";
+
+message AuthChallengeRequest {
+  bytes pubkey = 1;
+  optional string bootstrap_token = 2;
+}
+
+message AuthChallenge {
+  bytes pubkey = 1;
+  int32 nonce = 2;
+}
+
+message AuthChallengeSolution {
+  bytes signature = 1;
+}
+
+message AuthOk {}
+
+message ClientMessage {
+  oneof payload {
+    AuthChallengeRequest auth_challenge_request = 1;
+    AuthChallengeSolution auth_challenge_solution = 2;
+  }
+}
+
+message ServerMessage {
+  oneof payload {
+    AuthChallenge auth_challenge = 1;
+    AuthOk auth_ok = 2;
+  }
+}

protobufs/client.proto

@@ -1,25 +1,17 @@
 syntax = "proto3";
 
-package arbiter.client;
+package arbiter;
 
-import "client/auth.proto";
+import "auth.proto";
-import "client/evm.proto";
-import "client/vault.proto";
 
 message ClientRequest {
-  int32 request_id = 4;
   oneof payload {
-    auth.Request auth = 1;
+    arbiter.auth.ClientMessage auth_message = 1;
-    vault.Request vault = 2;
-    evm.Request evm = 3;
   }
 }
 
 message ClientResponse {
-  optional int32 request_id = 7;
   oneof payload {
-    auth.Response auth = 1;
+    arbiter.auth.ServerMessage auth_message = 1;
-    vault.Response vault = 2;
-    evm.Response evm = 3;
   }
 }

protobufs/client/auth.proto

@@ -1,43 +0,0 @@
-syntax = "proto3";
-
-package arbiter.client.auth;
-
-import "shared/client.proto";
-
-message AuthChallengeRequest {
-  bytes pubkey = 1;
-  arbiter.shared.ClientInfo client_info = 2;
-}
-
-message AuthChallenge {
-  bytes pubkey = 1;
-  int32 nonce = 2;
-}
-
-message AuthChallengeSolution {
-  bytes signature = 1;
-}
-
-enum AuthResult {
-  AUTH_RESULT_UNSPECIFIED = 0;
-  AUTH_RESULT_SUCCESS = 1;
-  AUTH_RESULT_INVALID_KEY = 2;
-  AUTH_RESULT_INVALID_SIGNATURE = 3;
-  AUTH_RESULT_APPROVAL_DENIED = 4;
-  AUTH_RESULT_NO_USER_AGENTS_ONLINE = 5;
-  AUTH_RESULT_INTERNAL = 6;
-}
-
-message Request {
-  oneof payload {
-    AuthChallengeRequest challenge_request = 1;
-    AuthChallengeSolution challenge_solution = 2;
-  }
-}
-
-message Response {
-  oneof payload {
-    AuthChallenge challenge = 1;
-    AuthResult result = 2;
-  }
-}

protobufs/client/evm.proto

@@ -1,19 +0,0 @@
-syntax = "proto3";
-
-package arbiter.client.evm;
-
-import "evm.proto";
-
-message Request {
-  oneof payload {
-    arbiter.evm.EvmSignTransactionRequest sign_transaction = 1;
-    arbiter.evm.EvmAnalyzeTransactionRequest analyze_transaction = 2;
-  }
-}
-
-message Response {
-  oneof payload {
-    arbiter.evm.EvmSignTransactionResponse sign_transaction = 1;
-    arbiter.evm.EvmAnalyzeTransactionResponse analyze_transaction = 2;
-  }
-}

protobufs/client/vault.proto

@@ -1,18 +0,0 @@
-syntax = "proto3";
-
-package arbiter.client.vault;
-
-import "google/protobuf/empty.proto";
-import "shared/vault.proto";
-
-message Request {
-  oneof payload {
-    google.protobuf.Empty query_state = 1;
-  }
-}
-
-message Response {
-  oneof payload {
-    arbiter.shared.VaultState state = 1;
-  }
-}

protobufs/evm.proto

@@ -1,153 +0,0 @@
-syntax = "proto3";
-
-package arbiter.evm;
-
-import "google/protobuf/empty.proto";
-import "google/protobuf/timestamp.proto";
-import "shared/evm.proto";
-
-enum EvmError {
-  EVM_ERROR_UNSPECIFIED = 0;
-  EVM_ERROR_VAULT_SEALED = 1;
-  EVM_ERROR_INTERNAL = 2;
-}
-
-message WalletEntry {
-  int32 id = 1;
-  bytes address = 2; // 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_access_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;
-  }
-}
-
-// --- UserAgent grant management ---
-message EvmGrantCreateRequest {
-  SharedSettings shared = 1;
-  SpecificGrant specific = 2;
-}
-
-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 wallet_access_id = 2;
-  SharedSettings shared = 3;
-  SpecificGrant specific = 4;
-}
-
-message EvmGrantListRequest {
-  optional int32 wallet_access_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]
-    arbiter.shared.evm.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 {
-    arbiter.shared.evm.SpecificMeaning meaning = 1;
-    arbiter.shared.evm.TransactionEvalError eval_error = 2;
-    EvmError error = 3;
-  }
-}

protobufs/shared/client.proto

@@ -1,9 +0,0 @@
-syntax = "proto3";
-
-package arbiter.shared;
-
-message ClientInfo {
-  string name = 1;
-  optional string description = 2;
-  optional string version = 3;
-}

protobufs/shared/evm.proto

@@ -1,68 +0,0 @@
-syntax = "proto3";
-
-package arbiter.shared.evm;
-
-import "google/protobuf/empty.proto";
-
-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;
-  }
-}
-
-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;
-  }
-}

protobufs/shared/vault.proto

@@ -1,11 +0,0 @@
-syntax = "proto3";
-
-package arbiter.shared;
-
-enum VaultState {
-  VAULT_STATE_UNSPECIFIED = 0;
-  VAULT_STATE_UNBOOTSTRAPPED = 1;
-  VAULT_STATE_SEALED = 2;
-  VAULT_STATE_UNSEALED = 3;
-  VAULT_STATE_ERROR = 4;
-}

protobufs/user_agent.proto

@@ -1,28 +1,51 @@
 syntax = "proto3";
 
-package arbiter.user_agent;
+package arbiter;
 
-import "user_agent/auth.proto";
+import "auth.proto";
-import "user_agent/evm.proto";
+import "google/protobuf/empty.proto";
-import "user_agent/sdk_client.proto";
+
-import "user_agent/vault/vault.proto";
+message UnsealStart {
+  bytes client_pubkey = 1;
+}
+
+message UnsealStartResponse {
+  bytes server_pubkey = 1;
+}
+message UnsealEncryptedKey {
+  bytes nonce = 1;
+  bytes ciphertext = 2;
+  bytes associated_data = 3;
+}
+
+enum UnsealResult {
+  UNSEAL_RESULT_UNSPECIFIED = 0;
+  UNSEAL_RESULT_SUCCESS = 1;
+  UNSEAL_RESULT_INVALID_KEY = 2;
+  UNSEAL_RESULT_UNBOOTSTRAPPED = 3;
+}
+
+enum VaultState {
+  VAULT_STATE_UNSPECIFIED = 0;
+  VAULT_STATE_UNBOOTSTRAPPED = 1;
+  VAULT_STATE_SEALED = 2;
+  VAULT_STATE_UNSEALED = 3;
+  VAULT_STATE_ERROR = 4;
+}
 
 message UserAgentRequest {
-  int32 id = 16;
   oneof payload {
-    auth.Request auth = 1;
+    arbiter.auth.ClientMessage auth_message = 1;
-    vault.Request vault = 2;
+    UnsealStart unseal_start = 2;
-    evm.Request evm = 3;
+    UnsealEncryptedKey unseal_encrypted_key = 3;
-    sdk_client.Request sdk_client = 4;
+    google.protobuf.Empty query_vault_state = 4;
   }
 }
-
 message UserAgentResponse {
-  optional int32 id = 16;
   oneof payload {
-    auth.Response auth = 1;
+    arbiter.auth.ServerMessage auth_message = 1;
-    vault.Response vault = 2;
+    UnsealStartResponse unseal_start_response = 2;
-    evm.Response evm = 3;
+    UnsealResult unseal_result = 3;
-    sdk_client.Response sdk_client = 4;
+    VaultState vault_state = 4;
   }
 }

protobufs/user_agent/auth.proto

@@ -1,48 +0,0 @@
-syntax = "proto3";
-
-package arbiter.user_agent.auth;
-
-enum KeyType {
-  KEY_TYPE_UNSPECIFIED = 0;
-  KEY_TYPE_ED25519 = 1;
-  KEY_TYPE_ECDSA_SECP256K1 = 2;
-  KEY_TYPE_RSA = 3;
-}
-
-message AuthChallengeRequest {
-  bytes pubkey = 1;
-  optional string bootstrap_token = 2;
-  KeyType key_type = 3;
-}
-
-message AuthChallenge {
-  int32 nonce = 1;
-}
-
-message AuthChallengeSolution {
-  bytes signature = 1;
-}
-
-enum AuthResult {
-  AUTH_RESULT_UNSPECIFIED = 0;
-  AUTH_RESULT_SUCCESS = 1;
-  AUTH_RESULT_INVALID_KEY = 2;
-  AUTH_RESULT_INVALID_SIGNATURE = 3;
-  AUTH_RESULT_BOOTSTRAP_REQUIRED = 4;
-  AUTH_RESULT_TOKEN_INVALID = 5;
-  AUTH_RESULT_INTERNAL = 6;
-}
-
-message Request {
-  oneof payload {
-    AuthChallengeRequest challenge_request = 1;
-    AuthChallengeSolution challenge_solution = 2;
-  }
-}
-
-message Response {
-  oneof payload {
-    AuthChallenge challenge = 1;
-    AuthResult result = 2;
-  }
-}

protobufs/user_agent/evm.proto

@@ -1,33 +0,0 @@
-syntax = "proto3";
-
-package arbiter.user_agent.evm;
-
-import "evm.proto";
-import "google/protobuf/empty.proto";
-
-message SignTransactionRequest {
-  int32 client_id = 1;
-  arbiter.evm.EvmSignTransactionRequest request = 2;
-}
-
-message Request {
-  oneof payload {
-    google.protobuf.Empty wallet_create = 1;
-    google.protobuf.Empty wallet_list = 2;
-    arbiter.evm.EvmGrantCreateRequest grant_create = 3;
-    arbiter.evm.EvmGrantDeleteRequest grant_delete = 4;
-    arbiter.evm.EvmGrantListRequest grant_list = 5;
-    SignTransactionRequest sign_transaction = 6;
-  }
-}
-
-message Response {
-  oneof payload {
-    arbiter.evm.WalletCreateResponse wallet_create = 1;
-    arbiter.evm.WalletListResponse wallet_list = 2;
-    arbiter.evm.EvmGrantCreateResponse grant_create = 3;
-    arbiter.evm.EvmGrantDeleteResponse grant_delete = 4;
-    arbiter.evm.EvmGrantListResponse grant_list = 5;
-    arbiter.evm.EvmSignTransactionResponse sign_transaction = 6;
-  }
-}

protobufs/user_agent/sdk_client.proto

@@ -1,100 +0,0 @@
-syntax = "proto3";
-
-package arbiter.user_agent.sdk_client;
-
-import "shared/client.proto";
-import "google/protobuf/empty.proto";
-
-enum Error {
-  ERROR_UNSPECIFIED = 0;
-  ERROR_ALREADY_EXISTS = 1;
-  ERROR_NOT_FOUND = 2;
-  ERROR_HAS_RELATED_DATA = 3; // hard-delete blocked by FK (client has grants or transaction logs)
-  ERROR_INTERNAL = 4;
-}
-
-message RevokeRequest {
-  int32 client_id = 1;
-}
-
-message Entry {
-  int32 id = 1;
-  bytes pubkey = 2;
-  arbiter.shared.ClientInfo info = 3;
-  int32 created_at = 4;
-}
-
-message List {
-  repeated Entry clients = 1;
-}
-
-message RevokeResponse {
-  oneof result {
-    google.protobuf.Empty ok = 1;
-    Error error = 2;
-  }
-}
-
-message ListResponse {
-  oneof result {
-    List clients = 1;
-    Error error = 2;
-  }
-}
-
-message ConnectionRequest {
-  bytes pubkey = 1;
-  arbiter.shared.ClientInfo info = 2;
-}
-
-message ConnectionResponse {
-  bool approved = 1;
-  bytes pubkey = 2;
-}
-
-message ConnectionCancel {
-  bytes pubkey = 1;
-}
-
-message WalletAccess {
-  int32 wallet_id = 1;
-  int32 sdk_client_id = 2;
-}
-
-message WalletAccessEntry {
-  int32 id = 1;
-  WalletAccess access = 2;
-}
-
-message GrantWalletAccess {
-  repeated WalletAccess accesses = 1;
-}
-
-message RevokeWalletAccess {
-  repeated int32 accesses = 1;
-}
-
-message ListWalletAccessResponse {
-  repeated WalletAccessEntry accesses = 1;
-}
-
-message Request {
-  oneof payload {
-    ConnectionResponse connection_response = 1;
-    RevokeRequest revoke = 2;
-    google.protobuf.Empty list = 3;
-    GrantWalletAccess grant_wallet_access = 4;
-    RevokeWalletAccess revoke_wallet_access = 5;
-    google.protobuf.Empty list_wallet_access = 6;
-  }
-}
-
-message Response {
-  oneof payload {
-    ConnectionRequest connection_request = 1;
-    ConnectionCancel connection_cancel = 2;
-    RevokeResponse revoke = 3;
-    ListResponse list = 4;
-    ListWalletAccessResponse list_wallet_access = 5;
-  }
-}

protobufs/user_agent/vault/bootstrap.proto

@@ -1,24 +0,0 @@
-syntax = "proto3";
-
-package arbiter.user_agent.vault.bootstrap;
-
-message BootstrapEncryptedKey {
-  bytes nonce = 1;
-  bytes ciphertext = 2;
-  bytes associated_data = 3;
-}
-
-enum BootstrapResult {
-  BOOTSTRAP_RESULT_UNSPECIFIED = 0;
-  BOOTSTRAP_RESULT_SUCCESS = 1;
-  BOOTSTRAP_RESULT_ALREADY_BOOTSTRAPPED = 2;
-  BOOTSTRAP_RESULT_INVALID_KEY = 3;
-}
-
-message Request {
-  BootstrapEncryptedKey encrypted_key = 2;
-}
-
-message Response {
-  BootstrapResult result = 1;
-}

protobufs/user_agent/vault/unseal.proto

@@ -1,37 +0,0 @@
-syntax = "proto3";
-
-package arbiter.user_agent.vault.unseal;
-
-message UnsealStart {
-  bytes client_pubkey = 1;
-}
-
-message UnsealStartResponse {
-  bytes server_pubkey = 1;
-}
-message UnsealEncryptedKey {
-  bytes nonce = 1;
-  bytes ciphertext = 2;
-  bytes associated_data = 3;
-}
-
-enum UnsealResult {
-  UNSEAL_RESULT_UNSPECIFIED = 0;
-  UNSEAL_RESULT_SUCCESS = 1;
-  UNSEAL_RESULT_INVALID_KEY = 2;
-  UNSEAL_RESULT_UNBOOTSTRAPPED = 3;
-}
-
-message Request {
-  oneof payload {
-    UnsealStart start = 1;
-    UnsealEncryptedKey encrypted_key = 2;
-  }
-}
-
-message Response {
-  oneof payload {
-    UnsealStartResponse start = 1;
-    UnsealResult result = 2;
-  }
-}

protobufs/user_agent/vault/vault.proto

@@ -1,24 +0,0 @@
-syntax = "proto3";
-
-package arbiter.user_agent.vault;
-
-import "google/protobuf/empty.proto";
-import "shared/vault.proto";
-import "user_agent/vault/bootstrap.proto";
-import "user_agent/vault/unseal.proto";
-
-message Request {
-  oneof payload {
-    google.protobuf.Empty query_state = 1;
-    unseal.Request unseal = 2;
-    bootstrap.Request bootstrap = 3;
-  }
-}
-
-message Response {
-  oneof payload {
-    arbiter.shared.VaultState state = 1;
-    unseal.Response unseal = 2;
-    bootstrap.Response bootstrap = 3;
-  }
-}

scripts/gen_erc20_registry.py

@@ -1,150 +0,0 @@
-#!/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/audit.toml

@@ -1,13 +0,0 @@
-[advisories]
-# RUSTSEC-2023-0071: Marvin Attack timing side-channel in rsa crate.
-# No fixed version is available upstream.
-# RSA support is required for Windows Hello / KeyCredentialManager
-# (https://learn.microsoft.com/en-us/uwp/api/windows.security.credentials.keycredentialmanager.requestcreateasync),
-# which only issues RSA-2048 keys.
-# Mitigations in place:
-#   - Signing uses BlindedSigningKey (PSS+SHA-256), which applies blinding to
-#     protect the private key from timing recovery during signing.
-#   - RSA decryption is never performed; we only verify public-key signatures.
-#   - The attack requires local, high-resolution timing access against the
-#     signing process, which is not exposed in our threat model.
-ignore = ["RUSTSEC-2023-0071"]

server/Cargo.toml

@@ -1,45 +1,34 @@
 [workspace]
 members = [
-    "crates/*",
+    "crates/arbiter-client",
+    "crates/arbiter-proto",
+    "crates/arbiter-server",
+    "crates/arbiter-useragent",
 ]
 resolver = "3"
 
-[workspace.lints.clippy]
-disallowed-methods = "deny"
-
 
 [workspace.dependencies]
-tonic = { version = "0.14.5", features = [
+tonic = { version = "0.14.3", features = ["deflate", "gzip", "tls-connect-info", "zstd"] }
-    "deflate",
-    "gzip",
-    "tls-connect-info",
-    "zstd",
-] }
 tracing = "0.1.44"
-tokio = { version = "1.50.0", features = ["full"] }
+tokio = { version = "1.49.0", features = ["full"] }
 ed25519-dalek = { version = "3.0.0-pre.6", features = ["rand_core"] }
-chrono = { version = "0.4.44", features = ["serde"] }
+chrono = { version = "0.4.43", features = ["serde"] }
 rand = "0.10.0"
-rustls = { version = "0.23.37", features = ["aws-lc-rs"] }
+rustls = "0.23.36"
 smlang = "0.8.0"
 miette = { version = "7.6.0", features = ["fancy", "serde"] }
 thiserror = "2.0.18"
 async-trait = "0.1.89"
-futures = "0.3.32"
+futures = "0.3.31"
 tokio-stream = { version = "0.1.18", features = ["full"] }
 kameo = "0.19.2"
-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",
     "x509-parser",
     "zeroize",
 ], default-features = false }
-k256 = { version = "0.13.4", features = ["ecdsa", "pkcs8"] }
-rsa = { version = "0.9", features = ["sha2"] }
-sha2 = "0.10"
-spki = "0.7"

server/clippy.toml

@@ -1,9 +0,0 @@
-disallowed-methods = [
-    # RSA decryption is forbidden: the rsa crate has RUSTSEC-2023-0071 (Marvin Attack).
-    # We only use RSA for Windows Hello (KeyCredentialManager) public-key verification — decryption
-    # is never required and must not be introduced.
-    { path = "rsa::RsaPrivateKey::decrypt", reason = "RSA decryption is forbidden (RUSTSEC-2023-0071 Marvin Attack). Only PSS signing/verification is permitted." },
-    { path = "rsa::RsaPrivateKey::decrypt_blinded", reason = "RSA decryption is forbidden (RUSTSEC-2023-0071 Marvin Attack). Only PSS signing/verification is permitted." },
-    { path = "rsa::traits::Decryptor::decrypt", reason = "RSA decryption is forbidden (RUSTSEC-2023-0071 Marvin Attack). This blocks decrypt() on rsa::{pkcs1v15,oaep}::DecryptingKey." },
-    { path = "rsa::traits::RandomizedDecryptor::decrypt_with_rng", reason = "RSA decryption is forbidden (RUSTSEC-2023-0071 Marvin Attack). This blocks decrypt_with_rng() on rsa::{pkcs1v15,oaep}::DecryptingKey." },
-]

server/crates/arbiter-client/Cargo.toml

@@ -5,22 +5,4 @@ edition = "2024"
 repository = "https://git.markettakers.org/MarketTakers/arbiter"
 license = "Apache-2.0"
 
-[lints]
-workspace = true
-
-[features]
-evm = ["dep:alloy"]
-
 [dependencies]
-arbiter-proto.path = "../arbiter-proto"
-alloy = { workspace = true, optional = true }
-tonic.workspace = true
-tonic.features = ["tls-aws-lc"]
-tokio.workspace = true
-tokio-stream.workspace = true
-ed25519-dalek.workspace = true
-thiserror.workspace = true
-http = "1.4.0"
-rustls-webpki = { version = "0.103.10", features = ["aws-lc-rs"] }
-async-trait.workspace = true
-rand.workspace = true

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

@@ -1,151 +0,0 @@
-use arbiter_proto::{
-    ClientMetadata, format_challenge,
-    proto::{
-        client::{
-            ClientRequest,
-            auth::{
-                self as proto_auth, AuthChallenge, AuthChallengeRequest, AuthChallengeSolution,
-                AuthResult, request::Payload as AuthRequestPayload,
-                response::Payload as AuthResponsePayload,
-            },
-            client_request::Payload as ClientRequestPayload,
-            client_response::Payload as ClientResponsePayload,
-        },
-        shared::ClientInfo as ProtoClientInfo,
-    },
-};
-use ed25519_dalek::Signer as _;
-
-use crate::{
-    storage::StorageError,
-    transport::{ClientTransport, next_request_id},
-};
-
-#[derive(Debug, thiserror::Error)]
-pub enum AuthError {
-    #[error("Auth challenge was not returned by server")]
-    MissingAuthChallenge,
-
-    #[error("Client approval denied by User Agent")]
-    ApprovalDenied,
-
-    #[error("No User Agents online to approve client")]
-    NoUserAgentsOnline,
-
-    #[error("Unexpected auth response payload")]
-    UnexpectedAuthResponse,
-
-    #[error("Signing key storage error")]
-    Storage(#[from] StorageError),
-}
-
-fn map_auth_result(code: i32) -> AuthError {
-    match AuthResult::try_from(code).unwrap_or(AuthResult::Unspecified) {
-        AuthResult::ApprovalDenied => AuthError::ApprovalDenied,
-        AuthResult::NoUserAgentsOnline => AuthError::NoUserAgentsOnline,
-        AuthResult::Unspecified
-        | AuthResult::Success
-        | AuthResult::InvalidKey
-        | AuthResult::InvalidSignature
-        | AuthResult::Internal => AuthError::UnexpectedAuthResponse,
-    }
-}
-
-async fn send_auth_challenge_request(
-    transport: &mut ClientTransport,
-    metadata: ClientMetadata,
-    key: &ed25519_dalek::SigningKey,
-) -> std::result::Result<(), AuthError> {
-    transport
-        .send(ClientRequest {
-            request_id: next_request_id(),
-            payload: Some(ClientRequestPayload::Auth(proto_auth::Request {
-                payload: Some(AuthRequestPayload::ChallengeRequest(AuthChallengeRequest {
-                    pubkey: key.verifying_key().to_bytes().to_vec(),
-                    client_info: Some(ProtoClientInfo {
-                        name: metadata.name,
-                        description: metadata.description,
-                        version: metadata.version,
-                    }),
-                })),
-            })),
-        })
-        .await
-        .map_err(|_| AuthError::UnexpectedAuthResponse)
-}
-
-async fn receive_auth_challenge(
-    transport: &mut ClientTransport,
-) -> std::result::Result<AuthChallenge, AuthError> {
-    let response = transport
-        .recv()
-        .await
-        .map_err(|_| AuthError::MissingAuthChallenge)?;
-
-    let payload = response.payload.ok_or(AuthError::MissingAuthChallenge)?;
-    match payload {
-        ClientResponsePayload::Auth(response) => match response.payload {
-            Some(AuthResponsePayload::Challenge(challenge)) => Ok(challenge),
-            Some(AuthResponsePayload::Result(result)) => Err(map_auth_result(result)),
-            None => Err(AuthError::MissingAuthChallenge),
-        },
-        _ => Err(AuthError::UnexpectedAuthResponse),
-    }
-}
-
-async fn send_auth_challenge_solution(
-    transport: &mut ClientTransport,
-    key: &ed25519_dalek::SigningKey,
-    challenge: AuthChallenge,
-) -> std::result::Result<(), AuthError> {
-    let challenge_payload = format_challenge(challenge.nonce, &challenge.pubkey);
-    let signature = key.sign(&challenge_payload).to_bytes().to_vec();
-
-    transport
-        .send(ClientRequest {
-            request_id: next_request_id(),
-            payload: Some(ClientRequestPayload::Auth(proto_auth::Request {
-                payload: Some(AuthRequestPayload::ChallengeSolution(
-                    AuthChallengeSolution { signature },
-                )),
-            })),
-        })
-        .await
-        .map_err(|_| AuthError::UnexpectedAuthResponse)
-}
-
-async fn receive_auth_confirmation(
-    transport: &mut ClientTransport,
-) -> std::result::Result<(), AuthError> {
-    let response = transport
-        .recv()
-        .await
-        .map_err(|_| AuthError::UnexpectedAuthResponse)?;
-
-    let payload = response
-        .payload
-        .ok_or(AuthError::UnexpectedAuthResponse)?;
-    match payload {
-        ClientResponsePayload::Auth(response) => match response.payload {
-            Some(AuthResponsePayload::Result(result))
-                if AuthResult::try_from(result).ok() == Some(AuthResult::Success) =>
-            {
-                Ok(())
-            }
-            Some(AuthResponsePayload::Result(result)) => Err(map_auth_result(result)),
-            _ => Err(AuthError::UnexpectedAuthResponse),
-        },
-        _ => Err(AuthError::UnexpectedAuthResponse),
-    }
-}
-
-pub(crate) async fn authenticate(
-    transport: &mut ClientTransport,
-    metadata: ClientMetadata,
-    key: &ed25519_dalek::SigningKey,
-) -> std::result::Result<(), AuthError> {
-    send_auth_challenge_request(transport, metadata, key).await?;
-    let challenge = receive_auth_challenge(transport).await?;
-    send_auth_challenge_solution(transport, key, challenge).await?;
-    receive_auth_confirmation(transport).await
-}

server/crates/arbiter-client/src/bin/test_connect.rs

@@ -1,47 +0,0 @@
-
-use std::io::{self, Write};
-
-use arbiter_client::ArbiterClient;
-use arbiter_proto::{ClientMetadata, url::ArbiterUrl};
-
-#[tokio::main]
-async fn main() {
-    println!("Testing connection to Arbiter server...");
-    print!("Enter ArbiterUrl: ");
-    let _ = io::stdout().flush();
-
-    let mut input = String::new();
-    if let Err(err) = io::stdin().read_line(&mut input) {
-        eprintln!("Failed to read input: {err}");
-        return;
-    }
-
-    let input = input.trim();
-    if input.is_empty() {
-        eprintln!("ArbiterUrl cannot be empty");
-        return;
-    }
-
-   
-
-    let url = match ArbiterUrl::try_from(input) {
-        Ok(url) => url,
-        Err(err) => {
-            eprintln!("Invalid ArbiterUrl: {err}");
-            return;
-        }
-    };
-
-     println!("{:#?}", url);
-
-    let metadata = ClientMetadata {
-        name: "arbiter-client test_connect".to_string(),
-        description: Some("Manual connection smoke test".to_string()),
-        version: Some(env!("CARGO_PKG_VERSION").to_string()),
-    };
-
-    match ArbiterClient::connect(url, metadata).await {
-        Ok(_) => println!("Connected and authenticated successfully."),
-        Err(err) => eprintln!("Failed to connect: {:#?}", err),
-    }
-}

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

@@ -1,89 +0,0 @@
-use arbiter_proto::{ClientMetadata, proto::arbiter_service_client::ArbiterServiceClient, url::ArbiterUrl};
-use std::sync::Arc;
-use tokio::sync::{Mutex, mpsc};
-use tokio_stream::wrappers::ReceiverStream;
-use tonic::transport::ClientTlsConfig;
-
-use crate::{
-    StorageError, auth::{AuthError, authenticate}, storage::{FileSigningKeyStorage, SigningKeyStorage}, transport::{BUFFER_LENGTH, ClientTransport}
-};
-
-#[cfg(feature = "evm")]
-use crate::wallets::evm::ArbiterEvmWallet;
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("gRPC error")]
-    Grpc(#[from] tonic::Status),
-
-    #[error("Could not establish connection")]
-    Connection(#[from] tonic::transport::Error),
-
-    #[error("Invalid server URI")]
-    InvalidUri(#[from] http::uri::InvalidUri),
-
-    #[error("Invalid CA certificate")]
-    InvalidCaCert(#[from] webpki::Error),
-
-    #[error("Authentication error")]
-    Authentication(#[from] AuthError),
-
-    #[error("Storage error")]
-    Storage(#[from] StorageError),
-    
-}
-
-pub struct ArbiterClient {
-    #[allow(dead_code)]
-    transport: Arc<Mutex<ClientTransport>>,
-}
-
-impl ArbiterClient {
-    pub async fn connect(url: ArbiterUrl, metadata: ClientMetadata) -> Result<Self, Error> {
-        let storage = FileSigningKeyStorage::from_default_location()?;
-        Self::connect_with_storage(url, metadata, &storage).await
-    }
-
-    pub async fn connect_with_storage<S: SigningKeyStorage>(
-        url: ArbiterUrl,
-        metadata: ClientMetadata,
-        storage: &S,
-    ) -> Result<Self, Error> {
-        let key = storage.load_or_create()?;
-        Self::connect_with_key(url, metadata, key).await
-    }
-
-    pub async fn connect_with_key(
-        url: ArbiterUrl,
-        metadata: ClientMetadata,
-        key: ed25519_dalek::SigningKey,
-    ) -> Result<Self, Error> {
-        let anchor = webpki::anchor_from_trusted_cert(&url.ca_cert)?.to_owned();
-        let tls = ClientTlsConfig::new().trust_anchor(anchor);
-
-        let channel = tonic::transport::Channel::from_shared(format!("https://{}:{}", url.host, url.port))?
-            .tls_config(tls)?
-            .connect()
-            .await?;
-
-        let mut client = ArbiterServiceClient::new(channel);
-        let (tx, rx) = mpsc::channel(BUFFER_LENGTH);
-        let response_stream = client.client(ReceiverStream::new(rx)).await?.into_inner();
-
-        let mut transport = ClientTransport {
-            sender: tx,
-            receiver: response_stream,
-        };
-
-        authenticate(&mut transport, metadata, &key).await?;
-
-        Ok(Self {
-            transport: Arc::new(Mutex::new(transport)),
-        })
-    }
-
-    #[cfg(feature = "evm")]
-    pub async fn evm_wallets(&self) -> Result<Vec<ArbiterEvmWallet>, Error> {
-        todo!("fetch EVM wallet list from server")
-    }
-}

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

@@ -1,12 +1,14 @@
-mod auth;
+pub fn add(left: u64, right: u64) -> u64 {
-mod client;
+    left + right
-mod storage;
+}
-mod transport;
-pub mod wallets;
 
-pub use auth::AuthError;
+#[cfg(test)]
-pub use client::{ArbiterClient, Error};
+mod tests {
-pub use storage::{FileSigningKeyStorage, SigningKeyStorage, StorageError};
+    use super::*;
 
-#[cfg(feature = "evm")]
+    #[test]
-pub use wallets::evm::ArbiterEvmWallet;
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
+    }
+}

server/crates/arbiter-client/src/storage.rs

@@ -1,132 +0,0 @@
-use arbiter_proto::home_path;
-use std::path::{Path, PathBuf};
-
-#[derive(Debug, thiserror::Error)]
-pub enum StorageError {
-    #[error("I/O error")]
-    Io(#[from] std::io::Error),
-
-    #[error("Invalid signing key length in storage: expected {expected} bytes, got {actual} bytes")]
-    InvalidKeyLength { expected: usize, actual: usize },
-}
-
-pub trait SigningKeyStorage {
-    fn load_or_create(&self) -> std::result::Result<ed25519_dalek::SigningKey, StorageError>;
-}
-
-#[derive(Debug, Clone)]
-pub struct FileSigningKeyStorage {
-    path: PathBuf,
-}
-
-impl FileSigningKeyStorage {
-    pub const DEFAULT_FILE_NAME: &str = "sdk_client_ed25519.key";
-
-    pub fn new(path: impl Into<PathBuf>) -> Self {
-        Self { path: path.into() }
-    }
-
-    pub fn from_default_location() -> std::result::Result<Self, StorageError> {
-        Ok(Self::new(home_path()?.join(Self::DEFAULT_FILE_NAME)))
-    }
-
-    fn read_key(path: &Path) -> std::result::Result<ed25519_dalek::SigningKey, StorageError> {
-        let bytes = std::fs::read(path)?;
-        let raw: [u8; 32] =
-            bytes
-                .try_into()
-                .map_err(|v: Vec<u8>| StorageError::InvalidKeyLength {
-                    expected: 32,
-                    actual: v.len(),
-                })?;
-        Ok(ed25519_dalek::SigningKey::from_bytes(&raw))
-    }
-}
-
-impl SigningKeyStorage for FileSigningKeyStorage {
-    fn load_or_create(&self) -> std::result::Result<ed25519_dalek::SigningKey, StorageError> {
-        if let Some(parent) = self.path.parent() {
-            std::fs::create_dir_all(parent)?;
-        }
-
-        if self.path.exists() {
-            return Self::read_key(&self.path);
-        }
-
-        let key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
-        let raw_key = key.to_bytes();
-
-        // Use create_new to prevent accidental overwrite if another process creates the key first.
-        match std::fs::OpenOptions::new()
-            .create_new(true)
-            .write(true)
-            .open(&self.path)
-        {
-            Ok(mut file) => {
-                use std::io::Write as _;
-                file.write_all(&raw_key)?;
-                Ok(key)
-            }
-            Err(err) if err.kind() == std::io::ErrorKind::AlreadyExists => {
-                Self::read_key(&self.path)
-            }
-            Err(err) => Err(StorageError::Io(err)),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{FileSigningKeyStorage, SigningKeyStorage, StorageError};
-
-    fn unique_temp_key_path() -> std::path::PathBuf {
-        let nanos = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .expect("clock should be after unix epoch")
-            .as_nanos();
-        std::env::temp_dir().join(format!(
-            "arbiter-client-key-{}-{}.bin",
-            std::process::id(),
-            nanos
-        ))
-    }
-
-    #[test]
-    fn file_storage_creates_and_reuses_key() {
-        let path = unique_temp_key_path();
-        let storage = FileSigningKeyStorage::new(path.clone());
-
-        let key_a = storage
-            .load_or_create()
-            .expect("first load_or_create should create key");
-        let key_b = storage
-            .load_or_create()
-            .expect("second load_or_create should read same key");
-
-        assert_eq!(key_a.to_bytes(), key_b.to_bytes());
-        assert!(path.exists());
-
-        std::fs::remove_file(path).expect("temp key file should be removable");
-    }
-
-    #[test]
-    fn file_storage_rejects_invalid_key_length() {
-        let path = unique_temp_key_path();
-        std::fs::write(&path, [42u8; 31]).expect("should write invalid key file");
-        let storage = FileSigningKeyStorage::new(path.clone());
-
-        let err = storage
-            .load_or_create()
-            .expect_err("storage should reject non-32-byte key file");
-
-        match err {
-            StorageError::InvalidKeyLength { expected, actual } => {
-                assert_eq!(expected, 32);
-                assert_eq!(actual, 31);
-            }
-            other => panic!("unexpected error: {other:?}"),
-        }
-
-        std::fs::remove_file(path).expect("temp key file should be removable");
-    }
-}

server/crates/arbiter-client/src/transport.rs

@@ -1,44 +0,0 @@
-use arbiter_proto::proto::client::{ClientRequest, ClientResponse};
-use std::sync::atomic::{AtomicI32, Ordering};
-use tokio::sync::mpsc;
-
-pub(crate) const BUFFER_LENGTH: usize = 16;
-static NEXT_REQUEST_ID: AtomicI32 = AtomicI32::new(1);
-
-pub(crate) fn next_request_id() -> i32 {
-    NEXT_REQUEST_ID.fetch_add(1, Ordering::Relaxed)
-}
-
-#[derive(Debug, thiserror::Error)]
-pub(crate) enum ClientSignError {
-    #[error("Transport channel closed")]
-    ChannelClosed,
-
-    #[error("Connection closed by server")]
-    ConnectionClosed,
-}
-
-pub(crate) struct ClientTransport {
-    pub(crate) sender: mpsc::Sender<ClientRequest>,
-    pub(crate) receiver: tonic::Streaming<ClientResponse>,
-}
-
-impl ClientTransport {
-    pub(crate) async fn send(
-        &mut self,
-        request: ClientRequest,
-    ) -> std::result::Result<(), ClientSignError> {
-        self.sender
-            .send(request)
-            .await
-            .map_err(|_| ClientSignError::ChannelClosed)
-    }
-
-    pub(crate) async fn recv(&mut self) -> std::result::Result<ClientResponse, ClientSignError> {
-        match self.receiver.message().await {
-            Ok(Some(resp)) => Ok(resp),
-            Ok(None) => Err(ClientSignError::ConnectionClosed),
-            Err(_) => Err(ClientSignError::ConnectionClosed),
-        }
-    }
-}

server/crates/arbiter-client/src/wallets/evm.rs

@@ -1,147 +0,0 @@
-use alloy::{
-    consensus::SignableTransaction,
-    network::TxSigner,
-    primitives::{Address, B256, ChainId, Signature},
-    signers::{Error, Result, Signer},
-};
-use async_trait::async_trait;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-use arbiter_proto::proto::{
-    client::{
-        ClientRequest, client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    },
-    evm::evm_sign_transaction_response::Result as EvmSignTransactionResult,
-};
-
-use crate::transport::{ClientTransport, next_request_id};
-
-pub struct ArbiterEvmWallet {
-    transport: Arc<Mutex<ClientTransport>>,
-    address: Address,
-    chain_id: Option<ChainId>,
-}
-
-impl ArbiterEvmWallet {
-    pub(crate) fn new(transport: Arc<Mutex<ClientTransport>>, address: Address) -> Self {
-        Self {
-            transport,
-            address,
-            chain_id: None,
-        }
-    }
-
-    pub fn address(&self) -> Address {
-        self.address
-    }
-
-    pub fn with_chain_id(mut self, chain_id: ChainId) -> Self {
-        self.chain_id = Some(chain_id);
-        self
-    }
-
-    fn validate_chain_id(&self, tx: &mut dyn SignableTransaction<Signature>) -> Result<()> {
-        if let Some(chain_id) = self.chain_id
-            && !tx.set_chain_id_checked(chain_id)
-        {
-            return Err(Error::TransactionChainIdMismatch {
-                signer: chain_id,
-                tx: tx.chain_id().unwrap(),
-            });
-        }
-
-        Ok(())
-    }
-}
-
-#[async_trait]
-impl Signer for ArbiterEvmWallet {
-    async fn sign_hash(&self, _hash: &B256) -> Result<Signature> {
-        Err(Error::other(
-            "hash-only signing is not supported for ArbiterEvmWallet; use transaction signing",
-        ))
-    }
-
-    fn address(&self) -> Address {
-        self.address
-    }
-
-    fn chain_id(&self) -> Option<ChainId> {
-        self.chain_id
-    }
-
-    fn set_chain_id(&mut self, chain_id: Option<ChainId>) {
-        self.chain_id = chain_id;
-    }
-}
-
-#[async_trait]
-impl TxSigner<Signature> for ArbiterEvmWallet {
-    fn address(&self) -> Address {
-        self.address
-    }
-
-    async fn sign_transaction(
-        &self,
-        tx: &mut dyn SignableTransaction<Signature>,
-    ) -> Result<Signature> {
-        self.validate_chain_id(tx)?;
-
-        let mut transport = self.transport.lock().await;
-        let request_id = next_request_id();
-        let rlp_transaction = tx.encoded_for_signing();
-
-        transport
-            .send(ClientRequest {
-                request_id,
-                payload: Some(ClientRequestPayload::EvmSignTransaction(
-                    arbiter_proto::proto::evm::EvmSignTransactionRequest {
-                        wallet_address: self.address.to_vec(),
-                        rlp_transaction,
-                    },
-                )),
-            })
-            .await
-            .map_err(|_| Error::other("failed to send evm sign transaction request"))?;
-
-        let response = transport
-            .recv()
-            .await
-            .map_err(|_| Error::other("failed to receive evm sign transaction response"))?;
-
-        if response.request_id != Some(request_id) {
-            return Err(Error::other(
-                "received mismatched response id for evm sign transaction",
-            ));
-        }
-
-        let payload = response
-            .payload
-            .ok_or_else(|| Error::other("missing evm sign transaction response payload"))?;
-
-        let ClientResponsePayload::EvmSignTransaction(response) = payload else {
-            return Err(Error::other(
-                "unexpected response payload for evm sign transaction request",
-            ));
-        };
-
-        let result = response
-            .result
-            .ok_or_else(|| Error::other("missing evm sign transaction result"))?;
-
-        match result {
-            EvmSignTransactionResult::Signature(signature) => {
-                Signature::try_from(signature.as_slice())
-                    .map_err(|_| Error::other("invalid signature returned by server"))
-            }
-            EvmSignTransactionResult::EvalError(eval_error) => Err(Error::other(format!(
-                "transaction rejected by policy: {eval_error:?}"
-            ))),
-            EvmSignTransactionResult::Error(code) => Err(Error::other(format!(
-                "server failed to sign transaction with error code {code}"
-            ))),
-        }
-    }
-}

server/crates/arbiter-client/src/wallets/mod.rs

@@ -1,2 +0,0 @@
-#[cfg(feature = "evm")]
-pub mod evm;

server/crates/arbiter-proto/Cargo.toml

@@ -9,8 +9,7 @@ license = "Apache-2.0"
 tonic.workspace = true
 tokio.workspace = true
 futures.workspace = true
-hex = "0.4.3"
+tonic-prost = "0.14.3"
-tonic-prost = "0.14.5"
 prost = "0.14.3"
 kameo.workspace = true
 url = "2.5.8"
@@ -18,14 +17,11 @@ miette.workspace = true
 thiserror.workspace = true
 rustls-pki-types.workspace = true
 base64 = "0.22.1"
-prost-types.workspace = true
 tracing.workspace = true
-async-trait.workspace = true
+
-tokio-stream.workspace = true
 
 [build-dependencies]
-tonic-prost-build = "0.14.5"
+tonic-prost-build = "0.14.3"
-protoc-bin-vendored = "3"
 
 [dev-dependencies]
 rstest.workspace = true
@@ -34,3 +30,5 @@ rcgen.workspace = true
 
 [package.metadata.cargo-shear]
 ignored = ["tonic-prost", "prost", "kameo"]
+
+

server/crates/arbiter-proto/build.rs

@@ -3,6 +3,7 @@ use tonic_prost_build::configure;
 static PROTOBUF_DIR: &str = "../../../protobufs";
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+
     println!("cargo::rerun-if-changed={PROTOBUF_DIR}");
 
     configure()
@@ -10,12 +11,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         .compile_protos(
             &[
                 format!("{}/arbiter.proto", PROTOBUF_DIR),
-                format!("{}/user_agent.proto", PROTOBUF_DIR),
+                format!("{}/auth.proto", PROTOBUF_DIR),
-                format!("{}/client.proto", PROTOBUF_DIR),
-                format!("{}/evm.proto", PROTOBUF_DIR),
             ],
             &[PROTOBUF_DIR.to_string()],
         )
+        
         .unwrap();
     Ok(())
 }

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

@@ -3,71 +3,14 @@ pub mod url;
 
 use base64::{Engine, prelude::BASE64_STANDARD};
 
+use crate::proto::auth::AuthChallenge;
+
 pub mod proto {
     tonic::include_proto!("arbiter");
 
-    pub mod shared {
+    pub mod auth {
-        tonic::include_proto!("arbiter.shared");
+        tonic::include_proto!("arbiter.auth");
-
-        pub mod evm {
-            tonic::include_proto!("arbiter.shared.evm");
-        }
     }
-
-    pub mod user_agent {
-        tonic::include_proto!("arbiter.user_agent");
-
-        pub mod auth {
-            tonic::include_proto!("arbiter.user_agent.auth");
-        }
-
-        pub mod evm {
-            tonic::include_proto!("arbiter.user_agent.evm");
-        }
-
-        pub mod sdk_client {
-            tonic::include_proto!("arbiter.user_agent.sdk_client");
-        }
-
-        pub mod vault {
-            tonic::include_proto!("arbiter.user_agent.vault");
-
-            pub mod bootstrap {
-                tonic::include_proto!("arbiter.user_agent.vault.bootstrap");
-            }
-
-            pub mod unseal {
-                tonic::include_proto!("arbiter.user_agent.vault.unseal");
-            }
-        }
-    }
-
-    pub mod client {
-        tonic::include_proto!("arbiter.client");
-
-        pub mod auth {
-            tonic::include_proto!("arbiter.client.auth");
-        }
-
-        pub mod evm {
-            tonic::include_proto!("arbiter.client.evm");
-        }
-
-        pub mod vault {
-            tonic::include_proto!("arbiter.client.vault");
-        }
-    }
-
-    pub mod evm {
-        tonic::include_proto!("arbiter.evm");
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ClientMetadata {
-    pub name: String,
-    pub description: Option<String>,
-    pub version: Option<String>,
 }
 
 pub static BOOTSTRAP_PATH: &str = "bootstrap_token";
@@ -85,7 +28,7 @@ pub fn home_path() -> Result<std::path::PathBuf, std::io::Error> {
     Ok(arbiter_home)
 }
 
-pub fn format_challenge(nonce: i32, pubkey: &[u8]) -> Vec<u8> {
+pub fn format_challenge(challenge: &AuthChallenge) -> Vec<u8> {
-    let concat_form = format!("{}:{}", nonce, BASE64_STANDARD.encode(pubkey));
+    let concat_form = format!("{}:{}", challenge.nonce, BASE64_STANDARD.encode(&challenge.pubkey));
-    concat_form.into_bytes()
+    concat_form.into_bytes().to_vec()
 }

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

@@ -1,163 +1,371 @@
-//! Transport-facing abstractions shared by protocol/session code.
+//! Transport abstraction layer for bridging gRPC bidirectional streaming with kameo actors.
 //!
-//! This module defines a small set of transport traits that actors and other
+//! This module provides a clean separation between the gRPC transport layer and business logic
-//! protocol code can depend on without knowing anything about the concrete
+//! by modeling the connection as two linked kameo actors:
-//! transport underneath.
 //!
-//! The abstraction is split into:
+//! - A **transport actor** ([`GrpcTransportActor`]) that owns the gRPC stream and channel,
-//! - [`Sender`] for outbound delivery
+//!   forwarding inbound messages to the business actor and outbound messages to the client.
-//! - [`Receiver`] for inbound delivery
+//! - A **business logic actor** that receives inbound messages from the transport actor and
-//! - [`Bi`] as the combined duplex form (`Sender + Receiver`)
+//!   sends outbound messages back through the transport actor.
 //!
-//! This split lets code depend only on the half it actually needs. For
+//! The [`wire()`] function sets up bidirectional linking between the two actors, ensuring
-//! example, some actor/session code only sends out-of-band messages, while
+//! that if either actor dies, the other is notified and can shut down gracefully.
-//! auth/state-machine code may need full duplex access.
 //!
-//! [`Bi`] remains intentionally minimal and transport-agnostic:
+//! # Terminology
-//! - [`Receiver::recv`] yields inbound messages
-//! - [`Sender::send`] accepts outbound messages
 //!
-//! Transport-specific adapters, including protobuf or gRPC bridges, live in the
+//! - **InboundMessage**: a message received by the transport actor from the channel/socket
-//! crates that own those boundaries rather than in `arbiter-proto`.
+//!   and forwarded to the business actor.
+//! - **OutboundMessage**: a message produced by the business actor and sent to the transport
+//!   actor to be forwarded to the channel/socket.
 //!
-//! [`Bi`] deliberately does not model request/response correlation. Some
+//! # Architecture
-//! transports may carry multiplexed request/response traffic, some may emit
-//! out-of-band messages, and some may be one-message-at-a-time state machines.
-//! Correlation concerns such as request IDs, pending response maps, and
-//! out-of-band routing belong in the adapter or connection layer built on top
-//! of [`Bi`], not in this abstraction itself.
 //!
-//! # Generic Ordering Rule
+//! ```text
+//! gRPC Stream ──InboundMessage──▶ GrpcTransportActor ──tell(InboundMessage)──▶ BusinessActor
+//!                                 ▲                                    │
+//!                                 └─tell(Result<OutboundMessage, _>)────┘
+//!                                 │
+//!                          mpsc::Sender ──▶ Client
+//! ```
 //!
-//! This module consistently uses `Inbound` first and `Outbound` second in
+//! # Example
-//! generic parameter lists.
 //!
-//! For [`Receiver`], [`Sender`], and [`Bi`], this means:
+//! ```rust,ignore
-//! - `Receiver<Inbound>`
+//! let (tx, rx) = mpsc::channel(1000);
-//! - `Sender<Outbound>`
+//! let context = server_context.clone();
-//! - `Bi<Inbound, Outbound>`
 //!
-//! Concretely, for [`Bi`]:
+//! wire(
-//! - `recv() -> Option<Inbound>`
+//!     |transport_ref| MyBusinessActor::new(context, transport_ref),
-//! - `send(Outbound)`
+//!     |business_recipient, business_id| GrpcTransportActor {
+//!         sender: tx,
+//!         receiver: grpc_stream,
+//!         business_logic_actor: business_recipient,
+//!         business_logic_actor_id: business_id,
+//!     },
+//! ).await;
 //!
-//! [`expect_message`] is a small helper for linear protocol steps: it reads one
+//! Ok(Response::new(ReceiverStream::new(rx)))
-//! inbound message from a transport and extracts a typed value from it, failing
+//! ```
-//! if the channel closes or the message shape is not what the caller expected.
-//!
-//! [`DummyTransport`] is a no-op implementation useful for tests and local
-//! actor execution where no real stream exists.
-//!
-//! # Design Notes
-//!
-//! - [`Bi::send`] returns [`Error`] only for transport delivery failures, such
-//!   as a closed outbound channel.
-//! - [`Bi::recv`] returns `None` when the underlying transport closes.
-//! - Message translation is intentionally out of scope for this module.
 
-use std::marker::PhantomData;
+use futures::{Stream, StreamExt};
+use kameo::{
+    Actor,
+    actor::{ActorRef, PreparedActor, Recipient, Spawn, WeakActorRef},
+    mailbox::Signal,
+    prelude::Message,
+};
+use tokio::{
+    select,
+    sync::mpsc::{self, error::SendError},
+};
+use tonic::{Status, Streaming};
+use tracing::{debug, error};
 
-use async_trait::async_trait;
+/// A bidirectional stream abstraction for sans-io testing.
-
+///
-/// Errors returned by transport adapters implementing [`Bi`].
+/// Combines a [`Stream`] of incoming messages with the ability to [`send`](Bi::send)
-#[derive(thiserror::Error, Debug)]
+/// outgoing responses. This trait allows business logic to be tested without a real
-pub enum Error {
+/// gRPC connection by swapping in an in-memory implementation.
-    #[error("Transport channel is closed")]
+///
-    ChannelClosed,
+/// # Type Parameters
-    #[error("Unexpected message received")]
+/// - `T`: `InboundMessage` received from the channel/socket (e.g., `UserAgentRequest`)
-    UnexpectedMessage,
+/// - `U`: `OutboundMessage` sent to the channel/socket (e.g., `UserAgentResponse`)
+pub trait Bi<T, U>: Stream<Item = Result<T, Status>> + Send + Sync + 'static {
+    type Error;
+    fn send(
+        &mut self,
+        item: Result<U, Status>,
+    ) -> impl std::future::Future<Output = Result<(), Self::Error>> + Send;
 }
 
-/// Receives one message from `transport` and extracts a value from it using
+/// Concrete [`Bi`] implementation backed by a tonic gRPC [`Streaming`] and an [`mpsc::Sender`].
-/// `extractor`. Returns [`Error::ChannelClosed`] if the transport closes and
+///
-/// [`Error::UnexpectedMessage`] if `extractor` returns `None`.
+/// This is the production implementation used in gRPC service handlers. The `request_stream`
-pub async fn expect_message<T, Inbound, Outbound, Target, F>(
+/// receives messages from the client, and `response_sender` sends responses back.
-    transport: &mut T,
+pub struct BiStream<T, U> {
-    extractor: F,
+    pub request_stream: Streaming<T>,
-) -> Result<Target, Error>
+    pub response_sender: mpsc::Sender<Result<U, Status>>,
+}
+
+impl<T, U> Stream for BiStream<T, U>
 where
-    T: Bi<Inbound, Outbound> + ?Sized,
+    T: Send + 'static,
-    F: FnOnce(Inbound) -> Option<Target>,
+    U: Send + 'static,
 {
-    let msg = transport.recv().await.ok_or(Error::ChannelClosed)?;
+    type Item = Result<T, Status>;
-    extractor(msg).ok_or(Error::UnexpectedMessage)
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        self.request_stream.poll_next_unpin(cx)
+    }
 }
 
-#[async_trait]
+impl<T, U> Bi<T, U> for BiStream<T, U>
-pub trait Sender<Outbound>: Send + Sync {
+where
-    async fn send(&mut self, item: Outbound) -> Result<(), Error>;
+    T: Send + 'static,
+    U: Send + 'static,
+{
+    type Error = SendError<Result<U, Status>>;
+
+    async fn send(&mut self, item: Result<U, Status>) -> Result<(), Self::Error> {
+        self.response_sender.send(item).await
+    }
 }
 
-#[async_trait]
+/// Marker trait for transport actors that can receive outbound messages of type `T`.
-pub trait Receiver<Inbound>: Send + Sync {
-    async fn recv(&mut self) -> Option<Inbound>;
-}
-
-/// Minimal bidirectional transport abstraction used by protocol code.
 ///
-/// `Bi<Inbound, Outbound>` is the combined duplex form of [`Sender`] and
+/// Implement this on your transport actor to indicate it can handle outbound messages
-/// [`Receiver`].
+/// produced by the business actor. Requires the actor to implement [`Message<Result<T, E>>`]
+/// so business logic can forward responses via [`tell()`](ActorRef::tell).
 ///
-/// It models a channel with:
+/// # Example
-/// - inbound items of type `Inbound` read via [`Bi::recv`]
-/// - outbound items of type `Outbound` written via [`Bi::send`]
 ///
-/// It does not imply request/response sequencing, one-at-a-time exchange, or
+/// ```rust,ignore
-/// any built-in correlation mechanism between inbound and outbound items.
+/// #[derive(Actor)]
-pub trait Bi<Inbound, Outbound>: Sender<Outbound> + Receiver<Inbound> + Send + Sync {}
+/// struct MyTransportActor { /* ... */ }
-
+///
-pub trait SplittableBi<Inbound, Outbound>: Bi<Inbound, Outbound> {
+/// impl Message<Result<MyResponse, MyError>> for MyTransportActor {
-    type Sender: Sender<Outbound>;
+///     type Reply = ();
-    type Receiver: Receiver<Inbound>;
+///     async fn handle(&mut self, msg: Result<MyResponse, MyError>, _ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
-
+///         // forward outbound message to channel/socket
-    fn split(self) -> (Self::Sender, Self::Receiver);
+///     }
-    fn from_parts(sender: Self::Sender, receiver: Self::Receiver) -> Self;
+/// }
+///
+/// impl TransportActor<MyResponse, MyError> for MyTransportActor {}
+/// ```
+pub trait TransportActor<Outbound: Send + 'static, DomainError: Send + 'static>:
+    Actor + Send + Message<Result<Outbound, DomainError>>
+{
 }
 
-/// No-op [`Bi`] transport for tests and manual actor usage.
+/// A kameo actor that bridges a gRPC bidirectional stream with a business logic actor.
 ///
-/// `send` drops all items and succeeds. [`Bi::recv`] never resolves and therefore
+/// This actor owns the gRPC [`Streaming`] receiver and an [`mpsc::Sender`] for responses.
-/// does not busy-wait or spuriously close the stream.
+/// It multiplexes between its own mailbox (for outbound messages from the business actor)
-pub struct DummyTransport<Inbound, Outbound> {
+/// and the gRPC stream (for inbound client messages) using [`tokio::select!`].
-    _marker: PhantomData<(Inbound, Outbound)>,
+///
+/// # Message Flow
+///
+/// - **Inbound**: Messages from the gRPC stream are forwarded to `business_logic_actor`
+///   via [`tell()`](Recipient::tell).
+/// - **Outbound**: The business actor sends `Result<Outbound, DomainError>` messages to this
+///   actor, which forwards them through the `sender` channel to the gRPC response stream.
+///
+/// # Lifecycle
+///
+/// - If the business logic actor dies (detected via actor linking), this actor stops,
+///   which closes the gRPC stream.
+/// - If the gRPC stream closes or errors, this actor stops, which (via linking) notifies
+///   the business actor.
+/// - Error responses (`Err(DomainError)`) are forwarded to the client and then the actor stops,
+///   closing the connection.
+///
+/// # Type Parameters
+/// - `Outbound`: `OutboundMessage` sent to the client (e.g., `UserAgentResponse`)
+/// - `Inbound`: `InboundMessage` received from the client (e.g., `UserAgentRequest`)
+/// - `E`: The domain error type, must implement `Into<tonic::Status>` for gRPC conversion
+pub struct GrpcTransportActor<Outbound, Inbound, DomainError>
+where
+    Outbound: Send + 'static,
+    Inbound: Send + 'static,
+    DomainError: Into<tonic::Status> + Send + 'static,
+{
+    sender: mpsc::Sender<Result<Outbound, tonic::Status>>,
+    receiver: tonic::Streaming<Inbound>,
+    business_logic_actor: Recipient<Inbound>,
+    _error: std::marker::PhantomData<DomainError>,
 }
 
-impl<Inbound, Outbound> Default for DummyTransport<Inbound, Outbound> {
+impl<Outbound, Inbound, DomainError> GrpcTransportActor<Outbound, Inbound, DomainError>
-    fn default() -> Self {
+where
+    Outbound: Send + 'static,
+    Inbound: Send + 'static,
+    DomainError: Into<tonic::Status> + Send + 'static,
+{
+    pub fn new(
+        sender: mpsc::Sender<Result<Outbound, tonic::Status>>,
+        receiver: tonic::Streaming<Inbound>,
+        business_logic_actor: Recipient<Inbound>,
+    ) -> Self {
         Self {
-            _marker: PhantomData,
+            sender,
+            receiver,
+            business_logic_actor,
+            _error: std::marker::PhantomData,
         }
     }
 }
 
-#[async_trait]
+impl<Outbound, Inbound, E> Actor for GrpcTransportActor<Outbound, Inbound, E>
-impl<Inbound, Outbound> Sender<Outbound> for DummyTransport<Inbound, Outbound>
 where
-    Inbound: Send + Sync + 'static,
+    Outbound: Send + 'static,
-    Outbound: Send + Sync + 'static,
+    Inbound: Send + 'static,
+    E: Into<tonic::Status> + Send + 'static,
 {
-    async fn send(&mut self, _item: Outbound) -> Result<(), Error> {
+    type Args = Self;
-        Ok(())
+
+    type Error = ();
+
+    async fn on_start(args: Self::Args, _: ActorRef<Self>) -> Result<Self, Self::Error> {
+        Ok(args)
+    }
+
+    fn on_link_died(
+        &mut self,
+        _: WeakActorRef<Self>,
+        id: kameo::prelude::ActorId,
+        _: kameo::prelude::ActorStopReason,
+    ) -> impl Future<
+        Output = Result<std::ops::ControlFlow<kameo::prelude::ActorStopReason>, Self::Error>,
+    > + Send {
+        async move {
+            if id == self.business_logic_actor.id() {
+                error!("Business logic actor died, stopping GrpcTransportActor");
+                Ok(std::ops::ControlFlow::Break(
+                    kameo::prelude::ActorStopReason::Normal,
+                ))
+            } else {
+                debug!(
+                    "Linked actor {} died, but it's not the business logic actor, ignoring",
+                    id
+                );
+                Ok(std::ops::ControlFlow::Continue(()))
+            }
+        }
+    }
+
+    async fn next(
+        &mut self,
+        _: WeakActorRef<Self>,
+        mailbox_rx: &mut kameo::prelude::MailboxReceiver<Self>,
+    ) -> Option<kameo::mailbox::Signal<Self>> {
+        select! {
+            msg = mailbox_rx.recv() => {
+                msg
+            }
+            recv_msg = self.receiver.next() => {
+                match recv_msg {
+                    Some(Ok(msg)) => {
+                        match self.business_logic_actor.tell(msg).await {
+                            Ok(_) => None,
+                            Err(e) => {
+                                // TODO: this would probably require better error handling - or resending if backpressure is the issue
+                                error!("Failed to send message to business logic actor: {}", e);
+                                Some(Signal::Stop)
+                            }
+                        }
+                    }
+                    Some(Err(e)) => {
+                        error!("Received error from stream: {}, stopping GrpcTransportActor", e);
+                        Some(Signal::Stop)
+                    }
+                    None => {
+                        error!("Receiver channel closed, stopping GrpcTransportActor");
+                        Some(Signal::Stop)
+                    }
+                }
+            }
+        }
     }
 }
 
-#[async_trait]
+impl<Outbound, Inbound, E> Message<Result<Outbound, E>> for GrpcTransportActor<Outbound, Inbound, E>
-impl<Inbound, Outbound> Receiver<Inbound> for DummyTransport<Inbound, Outbound>
 where
-    Inbound: Send + Sync + 'static,
+    Outbound: Send + 'static,
-    Outbound: Send + Sync + 'static,
+    Inbound: Send + 'static,
+    E: Into<tonic::Status> + Send + 'static,
 {
-    async fn recv(&mut self) -> Option<Inbound> {
+    type Reply = ();
-        std::future::pending::<()>().await;
+
-        None
+    async fn handle(
+        &mut self,
+        msg: Result<Outbound, E>,
+        ctx: &mut kameo::prelude::Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        let is_err = msg.is_err();
+        let grpc_msg = msg.map_err(Into::into);
+        match self.sender.send(grpc_msg).await {
+            Ok(_) => {
+                if is_err {
+                    ctx.stop();
+                }
+            }
+            Err(e) => {
+                error!("Failed to send message: {}", e);
+                ctx.stop();
+            }
+        }
     }
 }
 
-impl<Inbound, Outbound> Bi<Inbound, Outbound> for DummyTransport<Inbound, Outbound>
+impl<Outbound, Inbound, E> TransportActor<Outbound, E> for GrpcTransportActor<Outbound, Inbound, E>
 where
-    Inbound: Send + Sync + 'static,
+    Outbound: Send + 'static,
-    Outbound: Send + Sync + 'static,
+    Inbound: Send + 'static,
+    E: Into<tonic::Status> + Send + 'static,
 {
 }
 
-pub mod grpc;
+/// Wires together a transport actor and a business logic actor with bidirectional linking.
+///
+/// This function handles the chicken-and-egg problem of two actors that need references
+/// to each other at construction time. It uses kameo's [`PreparedActor`] to obtain
+/// [`ActorRef`]s before spawning, then links both actors so that if either dies,
+/// the other is notified via [`on_link_died`](Actor::on_link_died).
+///
+/// The business actor receives a type-erased [`Recipient<Result<Outbound, DomainError>>`] instead of an
+/// `ActorRef<Transport>`, keeping it decoupled from the concrete transport implementation.
+///
+/// # Type Parameters
+/// - `Transport`: The transport actor type (e.g., [`GrpcTransportActor`])
+/// - `Inbound`: `InboundMessage` received by the business actor from the transport
+/// - `Outbound`: `OutboundMessage` sent by the business actor back to the transport
+/// - `Business`: The business logic actor
+/// - `BusinessCtor`: Closure that receives a prepared business actor and transport recipient,
+///   spawns the business actor, and returns its [`ActorRef`]
+/// - `TransportCtor`: Closure that receives a prepared transport actor, a recipient for
+///   inbound messages, and the business actor id, then spawns the transport actor
+///
+/// # Returns
+/// A tuple of `(transport_ref, business_ref)` — actor references for both spawned actors.
+pub async fn wire<
+    Transport,
+    Inbound,
+    Outbound,
+    DomainError,
+    Business,
+    BusinessCtor,
+    TransportCtor,
+>(
+    business_ctor: BusinessCtor,
+    transport_ctor: TransportCtor,
+) -> (ActorRef<Transport>, ActorRef<Business>)
+where
+    Transport: TransportActor<Outbound, DomainError>,
+    Inbound: Send + 'static,
+    Outbound: Send + 'static,
+    DomainError: Send + 'static,
+    Business: Actor + Message<Inbound> + Send + 'static,
+    BusinessCtor: FnOnce(PreparedActor<Business>, Recipient<Result<Outbound, DomainError>>),
+    TransportCtor:
+        FnOnce(PreparedActor<Transport>, Recipient<Inbound>),
+{
+    let prepared_business: PreparedActor<Business> = Spawn::prepare();
+    let prepared_transport: PreparedActor<Transport> = Spawn::prepare();
+
+    let business_ref = prepared_business.actor_ref().clone();
+    let transport_ref = prepared_transport.actor_ref().clone();
+
+    transport_ref.link(&business_ref).await;
+    business_ref.link(&transport_ref).await;
+
+    let recipient = transport_ref.clone().recipient();
+    business_ctor(prepared_business, recipient);
+    let business_recipient = business_ref.clone().recipient();
+    transport_ctor(prepared_transport, business_recipient);
+
+
+    (transport_ref, business_ref)
+}

server/crates/arbiter-proto/src/transport/grpc.rs

@@ -1,106 +0,0 @@
-use async_trait::async_trait;
-use futures::StreamExt;
-use tokio::sync::mpsc;
-use tokio_stream::wrappers::ReceiverStream;
-
-use super::{Bi, Receiver, Sender};
-
-pub struct GrpcSender<Outbound> {
-    tx: mpsc::Sender<Result<Outbound, tonic::Status>>,
-}
-
-#[async_trait]
-impl<Outbound> Sender<Result<Outbound, tonic::Status>> for GrpcSender<Outbound>
-where
-    Outbound: Send + Sync + 'static,
-{
-    async fn send(&mut self, item: Result<Outbound, tonic::Status>) -> Result<(), super::Error> {
-        self.tx
-            .send(item)
-            .await
-            .map_err(|_| super::Error::ChannelClosed)
-    }
-}
-
-pub struct GrpcReceiver<Inbound> {
-    rx: tonic::Streaming<Inbound>,
-}
-#[async_trait]
-impl<Inbound> Receiver<Result<Inbound, tonic::Status>> for GrpcReceiver<Inbound>
-where
-    Inbound: Send + Sync + 'static,
-{
-    async fn recv(&mut self) -> Option<Result<Inbound, tonic::Status>> {
-        self.rx.next().await
-    }
-}
-
-pub struct GrpcBi<Inbound, Outbound> {
-    sender: GrpcSender<Outbound>,
-    receiver: GrpcReceiver<Inbound>,
-}
-
-impl<Inbound, Outbound> GrpcBi<Inbound, Outbound>
-where
-    Inbound: Send + Sync + 'static,
-    Outbound: Send + Sync + 'static,
-{
-    pub fn from_bi_stream(
-        receiver: tonic::Streaming<Inbound>,
-    ) -> (Self, ReceiverStream<Result<Outbound, tonic::Status>>) {
-        let (tx, rx) = mpsc::channel(10);
-        let sender = GrpcSender { tx };
-        let receiver = GrpcReceiver { rx: receiver };
-        let bi = GrpcBi { sender, receiver };
-        (bi, ReceiverStream::new(rx))
-    }
-}
-
-#[async_trait]
-impl<Inbound, Outbound> Sender<Result<Outbound, tonic::Status>> for GrpcBi<Inbound, Outbound>
-where
-    Inbound: Send + Sync + 'static,
-    Outbound: Send + Sync + 'static,
-{
-    async fn send(&mut self, item: Result<Outbound, tonic::Status>) -> Result<(), super::Error> {
-        self.sender.send(item).await
-    }
-}
-
-#[async_trait]
-impl<Inbound, Outbound> Receiver<Result<Inbound, tonic::Status>> for GrpcBi<Inbound, Outbound>
-where
-    Inbound: Send + Sync + 'static,
-    Outbound: Send + Sync + 'static,
-{
-    async fn recv(&mut self) -> Option<Result<Inbound, tonic::Status>> {
-        self.receiver.recv().await
-    }
-}
-
-impl<Inbound, Outbound> Bi<Result<Inbound, tonic::Status>, Result<Outbound, tonic::Status>>
-    for GrpcBi<Inbound, Outbound>
-where
-    Inbound: Send + Sync + 'static,
-    Outbound: Send + Sync + 'static,
-{
-}
-
-impl<Inbound, Outbound>
-    super::SplittableBi<Result<Inbound, tonic::Status>, Result<Outbound, tonic::Status>>
-    for GrpcBi<Inbound, Outbound>
-where
-    Inbound: Send + Sync + 'static,
-    Outbound: Send + Sync + 'static,
-{
-    type Sender = GrpcSender<Outbound>;
-    type Receiver = GrpcReceiver<Inbound>;
-
-    fn split(self) -> (Self::Sender, Self::Receiver) {
-        (self.sender, self.receiver)
-    }
-
-    fn from_parts(sender: Self::Sender, receiver: Self::Receiver) -> Self {
-        GrpcBi { sender, receiver }
-    }
-}

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

@@ -7,8 +7,6 @@ const ARBITER_URL_SCHEME: &str = "arbiter";
 const CERT_QUERY_KEY: &str = "cert";
 const BOOTSTRAP_TOKEN_QUERY_KEY: &str = "bootstrap_token";
 
-
-#[derive(Debug, Clone)]
 pub struct ArbiterUrl {
     pub host: String,
     pub port: u16,
@@ -22,7 +20,7 @@ impl Display for ArbiterUrl {
             "{ARBITER_URL_SCHEME}://{}:{}?{CERT_QUERY_KEY}={}",
             self.host,
             self.port,
-            BASE64_URL_SAFE.encode(&self.ca_cert)
+            BASE64_URL_SAFE.encode(self.ca_cert.to_vec())
         );
         if let Some(token) = &self.bootstrap_token {
             base.push_str(&format!("&{BOOTSTRAP_TOKEN_QUERY_KEY}={}", token));

server/crates/arbiter-server/Cargo.toml

@@ -5,12 +5,9 @@ edition = "2024"
 repository = "https://git.markettakers.org/MarketTakers/arbiter"
 license = "Apache-2.0"
 
-[lints]
-workspace = true
-
 [dependencies]
-diesel = { version = "2.3.7", features = ["chrono", "returning_clauses_for_sqlite_3_35", "serde_json", "time", "uuid"] }
+diesel = { version = "2.3.6", features = ["chrono", "returning_clauses_for_sqlite_3_35", "serde_json", "time", "uuid"] }
-diesel-async = { version = "0.8.0", features = [
+diesel-async = { version = "0.7.4", features = [
     "bb8",
     "migrations",
     "sqlite",
@@ -27,7 +24,6 @@ rustls.workspace = true
 smlang.workspace = true
 miette.workspace = true
 thiserror.workspace = true
-fatality = "0.1.1"
 diesel_migrations = { version = "2.3.1", features = ["sqlite"] }
 async-trait.workspace = true
 secrecy = "0.10.3"
@@ -44,15 +40,8 @@ x25519-dalek.workspace = true
 chacha20poly1305 = { version = "0.10.1", features = ["std"] }
 argon2 = { version = "0.5.3", features = ["zeroize"] }
 restructed = "0.2.2"
-strum = { version = "0.28.0", features = ["derive"] }
+strum = { version = "0.27.2", features = ["derive"] }
 pem = "3.0.6"
-k256.workspace = true
-rsa.workspace = true
-sha2.workspace = true
-spki.workspace = true
-alloy.workspace = true
-prost-types.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

@@ -28,7 +28,7 @@ create table if not exists tls_history (
     id INTEGER not null PRIMARY KEY,
     cert text not null,
     cert_key text not null, -- PEM Encoded private key
-    ca_cert text not null,
+    ca_cert text not null, 
     ca_key text not null, -- PEM Encoded private key
     created_at integer not null default(unixepoch ('now'))
 ) STRICT;
@@ -40,154 +40,20 @@ create table if not exists arbiter_settings (
     tls_id integer references tls_history (id) on delete RESTRICT
 ) STRICT;
 
-insert into arbiter_settings (id) values (1) on conflict do nothing;
+insert into arbiter_settings (id) values (1) on conflict do nothing; -- ensure singleton row exists
--- ensure singleton row exists
 
 create table if not exists useragent_client (
     id integer not null primary key,
     nonce integer not null default(1), -- used for auth challenge
     public_key blob not null,
-    key_type integer not null default(1), -- 1=Ed25519, 2=ECDSA(secp256k1)
     created_at integer not null default(unixepoch ('now')),
     updated_at integer not null default(unixepoch ('now'))
 ) STRICT;
-create unique index if not exists uniq_useragent_client_public_key on useragent_client (public_key, key_type);
-
-create table if not exists client_metadata (
-    id integer not null primary key,
-    name text not null, -- human-readable name for the client
-    description text, -- optional description for the client
-    version text, -- client version for tracking and debugging
-    created_at integer not null default(unixepoch ('now'))
-) STRICT;
-
--- created to track history of changes
-create table if not exists client_metadata_history (
-    id integer not null primary key,
-    metadata_id integer not null references client_metadata (id) on delete cascade,
-    client_id integer not null references program_client (id) on delete cascade,
-    created_at integer not null default(unixepoch ('now'))
-) STRICT;
-
-create unique index if not exists uniq_metadata_binding_client on client_metadata_history (client_id);
 
 create table if not exists program_client (
     id integer not null primary key,
     nonce integer not null default(1), -- used for auth challenge
     public_key blob not null,
-    metadata_id integer not null references client_metadata (id) on delete cascade,
     created_at integer not null default(unixepoch ('now')),
     updated_at integer not null default(unixepoch ('now'))
-) STRICT;
+) STRICT;
-
-create unique index if not exists program_client_public_key_unique
-    on program_client (public_key);
-
-create unique index if not exists uniq_program_client_public_key on program_client (public_key);
-
-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_wallet_access (
-    id integer not null primary key,
-    wallet_id integer not null references evm_wallet (id) on delete cascade,
-    client_id integer not null references program_client (id) on delete cascade,
-    created_at integer not null default(unixepoch ('now'))
-) STRICT;
-
-create unique index if not exists uniq_wallet_access on evm_wallet_access (wallet_id, client_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_access_id integer not null references evm_wallet_access (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,
-    wallet_access_id integer not null references evm_wallet_access (id) on delete restrict,
-    grant_id integer not null references evm_basic_grant (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_access_chain on evm_basic_grant (wallet_access_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/bootstrap.rs

@@ -3,7 +3,12 @@ use diesel::QueryDsl;
 use diesel_async::RunQueryDsl;
 use kameo::{Actor, messages};
 use miette::Diagnostic;
-use rand::{RngExt, distr::Alphanumeric, make_rng, rngs::StdRng};
+use rand::{
+    RngExt,
+    distr::{Alphanumeric},
+    make_rng,
+    rngs::StdRng,
+};
 use thiserror::Error;
 
 use crate::db::{self, DatabasePool, schema};
@@ -56,6 +61,7 @@ impl Bootstrapper {
 
         drop(conn);
 
+
         let token = if row_count == 0 {
             let token = generate_token().await?;
             Some(token)

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

@@ -0,0 +1,12 @@
+use arbiter_proto::{
+    proto::{ClientRequest, ClientResponse},
+    transport::Bi,
+};
+
+use crate::ServerContext;
+
+pub(crate) async fn handle_client(
+    _context: ServerContext,
+    _bistream: impl Bi<ClientRequest, ClientResponse>,
+) {
+}

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

@@ -1,332 +0,0 @@
-use arbiter_proto::{
-    ClientMetadata, format_challenge,
-    transport::{Bi, expect_message},
-};
-use chrono::Utc;
-use diesel::{
-    ExpressionMethods as _, OptionalExtension as _, QueryDsl as _, SelectableHelper as _,
-    dsl::insert_into, update,
-};
-use diesel_async::RunQueryDsl as _;
-use ed25519_dalek::{Signature, VerifyingKey};
-use kameo::error::SendError;
-use tracing::error;
-
-use crate::{
-    actors::{
-        client::{ClientConnection, ClientProfile},
-        flow_coordinator::{self, RequestClientApproval},
-    },
-    db::{
-        self,
-        models::{ProgramClientMetadata, SqliteTimestamp},
-        schema::program_client,
-    },
-};
-
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
-pub enum Error {
-    #[error("Database pool unavailable")]
-    DatabasePoolUnavailable,
-    #[error("Database operation failed")]
-    DatabaseOperationFailed,
-    #[error("Invalid challenge solution")]
-    InvalidChallengeSolution,
-    #[error("Client approval request failed")]
-    ApproveError(#[from] ApproveError),
-    #[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(flow_coordinator::ApprovalError),
-}
-
-#[derive(Debug, Clone)]
-pub enum Inbound {
-    AuthChallengeRequest {
-        pubkey: VerifyingKey,
-        metadata: ClientMetadata,
-    },
-    AuthChallengeSolution {
-        signature: Signature,
-    },
-}
-
-#[derive(Debug, Clone)]
-pub enum Outbound {
-    AuthChallenge { pubkey: VerifyingKey, nonce: i32 },
-    AuthSuccess,
-}
-
-pub struct ClientInfo {
-    pub id: i32,
-    pub current_nonce: i32,
-}
-
-/// Atomically reads and increments the nonce for a known client.
-/// Returns `None` if the pubkey is not registered.
-async fn get_client_and_nonce(
-    db: &db::DatabasePool,
-    pubkey: &VerifyingKey,
-) -> Result<Option<ClientInfo>, 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| {
-        Box::pin(async move {
-            let Some((client_id, current_nonce)) = program_client::table
-                .filter(program_client::public_key.eq(&pubkey_bytes))
-                .select((program_client::id, program_client::nonce))
-                .first::<(i32, 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(ClientInfo {
-                id: client_id,
-                current_nonce,
-            }))
-        })
-    })
-    .await
-    .map_err(|e| {
-        error!(error = ?e, "Database error");
-        Error::DatabaseOperationFailed
-    })
-}
-
-async fn approve_new_client(
-    actors: &crate::actors::GlobalActors,
-    profile: ClientProfile,
-) -> Result<(), Error> {
-    let result = actors
-        .flow_coordinator
-        .ask(RequestClientApproval { client: profile })
-        .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 flow coordinator failed");
-            Err(Error::ApproveError(ApproveError::Internal))
-        }
-    }
-}
-
-async fn insert_client(
-    db: &db::DatabasePool,
-    pubkey: &VerifyingKey,
-    metadata: &ClientMetadata,
-) -> Result<i32, Error> {
-    use crate::db::schema::{client_metadata, program_client};
-    let mut conn = db.get().await.map_err(|e| {
-        error!(error = ?e, "Database pool error");
-        Error::DatabasePoolUnavailable
-    })?;
-
-    let metadata_id = insert_into(client_metadata::table)
-        .values((
-            client_metadata::name.eq(&metadata.name),
-            client_metadata::description.eq(&metadata.description),
-            client_metadata::version.eq(&metadata.version),
-        ))
-        .returning(client_metadata::id)
-        .get_result::<i32>(&mut conn)
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to insert client metadata");
-            Error::DatabaseOperationFailed
-        })?;
-
-    let client_id = insert_into(program_client::table)
-        .values((
-            program_client::public_key.eq(pubkey.as_bytes().to_vec()),
-            program_client::metadata_id.eq(metadata_id),
-            program_client::nonce.eq(1), // pre-incremented; challenge uses 0
-        ))
-        .on_conflict_do_nothing()
-        .returning(program_client::id)
-        .get_result::<i32>(&mut conn)
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to insert client metadata");
-            Error::DatabaseOperationFailed
-        })?;
-
-    Ok(client_id)
-}
-
-async fn sync_client_metadata(
-    db: &db::DatabasePool,
-    client_id: i32,
-    metadata: &ClientMetadata,
-) -> Result<(), Error> {
-    use crate::db::schema::{client_metadata, client_metadata_history};
-
-    let now = SqliteTimestamp(Utc::now());
-
-    let mut conn = db.get().await.map_err(|e| {
-        error!(error = ?e, "Database pool error");
-        Error::DatabasePoolUnavailable
-    })?;
-
-    conn.exclusive_transaction(|conn| {
-        let metadata = metadata.clone();
-        Box::pin(async move {
-            let (current_metadata_id, current): (i32, ProgramClientMetadata) =
-                program_client::table
-                    .find(client_id)
-                    .inner_join(client_metadata::table)
-                    .select((
-                        program_client::metadata_id,
-                        ProgramClientMetadata::as_select(),
-                    ))
-                    .first(conn)
-                    .await?;
-
-            let unchanged = current.name == metadata.name
-                && current.description == metadata.description
-                && current.version == metadata.version;
-            if unchanged {
-                return Ok(());
-            }
-
-            insert_into(client_metadata_history::table)
-                .values((
-                    client_metadata_history::metadata_id.eq(current_metadata_id),
-                    client_metadata_history::client_id.eq(client_id),
-                ))
-                .execute(conn)
-                .await?;
-
-            let metadata_id = insert_into(client_metadata::table)
-                .values((
-                    client_metadata::name.eq(&metadata.name),
-                    client_metadata::description.eq(&metadata.description),
-                    client_metadata::version.eq(&metadata.version),
-                ))
-                .returning(client_metadata::id)
-                .get_result::<i32>(conn)
-                .await?;
-
-            update(program_client::table.find(client_id))
-                .set((
-                    program_client::metadata_id.eq(metadata_id),
-                    program_client::updated_at.eq(now),
-                ))
-                .execute(conn)
-                .await?;
-
-            Ok::<(), diesel::result::Error>(())
-        })
-    })
-    .await
-    .map_err(|e| {
-        error!(error = ?e, "Database error");
-        Error::DatabaseOperationFailed
-    })
-}
-
-async fn challenge_client<T>(
-    transport: &mut T,
-    pubkey: VerifyingKey,
-    nonce: i32,
-) -> Result<(), Error>
-where
-    T: Bi<Inbound, Result<Outbound, Error>> + ?Sized,
-{
-    transport
-        .send(Ok(Outbound::AuthChallenge { pubkey, nonce }))
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to send auth challenge");
-            Error::Transport
-        })?;
-
-    let signature = expect_message(transport, |req: Inbound| match req {
-        Inbound::AuthChallengeSolution { signature } => Some(signature),
-        _ => None,
-    })
-    .await
-    .map_err(|e| {
-        error!(error = ?e, "Failed to receive challenge solution");
-        Error::Transport
-    })?;
-
-    let formatted = format_challenge(nonce, pubkey.as_bytes());
-
-    pubkey.verify_strict(&formatted, &signature).map_err(|_| {
-        error!("Challenge solution verification failed");
-        Error::InvalidChallengeSolution
-    })?;
-
-    Ok(())
-}
-
-pub async fn authenticate<T>(
-    props: &mut ClientConnection,
-    transport: &mut T,
-) -> Result<i32, Error>
-where
-    T: Bi<Inbound, Result<Outbound, Error>> + Send + ?Sized,
-{
-    let Some(Inbound::AuthChallengeRequest { pubkey, metadata }) = transport.recv().await else {
-        return Err(Error::Transport);
-    };
-
-    let info = match get_client_and_nonce(&props.db, &pubkey).await? {
-        Some(nonce) => nonce,
-        None => {
-            approve_new_client(
-                &props.actors,
-                ClientProfile {
-                    pubkey,
-                    metadata: metadata.clone(),
-                },
-            )
-            .await?;
-            let client_id = insert_client(&props.db, &pubkey, &metadata).await?;
-            ClientInfo {
-                id: client_id,
-                current_nonce: 0,
-            }
-        }
-    };
-
-    sync_client_metadata(&props.db, info.id, &metadata).await?;
-    challenge_client(transport, pubkey, info.current_nonce).await?;
-    
-    transport
-        .send(Ok(Outbound::AuthSuccess))
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to send auth success");
-            Error::Transport
-        })?;
-
-    Ok(info.id)
-}

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

@@ -1,47 +0,0 @@
-use arbiter_proto::{ClientMetadata, transport::Bi};
-use kameo::actor::Spawn;
-use tracing::{error, info};
-
-use crate::{
-    actors::{GlobalActors, client::session::ClientSession},
-    db,
-};
-
-#[derive(Debug, Clone)]
-pub struct ClientProfile {
-    pub pubkey: ed25519_dalek::VerifyingKey,
-    pub metadata: ClientMetadata,
-}
-
-pub struct ClientConnection {
-    pub(crate) db: db::DatabasePool,
-    pub(crate) actors: GlobalActors,
-}
-
-impl ClientConnection {
-    pub fn new(db: db::DatabasePool, actors: GlobalActors) -> Self {
-        Self {
-            db,
-            actors,
-        }
-    }
-}
-
-pub mod auth;
-pub mod session;
-
-pub async fn connect_client<T>(mut props: ClientConnection, transport: &mut T)
-where
-    T: Bi<auth::Inbound, Result<auth::Outbound, auth::Error>> + Send + ?Sized,
-{
-    match auth::authenticate(&mut props, transport).await {
-        Ok(client_id) => {
-            ClientSession::spawn(ClientSession::new(props, client_id));
-            info!("Client authenticated, session started");
-        }
-        Err(err) => {
-            let _ = transport.send(Err(err.clone())).await;
-            error!(?err, "Authentication failed, closing connection");
-        }
-    }
-}

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

@@ -1,117 +0,0 @@
-use kameo::{Actor, messages};
-use tracing::error;
-
-use alloy::{consensus::TxEip1559, primitives::Address, signers::Signature};
-
-use crate::{
-    actors::{
-        GlobalActors,
-        client::ClientConnection, flow_coordinator::RegisterClient,
-       
-        evm::{ClientSignTransaction, SignTransactionError},
-        keyholder::KeyHolderState,
-       
-    },
-    db,
-    evm::VetError,
-};
-
-pub struct ClientSession {
-    props: ClientConnection,
-    client_id: i32,
-}
-
-impl ClientSession {
-    pub(crate) fn new(props: ClientConnection, client_id: i32) -> Self {
-        Self { props, client_id }
-    }
-}
-
-#[messages]
-impl ClientSession {
-    #[message]
-    pub(crate) async fn handle_query_vault_state(&mut self) -> Result<KeyHolderState, Error> {
-        use crate::actors::keyholder::GetState;
-
-        let vault_state = match self.props.actors.key_holder.ask(GetState {}).await {
-            Ok(state) => state,
-            Err(err) => {
-                error!(?err, actor = "client", "keyholder.query.failed");
-                return Err(Error::Internal);
-            }
-        };
-
-        Ok(vault_state)
-    }
-
-    #[message]
-    pub(crate) async fn handle_sign_transaction(
-        &mut self,
-        wallet_address: Address,
-        transaction: TxEip1559,
-    ) -> Result<Signature, SignTransactionRpcError> {
-        match self
-            .props
-            .actors
-            .evm
-            .ask(ClientSignTransaction {
-                client_id: self.client_id,
-                wallet_address,
-                transaction,
-            })
-            .await
-        {
-            Ok(signature) => Ok(signature),
-            Err(kameo::error::SendError::HandlerError(SignTransactionError::Vet(vet_error))) => {
-                Err(SignTransactionRpcError::Vet(vet_error))
-            }
-            Err(err) => {
-                error!(?err, "Failed to sign EVM transaction in client session");
-                Err(SignTransactionRpcError::Internal)
-            }
-        }
-    }
-}
-
-impl Actor for ClientSession {
-    type Args = Self;
-
-    type Error = Error;
-
-    async fn on_start(
-        args: Self::Args,
-        this: kameo::prelude::ActorRef<Self>,
-    ) -> Result<Self, Self::Error> {
-        args.props
-            .actors
-            .flow_coordinator
-            .ask(RegisterClient { actor: this })
-            .await
-            .map_err(|_| Error::ConnectionRegistrationFailed)?;
-        Ok(args)
-    }
-}
-
-impl ClientSession {
-    pub fn new_test(db: db::DatabasePool, actors: GlobalActors) -> Self {
-        let props = ClientConnection::new(db, actors);
-        Self { props, client_id: 0 }
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("Connection registration failed")]
-    ConnectionRegistrationFailed,
-    #[error("Internal error")]
-    Internal,
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum SignTransactionRpcError {
-    #[error("Policy evaluation failed")]
-    Vet(#[from] VetError),
-
-    #[error("Internal error")]
-    Internal,
-}

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

@@ -1,265 +0,0 @@
-use alloy::{consensus::TxEip1559, 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 rand::{SeedableRng, rng, rngs::StdRng};
-
-use crate::{
-    actors::keyholder::{CreateNew, Decrypt, KeyHolder},
-    db::{
-        DatabaseError, DatabasePool,
-        models::{self, SqliteTimestamp},
-        schema,
-    },
-    evm::{
-        self, RunKind,
-        policies::{
-            FullGrant, Grant, SharedGrantSettings, SpecificGrant, SpecificMeaning,
-            ether_transfer::EtherTransfer, token_transfers::TokenTransfer,
-        },
-    },
-    safe_cell::{SafeCell, SafeCellHandle as _},
-};
-
-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] DatabaseError),
-
-    #[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] DatabaseError),
-}
-
-#[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<(i32, Address), Error> {
-        let (mut key_cell, address) = safe_signer::generate(&mut self.rng);
-
-        let plaintext = key_cell.read_inline(|reader| SafeCell::new(reader.to_vec()));
-
-        let aead_id: i32 = self
-            .keyholder
-            .ask(CreateNew { plaintext })
-            .await
-            .map_err(|_| Error::KeyholderSend)?;
-
-        let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
-        let wallet_id = insert_into(schema::evm_wallet::table)
-            .values(&models::NewEvmWallet {
-                address: address.as_slice().to_vec(),
-                aead_encrypted_id: aead_id,
-            })
-            .returning(schema::evm_wallet::id)
-            .get_result(&mut conn)
-            .await
-            .map_err(DatabaseError::from)?;
-
-        Ok((wallet_id, address))
-    }
-
-    #[message]
-    pub async fn list_wallets(&self) -> Result<Vec<(i32, Address)>, Error> {
-        let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
-        let rows: Vec<models::EvmWallet> = schema::evm_wallet::table
-            .select(models::EvmWallet::as_select())
-            .load(&mut conn)
-            .await
-            .map_err(DatabaseError::from)?;
-
-        Ok(rows
-            .into_iter()
-            .map(|w| (w.id, Address::from_slice(&w.address)))
-            .collect())
-    }
-}
-
-#[messages]
-impl EvmActor {
-    #[message]
-    pub async fn useragent_create_grant(
-        &mut self,
-        basic: SharedGrantSettings,
-        grant: SpecificGrant,
-    ) -> Result<i32, DatabaseError> {
-        match grant {
-            SpecificGrant::EtherTransfer(settings) => {
-                self.engine
-                    .create_grant::<EtherTransfer>(FullGrant {
-                        basic,
-                        specific: settings,
-                    })
-                    .await
-            }
-            SpecificGrant::TokenTransfer(settings) => {
-                self.engine
-                    .create_grant::<TokenTransfer>(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.map_err(DatabaseError::from)?;
-        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
-            .map_err(DatabaseError::from)?;
-        Ok(())
-    }
-
-    #[message]
-    pub async fn useragent_list_grants(&mut self) -> Result<Vec<Grant<SpecificGrant>>, Error> {
-        Ok(self
-            .engine
-            .list_all_grants()
-            .await
-            .map_err(DatabaseError::from)?)
-    }
-
-    #[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.map_err(DatabaseError::from)?;
-        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()
-            .map_err(DatabaseError::from)?
-            .ok_or(SignTransactionError::WalletNotFound)?;
-        let wallet_access = schema::evm_wallet_access::table
-            .select(models::EvmWalletAccess::as_select())
-            .filter(schema::evm_wallet_access::wallet_id.eq(wallet.id))
-            .filter(schema::evm_wallet_access::client_id.eq(client_id))
-            .first(&mut conn)
-            .await
-            .optional()
-            .map_err(DatabaseError::from)?
-            .ok_or(SignTransactionError::WalletNotFound)?;
-        drop(conn);
-
-        let meaning = self
-            .engine
-            .evaluate_transaction(wallet_access, 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.map_err(DatabaseError::from)?;
-        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()
-            .map_err(DatabaseError::from)?
-            .ok_or(SignTransactionError::WalletNotFound)?;
-        let wallet_access = schema::evm_wallet_access::table
-            .select(models::EvmWalletAccess::as_select())
-            .filter(schema::evm_wallet_access::wallet_id.eq(wallet.id))
-            .filter(schema::evm_wallet_access::client_id.eq(client_id))
-            .first(&mut conn)
-            .await
-            .optional()
-            .map_err(DatabaseError::from)?
-            .ok_or(SignTransactionError::WalletNotFound)?;
-        drop(conn);
-
-        let raw_key: SafeCell<Vec<u8>> = self
-            .keyholder
-            .ask(Decrypt {
-                aead_id: wallet.aead_encrypted_id,
-            })
-            .await
-            .map_err(|_| SignTransactionError::KeyholderSend)?;
-
-        let signer = safe_signer::SafeSigner::from_cell(raw_key)?;
-
-        self.engine
-            .evaluate_transaction(wallet_access, transaction.clone(), RunKind::Execution)
-            .await?;
-
-        use alloy::network::TxSignerSync as _;
-        Ok(signer.sign_transaction_sync(&mut transaction)?)
-    }
-}

server/crates/arbiter-server/src/actors/flow_coordinator/client_connect_approval.rs

@@ -1,101 +0,0 @@
-use std::ops::ControlFlow;
-
-use kameo::{
-    Actor, messages,
-    prelude::{ActorId, ActorRef, ActorStopReason, Context, WeakActorRef},
-    reply::ReplySender,
-};
-
-use crate::actors::{
-    client::ClientProfile,
-    flow_coordinator::ApprovalError,
-    user_agent::{UserAgentSession, session::BeginNewClientApproval},
-};
-
-pub struct Args {
-    pub client: ClientProfile,
-    pub user_agents: Vec<ActorRef<UserAgentSession>>,
-    pub reply: ReplySender<Result<bool, ApprovalError>>
-}
-
-pub struct ClientApprovalController {
-    /// Number of UAs that have not yet responded (approval or denial) or died.
-    pending: usize,
-    /// Number of approvals received so far.
-    approved: usize,
-    reply: Option<ReplySender<Result<bool, ApprovalError>>>,
-}
-
-impl ClientApprovalController {
-    fn send_reply(&mut self, result: Result<bool, ApprovalError>) {
-        if let Some(reply) = self.reply.take() {
-            reply.send(result);
-        }
-    }
-}
-
-impl Actor for ClientApprovalController {
-    type Args = Args;
-    type Error = ();
-
-    async fn on_start(
-        Args { client, mut user_agents, reply }: Self::Args,
-        actor_ref: ActorRef<Self>,
-    ) -> Result<Self, Self::Error> {
-        let this = Self {
-            pending: user_agents.len(),
-            approved: 0,
-            reply: Some(reply),
-        };
-
-        for user_agent in user_agents.drain(..) {
-            actor_ref.link(&user_agent).await;
-            let _ = user_agent
-                .tell(BeginNewClientApproval {
-                    client: client.clone(),
-                    controller: actor_ref.clone(),
-                })
-                .await;
-        }
-
-        Ok(this)
-    }
-
-    async fn on_link_died(
-        &mut self,
-        _: WeakActorRef<Self>,
-        _: ActorId,
-        _: ActorStopReason,
-    ) -> Result<ControlFlow<ActorStopReason>, Self::Error> {
-        // A linked UA died before responding — counts as a non-approval.
-        self.pending = self.pending.saturating_sub(1);
-        if self.pending == 0 {
-            // At least one UA didn't approve: deny.
-            self.send_reply(Ok(false));
-            return Ok(ControlFlow::Break(ActorStopReason::Normal));
-        }
-        Ok(ControlFlow::Continue(()))
-    }
-}
-
-#[messages]
-impl ClientApprovalController {
-    #[message(ctx)]
-    pub async fn client_approval_answer(&mut self, approved: bool, ctx: &mut Context<Self, ()>) {
-        if !approved {
-            // Denial wins immediately regardless of other pending responses.
-            self.send_reply(Ok(false));
-            ctx.stop();
-            return;
-        }
-
-        self.approved += 1;
-        self.pending = self.pending.saturating_sub(1);
-
-        if self.pending == 0 {
-            // Every connected UA approved.
-            self.send_reply(Ok(true));
-            ctx.stop();
-        }
-    }
-}

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

@@ -1,118 +0,0 @@
-use std::{collections::HashMap, ops::ControlFlow};
-
-use kameo::{
-    Actor,
-    actor::{ActorId, ActorRef, Spawn},
-    messages,
-    prelude::{ActorStopReason, Context, WeakActorRef},
-    reply::DelegatedReply,
-};
-use tracing::info;
-
-use crate::actors::{
-    client::{ClientProfile, session::ClientSession},
-    flow_coordinator::client_connect_approval::ClientApprovalController,
-    user_agent::session::UserAgentSession,
-};
-
-pub mod client_connect_approval;
-
-#[derive(Default)]
-pub struct FlowCoordinator {
-    pub user_agents: HashMap<ActorId, ActorRef<UserAgentSession>>,
-    pub clients: HashMap<ActorId, ActorRef<ClientSession>>,
-}
-
-impl Actor for FlowCoordinator {
-    type Args = Self;
-
-    type Error = ();
-
-    async fn on_start(args: Self::Args, _: ActorRef<Self>) -> Result<Self, Self::Error> {
-        Ok(args)
-    }
-
-    async fn on_link_died(
-        &mut self,
-        _: WeakActorRef<Self>,
-        id: ActorId,
-        _: ActorStopReason,
-    ) -> Result<ControlFlow<ActorStopReason>, Self::Error> {
-        if self.user_agents.remove(&id).is_some() {
-            info!(
-                ?id,
-                actor = "FlowCoordinator",
-                event = "useragent.disconnected"
-            );
-        } else if self.clients.remove(&id).is_some() {
-            info!(
-                ?id,
-                actor = "FlowCoordinator",
-                event = "client.disconnected"
-            );
-        } else {
-            info!(
-                ?id,
-                actor = "FlowCoordinator",
-                event = "unknown.actor.disconnected"
-            );
-        }
-        Ok(ControlFlow::Continue(()))
-    }
-}
-
-#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq, Hash)]
-pub enum ApprovalError {
-    #[error("No user agents connected")]
-    NoUserAgentsConnected,
-}
-
-#[messages]
-impl FlowCoordinator {
-    #[message(ctx)]
-    pub async fn register_user_agent(
-        &mut self,
-        actor: ActorRef<UserAgentSession>,
-        ctx: &mut Context<Self, ()>,
-    ) {
-        info!(id = %actor.id(), actor = "FlowCoordinator", event = "useragent.connected");
-        ctx.actor_ref().link(&actor).await;
-        self.user_agents.insert(actor.id(), actor);
-    }
-
-    #[message(ctx)]
-    pub async fn register_client(
-        &mut self,
-        actor: ActorRef<ClientSession>,
-        ctx: &mut Context<Self, ()>,
-    ) {
-        info!(id = %actor.id(), actor = "FlowCoordinator", event = "client.connected");
-        ctx.actor_ref().link(&actor).await;
-        self.clients.insert(actor.id(), actor);
-    }
-
-    #[message(ctx)]
-    pub async fn request_client_approval(
-        &mut self,
-        client: ClientProfile,
-        ctx: &mut Context<Self, DelegatedReply<Result<bool, ApprovalError>>>,
-    ) -> DelegatedReply<Result<bool, ApprovalError>> {
-        let (reply, Some(reply_sender)) = ctx.reply_sender() else {
-            unreachable!("Expected `request_client_approval` to have callback channel");
-        };
-
-        let refs: Vec<_> = self.user_agents.values().cloned().collect();
-        if refs.is_empty() {
-            reply_sender.send(Err(ApprovalError::NoUserAgentsConnected));
-            return reply;
-        }
-
-        ClientApprovalController::spawn(client_connect_approval::Args {
-            client,
-            user_agents: refs,
-            reply: reply_sender,
-        });
-
-        reply
-    }
-}

server/crates/arbiter-server/src/actors/keyholder/encryption/v1.rs

@@ -5,13 +5,12 @@ use chacha20poly1305::{
     AeadInPlace, Key, KeyInit as _, XChaCha20Poly1305, XNonce,
     aead::{AeadMut, Error, Payload},
 };
+use memsafe::MemSafe;
 use rand::{
     Rng as _, SeedableRng,
     rngs::{StdRng, SysRng},
 };
 
-use crate::safe_cell::{SafeCell, SafeCellHandle as _};
-
 pub const ROOT_KEY_TAG: &[u8] = "arbiter/seal/v1".as_bytes();
 pub const TAG: &[u8] = "arbiter/private-key/v1".as_bytes();
 
@@ -48,37 +47,40 @@ impl<'a> TryFrom<&'a [u8]> for Nonce {
     }
 }
 
-pub struct KeyCell(pub SafeCell<Key>);
+pub struct KeyCell(pub MemSafe<Key>);
-impl From<SafeCell<Key>> for KeyCell {
+impl From<MemSafe<Key>> for KeyCell {
-    fn from(value: SafeCell<Key>) -> Self {
+    fn from(value: MemSafe<Key>) -> Self {
         Self(value)
     }
 }
-impl TryFrom<SafeCell<Vec<u8>>> for KeyCell {
+impl TryFrom<MemSafe<Vec<u8>>> for KeyCell {
     type Error = ();
 
-    fn try_from(mut value: SafeCell<Vec<u8>>) -> Result<Self, Self::Error> {
+    fn try_from(mut value: MemSafe<Vec<u8>>) -> Result<Self, Self::Error> {
-        let value = value.read();
+        let value = value.read().unwrap();
         if value.len() != size_of::<Key>() {
             return Err(());
         }
-        let cell = SafeCell::new_inline(|cell_write: &mut Key| {
+        let mut cell = MemSafe::new(Key::default()).unwrap();
-            cell_write.copy_from_slice(&value);
+        {
-        });
+            let mut cell_write = cell.write().unwrap();
+            let cell_slice: &mut [u8] = cell_write.as_mut();
+            cell_slice.copy_from_slice(&value);
+        }
         Ok(Self(cell))
     }
 }
 
 impl KeyCell {
     pub fn new_secure_random() -> Self {
-        let key = SafeCell::new_inline(|key_buffer: &mut Key| {
+        let mut key = MemSafe::new(Key::default()).unwrap();
-            #[allow(
+        {
-                clippy::unwrap_used,
+            let mut key_buffer = key.write().unwrap();
-                reason = "Rng failure is unrecoverable and should panic"
+            let key_buffer: &mut [u8] = key_buffer.as_mut();
-            )]
+
             let mut rng = StdRng::try_from_rng(&mut SysRng).unwrap();
             rng.fill_bytes(key_buffer);
-        });
+        }
 
         key.into()
     }
@@ -89,7 +91,7 @@ impl KeyCell {
         associated_data: &[u8],
         mut buffer: impl AsMut<Vec<u8>>,
     ) -> Result<(), Error> {
-        let key_reader = self.0.read();
+        let key_reader = self.0.read().unwrap();
         let key_ref = key_reader.deref();
         let cipher = XChaCha20Poly1305::new(key_ref);
         let nonce = XNonce::from_slice(nonce.0.as_ref());
@@ -100,13 +102,13 @@ impl KeyCell {
         &mut self,
         nonce: &Nonce,
         associated_data: &[u8],
-        buffer: &mut SafeCell<Vec<u8>>,
+        buffer: &mut MemSafe<Vec<u8>>,
     ) -> Result<(), Error> {
-        let key_reader = self.0.read();
+        let key_reader = self.0.read().unwrap();
         let key_ref = key_reader.deref();
         let cipher = XChaCha20Poly1305::new(key_ref);
         let nonce = XNonce::from_slice(nonce.0.as_ref());
-        let mut buffer = buffer.write();
+        let mut buffer = buffer.write().unwrap();
         let buffer: &mut Vec<u8> = buffer.as_mut();
         cipher.decrypt_in_place(nonce, associated_data, buffer)
     }
@@ -117,7 +119,7 @@ impl KeyCell {
         associated_data: &[u8],
         plaintext: impl AsRef<[u8]>,
     ) -> Result<Vec<u8>, Error> {
-        let key_reader = self.0.read();
+        let key_reader = self.0.read().unwrap();
         let key_ref = key_reader.deref();
         let mut cipher = XChaCha20Poly1305::new(key_ref);
         let nonce = XNonce::from_slice(nonce.0.as_ref());
@@ -137,10 +139,6 @@ pub type Salt = [u8; ArgonSalt::RECOMMENDED_LENGTH];
 
 pub fn generate_salt() -> Salt {
     let mut salt = Salt::default();
-    #[allow(
-        clippy::unwrap_used,
-        reason = "Rng failure is unrecoverable and should panic"
-    )]
     let mut rng = StdRng::try_from_rng(&mut SysRng).unwrap();
     rng.fill_bytes(&mut salt);
     salt
@@ -148,23 +146,19 @@ pub fn generate_salt() -> Salt {
 
 /// User password might be of different length, have not enough entropy, etc...
 /// Derive a fixed-length key from the password using Argon2id, which is designed for password hashing and key derivation.
-pub fn derive_seal_key(mut password: SafeCell<Vec<u8>>, salt: &Salt) -> KeyCell {
+pub fn derive_seal_key(mut password: MemSafe<Vec<u8>>, salt: &Salt) -> KeyCell {
-    #[allow(clippy::unwrap_used)]
     let params = argon2::Params::new(262_144, 3, 4, None).unwrap();
     let hasher = Argon2::new(Algorithm::Argon2id, argon2::Version::V0x13, params);
-    let mut key = SafeCell::new(Key::default());
+    let mut key = MemSafe::new(Key::default()).unwrap();
-    password.read_inline(|password_source| {
+    {
-        let mut key_buffer = key.write();
+        let password_source = password.read().unwrap();
+        let mut key_buffer = key.write().unwrap();
         let key_buffer: &mut [u8] = key_buffer.as_mut();
 
-        #[allow(
-            clippy::unwrap_used,
-            reason = "Better fail completely than return a weak key"
-        )]
         hasher
             .hash_password_into(password_source.deref(), salt, key_buffer)
             .unwrap();
-    });
+    }
 
     key.into()
 }
@@ -172,20 +166,20 @@ pub fn derive_seal_key(mut password: SafeCell<Vec<u8>>, salt: &Salt) -> KeyCell
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::safe_cell::SafeCell;
+    use memsafe::MemSafe;
 
     #[test]
     pub fn derive_seal_key_deterministic() {
         static PASSWORD: &[u8] = b"password";
-        let password = SafeCell::new(PASSWORD.to_vec());
+        let password = MemSafe::new(PASSWORD.to_vec()).unwrap();
-        let password2 = SafeCell::new(PASSWORD.to_vec());
+        let password2 = MemSafe::new(PASSWORD.to_vec()).unwrap();
         let salt = generate_salt();
 
         let mut key1 = derive_seal_key(password, &salt);
         let mut key2 = derive_seal_key(password2, &salt);
 
-        let key1_reader = key1.0.read();
+        let key1_reader = key1.0.read().unwrap();
-        let key2_reader = key2.0.read();
+        let key2_reader = key2.0.read().unwrap();
 
         assert_eq!(key1_reader.deref(), key2_reader.deref());
     }
@@ -193,11 +187,11 @@ mod tests {
     #[test]
     pub fn successful_derive() {
         static PASSWORD: &[u8] = b"password";
-        let password = SafeCell::new(PASSWORD.to_vec());
+        let password = MemSafe::new(PASSWORD.to_vec()).unwrap();
         let salt = generate_salt();
 
         let mut key = derive_seal_key(password, &salt);
-        let key_reader = key.0.read();
+        let key_reader = key.0.read().unwrap();
         let key_ref = key_reader.deref();
 
         assert_ne!(key_ref.as_slice(), &[0u8; 32][..]);
@@ -206,7 +200,7 @@ mod tests {
     #[test]
     pub fn encrypt_decrypt() {
         static PASSWORD: &[u8] = b"password";
-        let password = SafeCell::new(PASSWORD.to_vec());
+        let password = MemSafe::new(PASSWORD.to_vec()).unwrap();
         let salt = generate_salt();
 
         let mut key = derive_seal_key(password, &salt);
@@ -218,12 +212,12 @@ mod tests {
             .unwrap();
         assert_ne!(buffer, b"secret data");
 
-        let mut buffer = SafeCell::new(buffer);
+        let mut buffer = MemSafe::new(buffer).unwrap();
 
         key.decrypt_in_place(&nonce, associated_data, &mut buffer)
             .unwrap();
 
-        let buffer = buffer.read();
+        let buffer = buffer.read().unwrap();
         assert_eq!(*buffer, b"secret data");
     }
 

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

@@ -1,28 +1,24 @@
-use chrono::Utc;
 use diesel::{
     ExpressionMethods as _, OptionalExtension, QueryDsl, SelectableHelper,
     dsl::{insert_into, update},
 };
 use diesel_async::{AsyncConnection, RunQueryDsl};
 use kameo::{Actor, Reply, messages};
+use memsafe::MemSafe;
 use strum::{EnumDiscriminants, IntoDiscriminant};
 use tracing::{error, info};
 
-use crate::safe_cell::SafeCell;
+use crate::db::{
-use crate::{
+    self,
-    db::{
+    models::{self, RootKeyHistory},
-        self,
+    schema::{self},
-        models::{self, RootKeyHistory},
-        schema::{self},
-    },
-    safe_cell::SafeCellHandle as _,
 };
 use encryption::v1::{self, KeyCell, Nonce};
 
 pub mod encryption;
 
 #[derive(Default, EnumDiscriminants)]
-#[strum_discriminants(derive(Reply), vis(pub), name(KeyHolderState))]
+#[strum_discriminants(derive(Reply), vis(pub))]
 enum State {
     #[default]
     Unbootstrapped,
@@ -139,7 +135,7 @@ impl KeyHolder {
     }
 
     #[message]
-    pub async fn bootstrap(&mut self, seal_key_raw: SafeCell<Vec<u8>>) -> Result<(), Error> {
+    pub async fn bootstrap(&mut self, seal_key_raw: MemSafe<Vec<u8>>) -> Result<(), Error> {
         if !matches!(self.state, State::Unbootstrapped) {
             return Err(Error::AlreadyBootstrapped);
         }
@@ -151,15 +147,16 @@ impl KeyHolder {
         let root_key_nonce = v1::Nonce::default();
         let data_encryption_nonce = v1::Nonce::default();
 
-        let root_key_ciphertext: Vec<u8> = root_key.0.read_inline(|reader| {
+        let root_key_ciphertext: Vec<u8> = {
-            let root_key_reader = reader.as_slice();
+            let root_key_reader = root_key.0.read().unwrap();
+            let root_key_reader = root_key_reader.as_slice();
             seal_key
                 .encrypt(&root_key_nonce, v1::ROOT_KEY_TAG, root_key_reader)
                 .map_err(|err| {
                     error!(?err, "Fatal bootstrap error");
                     Error::Encryption(err)
-                })
+                })?
-        })?;
+        };
 
         let mut conn = self.db.get().await?;
 
@@ -201,7 +198,7 @@ impl KeyHolder {
     }
 
     #[message]
-    pub async fn try_unseal(&mut self, seal_key_raw: SafeCell<Vec<u8>>) -> Result<(), Error> {
+    pub async fn try_unseal(&mut self, seal_key_raw: MemSafe<Vec<u8>>) -> Result<(), Error> {
         let State::Sealed {
             root_key_history_id,
         } = &self.state
@@ -214,6 +211,7 @@ impl KeyHolder {
             let mut conn = self.db.get().await?;
             schema::root_key_history::table
                 .filter(schema::root_key_history::id.eq(*root_key_history_id))
+                .select(schema::root_key_history::data_encryption_nonce)
                 .select(RootKeyHistory::as_select())
                 .first(&mut conn)
                 .await?
@@ -226,7 +224,7 @@ impl KeyHolder {
         })?;
         let mut seal_key = v1::derive_seal_key(seal_key_raw, &salt);
 
-        let mut root_key = SafeCell::new(current_key.ciphertext.clone());
+        let mut root_key = MemSafe::new(current_key.ciphertext.clone()).unwrap();
 
         let nonce = v1::Nonce::try_from(current_key.root_key_encryption_nonce.as_slice()).map_err(
             |_| {
@@ -257,7 +255,7 @@ impl KeyHolder {
 
     // Decrypts the `aead_encrypted` entry with the given ID and returns the plaintext
     #[message]
-    pub async fn decrypt(&mut self, aead_id: i32) -> Result<SafeCell<Vec<u8>>, Error> {
+    pub async fn decrypt(&mut self, aead_id: i32) -> Result<MemSafe<Vec<u8>>, Error> {
         let State::Unsealed { root_key, .. } = &mut self.state else {
             return Err(Error::NotBootstrapped);
         };
@@ -280,14 +278,14 @@ impl KeyHolder {
             );
             Error::BrokenDatabase
         })?;
-        let mut output = SafeCell::new(row.ciphertext);
+        let mut output = MemSafe::new(row.ciphertext).unwrap();
         root_key.decrypt_in_place(&nonce, v1::TAG, &mut output)?;
         Ok(output)
     }
 
     // Creates new `aead_encrypted` entry in the database and returns it's ID
     #[message]
-    pub async fn create_new(&mut self, mut plaintext: SafeCell<Vec<u8>>) -> Result<i32, Error> {
+    pub async fn create_new(&mut self, mut plaintext: MemSafe<Vec<u8>>) -> Result<i32, Error> {
         let State::Unsealed {
             root_key,
             root_key_history_id,
@@ -300,7 +298,7 @@ impl KeyHolder {
         // Borrow checker note: &mut borrow a few lines above is disjoint from this field
         let nonce = Self::get_new_nonce(&self.db, *root_key_history_id).await?;
 
-        let mut ciphertext_buffer = plaintext.write();
+        let mut ciphertext_buffer = plaintext.write().unwrap();
         let ciphertext_buffer: &mut Vec<u8> = ciphertext_buffer.as_mut();
         root_key.encrypt_in_place(&nonce, v1::TAG, &mut *ciphertext_buffer)?;
 
@@ -314,7 +312,7 @@ impl KeyHolder {
                 current_nonce: nonce.to_vec(),
                 schema_version: 1,
                 associated_root_key_id: *root_key_history_id,
-                created_at: Utc::now().into(),
+                created_at: chrono::Utc::now().timestamp() as i32,
             })
             .returning(schema::aead_encrypted::id)
             .get_result(&mut conn)
@@ -324,7 +322,7 @@ impl KeyHolder {
     }
 
     #[message]
-    pub fn get_state(&self) -> KeyHolderState {
+    pub fn get_state(&self) -> StateDiscriminants {
         self.state.discriminant()
     }
 
@@ -347,19 +345,17 @@ impl KeyHolder {
 #[cfg(test)]
 mod tests {
     use diesel::SelectableHelper;
-
+    
     use diesel_async::RunQueryDsl;
+    use memsafe::MemSafe;
 
-    use crate::{
+    use crate::db::{self};
-        db::{self},
-        safe_cell::SafeCell,
-    };
 
     use super::*;
 
     async fn bootstrapped_actor(db: &db::DatabasePool) -> KeyHolder {
         let mut actor = KeyHolder::new(db.clone()).await.unwrap();
-        let seal_key = SafeCell::new(b"test-seal-key".to_vec());
+        let seal_key = MemSafe::new(b"test-seal-key".to_vec()).unwrap();
         actor.bootstrap(seal_key).await.unwrap();
         actor
     }
@@ -394,7 +390,7 @@ mod tests {
         assert_eq!(root_row.data_encryption_nonce, n2.to_vec());
 
         let id = actor
-            .create_new(SafeCell::new(b"post-interleave".to_vec()))
+            .create_new(MemSafe::new(b"post-interleave".to_vec()).unwrap())
             .await
             .unwrap();
         let row: models::AeadEncrypted = schema::aead_encrypted::table

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

@@ -3,17 +3,12 @@ use miette::Diagnostic;
 use thiserror::Error;
 
 use crate::{
-    actors::{
+    actors::{bootstrap::Bootstrapper, keyholder::KeyHolder},
-        bootstrap::Bootstrapper, evm::EvmActor, flow_coordinator::FlowCoordinator,
-        keyholder::KeyHolder,
-    },
     db,
 };
 
 pub mod bootstrap;
 pub mod client;
-mod evm;
-pub mod flow_coordinator;
 pub mod keyholder;
 pub mod user_agent;
 
@@ -33,18 +28,13 @@ pub enum SpawnError {
 pub struct GlobalActors {
     pub key_holder: ActorRef<KeyHolder>,
     pub bootstrapper: ActorRef<Bootstrapper>,
-    pub flow_coordinator: ActorRef<FlowCoordinator>,
-    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?),
-            evm: EvmActor::spawn(EvmActor::new(key_holder.clone(), db)),
+            key_holder: KeyHolder::spawn(KeyHolder::new(db.clone()).await?),
-            key_holder,
-            flow_coordinator: FlowCoordinator::spawn(FlowCoordinator::default()),
         })
     }
 }

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

@@ -1,101 +0,0 @@
-use arbiter_proto::transport::Bi;
-use tracing::error;
-
-use crate::actors::user_agent::{
-    AuthPublicKey, UserAgentConnection,
-    auth::state::{AuthContext, AuthStateMachine},
-};
-
-mod state;
-use state::*;
-
-#[derive(Debug, Clone)]
-pub enum Inbound {
-    AuthChallengeRequest {
-        pubkey: AuthPublicKey,
-        bootstrap_token: Option<String>,
-    },
-    AuthChallengeSolution {
-        signature: Vec<u8>,
-    },
-}
-
-#[derive(Debug)]
-pub enum Error {
-    UnregisteredPublicKey,
-    InvalidChallengeSolution,
-    InvalidBootstrapToken,
-    Internal { details: String },
-    Transport,
-}
-
-impl Error {
-    fn internal(details: impl Into<String>) -> Self {
-        Self::Internal {
-            details: details.into(),
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum Outbound {
-    AuthChallenge { nonce: i32 },
-    AuthSuccess,
-}
-
-fn parse_auth_event(payload: Inbound) -> AuthEvents {
-    match payload {
-        Inbound::AuthChallengeRequest {
-            pubkey,
-            bootstrap_token: None,
-        } => AuthEvents::AuthRequest(ChallengeRequest { pubkey }),
-        Inbound::AuthChallengeRequest {
-            pubkey,
-            bootstrap_token: Some(token),
-        } => AuthEvents::BootstrapAuthRequest(BootstrapAuthRequest { pubkey, token }),
-        Inbound::AuthChallengeSolution { signature } => {
-            AuthEvents::ReceivedSolution(ChallengeSolution {
-                solution: signature,
-            })
-        }
-    }
-}
-
-pub async fn authenticate<T>(
-    props: &mut UserAgentConnection,
-    transport: T,
-) -> Result<AuthPublicKey, Error>
-where
-    T: Bi<Inbound, Result<Outbound, Error>> + Send,
-{
-    let mut state = AuthStateMachine::new(AuthContext::new(props, transport));
-
-    loop {
-        // `state` holds a mutable reference to `props` so we can't access it directly here
-        let Some(payload) = state.context_mut().transport.recv().await else {
-            return Err(Error::Transport);
-        };
-
-        match state.process_event(parse_auth_event(payload)).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);
-            }
-
-            _ => (),
-        }
-    }
-}

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

@@ -1,225 +0,0 @@
-use arbiter_proto::transport::Bi;
-use diesel::{ExpressionMethods as _, OptionalExtension as _, QueryDsl, update};
-use diesel_async::RunQueryDsl;
-use tracing::error;
-
-use super::Error;
-use crate::{
-    actors::{
-        bootstrap::ConsumeToken,
-        user_agent::{AuthPublicKey, UserAgentConnection, auth::Outbound},
-    },
-    db::schema,
-};
-
-pub struct ChallengeRequest {
-    pub pubkey: AuthPublicKey,
-}
-
-pub struct BootstrapAuthRequest {
-    pub pubkey: AuthPublicKey,
-    pub token: String,
-}
-
-pub struct ChallengeContext {
-    pub challenge_nonce: i32,
-    pub key: AuthPublicKey,
-}
-
-pub struct ChallengeSolution {
-    pub solution: Vec<u8>,
-}
-
-smlang::statemachine!(
-    name: Auth,
-    custom_error: true,
-    transitions: {
-        *Init + AuthRequest(ChallengeRequest) / async prepare_challenge = SentChallenge(ChallengeContext),
-        Init + BootstrapAuthRequest(BootstrapAuthRequest) / async verify_bootstrap_token = AuthOk(AuthPublicKey),
-        SentChallenge(ChallengeContext) + ReceivedSolution(ChallengeSolution) / async verify_solution = AuthOk(AuthPublicKey),
-    }
-);
-
-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::internal("Database unavailable")
-    })?;
-    db_conn
-        .exclusive_transaction(|conn| {
-            Box::pin(async move {
-                let current_nonce = schema::useragent_client::table
-                    .filter(schema::useragent_client::public_key.eq(pubkey_bytes.to_vec()))
-                    .select(schema::useragent_client::nonce)
-                    .first::<i32>(conn)
-                    .await?;
-
-                update(schema::useragent_client::table)
-                    .filter(schema::useragent_client::public_key.eq(pubkey_bytes.to_vec()))
-                    .set(schema::useragent_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::internal("Database operation failed")
-        })?
-        .ok_or_else(|| {
-            error!(?pubkey_bytes, "Public key not found in database");
-            Error::UnregisteredPublicKey
-        })
-}
-
-async fn register_key(db: &crate::db::DatabasePool, pubkey: &AuthPublicKey) -> Result<(), Error> {
-    let pubkey_bytes = pubkey.to_stored_bytes();
-    let key_type = pubkey.key_type();
-    let mut conn = db.get().await.map_err(|e| {
-        error!(error = ?e, "Database pool error");
-        Error::internal("Database unavailable")
-    })?;
-
-    diesel::insert_into(schema::useragent_client::table)
-        .values((
-            schema::useragent_client::public_key.eq(pubkey_bytes),
-            schema::useragent_client::nonce.eq(1),
-            schema::useragent_client::key_type.eq(key_type),
-        ))
-        .execute(&mut conn)
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Database error");
-            Error::internal("Database operation failed")
-        })?;
-
-    Ok(())
-}
-
-pub struct AuthContext<'a, T> {
-    pub(super) conn: &'a mut UserAgentConnection,
-    pub(super) transport: T,
-}
-
-impl<'a, T> AuthContext<'a, T> {
-    pub fn new(conn: &'a mut UserAgentConnection, transport: T) -> Self {
-        Self { conn, transport }
-    }
-}
-
-impl<T> AuthStateMachineContext for AuthContext<'_, T>
-where
-    T: Bi<super::Inbound, Result<super::Outbound, Error>> + Send,
-{
-    type Error = Error;
-
-    async fn prepare_challenge(
-        &mut self,
-        ChallengeRequest { pubkey }: ChallengeRequest,
-    ) -> Result<ChallengeContext, Self::Error> {
-        let stored_bytes = pubkey.to_stored_bytes();
-        let nonce = create_nonce(&self.conn.db, &stored_bytes).await?;
-
-        self.transport
-            .send(Ok(Outbound::AuthChallenge { nonce }))
-            .await
-            .map_err(|e| {
-                error!(?e, "Failed to send auth challenge");
-                Error::Transport
-            })?;
-
-        Ok(ChallengeContext {
-            challenge_nonce: nonce,
-            key: pubkey,
-        })
-    }
-
-    #[allow(missing_docs)]
-    #[allow(clippy::result_unit_err)]
-    async fn verify_bootstrap_token(
-        &mut self,
-        BootstrapAuthRequest { pubkey, token }: BootstrapAuthRequest,
-    ) -> Result<AuthPublicKey, Self::Error> {
-        let token_ok: bool = self
-            .conn
-            .actors
-            .bootstrapper
-            .ask(ConsumeToken {
-                token: token.clone(),
-            })
-            .await
-            .map_err(|e| {
-                error!(?e, "Failed to consume bootstrap token");
-                Error::internal("Failed to consume bootstrap token")
-            })?;
-
-        if !token_ok {
-            error!("Invalid bootstrap token provided");
-            return Err(Error::InvalidBootstrapToken);
-        }
-
-        register_key(&self.conn.db, &pubkey).await?;
-
-        self.transport
-            .send(Ok(Outbound::AuthSuccess))
-            .await
-            .map_err(|_| Error::Transport)?;
-
-        Ok(pubkey)
-    }
-
-    #[allow(missing_docs)]
-    #[allow(clippy::unused_unit)]
-    async fn verify_solution(
-        &mut self,
-        ChallengeContext {
-            challenge_nonce,
-            key,
-        }: &ChallengeContext,
-        ChallengeSolution { solution }: ChallengeSolution,
-    ) -> Result<AuthPublicKey, Self::Error> {
-        let formatted = arbiter_proto::format_challenge(*challenge_nonce, &key.to_stored_bytes());
-
-        let valid = match key {
-            AuthPublicKey::Ed25519(vk) => {
-                let sig = solution.as_slice().try_into().map_err(|_| {
-                    error!(?solution, "Invalid Ed25519 signature length");
-                    Error::InvalidChallengeSolution
-                })?;
-                vk.verify_strict(&formatted, &sig).is_ok()
-            }
-            AuthPublicKey::EcdsaSecp256k1(vk) => {
-                use k256::ecdsa::signature::Verifier as _;
-                let sig = k256::ecdsa::Signature::try_from(solution.as_slice()).map_err(|_| {
-                    error!(?solution, "Invalid ECDSA signature bytes");
-                    Error::InvalidChallengeSolution
-                })?;
-                vk.verify(&formatted, &sig).is_ok()
-            }
-            AuthPublicKey::Rsa(pk) => {
-                use rsa::signature::Verifier as _;
-                let verifying_key = rsa::pss::VerifyingKey::<sha2::Sha256>::new(pk.clone());
-                let sig = rsa::pss::Signature::try_from(solution.as_slice()).map_err(|_| {
-                    error!(?solution, "Invalid RSA signature bytes");
-                    Error::InvalidChallengeSolution
-                })?;
-                verifying_key.verify(&formatted, &sig).is_ok()
-            }
-        };
-
-        if !valid {
-            error!("Invalid challenge solution signature");
-            return Err(Error::InvalidChallengeSolution);
-        }
-
-        self.transport
-            .send(Ok(Outbound::AuthSuccess))
-            .await
-            .map_err(|_| Error::Transport)?;
-
-        Ok(key.clone())
-    }
-}

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

@@ -0,0 +1,57 @@
+use tonic::Status;
+
+use crate::db;
+
+#[derive(Debug, thiserror::Error)]
+pub enum UserAgentError {
+    #[error("Missing payload in request")]
+    MissingPayload,
+
+    #[error("Invalid bootstrap token")]
+    InvalidBootstrapToken,
+
+    #[error("Public key not registered")]
+    PubkeyNotRegistered,
+
+    #[error("Invalid public key format")]
+    InvalidPubkey,
+
+    #[error("Invalid signature length")]
+    InvalidSignatureLength,
+
+    #[error("Invalid challenge solution")]
+    InvalidChallengeSolution,
+
+    #[error("Invalid state for operation")]
+    InvalidState,
+
+    #[error("Actor unavailable")]
+    ActorUnavailable,
+
+    #[error("Database error")]
+    Database(#[from] diesel::result::Error),
+
+    #[error("Database pool error")]
+    DatabasePool(#[from] db::PoolError),
+}
+
+impl From<UserAgentError> for Status {
+    fn from(err: UserAgentError) -> Self {
+        match err {
+            UserAgentError::MissingPayload
+            | UserAgentError::InvalidBootstrapToken
+            | UserAgentError::InvalidPubkey
+            | UserAgentError::InvalidSignatureLength => Status::invalid_argument(err.to_string()),
+
+            UserAgentError::PubkeyNotRegistered | UserAgentError::InvalidChallengeSolution => {
+                Status::unauthenticated(err.to_string())
+            }
+
+            UserAgentError::InvalidState => Status::failed_precondition(err.to_string()),
+
+            UserAgentError::ActorUnavailable
+            | UserAgentError::Database(_)
+            | UserAgentError::DatabasePool(_) => Status::internal(err.to_string()),
+        }
+    }
+}

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

@@ -1,94 +1,401 @@
+use std::{ops::DerefMut, sync::Mutex};
+
+use arbiter_proto::proto::{
+    UnsealEncryptedKey, UnsealResult, UnsealStart, UnsealStartResponse, UserAgentRequest,
+    UserAgentResponse,
+    auth::{
+        self, AuthChallengeRequest, AuthOk, ClientMessage as ClientAuthMessage,
+        ServerMessage as AuthServerMessage,
+        client_message::Payload as ClientAuthPayload,
+        server_message::Payload as ServerAuthPayload,
+    },
+    user_agent_request::Payload as UserAgentRequestPayload,
+    user_agent_response::Payload as UserAgentResponsePayload,
+};
+use chacha20poly1305::{AeadInPlace, XChaCha20Poly1305, XNonce, aead::KeyInit};
+use diesel::{ExpressionMethods as _, OptionalExtension as _, QueryDsl, dsl::update};
+use diesel_async::RunQueryDsl;
+use ed25519_dalek::VerifyingKey;
+use kameo::{Actor, actor::Recipient, error::SendError, messages, prelude::Message};
+use memsafe::MemSafe;
+use tracing::{error, info};
+use x25519_dalek::{EphemeralSecret, PublicKey};
+
 use crate::{
-    actors::{GlobalActors, client::ClientProfile},
+    ServerContext,
-    db::{self, models::KeyType},
+    actors::{
+        GlobalActors,
+        bootstrap::ConsumeToken,
+        keyholder::{self, TryUnseal},
+        user_agent::state::{
+            ChallengeContext, DummyContext, UnsealContext, UserAgentEvents, UserAgentStateMachine,
+            UserAgentStates,
+        },
+    },
+    db::{self, schema},
 };
 
-/// Abstraction over Ed25519 / ECDSA-secp256k1 / RSA public keys used during the auth handshake.
+mod error;
-#[derive(Clone, Debug)]
+mod state;
-pub enum AuthPublicKey {
+
-    Ed25519(ed25519_dalek::VerifyingKey),
+pub use error::UserAgentError;
-    /// Compressed SEC1 public key; signature bytes are raw 64-byte (r||s).
+
-    EcdsaSecp256k1(k256::ecdsa::VerifyingKey),
+#[derive(Actor)]
-    /// RSA-2048+ public key (Windows Hello / KeyCredentialManager); signature bytes are PSS+SHA-256.
+pub struct UserAgentActor {
-    Rsa(rsa::RsaPublicKey),
+    db: db::DatabasePool,
+    actors: GlobalActors,
+    state: UserAgentStateMachine<DummyContext>,
+    transport: Recipient<Result<UserAgentResponse, UserAgentError>>,
 }
 
-impl AuthPublicKey {
+impl UserAgentActor {
-    /// Canonical bytes stored in DB and echoed back in the challenge.
+    pub(crate) fn new(
-    /// Ed25519: raw 32 bytes. ECDSA: SEC1 compressed 33 bytes. RSA: DER-encoded SPKI.
+        context: ServerContext,
-    pub fn to_stored_bytes(&self) -> Vec<u8> {
+        transport: Recipient<Result<UserAgentResponse, UserAgentError>>,
-        match self {
+    ) -> Self {
-            AuthPublicKey::Ed25519(k) => k.to_bytes().to_vec(),
+        Self {
-            // SEC1 compressed (33 bytes) is the natural compact format for secp256k1
+            db: context.db.clone(),
-            AuthPublicKey::EcdsaSecp256k1(k) => k.to_encoded_point(true).as_bytes().to_vec(),
+            actors: context.actors.clone(),
-            AuthPublicKey::Rsa(k) => {
+            state: UserAgentStateMachine::new(DummyContext),
-                use rsa::pkcs8::EncodePublicKey as _;
+            transport,
-                #[allow(clippy::expect_used)]
+        }
-                k.to_public_key_der()
+    }
-                    .expect("rsa SPKI encoding is infallible")
+
-                    .to_vec()
+    pub fn new_manual(
+        db: db::DatabasePool,
+        actors: GlobalActors,
+        transport: Recipient<Result<UserAgentResponse, UserAgentError>>,
+    ) -> Self {
+        Self {
+            db,
+            actors,
+            state: UserAgentStateMachine::new(DummyContext),
+            transport,
+        }
+    }
+
+    async fn process_request(&mut self, req: UserAgentRequest) -> Output {
+        let msg = req.payload.ok_or_else(|| {
+            error!(actor = "useragent", "Received message with no payload");
+            UserAgentError::MissingPayload
+        })?;
+
+        match msg {
+            UserAgentRequestPayload::AuthMessage(ClientAuthMessage {
+                payload: Some(ClientAuthPayload::AuthChallengeRequest(req)),
+            }) => self.handle_auth_challenge_request(req).await,
+            UserAgentRequestPayload::AuthMessage(ClientAuthMessage {
+                payload: Some(ClientAuthPayload::AuthChallengeSolution(solution)),
+            }) => self.handle_auth_challenge_solution(solution).await,
+            UserAgentRequestPayload::UnsealStart(unseal_start) => {
+                self.handle_unseal_request(unseal_start).await
+            }
+            UserAgentRequestPayload::UnsealEncryptedKey(unseal_encrypted_key) => {
+                self.handle_unseal_encrypted_key(unseal_encrypted_key).await
+            }
+            _ => Err(UserAgentError::MissingPayload),
+        }
+    }
+
+    fn transition(&mut self, event: UserAgentEvents) -> Result<(), UserAgentError> {
+        self.state.process_event(event).map_err(|e| {
+            error!(?e, "State transition failed");
+            UserAgentError::InvalidState
+        })?;
+        Ok(())
+    }
+
+    async fn auth_with_bootstrap_token(
+        &mut self,
+        pubkey: ed25519_dalek::VerifyingKey,
+        token: String,
+    ) -> Output {
+        let token_ok: bool = self
+            .actors
+            .bootstrapper
+            .ask(ConsumeToken { token })
+            .await
+            .map_err(|e| {
+                error!(?pubkey, "Failed to consume bootstrap token: {e}");
+                UserAgentError::ActorUnavailable
+            })?;
+
+        if !token_ok {
+            error!(?pubkey, "Invalid bootstrap token provided");
+            return Err(UserAgentError::InvalidBootstrapToken);
+        }
+
+        {
+            let mut conn = self.db.get().await?;
+
+            diesel::insert_into(schema::useragent_client::table)
+                .values((
+                    schema::useragent_client::public_key.eq(pubkey.as_bytes().to_vec()),
+                    schema::useragent_client::nonce.eq(1),
+                ))
+                .execute(&mut conn)
+                .await?;
+        }
+
+        self.transition(UserAgentEvents::ReceivedBootstrapToken)?;
+
+        Ok(auth_response(ServerAuthPayload::AuthOk(AuthOk {})))
+    }
+
+    async fn auth_with_challenge(&mut self, pubkey: VerifyingKey, pubkey_bytes: Vec<u8>) -> Output {
+        let nonce: Option<i32> = {
+            let mut db_conn = self.db.get().await?;
+            db_conn
+                .exclusive_transaction(|conn| {
+                    Box::pin(async move {
+                        let current_nonce = schema::useragent_client::table
+                            .filter(
+                                schema::useragent_client::public_key.eq(pubkey.as_bytes().to_vec()),
+                            )
+                            .select(schema::useragent_client::nonce)
+                            .first::<i32>(conn)
+                            .await?;
+
+                        update(schema::useragent_client::table)
+                            .filter(
+                                schema::useragent_client::public_key.eq(pubkey.as_bytes().to_vec()),
+                            )
+                            .set(schema::useragent_client::nonce.eq(current_nonce + 1))
+                            .execute(conn)
+                            .await?;
+
+                        Result::<_, diesel::result::Error>::Ok(current_nonce)
+                    })
+                })
+                .await
+                .optional()?
+        };
+
+        let Some(nonce) = nonce else {
+            error!(?pubkey, "Public key not found in database");
+            return Err(UserAgentError::PubkeyNotRegistered);
+        };
+
+        let challenge = auth::AuthChallenge {
+            pubkey: pubkey_bytes,
+            nonce,
+        };
+
+        self.transition(UserAgentEvents::SentChallenge(ChallengeContext {
+            challenge: challenge.clone(),
+            key: pubkey,
+        }))?;
+
+        info!(
+            ?pubkey,
+            ?challenge,
+            "Sent authentication challenge to client"
+        );
+
+        Ok(auth_response(ServerAuthPayload::AuthChallenge(challenge)))
+    }
+
+    fn verify_challenge_solution(
+        &self,
+        solution: &auth::AuthChallengeSolution,
+    ) -> Result<(bool, &ChallengeContext), UserAgentError> {
+        let UserAgentStates::WaitingForChallengeSolution(challenge_context) = self.state.state()
+        else {
+            error!("Received challenge solution in invalid state");
+            return Err(UserAgentError::InvalidState);
+        };
+        let formatted_challenge = arbiter_proto::format_challenge(&challenge_context.challenge);
+
+        let signature = solution.signature.as_slice().try_into().map_err(|_| {
+            error!(?solution, "Invalid signature length");
+            UserAgentError::InvalidSignatureLength
+        })?;
+
+        let valid = challenge_context
+            .key
+            .verify_strict(&formatted_challenge, &signature)
+            .is_ok();
+
+        Ok((valid, challenge_context))
+    }
+}
+
+type Output = Result<UserAgentResponse, UserAgentError>;
+
+fn auth_response(payload: ServerAuthPayload) -> UserAgentResponse {
+    UserAgentResponse {
+        payload: Some(UserAgentResponsePayload::AuthMessage(AuthServerMessage {
+            payload: Some(payload),
+        })),
+    }
+}
+
+fn unseal_response(payload: UserAgentResponsePayload) -> UserAgentResponse {
+    UserAgentResponse {
+        payload: Some(payload),
+    }
+}
+
+#[messages]
+impl UserAgentActor {
+    #[message]
+    pub async fn handle_unseal_request(&mut self, req: UnsealStart) -> Output {
+        let secret = EphemeralSecret::random();
+        let public_key = PublicKey::from(&secret);
+
+        let client_pubkey_bytes: [u8; 32] = req
+            .client_pubkey
+            .try_into()
+            .map_err(|_| UserAgentError::InvalidPubkey)?;
+
+        let client_public_key = PublicKey::from(client_pubkey_bytes);
+
+        self.transition(UserAgentEvents::UnsealRequest(UnsealContext {
+            secret: Mutex::new(Some(secret)),
+            client_public_key,
+        }))?;
+
+        Ok(unseal_response(
+            UserAgentResponsePayload::UnsealStartResponse(UnsealStartResponse {
+                server_pubkey: public_key.as_bytes().to_vec(),
+            }),
+        ))
+    }
+
+    #[message]
+    pub 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(UserAgentError::InvalidState);
+        };
+        let ephemeral_secret = {
+            let mut secret_lock = unseal_context.secret.lock().unwrap();
+            let secret = secret_lock.take();
+            match secret {
+                Some(secret) => secret,
+                None => {
+                    drop(secret_lock);
+                    error!("Ephemeral secret already taken");
+                    self.transition(UserAgentEvents::ReceivedInvalidKey)?;
+                    return Ok(unseal_response(UserAgentResponsePayload::UnsealResult(
+                        UnsealResult::InvalidKey.into(),
+                    )));
+                }
+            }
+        };
+
+        let nonce = XNonce::from_slice(&req.nonce);
+
+        let shared_secret = ephemeral_secret.diffie_hellman(&unseal_context.client_public_key);
+        let cipher = XChaCha20Poly1305::new(shared_secret.as_bytes().into());
+
+        let mut seal_key_buffer = MemSafe::new(req.ciphertext.clone()).unwrap();
+
+        let decryption_result = {
+            let mut write_handle = seal_key_buffer.write().unwrap();
+            let write_handle = write_handle.deref_mut();
+            cipher.decrypt_in_place(nonce, &req.associated_data, write_handle)
+        };
+
+        match decryption_result {
+            Ok(_) => {
+                match self
+                    .actors
+                    .key_holder
+                    .ask(TryUnseal {
+                        seal_key_raw: seal_key_buffer,
+                    })
+                    .await
+                {
+                    Ok(_) => {
+                        info!("Successfully unsealed key with client-provided key");
+                        self.transition(UserAgentEvents::ReceivedValidKey)?;
+                        Ok(unseal_response(UserAgentResponsePayload::UnsealResult(
+                            UnsealResult::Success.into(),
+                        )))
+                    }
+                    Err(SendError::HandlerError(keyholder::Error::InvalidKey)) => {
+                        self.transition(UserAgentEvents::ReceivedInvalidKey)?;
+                        Ok(unseal_response(UserAgentResponsePayload::UnsealResult(
+                            UnsealResult::InvalidKey.into(),
+                        )))
+                    }
+                    Err(SendError::HandlerError(err)) => {
+                        error!(?err, "Keyholder failed to unseal key");
+                        self.transition(UserAgentEvents::ReceivedInvalidKey)?;
+                        Ok(unseal_response(UserAgentResponsePayload::UnsealResult(
+                            UnsealResult::InvalidKey.into(),
+                        )))
+                    }
+                    Err(err) => {
+                        error!(?err, "Failed to send unseal request to keyholder");
+                        self.transition(UserAgentEvents::ReceivedInvalidKey)?;
+                        Err(UserAgentError::ActorUnavailable)
+                    }
+                }
+            }
+            Err(err) => {
+                error!(?err, "Failed to decrypt unseal key");
+                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
+                Ok(unseal_response(UserAgentResponsePayload::UnsealResult(
+                    UnsealResult::InvalidKey.into(),
+                )))
             }
         }
     }
 
-    pub fn key_type(&self) -> KeyType {
+    #[message]
-        match self {
+    pub async fn handle_auth_challenge_request(&mut self, req: AuthChallengeRequest) -> Output {
-            AuthPublicKey::Ed25519(_) => KeyType::Ed25519,
+        let pubkey = req
-            AuthPublicKey::EcdsaSecp256k1(_) => KeyType::EcdsaSecp256k1,
+            .pubkey
-            AuthPublicKey::Rsa(_) => KeyType::Rsa,
+            .as_array()
+            .ok_or(UserAgentError::InvalidPubkey)?;
+        let pubkey = VerifyingKey::from_bytes(pubkey).map_err(|_err| {
+            error!(?pubkey, "Failed to convert to VerifyingKey");
+            UserAgentError::InvalidPubkey
+        })?;
+
+        self.transition(UserAgentEvents::AuthRequest)?;
+
+        match req.bootstrap_token {
+            Some(token) => self.auth_with_bootstrap_token(pubkey, token).await,
+            None => self.auth_with_challenge(pubkey, req.pubkey).await,
+        }
+    }
+
+    #[message]
+    pub async fn handle_auth_challenge_solution(
+        &mut self,
+        solution: auth::AuthChallengeSolution,
+    ) -> Output {
+        let (valid, challenge_context) = self.verify_challenge_solution(&solution)?;
+
+        if valid {
+            info!(
+                ?challenge_context,
+                "Client provided valid solution to authentication challenge"
+            );
+            self.transition(UserAgentEvents::ReceivedGoodSolution)?;
+            Ok(auth_response(ServerAuthPayload::AuthOk(AuthOk {})))
+        } else {
+            error!("Client provided invalid solution to authentication challenge");
+            self.transition(UserAgentEvents::ReceivedBadSolution)?;
+            Err(UserAgentError::InvalidChallengeSolution)
         }
     }
 }
 
-impl TryFrom<(KeyType, Vec<u8>)> for AuthPublicKey {
+impl Message<UserAgentRequest> for UserAgentActor {
-    type Error = &'static str;
+    type Reply = ();
 
-    fn try_from(value: (KeyType, Vec<u8>)) -> Result<Self, Self::Error> {
+    async fn handle(
-        let (key_type, bytes) = value;
+        &mut self,
-        match key_type {
+        msg: UserAgentRequest,
-            KeyType::Ed25519 => {
+        _ctx: &mut kameo::prelude::Context<Self, Self::Reply>,
-                let bytes: [u8; 32] = bytes.try_into().map_err(|_| "invalid Ed25519 key length")?;
+    ) -> Self::Reply {
-                let key = ed25519_dalek::VerifyingKey::from_bytes(&bytes)
+        let result = self.process_request(msg).await;
-                    .map_err(|_e| "invalid Ed25519 key")?;
+        if let Err(e) = self.transport.tell(result).await {
-                Ok(AuthPublicKey::Ed25519(key))
+            error!(actor = "useragent", "Failed to send response to transport: {}", e);
-            }
-            KeyType::EcdsaSecp256k1 => {
-                let point =
-                    k256::EncodedPoint::from_bytes(&bytes).map_err(|_e| "invalid ECDSA key")?;
-                let key = k256::ecdsa::VerifyingKey::from_encoded_point(&point)
-                    .map_err(|_e| "invalid ECDSA key")?;
-                Ok(AuthPublicKey::EcdsaSecp256k1(key))
-            }
-            KeyType::Rsa => {
-                use rsa::pkcs8::DecodePublicKey as _;
-                let key = rsa::RsaPublicKey::from_public_key_der(&bytes)
-                    .map_err(|_e| "invalid RSA key")?;
-                Ok(AuthPublicKey::Rsa(key))
-            }
         }
     }
 }
-
-// Messages, sent by user agent to connection client without having a request
-#[derive(Debug)]
-pub enum OutOfBand {
-    ClientConnectionRequest { profile: ClientProfile },
-    ClientConnectionCancel { pubkey: ed25519_dalek::VerifyingKey },
-}
-
-pub struct UserAgentConnection {
-    pub(crate) db: db::DatabasePool,
-    pub(crate) actors: GlobalActors,
-}
-
-impl UserAgentConnection {
-    pub fn new(db: db::DatabasePool, actors: GlobalActors) -> Self {
-        Self { db, actors }
-    }
-}
-
-pub mod auth;
-pub mod session;
-
-pub use auth::authenticate;
-pub use session::UserAgentSession;

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

@@ -1,181 +0,0 @@
-use std::{borrow::Cow, collections::HashMap};
-
-use arbiter_proto::transport::Sender;
-use async_trait::async_trait;
-use ed25519_dalek::VerifyingKey;
-use kameo::{Actor, actor::ActorRef, messages};
-use thiserror::Error;
-use tracing::error;
-
-use crate::actors::{
-    client::ClientProfile,
-    flow_coordinator::{RegisterUserAgent, client_connect_approval::ClientApprovalController},
-    user_agent::{OutOfBand, UserAgentConnection},
-};
-
-mod state;
-use state::{DummyContext, UserAgentEvents, UserAgentStateMachine};
-
-#[derive(Debug, Error)]
-pub enum Error {
-    #[error("State transition failed")]
-    State,
-
-    #[error("Internal error: {message}")]
-    Internal { message: Cow<'static, str> },
-}
-
-impl From<crate::db::PoolError> for Error {
-    fn from(err: crate::db::PoolError) -> Self {
-        error!(?err, "Database pool error");
-        Self::internal("Database pool error")
-    }
-}
-impl From<diesel::result::Error> for Error {
-    fn from(err: diesel::result::Error) -> Self {
-        error!(?err, "Database error");
-        Self::internal("Database error")
-    }
-}
-
-impl Error {
-    pub fn internal(message: impl Into<Cow<'static, str>>) -> Self {
-        Self::Internal {
-            message: message.into(),
-        }
-    }
-}
-
-pub struct PendingClientApproval {
-    controller: ActorRef<ClientApprovalController>,
-}
-
-pub struct UserAgentSession {
-    props: UserAgentConnection,
-    state: UserAgentStateMachine<DummyContext>,
-    sender: Box<dyn Sender<OutOfBand>>,
-
-    pending_client_approvals: HashMap<VerifyingKey, PendingClientApproval>,
-}
-
-pub mod connection;
-
-impl UserAgentSession {
-    pub(crate) fn new(props: UserAgentConnection, sender: Box<dyn Sender<OutOfBand>>) -> Self {
-        Self {
-            props,
-            state: UserAgentStateMachine::new(DummyContext),
-            sender,
-            pending_client_approvals: Default::default(),
-        }
-    }
-
-    pub fn new_test(db: crate::db::DatabasePool, actors: crate::actors::GlobalActors) -> Self {
-        struct DummySender;
-
-        #[async_trait]
-        impl Sender<OutOfBand> for DummySender {
-            async fn send(
-                &mut self,
-                _item: OutOfBand,
-            ) -> Result<(), arbiter_proto::transport::Error> {
-                Ok(())
-            }
-        }
-
-        Self::new(UserAgentConnection::new(db, actors), Box::new(DummySender))
-    }
-
-    fn transition(&mut self, event: UserAgentEvents) -> Result<(), Error> {
-        self.state.process_event(event).map_err(|e| {
-            error!(?e, "State transition failed");
-            Error::State
-        })?;
-        Ok(())
-    }
-}
-
-#[messages]
-impl UserAgentSession {
-    #[message]
-    pub async fn begin_new_client_approval(
-        &mut self,
-        client: ClientProfile,
-        controller: ActorRef<ClientApprovalController>,
-    ) {
-        if let Err(e) = self
-            .sender
-            .send(OutOfBand::ClientConnectionRequest {
-                profile: client.clone(),
-            })
-            .await
-        {
-            error!(
-                ?e,
-                actor = "user_agent",
-                event = "failed to announce new client connection"
-            );
-            return;
-        }
-
-        self.pending_client_approvals
-            .insert(client.pubkey, PendingClientApproval { controller });
-    }
-}
-
-impl Actor for UserAgentSession {
-    type Args = Self;
-
-    type Error = Error;
-
-    async fn on_start(
-        args: Self::Args,
-        this: kameo::prelude::ActorRef<Self>,
-    ) -> Result<Self, Self::Error> {
-        args.props
-            .actors
-            .flow_coordinator
-            .ask(RegisterUserAgent {
-                actor: this.clone(),
-            })
-            .await
-            .map_err(|err| {
-                error!(
-                    ?err,
-                    "Failed to register user agent connection with flow coordinator"
-                );
-                Error::internal("Failed to register user agent connection with flow coordinator")
-            })?;
-        Ok(args)
-    }
-
-    async fn on_link_died(
-        &mut self,
-        _: kameo::prelude::WeakActorRef<Self>,
-        id: kameo::prelude::ActorId,
-        _: kameo::prelude::ActorStopReason,
-    ) -> Result<std::ops::ControlFlow<kameo::prelude::ActorStopReason>, Self::Error> {
-        let cancelled_pubkey = self
-            .pending_client_approvals
-            .iter()
-            .find_map(|(k, v)| (v.controller.id() == id).then_some(*k));
-
-        if let Some(pubkey) = cancelled_pubkey {
-            self.pending_client_approvals.remove(&pubkey);
-
-            if let Err(e) = self
-                .sender
-                .send(OutOfBand::ClientConnectionCancel { pubkey })
-                .await
-            {
-                error!(
-                    ?e,
-                    actor = "user_agent",
-                    event = "failed to announce client connection cancellation"
-                );
-            }
-        }
-
-        Ok(std::ops::ControlFlow::Continue(()))
-    }
-}

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

@@ -1,510 +0,0 @@
-use std::sync::Mutex;
-
-use alloy::{consensus::TxEip1559, primitives::Address, signers::Signature};
-use chacha20poly1305::{AeadInPlace, XChaCha20Poly1305, XNonce, aead::KeyInit};
-use diesel::{ExpressionMethods as _, QueryDsl as _, SelectableHelper};
-use diesel_async::{AsyncConnection, RunQueryDsl};
-use kameo::error::SendError;
-use kameo::prelude::Context;
-use kameo::messages;
-use tracing::{error, info};
-use x25519_dalek::{EphemeralSecret, PublicKey};
-
-use crate::actors::flow_coordinator::client_connect_approval::ClientApprovalAnswer;
-use crate::actors::keyholder::KeyHolderState;
-use crate::actors::user_agent::session::Error;
-use crate::db::models::{
-    EvmWalletAccess, NewEvmWalletAccess, ProgramClient, ProgramClientMetadata,
-};
-use crate::evm::policies::{Grant, SpecificGrant};
-use crate::safe_cell::SafeCell;
-use crate::{
-    actors::{
-        evm::{
-            ClientSignTransaction, Generate, ListWallets, SignTransactionError as EvmSignError,
-            UseragentCreateGrant, UseragentDeleteGrant, UseragentListGrants,
-        },
-        keyholder::{self, Bootstrap, TryUnseal},
-        user_agent::session::{
-            UserAgentSession,
-            state::{UnsealContext, UserAgentEvents, UserAgentStates},
-        },
-    },
-    safe_cell::SafeCellHandle as _,
-};
-
-impl UserAgentSession {
-    fn take_unseal_secret(&mut self) -> Result<(EphemeralSecret, PublicKey), Error> {
-        let UserAgentStates::WaitingForUnsealKey(unseal_context) = self.state.state() else {
-            error!("Received encrypted key in invalid state");
-            return Err(Error::internal("Invalid state for unseal encrypted key"));
-        };
-
-        let ephemeral_secret = {
-            #[allow(
-                clippy::unwrap_used,
-                reason = "Mutex poison is unrecoverable and should panic"
-            )]
-            let mut secret_lock = unseal_context.secret.lock().unwrap();
-            let secret = secret_lock.take();
-            match secret {
-                Some(secret) => secret,
-                None => {
-                    drop(secret_lock);
-                    error!("Ephemeral secret already taken");
-                    return Err(Error::internal("Ephemeral secret already taken"));
-                }
-            }
-        };
-
-        Ok((ephemeral_secret, unseal_context.client_public_key))
-    }
-
-    fn decrypt_client_key_material(
-        ephemeral_secret: EphemeralSecret,
-        client_public_key: PublicKey,
-        nonce: &[u8],
-        ciphertext: &[u8],
-        associated_data: &[u8],
-    ) -> Result<SafeCell<Vec<u8>>, ()> {
-        let nonce = XNonce::from_slice(nonce);
-
-        let shared_secret = ephemeral_secret.diffie_hellman(&client_public_key);
-        let cipher = XChaCha20Poly1305::new(shared_secret.as_bytes().into());
-
-        let mut key_buffer = SafeCell::new(ciphertext.to_vec());
-
-        let decryption_result = key_buffer.write_inline(|write_handle| {
-            cipher.decrypt_in_place(nonce, associated_data, write_handle)
-        });
-
-        match decryption_result {
-            Ok(_) => Ok(key_buffer),
-            Err(err) => {
-                error!(?err, "Failed to decrypt encrypted key material");
-                Err(())
-            }
-        }
-    }
-}
-
-pub struct UnsealStartResponse {
-    pub server_pubkey: PublicKey,
-}
-
-#[derive(Debug, Error)]
-pub enum UnsealError {
-    #[error("Invalid key provided for unsealing")]
-    InvalidKey,
-    #[error("Internal error during unsealing process")]
-    General(#[from] super::Error),
-}
-
-#[derive(Debug, Error)]
-pub enum BootstrapError {
-    #[error("Invalid key provided for bootstrapping")]
-    InvalidKey,
-    #[error("Vault is already bootstrapped")]
-    AlreadyBootstrapped,
-
-    #[error("Internal error during bootstrapping process")]
-    General(#[from] super::Error),
-}
-
-#[derive(Debug, Error)]
-pub enum SignTransactionError {
-    #[error("Policy evaluation failed")]
-    Vet(#[from] crate::evm::VetError),
-
-    #[error("Internal signing error")]
-    Internal,
-}
-
-#[messages]
-impl UserAgentSession {
-    #[message]
-    pub async fn handle_unseal_request(
-        &mut self,
-        client_pubkey: x25519_dalek::PublicKey,
-    ) -> Result<UnsealStartResponse, Error> {
-        let secret = EphemeralSecret::random();
-        let public_key = PublicKey::from(&secret);
-
-        self.transition(UserAgentEvents::UnsealRequest(UnsealContext {
-            secret: Mutex::new(Some(secret)),
-            client_public_key: client_pubkey,
-        }))?;
-
-        Ok(UnsealStartResponse {
-            server_pubkey: public_key,
-        })
-    }
-
-    #[message]
-    pub async fn handle_unseal_encrypted_key(
-        &mut self,
-        nonce: Vec<u8>,
-        ciphertext: Vec<u8>,
-        associated_data: Vec<u8>,
-    ) -> Result<(), UnsealError> {
-        let (ephemeral_secret, client_public_key) = match self.take_unseal_secret() {
-            Ok(values) => values,
-            Err(Error::State) => {
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                return Err(UnsealError::InvalidKey);
-            }
-            Err(_err) => {
-                return Err(Error::internal("Failed to take unseal secret").into());
-            }
-        };
-
-        let seal_key_buffer = match Self::decrypt_client_key_material(
-            ephemeral_secret,
-            client_public_key,
-            &nonce,
-            &ciphertext,
-            &associated_data,
-        ) {
-            Ok(buffer) => buffer,
-            Err(()) => {
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                return Err(UnsealError::InvalidKey);
-            }
-        };
-
-        match self
-            .props
-            .actors
-            .key_holder
-            .ask(TryUnseal {
-                seal_key_raw: seal_key_buffer,
-            })
-            .await
-        {
-            Ok(_) => {
-                info!("Successfully unsealed key with client-provided key");
-                self.transition(UserAgentEvents::ReceivedValidKey)?;
-                Ok(())
-            }
-            Err(SendError::HandlerError(keyholder::Error::InvalidKey)) => {
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Err(UnsealError::InvalidKey)
-            }
-            Err(SendError::HandlerError(err)) => {
-                error!(?err, "Keyholder failed to unseal key");
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Err(UnsealError::InvalidKey)
-            }
-            Err(err) => {
-                error!(?err, "Failed to send unseal request to keyholder");
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Err(Error::internal("Vault actor error").into())
-            }
-        }
-    }
-
-    #[message]
-    pub(crate) async fn handle_bootstrap_encrypted_key(
-        &mut self,
-        nonce: Vec<u8>,
-        ciphertext: Vec<u8>,
-        associated_data: Vec<u8>,
-    ) -> Result<(), BootstrapError> {
-        let (ephemeral_secret, client_public_key) = match self.take_unseal_secret() {
-            Ok(values) => values,
-            Err(Error::State) => {
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                return Err(BootstrapError::InvalidKey);
-            }
-            Err(err) => return Err(err.into()),
-        };
-
-        let seal_key_buffer = match Self::decrypt_client_key_material(
-            ephemeral_secret,
-            client_public_key,
-            &nonce,
-            &ciphertext,
-            &associated_data,
-        ) {
-            Ok(buffer) => buffer,
-            Err(()) => {
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                return Err(BootstrapError::InvalidKey);
-            }
-        };
-
-        match self
-            .props
-            .actors
-            .key_holder
-            .ask(Bootstrap {
-                seal_key_raw: seal_key_buffer,
-            })
-            .await
-        {
-            Ok(_) => {
-                info!("Successfully bootstrapped vault with client-provided key");
-                self.transition(UserAgentEvents::ReceivedValidKey)?;
-                Ok(())
-            }
-            Err(SendError::HandlerError(keyholder::Error::AlreadyBootstrapped)) => {
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Err(BootstrapError::AlreadyBootstrapped)
-            }
-            Err(SendError::HandlerError(err)) => {
-                error!(?err, "Keyholder failed to bootstrap vault");
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Err(BootstrapError::InvalidKey)
-            }
-            Err(err) => {
-                error!(?err, "Failed to send bootstrap request to keyholder");
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Err(BootstrapError::General(Error::internal(
-                    "Vault actor error",
-                )))
-            }
-        }
-    }
-}
-
-#[messages]
-impl UserAgentSession {
-    #[message]
-    pub(crate) async fn handle_query_vault_state(&mut self) -> Result<KeyHolderState, Error> {
-        use crate::actors::keyholder::GetState;
-
-        let vault_state = match self.props.actors.key_holder.ask(GetState {}).await {
-            Ok(state) => state,
-            Err(err) => {
-                error!(?err, actor = "useragent", "keyholder.query.failed");
-                return Err(Error::internal("Vault is in broken state"));
-            }
-        };
-
-        Ok(vault_state)
-    }
-}
-
-#[messages]
-impl UserAgentSession {
-    #[message]
-    pub(crate) async fn handle_evm_wallet_create(&mut self) -> Result<(i32, Address), Error> {
-        match self.props.actors.evm.ask(Generate {}).await {
-            Ok(address) => Ok(address),
-            Err(SendError::HandlerError(err)) => Err(Error::internal(format!(
-                "EVM wallet generation failed: {err}"
-            ))),
-            Err(err) => {
-                error!(?err, "EVM actor unreachable during wallet create");
-                Err(Error::internal("EVM actor unreachable"))
-            }
-        }
-    }
-
-    #[message]
-    pub(crate) async fn handle_evm_wallet_list(&mut self) -> Result<Vec<(i32, Address)>, Error> {
-        match self.props.actors.evm.ask(ListWallets {}).await {
-            Ok(wallets) => Ok(wallets),
-            Err(err) => {
-                error!(?err, "EVM wallet list failed");
-                Err(Error::internal("Failed to list EVM wallets"))
-            }
-        }
-    }
-}
-
-#[messages]
-impl UserAgentSession {
-    #[message]
-    pub(crate) async fn handle_grant_list(&mut self) -> Result<Vec<Grant<SpecificGrant>>, Error> {
-        match self.props.actors.evm.ask(UseragentListGrants {}).await {
-            Ok(grants) => Ok(grants),
-            Err(err) => {
-                error!(?err, "EVM grant list failed");
-                Err(Error::internal("Failed to list EVM grants"))
-            }
-        }
-    }
-
-    #[message]
-    pub(crate) async fn handle_grant_create(
-        &mut self,
-        basic: crate::evm::policies::SharedGrantSettings,
-        grant: crate::evm::policies::SpecificGrant,
-    ) -> Result<i32, Error> {
-        match self
-            .props
-            .actors
-            .evm
-            .ask(UseragentCreateGrant { basic, grant })
-            .await
-        {
-            Ok(grant_id) => Ok(grant_id),
-            Err(err) => {
-                error!(?err, "EVM grant create failed");
-                Err(Error::internal("Failed to create EVM grant"))
-            }
-        }
-    }
-
-    #[message]
-    pub(crate) async fn handle_grant_delete(&mut self, grant_id: i32) -> Result<(), Error> {
-        match self
-            .props
-            .actors
-            .evm
-            .ask(UseragentDeleteGrant { grant_id })
-            .await
-        {
-            Ok(()) => Ok(()),
-            Err(err) => {
-                error!(?err, "EVM grant delete failed");
-                Err(Error::internal("Failed to delete EVM grant"))
-            }
-        }
-    }
-
-    #[message]
-    pub(crate) async fn handle_sign_transaction(
-        &mut self,
-        client_id: i32,
-        wallet_address: Address,
-        transaction: TxEip1559,
-    ) -> Result<Signature, SignTransactionError> {
-        match self
-            .props
-            .actors
-            .evm
-            .ask(ClientSignTransaction {
-                client_id,
-                wallet_address,
-                transaction,
-            })
-            .await
-        {
-            Ok(signature) => Ok(signature),
-            Err(SendError::HandlerError(EvmSignError::Vet(vet_error))) => {
-                Err(SignTransactionError::Vet(vet_error))
-            }
-            Err(err) => {
-                error!(?err, "EVM sign transaction failed in user-agent session");
-                Err(SignTransactionError::Internal)
-            }
-        }
-    }
-
-    #[message]
-    pub(crate) async fn handle_grant_evm_wallet_access(
-        &mut self,
-        entries: Vec<NewEvmWalletAccess>,
-    ) -> Result<(), Error> {
-        let mut conn = self.props.db.get().await?;
-        conn.transaction(|conn| {
-            Box::pin(async move {
-                use crate::db::schema::evm_wallet_access;
-
-                for entry in entries {
-                    diesel::insert_into(evm_wallet_access::table)
-                        .values(&entry)
-                        .on_conflict_do_nothing()
-                        .execute(conn)
-                        .await?;
-                }
-
-                Result::<_, Error>::Ok(())
-            })
-        })
-        .await?;
-        Ok(())
-    }
-
-    #[message]
-    pub(crate) async fn handle_revoke_evm_wallet_access(
-        &mut self,
-        entries: Vec<i32>,
-    ) -> Result<(), Error> {
-        let mut conn = self.props.db.get().await?;
-        conn.transaction(|conn| {
-            Box::pin(async move {
-                use crate::db::schema::evm_wallet_access;
-                for entry in entries {
-                    diesel::delete(evm_wallet_access::table)
-                        .filter(evm_wallet_access::wallet_id.eq(entry))
-                        .execute(conn)
-                        .await?;
-                }
-
-                Result::<_, Error>::Ok(())
-            })
-        })
-        .await?;
-        Ok(())
-    }
-
-    #[message]
-    pub(crate) async fn handle_list_wallet_access(
-        &mut self,
-    ) -> Result<Vec<EvmWalletAccess>, Error> {
-        let mut conn = self.props.db.get().await?;
-        use crate::db::schema::evm_wallet_access;
-        let access_entries = evm_wallet_access::table
-            .select(EvmWalletAccess::as_select())
-            .load::<_>(&mut conn)
-            .await?;
-        Ok(access_entries)
-    }
-}
-
-#[messages]
-impl UserAgentSession {
-    #[message(ctx)]
-    pub(crate) async fn handle_new_client_approve(
-        &mut self,
-        approved: bool,
-        pubkey: ed25519_dalek::VerifyingKey,
-        ctx: &mut Context<Self, Result<(), Error>>,
-    ) -> Result<(), Error> {
-        let pending_approval = match self.pending_client_approvals.remove(&pubkey) {
-            Some(approval) => approval,
-            None => {
-                error!("Received client connection response for unknown client");
-                return Err(Error::internal("Unknown client in connection response"));
-            }
-        };
-
-        pending_approval
-            .controller
-            .tell(ClientApprovalAnswer { approved })
-            .await
-            .map_err(|err| {
-                error!(
-                    ?err,
-                    "Failed to send client approval response to controller"
-                );
-                Error::internal("Failed to send client approval response to controller")
-            })?;
-
-        ctx.actor_ref().unlink(&pending_approval.controller).await;
-
-        Ok(())
-    }
-
-    #[message]
-    pub(crate) async fn handle_sdk_client_list(
-        &mut self,
-    ) -> Result<Vec<(ProgramClient, ProgramClientMetadata)>, Error> {
-        use crate::db::schema::{client_metadata, program_client};
-        let mut conn = self.props.db.get().await?;
-
-        let clients = program_client::table
-            .inner_join(client_metadata::table)
-            .select((
-                ProgramClient::as_select(),
-                ProgramClientMetadata::as_select(),
-            ))
-            .load::<(ProgramClient, ProgramClientMetadata)>(&mut conn)
-            .await?;
-
-        Ok(clients)
-    }
-}

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

@@ -1,27 +0,0 @@
-use std::sync::Mutex;
-
-use x25519_dalek::{EphemeralSecret, PublicKey};
-
-pub struct UnsealContext {
-    pub client_public_key: PublicKey,
-    pub secret: Mutex<Option<EphemeralSecret>>,
-}
-
-smlang::statemachine!(
-    name: UserAgent,
-    custom_error: false,
-    transitions: {
-        *Idle + UnsealRequest(UnsealContext) / generate_temp_keypair = WaitingForUnsealKey(UnsealContext),
-        WaitingForUnsealKey(UnsealContext) + ReceivedValidKey = Unsealed,
-        WaitingForUnsealKey(UnsealContext) + ReceivedInvalidKey = Idle,
-    }
-);
-
-pub struct DummyContext;
-impl UserAgentStateMachineContext for DummyContext {
-    #[allow(missing_docs)]
-    #[allow(clippy::unused_unit)]
-    fn generate_temp_keypair(&mut self, event_data: UnsealContext) -> Result<UnsealContext, ()> {
-        Ok(event_data)
-    }
-}

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

@@ -0,0 +1,51 @@
+use std::sync::Mutex;
+
+use arbiter_proto::proto::auth::AuthChallenge;
+use ed25519_dalek::VerifyingKey;
+use x25519_dalek::{EphemeralSecret, PublicKey};
+
+/// Context for state machine with validated key and sent challenge
+/// Challenge is then transformed to bytes using shared function and verified
+#[derive(Clone, Debug)]
+pub struct ChallengeContext {
+    pub challenge: AuthChallenge,
+    pub key: VerifyingKey,
+}
+
+pub struct UnsealContext {
+    pub client_public_key: PublicKey,
+    pub secret: Mutex<Option<EphemeralSecret>>,
+}
+
+smlang::statemachine!(
+    name: UserAgent,
+    custom_error: false,
+    transitions: {
+        *Init + AuthRequest =  ReceivedAuthRequest,
+        ReceivedAuthRequest + ReceivedBootstrapToken = Idle,
+
+        ReceivedAuthRequest + SentChallenge(ChallengeContext) / move_challenge = WaitingForChallengeSolution(ChallengeContext),
+
+        WaitingForChallengeSolution(ChallengeContext) + ReceivedGoodSolution = Idle,
+        WaitingForChallengeSolution(ChallengeContext) + ReceivedBadSolution = AuthError, // block further transitions, but connection should close anyway
+
+        Idle + UnsealRequest(UnsealContext) / generate_temp_keypair = WaitingForUnsealKey(UnsealContext),
+        WaitingForUnsealKey(UnsealContext) + ReceivedValidKey = Unsealed,
+        WaitingForUnsealKey(UnsealContext) + ReceivedInvalidKey = Idle,
+    }
+);
+
+pub struct DummyContext;
+impl UserAgentStateMachineContext for DummyContext {
+    #[allow(missing_docs)]
+    #[allow(clippy::unused_unit)]
+    fn generate_temp_keypair(&mut self, event_data: UnsealContext) -> Result<UnsealContext, ()> {
+        Ok(event_data)
+    }
+
+    #[allow(missing_docs)]
+    #[allow(clippy::unused_unit)]
+    fn move_challenge(&mut self, event_data: ChallengeContext) -> Result<ChallengeContext, ()> {
+        Ok(event_data)
+    }
+}

server/crates/arbiter-server/src/context/tls.rs

@@ -1,4 +1,4 @@
-use std::{net::IpAddr, string::FromUtf8Error};
+use std::string::FromUtf8Error;
 
 use diesel::{ExpressionMethods as _, QueryDsl, SelectableHelper as _};
 use diesel_async::{AsyncConnection, RunQueryDsl};
@@ -6,9 +6,9 @@ use miette::Diagnostic;
 use pem::Pem;
 use rcgen::{
     BasicConstraints, Certificate, CertificateParams, CertifiedIssuer, DistinguishedName, DnType,
-    IsCa, Issuer, KeyPair, KeyUsagePurpose, SanType,
+    IsCa, Issuer, KeyPair, KeyUsagePurpose,
 };
-use rustls::pki_types::pem::PemObject;
+use rustls::pki_types::{pem::PemObject};
 use thiserror::Error;
 use tonic::transport::CertificateDer;
 
@@ -59,7 +59,10 @@ pub enum InitError {
 pub type PemCert = String;
 
 pub fn encode_cert_to_pem(cert: &CertificateDer) -> PemCert {
-    pem::encode_config(&Pem::new("CERTIFICATE", cert.to_vec()), ENCODE_CONFIG)
+    pem::encode_config(
+        &Pem::new("CERTIFICATE", cert.to_vec()),
+        ENCODE_CONFIG,
+    )
 }
 
 #[allow(unused)]
@@ -91,10 +94,6 @@ impl TlsCa {
 
         let cert_key_pem = certified_issuer.key().serialize_pem();
 
-        #[allow(
-            clippy::unwrap_used,
-            reason = "Broken cert couldn't bootstrap server anyway"
-        )]
         let issuer = Issuer::from_ca_cert_pem(
             &certified_issuer.pem(),
             KeyPair::from_pem(cert_key_pem.as_ref()).unwrap(),
@@ -114,11 +113,6 @@ impl TlsCa {
             KeyUsagePurpose::DigitalSignature,
             KeyUsagePurpose::KeyEncipherment,
         ];
-        params
-            .subject_alt_names
-            .push(SanType::IpAddress(IpAddr::from([
-                127, 0, 0, 1,
-            ])));
 
         let mut dn = DistinguishedName::new();
         dn.push(DnType::CommonName, "Arbiter Instance Leaf");

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

@@ -44,14 +44,6 @@ pub enum DatabaseSetupError {
     Pool(#[from] PoolInitError),
 }
 
-#[derive(Error, Debug)]
-pub enum DatabaseError {
-    #[error("Database connection error")]
-    Pool(#[from] PoolError),
-    #[error("Database query error")]
-    Connection(#[from] diesel::result::Error),
-}
-
 #[tracing::instrument(level = "info")]
 fn database_path() -> Result<std::path::PathBuf, DatabaseSetupError> {
     let arbiter_home = arbiter_proto::home_path().map_err(DatabaseSetupError::HomeDir)?;
@@ -100,7 +92,6 @@ fn initialize_database(url: &str) -> Result<(), DatabaseSetupError> {
 #[tracing::instrument(level = "info")]
 pub async fn create_pool(url: Option<&str>) -> Result<DatabasePool, DatabaseSetupError> {
     let database_url = url.map(String::from).unwrap_or(
-        #[allow(clippy::expect_used)]
         database_path()?
             .to_str()
             .expect("database path is not valid UTF-8")
@@ -144,13 +135,11 @@ pub async fn create_test_pool() -> DatabasePool {
     let tempfile_name = Alphanumeric.sample_string(&mut rand::rng(), 16);
 
     let file = std::env::temp_dir().join(tempfile_name);
-    #[allow(clippy::expect_used)]
+    let url = format!(
-    let url = file
+        "{}?mode=rwc",
-        .to_str()
+        file.to_str().expect("temp file path is not valid UTF-8")
-        .expect("temp file path is not valid UTF-8")
+    );
-        .to_string();
 
-    #[allow(clippy::expect_used)]
     create_pool(Some(&url))
         .await
         .expect("Failed to create test database pool")

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

@@ -1,113 +1,14 @@
 #![allow(unused)]
 #![allow(clippy::all)]
 
-use crate::db::schema::{
+use crate::db::schema::{self, aead_encrypted, arbiter_settings, root_key_history, tls_history};
-    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 chrono::{DateTime, Utc};
-    use diesel::{
+    pub struct SqliteTimestamp(DateTime<Utc>);
-        deserialize::{FromSql, FromSqlRow},
-        expression::AsExpression,
-        serialize::{IsNull, ToSql},
-        sql_types::Integer,
-        sqlite::{Sqlite, SqliteType},
-    };
-
-    #[derive(Debug, FromSqlRow, AsExpression, Clone)]
-    #[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 From<SqliteTimestamp> for chrono::DateTime<Utc> {
-        fn from(ts: SqliteTimestamp) -> Self {
-            ts.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))
-        }
-    }
-
-    /// Key algorithm stored in the `useragent_client.key_type` column.
-    /// Values must stay stable — they are persisted in the database.
-    #[derive(Debug, Clone, Copy, PartialEq, Eq, FromSqlRow, AsExpression, strum::FromRepr)]
-    #[diesel(sql_type = Integer)]
-    #[repr(i32)]
-    pub enum KeyType {
-        Ed25519 = 1,
-        EcdsaSecp256k1 = 2,
-        Rsa = 3,
-    }
-
-    impl ToSql<Integer, Sqlite> for KeyType {
-        fn to_sql<'b>(
-            &'b self,
-            out: &mut diesel::serialize::Output<'b, '_, Sqlite>,
-        ) -> diesel::serialize::Result {
-            out.set_value(*self as i32);
-            Ok(IsNull::No)
-        }
-    }
-
-    impl FromSql<Integer, Sqlite> for KeyType {
-        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("Expected Integer for KeyType".into());
-            };
-            let discriminant = bytes.read_long();
-            KeyType::from_repr(discriminant as i32)
-                .ok_or_else(|| format!("Unknown KeyType discriminant: {discriminant}").into())
-        }
-    }
 }
-pub use types::*;
 
 #[derive(Models, Queryable, Debug, Insertable, Selectable)]
 #[view(
@@ -124,7 +25,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: SqliteTimestamp,
+    pub created_at: i32,
 }
 
 #[derive(Models, Queryable, Debug, Insertable, Selectable)]
@@ -157,9 +58,9 @@ pub struct TlsHistory {
     pub id: i32,
     pub cert: String,
     pub cert_key: String, // PEM Encoded private key
-    pub ca_cert: String,  // PEM Encoded certificate for cert signing
+    pub ca_cert: String, // PEM Encoded certificate for cert signing
-    pub ca_key: String,   // PEM Encoded public key for cert signing
+    pub ca_key: String, // PEM Encoded public key for cert signing
-    pub created_at: SqliteTimestamp,
+    pub created_at: i32,
 }
 
 #[derive(Queryable, Debug, Insertable, Selectable)]
@@ -167,212 +68,25 @@ pub struct TlsHistory {
 pub struct ArbiterSettings {
     pub id: i32,
     pub root_key_id: Option<i32>, // references root_key_history.id
-    pub tls_id: Option<i32>,      // references tls_history.id
+    pub tls_id: Option<i32>, // references tls_history.id
 }
 
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
+#[derive(Queryable, Debug)]
-#[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(Models, Queryable, Debug, Insertable, Selectable, Clone)]
-#[diesel(table_name = schema::evm_wallet_access, check_for_backend(Sqlite))]
-#[view(
-    NewEvmWalletAccess,
-    derive(Insertable),
-    omit(id, created_at),
-    attributes_with = "deriveless"
-)]
-#[view(
-    CoreEvmWalletAccess,
-    derive(Insertable),
-    omit(created_at),
-    attributes_with = "deriveless"
-)]
-pub struct EvmWalletAccess {
-    pub id: i32,
-    pub wallet_id: i32,
-    pub client_id: i32,
-    pub created_at: SqliteTimestamp,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = schema::client_metadata, check_for_backend(Sqlite))]
-pub struct ProgramClientMetadata {
-    pub id: i32,
-    pub name: String,
-    pub description: Option<String>,
-    pub version: Option<String>,
-    pub created_at: SqliteTimestamp,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = schema::client_metadata_history, check_for_backend(Sqlite))]
-pub struct ProgramClientMetadataHistory {
-    pub id: i32,
-    pub metadata_id: i32,
-    pub client_id: i32,
-    pub created_at: SqliteTimestamp,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
 #[diesel(table_name = schema::program_client, check_for_backend(Sqlite))]
 pub struct ProgramClient {
     pub id: i32,
-    pub nonce: i32,
     pub public_key: Vec<u8>,
-    pub metadata_id: i32,
+    pub nonce: i32,
-    pub created_at: SqliteTimestamp,
+    pub created_at: i32,
-    pub updated_at: SqliteTimestamp,
+    pub updated_at: i32,
 }
 
 #[derive(Queryable, Debug)]
 #[diesel(table_name = schema::useragent_client, check_for_backend(Sqlite))]
 pub struct UseragentClient {
     pub id: i32,
-    pub nonce: i32,
     pub public_key: Vec<u8>,
-    pub created_at: SqliteTimestamp,
+    pub nonce: i32,
-    pub updated_at: SqliteTimestamp,
+    pub created_at: i32,
-    pub key_type: KeyType,
+    pub updated_at: i32,
-}
-
-#[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_access_id: i32, // references evm_wallet_access.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 wallet_access_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,131 +20,11 @@ diesel::table! {
     }
 }
 
-diesel::table! {
-    client_metadata (id) {
-        id -> Integer,
-        name -> Text,
-        description -> Nullable<Text>,
-        version -> Nullable<Text>,
-        created_at -> Integer,
-    }
-}
-
-diesel::table! {
-    client_metadata_history (id) {
-        id -> Integer,
-        metadata_id -> Integer,
-        client_id -> Integer,
-        created_at -> Integer,
-    }
-}
-
-diesel::table! {
-    evm_basic_grant (id) {
-        id -> Integer,
-        wallet_access_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,
-        wallet_access_id -> Integer,
-        grant_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! {
-    evm_wallet_access (id) {
-        id -> Integer,
-        wallet_id -> Integer,
-        client_id -> Integer,
-        created_at -> Integer,
-    }
-}
-
 diesel::table! {
     program_client (id) {
         id -> Integer,
         nonce -> Integer,
         public_key -> Binary,
-        metadata_id -> Integer,
         created_at -> Integer,
         updated_at -> Integer,
     }
@@ -178,7 +58,6 @@ diesel::table! {
         id -> Integer,
         nonce -> Integer,
         public_key -> Binary,
-        key_type -> Integer,
         created_at -> Integer,
         updated_at -> Integer,
     }
@@ -187,38 +66,10 @@ 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!(client_metadata_history -> client_metadata (metadata_id));
-diesel::joinable!(client_metadata_history -> program_client (client_id));
-diesel::joinable!(evm_basic_grant -> evm_wallet_access (wallet_access_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_transaction_log -> evm_basic_grant (grant_id));
-diesel::joinable!(evm_transaction_log -> evm_wallet_access (wallet_access_id));
-diesel::joinable!(evm_wallet -> aead_encrypted (aead_encrypted_id));
-diesel::joinable!(evm_wallet_access -> evm_wallet (wallet_id));
-diesel::joinable!(evm_wallet_access -> program_client (client_id));
-diesel::joinable!(program_client -> client_metadata (metadata_id));
 
 diesel::allow_tables_to_appear_in_same_query!(
     aead_encrypted,
     arbiter_settings,
-    client_metadata,
-    client_metadata_history,
-    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,
-    evm_wallet_access,
     program_client,
     root_key_history,
     tls_history,

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

@@ -1,84 +0,0 @@
-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

@@ -1,306 +0,0 @@
-pub mod abi;
-pub mod safe_signer;
-
-use alloy::{
-    consensus::TxEip1559,
-    primitives::{TxKind, U256},
-};
-use chrono::Utc;
-use diesel::{ExpressionMethods as _, QueryDsl as _, QueryResult, insert_into, sqlite::Sqlite};
-use diesel_async::{AsyncConnection, RunQueryDsl};
-
-use crate::{
-    db::{
-        self, DatabaseError,
-        models::{
-            EvmBasicGrant, EvmWalletAccess, 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 error")]
-    Database(#[from] crate::db::DatabaseError),
-    #[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 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,
-}
-
-/// 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.is_some_and(|t| now < t) || shared.valid_until.is_some_and(|t| now > t) {
-        violations.push(EvalViolation::InvalidTime);
-    }
-
-    // Gas fee caps
-    let fee_exceeded = shared
-        .max_gas_fee_per_gas
-        .is_some_and(|cap| U256::from(context.max_fee_per_gas) > cap);
-    let priority_exceeded = shared
-        .max_priority_fee_per_gas
-        .is_some_and(|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.map_err(DatabaseError::from)?;
-
-        let grant = P::try_find_grant(&context, &mut conn)
-            .await
-            .map_err(DatabaseError::from)?
-            .ok_or(PolicyError::NoMatchingGrant)?;
-
-        let mut violations =
-            check_shared_constraints(&context, &grant.shared, grant.shared_grant_id, &mut conn)
-                .await
-                .map_err(DatabaseError::from)?;
-        violations.extend(
-            P::evaluate(&context, meaning, &grant, &mut conn)
-                .await
-                .map_err(DatabaseError::from)?,
-        );
-
-        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,
-                            wallet_access_id: context.target.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
-            .map_err(DatabaseError::from)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Engine {
-    pub fn new(db: db::DatabasePool) -> Self {
-        Self { db }
-    }
-
-    pub async fn create_grant<P: Policy>(
-        &self,
-        full_grant: FullGrant<P::Settings>,
-    ) -> Result<i32, DatabaseError> {
-        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 {
-                            chain_id: full_grant.basic.chain as i32,
-                            wallet_access_id: full_grant.basic.wallet_access_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>>, DatabaseError> {
-        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,
-        target: EvmWalletAccess,
-        transaction: TxEip1559,
-        run_kind: RunKind,
-    ) -> Result<SpecificMeaning, VetError> {
-        let TxKind::Call(to) = transaction.to else {
-            return Err(VetError::ContractCreationNotSupported);
-        };
-        let context = policies::EvalContext {
-            target,
-            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

@@ -1,209 +0,0 @@
-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, EvmWalletAccess},
-    evm::utils,
-};
-
-pub mod ether_transfer;
-pub mod token_transfers;
-
-#[derive(Debug, Clone)]
-pub struct EvalContext {
-    // Which wallet is this transaction for and who requested it
-    pub target: EvmWalletAccess,
-
-    // 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;
-
-#[derive(Debug)]
-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_access_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_access_id: model.wallet_access_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)
-    }
-}
-
-#[derive(Debug, Clone)]
-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

@@ -1,348 +0,0 @@
-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 {
-    pub(crate) to: Address,
-    pub(crate) 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)
-    }
-}
-impl From<Meaning> for SpecificMeaning {
-    fn from(val: Meaning) -> SpecificMeaning {
-        SpecificMeaning::EtherTransfer(val)
-    }
-}
-
-// A grant for ether transfers, which can be scoped to specific target addresses and volume limits
-#[derive(Debug, Clone)]
-pub struct Settings {
-    pub target: Vec<Address>,
-    pub limit: VolumeRateLimit,
-}
-
-impl From<Settings> for SpecificGrant {
-    fn from(val: Settings) -> SpecificGrant {
-        SpecificGrant::EtherTransfer(val)
-    }
-}
-
-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>,
-    current_transfer_value: U256,
-    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 prospective_cumulative_volume: U256 = past_transaction
-        .iter()
-        .filter(|(_, timestamp)| timestamp >= &window_start)
-        .fold(current_transfer_value, |acc, (value, _)| acc + *value);
-
-    if prospective_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, meaning.value, 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_access_id
-                    .eq(context.target.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

@@ -1,386 +0,0 @@
-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, EvmWalletAccess, 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_ACCESS_ID: i32 = 1;
-const CHAIN_ID: u64 = 1;
-
-const ALLOWED: Address = address!("1111111111111111111111111111111111111111");
-const OTHER: Address = address!("2222222222222222222222222222222222222222");
-
-fn ctx(to: Address, value: U256) -> EvalContext {
-    EvalContext {
-        target: EvmWalletAccess {
-            id: WALLET_ACCESS_ID,
-            wallet_id: 10,
-            client_id: 20,
-            created_at: SqliteTimestamp(Utc::now()),
-        },
-        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_access_id: WALLET_ACCESS_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_access_id: WALLET_ACCESS_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,
-            wallet_access_id: WALLET_ACCESS_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,
-            wallet_access_id: WALLET_ACCESS_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(1u64));
-    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 including current transfer — check is `>`, so this should not violate
-    insert_into(evm_transaction_log::table)
-        .values(NewEvmTransactionLog {
-            grant_id,
-            wallet_access_id: WALLET_ACCESS_ID,
-            chain_id: CHAIN_ID as i32,
-            eth_value: utils::u256_to_bytes(U256::from(900u64)).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

@@ -1,386 +0,0 @@
-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 {
-    pub(crate) token: &'static TokenInfo,
-    pub(crate) to: Address,
-    pub(crate) 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 From<Meaning> for SpecificMeaning {
-    fn from(val: Meaning) -> SpecificMeaning {
-        SpecificMeaning::TokenTransfer(val)
-    }
-}
-
-// A grant for token transfers, which can be scoped to specific target addresses and volume limits
-#[derive(Debug, Clone)]
-pub struct Settings {
-    pub token_contract: Address,
-    pub target: Option<Address>,
-    pub volume_limits: Vec<VolumeRateLimit>,
-}
-impl From<Settings> for SpecificGrant {
-    fn from(val: Settings) -> SpecificGrant {
-        SpecificGrant::TokenTransfer(val)
-    }
-}
-
-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>,
-    current_transfer_value: U256,
-    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 prospective_cumulative_volume: U256 = past_transfers
-            .iter()
-            .filter(|(_, timestamp)| timestamp >= &window_start)
-            .fold(current_transfer_value, |acc, (value, _)| acc + *value);
-
-        if prospective_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
-            && allowed != meaning.to
-        {
-            violations.push(EvalViolation::InvalidTarget { target: meaning.to });
-        }
-
-        let rate_violations = check_volume_rate_limits(grant, meaning.value, 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_access_id.eq(context.target.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

@@ -1,464 +0,0 @@
-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, EvmWalletAccess, 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_ACCESS_ID: i32 = 1;
-
-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 {
-        target: EvmWalletAccess {
-            id: WALLET_ACCESS_ID,
-            wallet_id: 10,
-            client_id: 20,
-            created_at: SqliteTimestamp(Utc::now()),
-        },
-        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_access_id: WALLET_ACCESS_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_access_id: WALLET_ACCESS_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_at_exact_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 900, with current transfer 100 => exactly 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(900u64)).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_000u64)).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(1u64));
-    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

@@ -1,195 +0,0 @@
-use std::sync::Mutex;
-
-use crate::safe_cell::{SafeCell, SafeCellHandle as _};
-use alloy::{
-    consensus::SignableTransaction,
-    network::{TxSigner, TxSignerSync},
-    primitives::{Address, B256, ChainId, Signature},
-    signers::{Error, Result, Signer, SignerSync, utils::secret_key_to_address},
-};
-use async_trait::async_trait;
-use k256::ecdsa::{self, RecoveryId, SigningKey, signature::hazmat::PrehashSigner};
-
-/// 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<SafeCell<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) -> (SafeCell<[u8; 32]>, Address) {
-    loop {
-        let mut cell = SafeCell::new_inline(|w: &mut [u8; 32]| {
-            rng.fill_bytes(w);
-        });
-
-        let reader = cell.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_cell(mut cell: SafeCell<Vec<u8>>) -> Result<Self> {
-        let reader = cell.read();
-        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 = SafeCell::new(key);
-        Ok(Self {
-            key: Mutex::new(cell),
-            address,
-            chain_id: None,
-        })
-    }
-
-    fn sign_hash_inner(&self, hash: &B256) -> Result<Signature> {
-        #[allow(clippy::expect_used)]
-        let mut cell = self.key.lock().expect("SafeSigner mutex poisoned");
-        let reader = cell.read();
-        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
-            && !tx.set_chain_id_checked(chain_id)
-        {
-            return Err(Error::TransactionChainIdMismatch {
-                signer: chain_id,
-                #[allow(clippy::expect_used)]
-                tx: tx.chain_id().expect("Chain ID is guaranteed to be set"),
-            });
-        }
-        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

@@ -1,26 +0,0 @@
-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/grpc/client.rs

@@ -1,116 +0,0 @@
-use arbiter_proto::{
-    proto::client::{
-        ClientRequest, ClientResponse, client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    },
-    transport::{Receiver, Sender, grpc::GrpcBi},
-};
-use kameo::actor::{ActorRef, Spawn as _};
-use tonic::Status;
-use tracing::{info, warn};
-
-use crate::{
-    actors::client::{ClientConnection, session::ClientSession},
-    grpc::request_tracker::RequestTracker,
-};
-
-mod auth;
-mod evm;
-mod inbound;
-mod outbound;
-mod vault;
-
-async fn dispatch_loop(
-    mut bi: GrpcBi<ClientRequest, ClientResponse>,
-    actor: ActorRef<ClientSession>,
-    mut request_tracker: RequestTracker,
-) {
-    loop {
-        let Some(message) = bi.recv().await else {
-            return;
-        };
-
-        let conn = match message {
-            Ok(conn) => conn,
-            Err(err) => {
-                warn!(error = ?err, "Failed to receive client request");
-                return;
-            }
-        };
-
-        let request_id = match request_tracker.request(conn.request_id) {
-            Ok(id) => id,
-            Err(err) => {
-                let _ = bi.send(Err(err)).await;
-                return;
-            }
-        };
-
-        let Some(payload) = conn.payload else {
-            let _ = bi
-                .send(Err(Status::invalid_argument(
-                    "Missing client request payload",
-                )))
-                .await;
-            return;
-        };
-
-        match dispatch_inner(&actor, payload).await {
-            Ok(response) => {
-                if bi
-                    .send(Ok(ClientResponse {
-                        request_id: Some(request_id),
-                        payload: Some(response),
-                    }))
-                    .await
-                    .is_err()
-                {
-                    return;
-                }
-            }
-            Err(status) => {
-                let _ = bi.send(Err(status)).await;
-                return;
-            }
-        }
-    }
-}
-
-async fn dispatch_inner(
-    actor: &ActorRef<ClientSession>,
-    payload: ClientRequestPayload,
-) -> Result<ClientResponsePayload, Status> {
-    match payload {
-        ClientRequestPayload::Vault(req) => vault::dispatch(actor, req).await,
-        ClientRequestPayload::Evm(req) => evm::dispatch(actor, req).await,
-        ClientRequestPayload::Auth(..) => {
-            warn!("Unsupported post-auth client auth request");
-            Err(Status::invalid_argument("Unsupported client request"))
-        }
-    }
-}
-
-pub async fn start(mut conn: ClientConnection, mut bi: GrpcBi<ClientRequest, ClientResponse>) {
-    let mut request_tracker = RequestTracker::default();
-
-    let client_id = match auth::start(&mut conn, &mut bi, &mut request_tracker).await {
-        Ok(id) => id,
-        Err(err) => {
-            let _ = bi
-                .send(Err(Status::unauthenticated(format!(
-                    "Authentication failed: {}",
-                    err
-                ))))
-                .await;
-            warn!(error = ?err, "Client authentication failed");
-            return;
-        }
-    };
-
-    let actor = ClientSession::spawn(ClientSession::new(conn, client_id));
-    let actor_for_cleanup = actor.clone();
-
-    info!("Client authenticated successfully");
-    dispatch_loop(bi, actor, request_tracker).await;
-    actor_for_cleanup.kill();
-}

server/crates/arbiter-server/src/grpc/client/auth.rs

@@ -1,205 +0,0 @@
-use arbiter_proto::{
-    ClientMetadata,
-    proto::{
-        client::{
-            ClientRequest, ClientResponse,
-            auth::{
-                self as proto_auth, AuthChallenge as ProtoAuthChallenge,
-                AuthChallengeRequest as ProtoAuthChallengeRequest,
-                AuthChallengeSolution as ProtoAuthChallengeSolution, AuthResult as ProtoAuthResult,
-                request::Payload as AuthRequestPayload, response::Payload as AuthResponsePayload,
-            },
-            client_request::Payload as ClientRequestPayload,
-            client_response::Payload as ClientResponsePayload,
-        },
-        shared::ClientInfo as ProtoClientInfo,
-    },
-    transport::{Bi, Error as TransportError, Receiver, Sender, grpc::GrpcBi},
-};
-use async_trait::async_trait;
-use tonic::Status;
-use tracing::warn;
-
-use crate::{
-    actors::client::{self, ClientConnection, auth},
-    grpc::request_tracker::RequestTracker,
-};
-
-pub struct AuthTransportAdapter<'a> {
-    bi: &'a mut GrpcBi<ClientRequest, ClientResponse>,
-    request_tracker: &'a mut RequestTracker,
-}
-
-impl<'a> AuthTransportAdapter<'a> {
-    pub fn new(
-        bi: &'a mut GrpcBi<ClientRequest, ClientResponse>,
-        request_tracker: &'a mut RequestTracker,
-    ) -> Self {
-        Self {
-            bi,
-            request_tracker,
-        }
-    }
-
-    fn response_to_proto(response: auth::Outbound) -> AuthResponsePayload {
-        match response {
-            auth::Outbound::AuthChallenge { pubkey, nonce } => {
-                AuthResponsePayload::Challenge(ProtoAuthChallenge {
-                    pubkey: pubkey.to_bytes().to_vec(),
-                    nonce,
-                })
-            }
-            auth::Outbound::AuthSuccess => {
-                AuthResponsePayload::Result(ProtoAuthResult::Success.into())
-            }
-        }
-    }
-
-    fn error_to_proto(error: auth::Error) -> AuthResponsePayload {
-        AuthResponsePayload::Result(
-            match error {
-                auth::Error::InvalidChallengeSolution => ProtoAuthResult::InvalidSignature,
-                auth::Error::ApproveError(auth::ApproveError::Denied) => {
-                    ProtoAuthResult::ApprovalDenied
-                }
-                auth::Error::ApproveError(auth::ApproveError::Upstream(
-                    crate::actors::flow_coordinator::ApprovalError::NoUserAgentsConnected,
-                )) => ProtoAuthResult::NoUserAgentsOnline,
-                auth::Error::ApproveError(auth::ApproveError::Internal)
-                | auth::Error::DatabasePoolUnavailable
-                | auth::Error::DatabaseOperationFailed
-                | auth::Error::Transport => ProtoAuthResult::Internal,
-            }
-            .into(),
-        )
-    }
-
-    async fn send_client_response(
-        &mut self,
-        payload: AuthResponsePayload,
-    ) -> Result<(), TransportError> {
-        self.bi
-            .send(Ok(ClientResponse {
-                request_id: Some(self.request_tracker.current_request_id()),
-                payload: Some(ClientResponsePayload::Auth(proto_auth::Response {
-                    payload: Some(payload),
-                })),
-            }))
-            .await
-    }
-
-    async fn send_auth_result(&mut self, result: ProtoAuthResult) -> Result<(), TransportError> {
-        self.send_client_response(AuthResponsePayload::Result(result.into()))
-            .await
-    }
-}
-
-#[async_trait]
-impl Sender<Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {
-    async fn send(
-        &mut self,
-        item: Result<auth::Outbound, auth::Error>,
-    ) -> Result<(), TransportError> {
-        let payload = match item {
-            Ok(message) => AuthTransportAdapter::response_to_proto(message),
-            Err(err) => AuthTransportAdapter::error_to_proto(err),
-        };
-
-        self.send_client_response(payload).await
-    }
-}
-
-#[async_trait]
-impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
-    async fn recv(&mut self) -> Option<auth::Inbound> {
-        let request = match self.bi.recv().await? {
-            Ok(request) => request,
-            Err(error) => {
-                warn!(error = ?error, "grpc client recv failed; closing stream");
-                return None;
-            }
-        };
-
-        match self.request_tracker.request(request.request_id) {
-            Ok(request_id) => request_id,
-            Err(error) => {
-                let _ = self.bi.send(Err(error)).await;
-                return None;
-            }
-        };
-        let payload = request.payload?;
-        let ClientRequestPayload::Auth(auth_request) = payload else {
-            let _ = self
-                .bi
-                .send(Err(Status::invalid_argument(
-                    "Unsupported client auth request",
-                )))
-                .await;
-            return None;
-        };
-        let Some(payload) = auth_request.payload else {
-            let _ = self
-                .bi
-                .send(Err(Status::invalid_argument("Missing client auth request payload")))
-                .await;
-            return None;
-        };
-
-        match payload {
-            AuthRequestPayload::ChallengeRequest(ProtoAuthChallengeRequest {
-                pubkey,
-                client_info,
-            }) => {
-                let Some(client_info) = client_info else {
-                    let _ = self
-                        .bi
-                        .send(Err(Status::invalid_argument("Missing client info")))
-                        .await;
-                    return None;
-                };
-                let Ok(pubkey) = <[u8; 32]>::try_from(pubkey) else {
-                    let _ = self.send_auth_result(ProtoAuthResult::InvalidKey).await;
-                    return None;
-                };
-                let Ok(pubkey) = ed25519_dalek::VerifyingKey::from_bytes(&pubkey) else {
-                    let _ = self.send_auth_result(ProtoAuthResult::InvalidKey).await;
-                    return None;
-                };
-                Some(auth::Inbound::AuthChallengeRequest {
-                    pubkey,
-                    metadata: client_metadata_from_proto(client_info),
-                })
-            }
-            AuthRequestPayload::ChallengeSolution(ProtoAuthChallengeSolution {
-                signature,
-            }) => {
-                let Ok(signature) = ed25519_dalek::Signature::try_from(signature.as_slice()) else {
-                    let _ = self
-                        .send_auth_result(ProtoAuthResult::InvalidSignature)
-                        .await;
-                    return None;
-                };
-                Some(auth::Inbound::AuthChallengeSolution { signature })
-            }
-        }
-    }
-}
-
-impl Bi<auth::Inbound, Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {}
-
-fn client_metadata_from_proto(metadata: ProtoClientInfo) -> ClientMetadata {
-    ClientMetadata {
-        name: metadata.name,
-        description: metadata.description,
-        version: metadata.version,
-    }
-}
-
-pub async fn start(
-    conn: &mut ClientConnection,
-    bi: &mut GrpcBi<ClientRequest, ClientResponse>,
-    request_tracker: &mut RequestTracker,
-) -> Result<i32, auth::Error> {
-    let mut transport = AuthTransportAdapter::new(bi, request_tracker);
-    client::auth::authenticate(conn, &mut transport).await
-}

server/crates/arbiter-server/src/grpc/client/evm.rs

@@ -1,85 +0,0 @@
-use arbiter_proto::proto::{
-    client::{
-        client_response::Payload as ClientResponsePayload,
-        evm::{
-            self as proto_evm, request::Payload as EvmRequestPayload,
-            response::Payload as EvmResponsePayload,
-        },
-    },
-    evm::{
-        EvmError as ProtoEvmError, EvmSignTransactionResponse,
-        evm_sign_transaction_response::Result as EvmSignTransactionResult,
-    },
-};
-use kameo::actor::ActorRef;
-use tonic::Status;
-use tracing::warn;
-
-use crate::{
-    actors::client::session::{ClientSession, HandleSignTransaction, SignTransactionRpcError},
-    grpc::{
-        Convert, TryConvert,
-        common::inbound::{RawEvmAddress, RawEvmTransaction},
-    },
-};
-
-fn wrap_response(payload: EvmResponsePayload) -> ClientResponsePayload {
-    ClientResponsePayload::Evm(proto_evm::Response {
-        payload: Some(payload),
-    })
-}
-
-pub(super) async fn dispatch(
-    actor: &ActorRef<ClientSession>,
-    req: proto_evm::Request,
-) -> Result<ClientResponsePayload, Status> {
-    let Some(payload) = req.payload else {
-        return Err(Status::invalid_argument("Missing client EVM request payload"));
-    };
-
-    match payload {
-        EvmRequestPayload::SignTransaction(request) => {
-            let address = RawEvmAddress(request.wallet_address).try_convert()?;
-            let transaction = RawEvmTransaction(request.rlp_transaction).try_convert()?;
-
-            let response = match actor
-                .ask(HandleSignTransaction {
-                    wallet_address: address,
-                    transaction,
-                })
-                .await
-            {
-                Ok(signature) => EvmSignTransactionResponse {
-                    result: Some(EvmSignTransactionResult::Signature(
-                        signature.as_bytes().to_vec(),
-                    )),
-                },
-                Err(kameo::error::SendError::HandlerError(SignTransactionRpcError::Vet(
-                    vet_error,
-                ))) => EvmSignTransactionResponse {
-                    result: Some(vet_error.convert()),
-                },
-                Err(kameo::error::SendError::HandlerError(
-                    SignTransactionRpcError::Internal,
-                )) => EvmSignTransactionResponse {
-                    result: Some(EvmSignTransactionResult::Error(
-                        ProtoEvmError::Internal.into(),
-                    )),
-                },
-                Err(err) => {
-                    warn!(error = ?err, "Failed to sign EVM transaction");
-                    EvmSignTransactionResponse {
-                        result: Some(EvmSignTransactionResult::Error(
-                            ProtoEvmError::Internal.into(),
-                        )),
-                    }
-                }
-            };
-
-            Ok(wrap_response(EvmResponsePayload::SignTransaction(response)))
-        }
-        EvmRequestPayload::AnalyzeTransaction(_) => {
-            Err(Status::unimplemented("EVM transaction analysis is not yet implemented"))
-        }
-    }
-}

server/crates/arbiter-server/src/grpc/client/vault.rs

@@ -1,47 +0,0 @@
-use arbiter_proto::proto::{
-    client::{
-        client_response::Payload as ClientResponsePayload,
-        vault::{
-            self as proto_vault, request::Payload as VaultRequestPayload,
-            response::Payload as VaultResponsePayload,
-        },
-    },
-    shared::VaultState as ProtoVaultState,
-};
-use kameo::{actor::ActorRef, error::SendError};
-use tonic::Status;
-use tracing::warn;
-
-use crate::{
-    actors::{
-        client::session::{ClientSession, Error, HandleQueryVaultState},
-        keyholder::KeyHolderState,
-    },
-};
-
-pub(super) async fn dispatch(
-    actor: &ActorRef<ClientSession>,
-    req: proto_vault::Request,
-) -> Result<ClientResponsePayload, Status> {
-    let Some(payload) = req.payload else {
-        return Err(Status::invalid_argument("Missing client vault request payload"));
-    };
-
-    match payload {
-        VaultRequestPayload::QueryState(_) => {
-            let state = match actor.ask(HandleQueryVaultState {}).await {
-                Ok(KeyHolderState::Unbootstrapped) => ProtoVaultState::Unbootstrapped,
-                Ok(KeyHolderState::Sealed) => ProtoVaultState::Sealed,
-                Ok(KeyHolderState::Unsealed) => ProtoVaultState::Unsealed,
-                Err(SendError::HandlerError(Error::Internal)) => ProtoVaultState::Error,
-                Err(err) => {
-                    warn!(error = ?err, "Failed to query vault state");
-                    ProtoVaultState::Error
-                }
-            };
-            Ok(ClientResponsePayload::Vault(proto_vault::Response {
-                payload: Some(VaultResponsePayload::State(state.into())),
-            }))
-        }
-    }
-}

server/crates/arbiter-server/src/grpc/common.rs

@@ -1,2 +0,0 @@
-pub mod inbound;
-pub mod outbound;

server/crates/arbiter-server/src/grpc/common/inbound.rs

@@ -1,36 +0,0 @@
-use alloy::{consensus::TxEip1559, primitives::Address, rlp::Decodable as _};
-
-use crate::grpc::TryConvert;
-
-pub struct RawEvmAddress(pub Vec<u8>);
-impl TryConvert for RawEvmAddress {
-    type Output = Address;
-
-    type Error = tonic::Status;
-
-    fn try_convert(self) -> Result<Self::Output, Self::Error> {
-        let wallet_address = match <[u8; 20]>::try_from(self.0.as_slice()) {
-            Ok(address) => Address::from(address),
-            Err(_) => {
-                return Err(tonic::Status::invalid_argument(
-                    "Invalid EVM wallet address",
-                ));
-            }
-        };
-        Ok(wallet_address)
-    }
-}
-
-pub struct RawEvmTransaction(pub Vec<u8>);
-impl TryConvert for RawEvmTransaction {
-    type Output = TxEip1559;
-
-    type Error = tonic::Status;
-
-    fn try_convert(self) -> Result<Self::Output, Self::Error> {
-        let tx = TxEip1559::decode(&mut self.0.as_slice()).map_err(|_| {
-            tonic::Status::invalid_argument("Invalid EVM transaction format")
-        })?;
-        Ok(tx)
-    }
-}

server/crates/arbiter-server/src/grpc/common/outbound.rs

@@ -1,116 +0,0 @@
-use alloy::primitives::U256;
-use arbiter_proto::proto::{
-    evm::{EvmError as ProtoEvmError, evm_sign_transaction_response::Result as EvmSignTransactionResult},
-    shared::evm::{
-        EvalViolation as ProtoEvalViolation, GasLimitExceededViolation,
-        NoMatchingGrantError, PolicyViolationsError, SpecificMeaning as ProtoSpecificMeaning,
-        TokenInfo as ProtoTokenInfo, TransactionEvalError as ProtoTransactionEvalError,
-        eval_violation::Kind as ProtoEvalViolationKind,
-        specific_meaning::Meaning as ProtoSpecificMeaningKind,
-        transaction_eval_error::Kind as ProtoTransactionEvalErrorKind,
-    },
-};
-
-use crate::{
-    evm::{
-        PolicyError, VetError,
-        policies::{EvalViolation, SpecificMeaning},
-    },
-    grpc::Convert,
-};
-
-fn u256_to_proto_bytes(value: U256) -> Vec<u8> {
-    value.to_be_bytes::<32>().to_vec()
-}
-
-impl Convert for SpecificMeaning {
-    type Output = ProtoSpecificMeaning;
-
-    fn convert(self) -> Self::Output {
-        let kind = match self {
-            SpecificMeaning::EtherTransfer(meaning) => ProtoSpecificMeaningKind::EtherTransfer(
-                arbiter_proto::proto::shared::evm::EtherTransferMeaning {
-                    to: meaning.to.to_vec(),
-                    value: u256_to_proto_bytes(meaning.value),
-                },
-            ),
-            SpecificMeaning::TokenTransfer(meaning) => ProtoSpecificMeaningKind::TokenTransfer(
-                arbiter_proto::proto::shared::evm::TokenTransferMeaning {
-                    token: Some(ProtoTokenInfo {
-                        symbol: meaning.token.symbol.to_string(),
-                        address: meaning.token.contract.to_vec(),
-                        chain_id: meaning.token.chain,
-                    }),
-                    to: meaning.to.to_vec(),
-                    value: u256_to_proto_bytes(meaning.value),
-                },
-            ),
-        };
-
-        ProtoSpecificMeaning {
-            meaning: Some(kind),
-        }
-    }
-}
-
-impl Convert for EvalViolation {
-    type Output = ProtoEvalViolation;
-
-    fn convert(self) -> Self::Output {
-        let kind = match self {
-            EvalViolation::InvalidTarget { target } => {
-                ProtoEvalViolationKind::InvalidTarget(target.to_vec())
-            }
-            EvalViolation::GasLimitExceeded {
-                max_gas_fee_per_gas,
-                max_priority_fee_per_gas,
-            } => ProtoEvalViolationKind::GasLimitExceeded(GasLimitExceededViolation {
-                max_gas_fee_per_gas: max_gas_fee_per_gas.map(u256_to_proto_bytes),
-                max_priority_fee_per_gas: max_priority_fee_per_gas.map(u256_to_proto_bytes),
-            }),
-            EvalViolation::RateLimitExceeded => ProtoEvalViolationKind::RateLimitExceeded(()),
-            EvalViolation::VolumetricLimitExceeded => {
-                ProtoEvalViolationKind::VolumetricLimitExceeded(())
-            }
-            EvalViolation::InvalidTime => ProtoEvalViolationKind::InvalidTime(()),
-            EvalViolation::InvalidTransactionType => {
-                ProtoEvalViolationKind::InvalidTransactionType(())
-            }
-        };
-
-        ProtoEvalViolation { kind: Some(kind) }
-    }
-}
-
-impl Convert for VetError {
-    type Output = EvmSignTransactionResult;
-
-    fn convert(self) -> Self::Output {
-        let kind = match self {
-            VetError::ContractCreationNotSupported => {
-                ProtoTransactionEvalErrorKind::ContractCreationNotSupported(())
-            }
-            VetError::UnsupportedTransactionType => {
-                ProtoTransactionEvalErrorKind::UnsupportedTransactionType(())
-            }
-            VetError::Evaluated(meaning, policy_error) => match policy_error {
-                PolicyError::NoMatchingGrant => {
-                    ProtoTransactionEvalErrorKind::NoMatchingGrant(NoMatchingGrantError {
-                        meaning: Some(meaning.convert()),
-                    })
-                }
-                PolicyError::Violations(violations) => {
-                    ProtoTransactionEvalErrorKind::PolicyViolations(PolicyViolationsError {
-                        meaning: Some(meaning.convert()),
-                        violations: violations.into_iter().map(Convert::convert).collect(),
-                    })
-                }
-                PolicyError::Database(_) => {
-                    return EvmSignTransactionResult::Error(ProtoEvmError::Internal.into());
-                }
-            },
-        };
-
-        EvmSignTransactionResult::EvalError(ProtoTransactionEvalError { kind: Some(kind) }.into())
-    }
-}

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

@@ -1,78 +0,0 @@
-use arbiter_proto::{
-    proto::{
-        client::{ClientRequest, ClientResponse},
-        user_agent::{UserAgentRequest, UserAgentResponse},
-    },
-    transport::grpc::GrpcBi,
-};
-use tokio_stream::wrappers::ReceiverStream;
-use tonic::{Request, Response, Status, async_trait};
-use tracing::info;
-
-use crate::{
-    actors::{client::ClientConnection, user_agent::UserAgentConnection},
-    grpc::user_agent::start,
-};
-
-mod request_tracker;
-
-pub mod client;
-pub mod user_agent;
-
-mod common;
-
-pub trait Convert {
-    type Output;
-
-    fn convert(self) -> Self::Output;
-}
-
-pub trait TryConvert {
-    type Output;
-    type Error;
-
-    fn try_convert(self) -> Result<Self::Output, Self::Error>;
-}
-
-#[async_trait]
-impl arbiter_proto::proto::arbiter_service_server::ArbiterService for super::Server {
-    type UserAgentStream = ReceiverStream<Result<UserAgentResponse, Status>>;
-    type ClientStream = ReceiverStream<Result<ClientResponse, Status>>;
-
-    #[tracing::instrument(level = "debug", skip(self))]
-    async fn client(
-        &self,
-        request: Request<tonic::Streaming<ClientRequest>>,
-    ) -> Result<Response<Self::ClientStream>, Status> {
-        let req_stream = request.into_inner();
-        let (bi, rx) = GrpcBi::from_bi_stream(req_stream);
-        let props = ClientConnection::new(self.context.db.clone(), self.context.actors.clone());
-        tokio::spawn(client::start(props, bi));
-
-        info!(event = "connection established", "grpc.client");
-
-        Ok(Response::new(rx))
-    }
-
-    #[tracing::instrument(level = "debug", skip(self))]
-    async fn user_agent(
-        &self,
-        request: Request<tonic::Streaming<UserAgentRequest>>,
-    ) -> Result<Response<Self::UserAgentStream>, Status> {
-        let req_stream = request.into_inner();
-
-        let (bi, rx) = GrpcBi::from_bi_stream(req_stream);
-
-        tokio::spawn(start(
-            UserAgentConnection {
-                db: self.context.db.clone(),
-                actors: self.context.actors.clone(),
-            },
-            bi,
-        ));
-
-        info!(event = "connection established", "grpc.user_agent");
-
-        Ok(Response::new(rx))
-    }
-}

server/crates/arbiter-server/src/grpc/request_tracker.rs

@@ -1,26 +0,0 @@
-use tonic::Status;
-
-#[derive(Default)]
-pub struct RequestTracker {
-    next_request_id: i32,
-}
-
-impl RequestTracker {
-    pub fn request(&mut self, id: i32) -> Result<i32, Status> {
-        if id < self.next_request_id {
-            return Err(Status::invalid_argument("Duplicate request id"));
-        }
-
-        self.next_request_id = id
-            .checked_add(1)
-            .ok_or_else(|| Status::invalid_argument("Invalid request id"))?;
-
-        Ok(id)
-    }
-
-    // This is used to set the response id for auth responses, which need to match the request id of the auth challenge request.
-    // -1 offset is needed because request() increments the next_request_id after returning the current request id.
-    pub fn current_request_id(&self) -> i32 {
-        self.next_request_id - 1
-    }
-}

server/crates/arbiter-server/src/grpc/user_agent.rs

@@ -1,145 +0,0 @@
-use tokio::sync::mpsc;
-
-use arbiter_proto::{
-    proto::{
-        user_agent::{
-            UserAgentRequest, UserAgentResponse,
-            user_agent_request::Payload as UserAgentRequestPayload,
-            user_agent_response::Payload as UserAgentResponsePayload,
-        },
-    },
-    transport::{Error as TransportError, Receiver, Sender, grpc::GrpcBi},
-};
-use async_trait::async_trait;
-use kameo::actor::{ActorRef, Spawn as _};
-use tonic::Status;
-use tracing::{error, info, warn};
-
-use crate::{
-    actors::user_agent::{OutOfBand, UserAgentConnection, UserAgentSession},
-    grpc::request_tracker::RequestTracker,
-};
-mod auth;
-mod evm;
-mod inbound;
-mod outbound;
-mod sdk_client;
-mod vault;
-
-pub struct OutOfBandAdapter(mpsc::Sender<OutOfBand>);
-
-#[async_trait]
-impl Sender<OutOfBand> for OutOfBandAdapter {
-    async fn send(&mut self, item: OutOfBand) -> Result<(), TransportError> {
-        self.0.send(item).await.map_err(|e| {
-            warn!(error = ?e, "Failed to send out-of-band message");
-            TransportError::ChannelClosed
-        })
-    }
-}
-
-async fn dispatch_loop(
-    mut bi: GrpcBi<UserAgentRequest, UserAgentResponse>,
-    actor: ActorRef<UserAgentSession>,
-    mut receiver: mpsc::Receiver<OutOfBand>,
-    mut request_tracker: RequestTracker,
-) {
-    loop {
-        tokio::select! {
-            oob = receiver.recv() => {
-                let Some(oob) = oob else {
-                    warn!("Out-of-band message channel closed");
-                    return;
-                };
-
-                let payload = sdk_client::out_of_band_payload(oob);
-
-                if bi.send(Ok(UserAgentResponse { id: None, payload: Some(payload) })).await.is_err() {
-                    return;
-                }
-            }
-
-            message = bi.recv() => {
-                let Some(message) = message else { return; };
-
-                let conn = match message {
-                    Ok(conn) => conn,
-                    Err(err) => {
-                        warn!(error = ?err, "Failed to receive user agent request");
-                        return;
-                    }
-                };
-
-                let request_id = match request_tracker.request(conn.id) {
-                    Ok(id) => id,
-                    Err(err) => {
-                        let _ = bi.send(Err(err)).await;
-                        return;
-                    }
-                };
-
-                let Some(payload) = conn.payload else {
-                    let _ = bi.send(Err(Status::invalid_argument("Missing user-agent request payload"))).await;
-                    return;
-                };
-
-                match dispatch_inner(&actor, payload).await {
-                    Ok(Some(response)) => {
-                        if bi.send(Ok(UserAgentResponse {
-                            id: Some(request_id),
-                            payload: Some(response),
-                        })).await.is_err() {
-                            return;
-                        }
-                    }
-                    Ok(None) => {}
-                    Err(status) => {
-                        error!(?status, "Failed to process user agent request");
-                        let _ = bi.send(Err(status)).await;
-                        return;
-                    }
-                }
-            }
-        }
-    }
-}
-
-async fn dispatch_inner(
-    actor: &ActorRef<UserAgentSession>,
-    payload: UserAgentRequestPayload,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    match payload {
-        UserAgentRequestPayload::Vault(req) => vault::dispatch(actor, req).await,
-        UserAgentRequestPayload::Evm(req) => evm::dispatch(actor, req).await,
-        UserAgentRequestPayload::SdkClient(req) => sdk_client::dispatch(actor, req).await,
-        UserAgentRequestPayload::Auth(..) => {
-            warn!("Unsupported post-auth user agent auth request");
-            Err(Status::invalid_argument("Unsupported user-agent request"))
-        }
-    }
-}
-
-pub async fn start(
-    mut conn: UserAgentConnection,
-    mut bi: GrpcBi<UserAgentRequest, UserAgentResponse>,
-) {
-    let mut request_tracker = RequestTracker::default();
-
-    let pubkey = match auth::start(&mut conn, &mut bi, &mut request_tracker).await {
-        Ok(pubkey) => pubkey,
-        Err(e) => {
-            warn!(error = ?e, "Authentication failed");
-            return;
-        }
-    };
-
-    let (oob_sender, oob_receiver) = mpsc::channel(16);
-    let oob_adapter = OutOfBandAdapter(oob_sender);
-
-    let actor = UserAgentSession::spawn(UserAgentSession::new(conn, Box::new(oob_adapter)));
-    let actor_for_cleanup = actor.clone();
-
-    info!(?pubkey, "User authenticated successfully");
-    dispatch_loop(bi, actor, oob_receiver, request_tracker).await;
-    actor_for_cleanup.kill();
-}