feat(transport): add domain error type to GrpcTransportActor

.gitignore

@@ -1,4 +1 @@
-target/
-scripts/__pycache__/
-.DS_Store
-.cargo/config.toml
+target/

.vscode/settings.json

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

IMPLEMENTATION.md

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

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/"}]}

mise.lock

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

mise.toml

@@ -9,4 +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"

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 UserAgent(stream arbiter.user_agent.UserAgentRequest) returns (stream arbiter.user_agent.UserAgentResponse);
+  rpc Client(stream ClientRequest) returns (stream ClientResponse);
+  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,47 +1,17 @@
 syntax = "proto3";
 
-package arbiter.client;
+package arbiter;
 
-import "evm.proto";
-
-message AuthChallengeRequest {
-  bytes pubkey = 1;
-}
-
-message AuthChallenge {
-  bytes pubkey = 1;
-  int32 nonce = 2;
-}
-
-message AuthChallengeSolution {
-  bytes signature = 1;
-}
-
-message AuthOk {}
+import "auth.proto";
 
 message ClientRequest {
   oneof payload {
-    AuthChallengeRequest auth_challenge_request = 1;
-    AuthChallengeSolution auth_challenge_solution = 2;
-    arbiter.evm.EvmSignTransactionRequest evm_sign_transaction = 3;
+    arbiter.auth.ClientMessage auth_message = 1;
   }
 }
 
-message ClientConnectError {
-  enum Code {
-    UNKNOWN = 0;
-    APPROVAL_DENIED = 1;
-    NO_USER_AGENTS_ONLINE = 2;
-  }
-  Code code = 1;
-}
-
 message ClientResponse {
   oneof payload {
-    AuthChallenge auth_challenge = 1;
-    AuthOk auth_ok = 2;
-    ClientConnectError client_connect_error = 5;
-    arbiter.evm.EvmSignTransactionResponse evm_sign_transaction = 3;
-    arbiter.evm.EvmAnalyzeTransactionResponse evm_analyze_transaction = 4;
+    arbiter.auth.ServerMessage auth_message = 1;
   }
 }

protobufs/evm.proto

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

protobufs/user_agent.proto

@@ -1,82 +1,9 @@
 syntax = "proto3";
 
-package arbiter.user_agent;
+package arbiter;
 
+import "auth.proto";
 import "google/protobuf/empty.proto";
-import "evm.proto";
-
-enum KeyType {
-  KEY_TYPE_UNSPECIFIED = 0;
-  KEY_TYPE_ED25519 = 1;
-  KEY_TYPE_ECDSA_SECP256K1 = 2;
-  KEY_TYPE_RSA = 3;
-}
-
-// --- SDK client management ---
-
-enum SdkClientError {
-  SDK_CLIENT_ERROR_UNSPECIFIED = 0;
-  SDK_CLIENT_ERROR_ALREADY_EXISTS = 1;
-  SDK_CLIENT_ERROR_NOT_FOUND = 2;
-  SDK_CLIENT_ERROR_HAS_RELATED_DATA = 3; // hard-delete blocked by FK (client has grants or transaction logs)
-  SDK_CLIENT_ERROR_INTERNAL = 4;
-}
-
-message SdkClientApproveRequest {
-  bytes pubkey = 1; // 32-byte ed25519 public key
-}
-
-message SdkClientRevokeRequest {
-  int32 client_id = 1;
-}
-
-message SdkClientEntry {
-  int32 id = 1;
-  bytes pubkey = 2;
-  int32 created_at = 3;
-}
-
-message SdkClientList {
-  repeated SdkClientEntry clients = 1;
-}
-
-message SdkClientApproveResponse {
-  oneof result {
-    SdkClientEntry client = 1;
-    SdkClientError error = 2;
-  }
-}
-
-message SdkClientRevokeResponse {
-  oneof result {
-    google.protobuf.Empty ok = 1;
-    SdkClientError error = 2;
-  }
-}
-
-message SdkClientListResponse {
-  oneof result {
-    SdkClientList clients = 1;
-    SdkClientError error = 2;
-  }
-}
-
-message AuthChallengeRequest {
-  bytes pubkey = 1;
-  optional string bootstrap_token = 2;
-  KeyType key_type = 3;
-}
-
-message AuthChallenge {
-  bytes pubkey = 1;
-  int32 nonce = 2;
-}
-
-message AuthChallengeSolution {
-  bytes signature = 1;
-}
-
-message AuthOk {}
 
 message UnsealStart {
   bytes client_pubkey = 1;
@@ -108,37 +35,17 @@ enum VaultState {
 
 message UserAgentRequest {
   oneof payload {
-    AuthChallengeRequest auth_challenge_request = 1;
-    AuthChallengeSolution auth_challenge_solution = 2;
-    UnsealStart unseal_start = 3;
-    UnsealEncryptedKey unseal_encrypted_key = 4;
-    google.protobuf.Empty query_vault_state = 5;
-    google.protobuf.Empty evm_wallet_create = 6;
-    google.protobuf.Empty evm_wallet_list = 7;
-    arbiter.evm.EvmGrantCreateRequest evm_grant_create = 8;
-    arbiter.evm.EvmGrantDeleteRequest evm_grant_delete = 9;
-    arbiter.evm.EvmGrantListRequest evm_grant_list = 10;
-    // field 11 reserved: was client_connection_response (online approval removed)
-    SdkClientApproveRequest sdk_client_approve = 12;
-    SdkClientRevokeRequest sdk_client_revoke = 13;
-    google.protobuf.Empty sdk_client_list = 14;
+    arbiter.auth.ClientMessage auth_message = 1;
+    UnsealStart unseal_start = 2;
+    UnsealEncryptedKey unseal_encrypted_key = 3;
+    google.protobuf.Empty query_vault_state = 4;
   }
 }
 message UserAgentResponse {
   oneof payload {
-    AuthChallenge auth_challenge = 1;
-    AuthOk auth_ok = 2;
-    UnsealStartResponse unseal_start_response = 3;
-    UnsealResult unseal_result = 4;
-    VaultState vault_state = 5;
-    arbiter.evm.WalletCreateResponse evm_wallet_create = 6;
-    arbiter.evm.WalletListResponse evm_wallet_list = 7;
-    arbiter.evm.EvmGrantCreateResponse evm_grant_create = 8;
-    arbiter.evm.EvmGrantDeleteResponse evm_grant_delete = 9;
-    arbiter.evm.EvmGrantListResponse evm_grant_list = 10;
-    // fields 11, 12 reserved: were client_connection_request, client_connection_cancel (online approval removed)
-    SdkClientApproveResponse sdk_client_approve = 13;
-    SdkClientRevokeResponse sdk_client_revoke = 14;
-    SdkClientListResponse sdk_client_list = 15;
+    arbiter.auth.ServerMessage auth_message = 1;
+    UnsealStartResponse unseal_start_response = 2;
+    UnsealResult unseal_result = 3;
+    VaultState vault_state = 4;
   }
 }

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,20 +1,15 @@
 [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.3", features = [
-    "deflate",
-    "gzip",
-    "tls-connect-info",
-    "zstd",
-] }
+tonic = { version = "0.14.3", features = ["deflate", "gzip", "tls-connect-info", "zstd"] }
 tracing = "0.1.44"
 tokio = { version = "1.49.0", features = ["full"] }
 ed25519-dalek = { version = "3.0.0-pre.6", features = ["rand_core"] }
@@ -28,18 +23,12 @@ async-trait = "0.1.89"
 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,18 +5,4 @@ edition = "2024"
 repository = "https://git.markettakers.org/MarketTakers/arbiter"
 license = "Apache-2.0"
 
-[lints]
-workspace = true
-
 [dependencies]
-arbiter-proto.path = "../arbiter-proto"
-alloy.workspace = 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.9", features = ["aws-lc-rs"] }
-async-trait.workspace = true

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

@@ -1,272 +1,14 @@
-use alloy::{
-    consensus::SignableTransaction,
-    network::TxSigner,
-    primitives::{Address, B256, ChainId, Signature},
-    signers::{Error, Result, Signer},
-};
-use arbiter_proto::{
-    format_challenge,
-    proto::{
-        arbiter_service_client::ArbiterServiceClient,
-        client::{
-            AuthChallengeRequest, AuthChallengeSolution, ClientRequest, ClientResponse,
-            client_connect_error, client_request::Payload as ClientRequestPayload,
-            client_response::Payload as ClientResponsePayload,
-        },
-        evm::{
-            EvmSignTransactionRequest, evm_sign_transaction_response::Result as SignResponseResult,
-        },
-    },
-    url::ArbiterUrl,
-};
-use async_trait::async_trait;
-use ed25519_dalek::Signer as _;
-use tokio::sync::{Mutex, mpsc};
-use tokio_stream::wrappers::ReceiverStream;
-use tonic::transport::ClientTlsConfig;
-
-#[derive(Debug, thiserror::Error)]
-pub enum ConnectError {
-    #[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("gRPC error")]
-    Grpc(#[from] tonic::Status),
-
-    #[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,
+pub fn add(left: u64, right: u64) -> u64 {
+    left + right
 }
 
-#[derive(Debug, thiserror::Error)]
-enum ClientSignError {
-    #[error("Transport channel closed")]
-    ChannelClosed,
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    #[error("Connection closed by server")]
-    ConnectionClosed,
-
-    #[error("Invalid response payload")]
-    InvalidResponse,
-
-    #[error("Remote signing was rejected")]
-    Rejected,
-}
-
-struct ClientTransport {
-    sender: mpsc::Sender<ClientRequest>,
-    receiver: tonic::Streaming<ClientResponse>,
-}
-
-impl ClientTransport {
-    async fn send(&mut self, request: ClientRequest) -> std::result::Result<(), ClientSignError> {
-        self.sender
-            .send(request)
-            .await
-            .map_err(|_| ClientSignError::ChannelClosed)
-    }
-
-    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),
-        }
-    }
-}
-
-pub struct ArbiterSigner {
-    transport: Mutex<ClientTransport>,
-    address: Address,
-    chain_id: Option<ChainId>,
-}
-
-impl ArbiterSigner {
-    pub async fn connect_grpc(
-        url: ArbiterUrl,
-        key: ed25519_dalek::SigningKey,
-        address: Address,
-    ) -> std::result::Result<Self, ConnectError> {
-        let anchor = webpki::anchor_from_trusted_cert(&url.ca_cert)?.to_owned();
-        let tls = ClientTlsConfig::new().trust_anchor(anchor);
-
-        // NOTE: We intentionally keep the same URL construction strategy as the user-agent crate
-        // to avoid behavior drift between the two clients.
-        let channel = tonic::transport::Channel::from_shared(format!("{}:{}", url.host, url.port))?
-            .tls_config(tls)?
-            .connect()
-            .await?;
-
-        let mut client = ArbiterServiceClient::new(channel);
-        let (tx, rx) = mpsc::channel(16);
-        let response_stream = client.client(ReceiverStream::new(rx)).await?.into_inner();
-
-        let mut transport = ClientTransport {
-            sender: tx,
-            receiver: response_stream,
-        };
-
-        authenticate(&mut transport, key).await?;
-
-        Ok(Self {
-            transport: Mutex::new(transport),
-            address,
-            chain_id: None,
-        })
-    }
-
-    async fn sign_transaction_via_arbiter(
-        &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,
-                tx: tx.chain_id().unwrap(),
-            });
-        }
-
-        let mut rlp_transaction = Vec::new();
-        tx.encode_for_signing(&mut rlp_transaction);
-
-        let request = ClientRequest {
-            payload: Some(ClientRequestPayload::EvmSignTransaction(
-                EvmSignTransactionRequest {
-                    wallet_address: self.address.as_slice().to_vec(),
-                    rlp_transaction,
-                },
-            )),
-        };
-
-        let mut transport = self.transport.lock().await;
-        transport.send(request).await.map_err(Error::other)?;
-        let response = transport.recv().await.map_err(Error::other)?;
-
-        let payload = response
-            .payload
-            .ok_or_else(|| Error::other(ClientSignError::InvalidResponse))?;
-
-        let ClientResponsePayload::EvmSignTransaction(sign_response) = payload else {
-            return Err(Error::other(ClientSignError::InvalidResponse));
-        };
-
-        let Some(result) = sign_response.result else {
-            return Err(Error::other(ClientSignError::InvalidResponse));
-        };
-
-        match result {
-            SignResponseResult::Signature(bytes) => {
-                Signature::try_from(bytes.as_slice()).map_err(Error::other)
-            }
-            SignResponseResult::EvalError(_) | SignResponseResult::Error(_) => {
-                Err(Error::other(ClientSignError::Rejected))
-            }
-        }
-    }
-}
-
-async fn authenticate(
-    transport: &mut ClientTransport,
-    key: ed25519_dalek::SigningKey,
-) -> std::result::Result<(), ConnectError> {
-    transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: key.verifying_key().to_bytes().to_vec(),
-                },
-            )),
-        })
-        .await
-        .map_err(|_| ConnectError::UnexpectedAuthResponse)?;
-
-    let response = transport
-        .recv()
-        .await
-        .map_err(|_| ConnectError::MissingAuthChallenge)?;
-
-    let payload = response.payload.ok_or(ConnectError::MissingAuthChallenge)?;
-    match payload {
-        ClientResponsePayload::AuthChallenge(challenge) => {
-            let challenge_payload = format_challenge(challenge.nonce, &challenge.pubkey);
-            let signature = key.sign(&challenge_payload).to_bytes().to_vec();
-
-            transport
-                .send(ClientRequest {
-                    payload: Some(ClientRequestPayload::AuthChallengeSolution(
-                        AuthChallengeSolution { signature },
-                    )),
-                })
-                .await
-                .map_err(|_| ConnectError::UnexpectedAuthResponse)?;
-
-            // Current server flow does not emit `AuthOk` for SDK clients, so we proceed after
-            // sending the solution. If authentication fails, the first business request will return
-            // a `ClientConnectError` or the stream will close.
-            Ok(())
-        }
-        ClientResponsePayload::ClientConnectError(err) => {
-            match client_connect_error::Code::try_from(err.code)
-                .unwrap_or(client_connect_error::Code::Unknown)
-            {
-                client_connect_error::Code::ApprovalDenied => Err(ConnectError::ApprovalDenied),
-                client_connect_error::Code::NoUserAgentsOnline => {
-                    Err(ConnectError::NoUserAgentsOnline)
-                }
-                client_connect_error::Code::Unknown => Err(ConnectError::UnexpectedAuthResponse),
-            }
-        }
-        _ => Err(ConnectError::UnexpectedAuthResponse),
-    }
-}
-
-#[async_trait]
-impl Signer for ArbiterSigner {
-    async fn sign_hash(&self, _hash: &B256) -> Result<Signature> {
-        Err(Error::other(
-            "hash-only signing is not supported for ArbiterSigner; 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 ArbiterSigner {
-    fn address(&self) -> Address {
-        self.address
-    }
-
-    async fn sign_transaction(
-        &self,
-        tx: &mut dyn SignableTransaction<Signature>,
-    ) -> Result<Signature> {
-        self.sign_transaction_via_arbiter(tx).await
+    #[test]
+    fn it_works() {
+        let result = add(2, 2);
+        assert_eq!(result, 4);
     }
 }

server/crates/arbiter-proto/Cargo.toml

@@ -9,7 +9,6 @@ license = "Apache-2.0"
 tonic.workspace = true
 tokio.workspace = true
 futures.workspace = true
-hex = "0.4.3"
 tonic-prost = "0.14.3"
 prost = "0.14.3"
 kameo.workspace = true
@@ -18,13 +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
+
 
 [build-dependencies]
 tonic-prost-build = "0.14.3"
-protoc-bin-vendored = "3"
 
 [dev-dependencies]
 rstest.workspace = true

server/crates/arbiter-proto/build.rs

@@ -3,11 +3,6 @@ use tonic_prost_build::configure;
 static PROTOBUF_DIR: &str = "../../../protobufs";
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    if std::env::var("PROTOC").is_err() {
-        println!("cargo:warning=PROTOC environment variable not set, using vendored protoc");
-        let protoc = protoc_bin_vendored::protoc_bin_path().unwrap();
-        unsafe { std::env::set_var("PROTOC", protoc) };
-    }
 
     println!("cargo::rerun-if-changed={PROTOBUF_DIR}");
 
@@ -16,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!("{}/client.proto", PROTOBUF_DIR),
-                format!("{}/evm.proto", PROTOBUF_DIR),
+                format!("{}/auth.proto", PROTOBUF_DIR),
             ],
             &[PROTOBUF_DIR.to_string()],
         )
+        
         .unwrap();
     Ok(())
 }

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

@@ -3,19 +3,13 @@ pub mod url;
 
 use base64::{Engine, prelude::BASE64_STANDARD};
 
+use crate::proto::auth::AuthChallenge;
+
 pub mod proto {
     tonic::include_proto!("arbiter");
 
-    pub mod user_agent {
-        tonic::include_proto!("arbiter.user_agent");
-    }
-
-    pub mod client {
-        tonic::include_proto!("arbiter.client");
-    }
-
-    pub mod evm {
-        tonic::include_proto!("arbiter.evm");
+    pub mod auth {
+        tonic::include_proto!("arbiter.auth");
     }
 }
 
@@ -34,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> {
-    let concat_form = format!("{}:{}", nonce, BASE64_STANDARD.encode(pubkey));
-    concat_form.into_bytes()
+pub fn format_challenge(challenge: &AuthChallenge) -> Vec<u8> {
+    let concat_form = format!("{}:{}", challenge.nonce, BASE64_STANDARD.encode(&challenge.pubkey));
+    concat_form.into_bytes().to_vec()
 }

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

@@ -1,309 +1,371 @@
-//! Transport-facing abstractions for protocol/session code.
+//! Transport abstraction layer for bridging gRPC bidirectional streaming with kameo actors.
 //!
-//! This module separates three concerns:
+//! This module provides a clean separation between the gRPC transport layer and business logic
+//! by modeling the connection as two linked kameo actors:
 //!
-//! - protocol/session logic wants a small duplex interface ([`Bi`])
-//! - transport adapters push concrete stream items to an underlying IO layer
-//! - transport boundaries translate between protocol-facing and transport-facing
-//!   item types via direction-specific converters
+//! - A **transport actor** ([`GrpcTransportActor`]) that owns the gRPC stream and channel,
+//!   forwarding inbound messages to the business actor and outbound messages to the client.
+//! - A **business logic actor** that receives inbound messages from the transport actor and
+//!   sends outbound messages back through the transport actor.
 //!
-//! [`Bi`] is intentionally minimal and transport-agnostic:
-//! - [`Bi::recv`] yields inbound protocol messages
-//! - [`Bi::send`] accepts outbound protocol/domain items
+//! The [`wire()`] function sets up bidirectional linking between the two actors, ensuring
+//! that if either actor dies, the other is notified and can shut down gracefully.
 //!
-//! # Generic Ordering Rule
+//! # Terminology
 //!
-//! This module uses a single convention consistently: when a type or trait is
-//! parameterized by protocol message directions, the generic parameters are
-//! declared as `Inbound` first, then `Outbound`.
+//! - **InboundMessage**: a message received by the transport actor from the channel/socket
+//!   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.
 //!
-//! For [`Bi`], that means `Bi<Inbound, Outbound>`:
-//! - `recv() -> Option<Inbound>`
-//! - `send(Outbound)`
-//!
-//! For adapter types that are parameterized by direction-specific converters,
-//! inbound-related converter parameters are declared before outbound-related
-//! converter parameters.
-//!
-//! [`RecvConverter`] and [`SendConverter`] are infallible conversion traits used
-//! by adapters to map between protocol-facing and transport-facing item types.
-//! The traits themselves are not result-aware; adapters decide how transport
-//! errors are handled before (or instead of) conversion.
-//!
-//! [`grpc::GrpcAdapter`] combines:
-//! - a tonic inbound stream
-//! - a Tokio sender for outbound transport items
-//! - a [`RecvConverter`] for the receive path
-//! - a [`SendConverter`] for the send path
-//!
-//! [`DummyTransport`] is a no-op implementation useful for tests and local actor
-//! execution where no real network stream exists.
-//!
-//! # Component Interaction
+//! # Architecture
 //!
 //! ```text
-//! inbound (network -> protocol)
-//! ============================
-//!
-//! tonic::Streaming<RecvTransport>
-//!     -> grpc::GrpcAdapter::recv()
-//!          |
-//!          +--> on `Ok(item)`: RecvConverter::convert(RecvTransport) -> Inbound
-//!          +--> on `Err(status)`: log error and close stream (`None`)
-//!     -> Bi::recv()
-//!     -> protocol/session actor
-//!
-//! outbound (protocol -> network)
-//! ==============================
-//!
-//! protocol/session actor
-//!     -> Bi::send(Outbound)
-//!     -> grpc::GrpcAdapter::send()
-//!          |
-//!          +--> SendConverter::convert(Outbound) -> SendTransport
-//!     -> Tokio mpsc::Sender<SendTransport>
-//!     -> tonic response stream
+//! gRPC Stream ──InboundMessage──▶ GrpcTransportActor ──tell(InboundMessage)──▶ BusinessActor
+//!                                 ▲                                    │
+//!                                 └─tell(Result<OutboundMessage, _>)────┘
+//!                                 │
+//!                          mpsc::Sender ──▶ Client
 //! ```
 //!
-//! # Design Notes
+//! # Example
 //!
-//! - `send()` returns [`Error`] only for transport delivery failures (for
-//!   example, when the outbound channel is closed).
-//! - [`grpc::GrpcAdapter`] logs tonic receive errors and treats them as stream
-//!   closure (`None`).
-//! - When protocol-facing and transport-facing types are identical, use
-//!   [`IdentityRecvConverter`] / [`IdentitySendConverter`].
+//! ```rust,ignore
+//! let (tx, rx) = mpsc::channel(1000);
+//! let context = server_context.clone();
+//!
+//! wire(
+//!     |transport_ref| MyBusinessActor::new(context, transport_ref),
+//!     |business_recipient, business_id| GrpcTransportActor {
+//!         sender: tx,
+//!         receiver: grpc_stream,
+//!         business_logic_actor: business_recipient,
+//!         business_logic_actor_id: business_id,
+//!     },
+//! ).await;
+//!
+//! Ok(Response::new(ReceiverStream::new(rx)))
+//! ```
 
-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;
-
-/// Errors returned by transport adapters implementing [`Bi`].
-#[derive(thiserror::Error, Debug)]
-pub enum Error {
-    #[error("Transport channel is closed")]
-    ChannelClosed,
-    #[error("Unexpected message received")]
-    UnexpectedMessage,
-}
-
-/// Receives one message from `transport` and extracts a value from it using
-/// `extractor`. Returns [`Error::ChannelClosed`] if the transport closes and
-/// [`Error::UnexpectedMessage`] if `extractor` returns `None`.
-pub async fn expect_message<T, Inbound, Outbound, Target, F>(
-    transport: &mut T,
-    extractor: F,
-) -> Result<Target, Error>
-where
-    T: Bi<Inbound, Outbound> + ?Sized,
-    F: FnOnce(Inbound) -> Option<Target>,
-{
-    let msg = transport.recv().await.ok_or(Error::ChannelClosed)?;
-    extractor(msg).ok_or(Error::UnexpectedMessage)
-}
-
-/// Minimal bidirectional transport abstraction used by protocol code.
+/// A bidirectional stream abstraction for sans-io testing.
 ///
-/// `Bi<Inbound, Outbound>` models a duplex channel with:
-/// - inbound items of type `Inbound` read via [`Bi::recv`]
-/// - outbound items of type `Outbound` written via [`Bi::send`]
-#[async_trait]
-pub trait Bi<Inbound, Outbound>: Send + Sync + 'static {
-    async fn send(&mut self, item: Outbound) -> Result<(), Error>;
-
-    async fn recv(&mut self) -> Option<Inbound>;
+/// Combines a [`Stream`] of incoming messages with the ability to [`send`](Bi::send)
+/// outgoing responses. This trait allows business logic to be tested without a real
+/// gRPC connection by swapping in an in-memory implementation.
+///
+/// # Type Parameters
+/// - `T`: `InboundMessage` received from the channel/socket (e.g., `UserAgentRequest`)
+/// - `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;
 }
 
-/// Converts transport-facing inbound items into protocol-facing inbound items.
-pub trait RecvConverter: Send + Sync + 'static {
-    type Input;
-    type Output;
-
-    fn convert(&self, item: Self::Input) -> Self::Output;
+/// Concrete [`Bi`] implementation backed by a tonic gRPC [`Streaming`] and an [`mpsc::Sender`].
+///
+/// This is the production implementation used in gRPC service handlers. The `request_stream`
+/// receives messages from the client, and `response_sender` sends responses back.
+pub struct BiStream<T, U> {
+    pub request_stream: Streaming<T>,
+    pub response_sender: mpsc::Sender<Result<U, Status>>,
 }
 
-/// Converts protocol/domain outbound items into transport-facing outbound items.
-pub trait SendConverter: Send + Sync + 'static {
-    type Input;
-    type Output;
+impl<T, U> Stream for BiStream<T, U>
+where
+    T: Send + 'static,
+    U: Send + 'static,
+{
+    type Item = Result<T, Status>;
 
-    fn convert(&self, item: Self::Input) -> Self::Output;
+    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)
+    }
 }
 
-/// A [`RecvConverter`] that forwards values unchanged.
-pub struct IdentityRecvConverter<T> {
-    _marker: PhantomData<T>,
+impl<T, U> Bi<T, U> for BiStream<T, U>
+where
+    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
+    }
 }
 
-impl<T> IdentityRecvConverter<T> {
-    pub fn new() -> Self {
+/// Marker trait for transport actors that can receive outbound messages of type `T`.
+///
+/// Implement this on your transport actor to indicate it can handle outbound messages
+/// produced by the business actor. Requires the actor to implement [`Message<Result<T, E>>`]
+/// so business logic can forward responses via [`tell()`](ActorRef::tell).
+///
+/// # Example
+///
+/// ```rust,ignore
+/// #[derive(Actor)]
+/// struct MyTransportActor { /* ... */ }
+///
+/// impl Message<Result<MyResponse, MyError>> for MyTransportActor {
+///     type Reply = ();
+///     async fn handle(&mut self, msg: Result<MyResponse, MyError>, _ctx: &mut Context<Self, Self::Reply>) -> Self::Reply {
+///         // forward outbound message to channel/socket
+///     }
+/// }
+///
+/// impl TransportActor<MyResponse, MyError> for MyTransportActor {}
+/// ```
+pub trait TransportActor<Outbound: Send + 'static, DomainError: Send + 'static>:
+    Actor + Send + Message<Result<Outbound, DomainError>>
+{
+}
+
+/// A kameo actor that bridges a gRPC bidirectional stream with a business logic actor.
+///
+/// This actor owns the gRPC [`Streaming`] receiver and an [`mpsc::Sender`] for responses.
+/// It multiplexes between its own mailbox (for outbound messages from the business actor)
+/// and the gRPC stream (for inbound client messages) using [`tokio::select!`].
+///
+/// # 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<Outbound, Inbound, DomainError> GrpcTransportActor<Outbound, Inbound, DomainError>
+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,
         }
     }
 }
 
-impl<T> Default for IdentityRecvConverter<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T> RecvConverter for IdentityRecvConverter<T>
+impl<Outbound, Inbound, E> Actor for GrpcTransportActor<Outbound, Inbound, E>
 where
-    T: Send + Sync + 'static,
+    Outbound: Send + 'static,
+    Inbound: Send + 'static,
+    E: Into<tonic::Status> + Send + 'static,
 {
-    type Input = T;
-    type Output = T;
+    type Args = Self;
 
-    fn convert(&self, item: Self::Input) -> Self::Output {
-        item
-    }
-}
+    type Error = ();
 
-/// A [`SendConverter`] that forwards values unchanged.
-pub struct IdentitySendConverter<T> {
-    _marker: PhantomData<T>,
-}
-
-impl<T> IdentitySendConverter<T> {
-    pub fn new() -> Self {
-        Self {
-            _marker: PhantomData,
-        }
-    }
-}
-
-impl<T> Default for IdentitySendConverter<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T> SendConverter for IdentitySendConverter<T>
-where
-    T: Send + Sync + 'static,
-{
-    type Input = T;
-    type Output = T;
-
-    fn convert(&self, item: Self::Input) -> Self::Output {
-        item
-    }
-}
-
-/// gRPC-specific transport adapters and helpers.
-pub mod grpc {
-    use async_trait::async_trait;
-    use futures::StreamExt;
-    use tokio::sync::mpsc;
-    use tonic::Streaming;
-
-    use super::{Bi, Error, RecvConverter, SendConverter};
-
-    /// [`Bi`] adapter backed by a tonic gRPC bidirectional stream.
-    ///
-    /// Tonic receive errors are logged and treated as stream closure (`None`).
-    /// The receive converter is only invoked for successful inbound transport
-    /// items.
-    pub struct GrpcAdapter<InboundConverter, OutboundConverter>
-    where
-        InboundConverter: RecvConverter,
-        OutboundConverter: SendConverter,
-    {
-        sender: mpsc::Sender<OutboundConverter::Output>,
-        receiver: Streaming<InboundConverter::Input>,
-        inbound_converter: InboundConverter,
-        outbound_converter: OutboundConverter,
+    async fn on_start(args: Self::Args, _: ActorRef<Self>) -> Result<Self, Self::Error> {
+        Ok(args)
     }
 
-    impl<InboundTransport, Inbound, InboundConverter, OutboundConverter>
-        GrpcAdapter<InboundConverter, OutboundConverter>
-    where
-        InboundConverter: RecvConverter<Input = InboundTransport, Output = Inbound>,
-        OutboundConverter: SendConverter,
-    {
-        pub fn new(
-            sender: mpsc::Sender<OutboundConverter::Output>,
-            receiver: Streaming<InboundTransport>,
-            inbound_converter: InboundConverter,
-            outbound_converter: OutboundConverter,
-        ) -> Self {
-            Self {
-                sender,
-                receiver,
-                inbound_converter,
-                outbound_converter,
+    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_trait]
-    impl<InboundConverter, OutboundConverter> Bi<InboundConverter::Output, OutboundConverter::Input>
-        for GrpcAdapter<InboundConverter, OutboundConverter>
-    where
-        InboundConverter: RecvConverter,
-        OutboundConverter: SendConverter,
-        OutboundConverter::Input: Send + 'static,
-        OutboundConverter::Output: Send + 'static,
-    {
-        #[tracing::instrument(level = "trace", skip(self, item))]
-        async fn send(&mut self, item: OutboundConverter::Input) -> Result<(), Error> {
-            let outbound = self.outbound_converter.convert(item);
-            self.sender
-                .send(outbound)
-                .await
-                .map_err(|_| Error::ChannelClosed)
-        }
-
-        #[tracing::instrument(level = "trace", skip(self))]
-        async fn recv(&mut self) -> Option<InboundConverter::Output> {
-            match self.receiver.next().await {
-                Some(Ok(item)) => Some(self.inbound_converter.convert(item)),
-                Some(Err(error)) => {
-                    tracing::error!(error = ?error, "grpc transport recv failed; closing stream");
-                    None
+    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)
+                    }
                 }
-                None => None,
             }
         }
     }
 }
 
-/// No-op [`Bi`] transport for tests and manual actor usage.
-///
-/// `send` drops all items and succeeds. [`Bi::recv`] never resolves and therefore
-/// does not busy-wait or spuriously close the stream.
-pub struct DummyTransport<Inbound, Outbound> {
-    _marker: PhantomData<(Inbound, Outbound)>,
-}
+impl<Outbound, Inbound, E> Message<Result<Outbound, E>> for GrpcTransportActor<Outbound, Inbound, E>
+where
+    Outbound: Send + 'static,
+    Inbound: Send + 'static,
+    E: Into<tonic::Status> + Send + 'static,
+{
+    type Reply = ();
 
-impl<Inbound, Outbound> DummyTransport<Inbound, Outbound> {
-    pub fn new() -> Self {
-        Self {
-            _marker: PhantomData,
+    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> Default for DummyTransport<Inbound, Outbound> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[async_trait]
-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 + Sync + 'static,
+    Outbound: Send + 'static,
+    Inbound: Send + 'static,
+    E: Into<tonic::Status> + Send + 'static,
 {
-    async fn send(&mut self, _item: Outbound) -> Result<(), Error> {
-        Ok(())
-    }
-
-    async fn recv(&mut self) -> Option<Inbound> {
-        std::future::pending::<()>().await;
-        None
-    }
+}
+
+/// 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/url.rs

@@ -20,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,9 +5,6 @@ edition = "2024"
 repository = "https://git.markettakers.org/MarketTakers/arbiter"
 license = "Apache-2.0"
 
-[lints]
-workspace = true
-
 [dependencies]
 diesel = { version = "2.3.6", features = ["chrono", "returning_clauses_for_sqlite_3_35", "serde_json", "time", "uuid"] }
 diesel-async = { version = "0.7.4", features = [
@@ -45,12 +42,6 @@ argon2 = { version = "0.5.3", features = ["zeroize"] }
 restructed = "0.2.2"
 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
-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

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

server/crates/arbiter-server/migrations/2026-03-15-103112-0000_add_program_client_pubkey_unique/down.sql

@@ -1 +0,0 @@
-DROP INDEX IF EXISTS program_client_public_key_unique;

server/crates/arbiter-server/migrations/2026-03-15-103112-0000_add_program_client_pubkey_unique/up.sql

@@ -1,2 +0,0 @@
-CREATE UNIQUE INDEX program_client_public_key_unique
-    ON program_client (public_key);

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,183 +0,0 @@
-use arbiter_proto::{
-    format_challenge,
-    proto::client::{
-        AuthChallenge, AuthChallengeSolution, ClientConnectError, ClientRequest, ClientResponse,
-        client_connect_error::Code as ConnectErrorCode,
-        client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    },
-    transport::expect_message,
-};
-use diesel::{ExpressionMethods as _, OptionalExtension as _, QueryDsl as _, update};
-use diesel_async::RunQueryDsl as _;
-use ed25519_dalek::VerifyingKey;
-use tracing::error;
-
-use crate::{
-    actors::client::ClientConnection,
-    db::{self, schema::program_client},
-};
-
-use super::session::ClientSession;
-
-#[derive(thiserror::Error, Debug, Clone, PartialEq, Eq)]
-pub enum Error {
-    #[error("Unexpected message payload")]
-    UnexpectedMessagePayload,
-    #[error("Invalid client public key length")]
-    InvalidClientPubkeyLength,
-    #[error("Invalid client public key encoding")]
-    InvalidAuthPubkeyEncoding,
-    #[error("Database pool unavailable")]
-    DatabasePoolUnavailable,
-    #[error("Database operation failed")]
-    DatabaseOperationFailed,
-    #[error("Invalid challenge solution")]
-    InvalidChallengeSolution,
-    #[error("Client not registered")]
-    NotRegistered,
-    #[error("Internal error")]
-    InternalError,
-    #[error("Transport error")]
-    Transport,
-}
-
-/// Atomically reads and increments the nonce for a known client.
-/// Returns `None` if the pubkey is not registered.
-async fn get_nonce(
-    db: &db::DatabasePool,
-    pubkey: &VerifyingKey,
-) -> Result<Option<(i32, i32)>, Error> {
-    let pubkey_bytes = pubkey.as_bytes().to_vec();
-
-    let mut conn = db.get().await.map_err(|e| {
-        error!(error = ?e, "Database pool error");
-        Error::DatabasePoolUnavailable
-    })?;
-
-    conn.exclusive_transaction(|conn| {
-        let pubkey_bytes = pubkey_bytes.clone();
-        Box::pin(async move {
-            let Some((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((client_id, current_nonce)))
-        })
-    })
-    .await
-    .map_err(|e| {
-        error!(error = ?e, "Database error");
-        Error::DatabaseOperationFailed
-    })
-}
-
-async fn challenge_client(
-    props: &mut ClientConnection,
-    pubkey: VerifyingKey,
-    nonce: i32,
-) -> Result<(), Error> {
-    let challenge = AuthChallenge {
-        pubkey: pubkey.as_bytes().to_vec(),
-        nonce,
-    };
-
-    props
-        .transport
-        .send(Ok(ClientResponse {
-            payload: Some(ClientResponsePayload::AuthChallenge(challenge.clone())),
-        }))
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to send auth challenge");
-            Error::Transport
-        })?;
-
-    let AuthChallengeSolution { signature } =
-        expect_message(&mut *props.transport, |req: ClientRequest| {
-            match req.payload? {
-                ClientRequestPayload::AuthChallengeSolution(s) => Some(s),
-                _ => None,
-            }
-        })
-        .await
-        .map_err(|e| {
-            error!(error = ?e, "Failed to receive challenge solution");
-            Error::Transport
-        })?;
-
-    let formatted = format_challenge(nonce, &challenge.pubkey);
-    let sig = signature.as_slice().try_into().map_err(|_| {
-        error!("Invalid signature length");
-        Error::InvalidChallengeSolution
-    })?;
-
-    pubkey.verify_strict(&formatted, &sig).map_err(|_| {
-        error!("Challenge solution verification failed");
-        Error::InvalidChallengeSolution
-    })?;
-
-    Ok(())
-}
-
-fn connect_error_code(err: &Error) -> ConnectErrorCode {
-    match err {
-        Error::NotRegistered => ConnectErrorCode::ApprovalDenied,
-        _ => ConnectErrorCode::Unknown,
-    }
-}
-
-async fn authenticate(props: &mut ClientConnection) -> Result<(VerifyingKey, i32), Error> {
-    let Some(ClientRequest {
-        payload: Some(ClientRequestPayload::AuthChallengeRequest(challenge)),
-    }) = props.transport.recv().await
-    else {
-        return Err(Error::Transport);
-    };
-
-    let pubkey_bytes = challenge
-        .pubkey
-        .as_array()
-        .ok_or(Error::InvalidClientPubkeyLength)?;
-    let pubkey =
-        VerifyingKey::from_bytes(pubkey_bytes).map_err(|_| Error::InvalidAuthPubkeyEncoding)?;
-
-    let (client_id, nonce) = match get_nonce(&props.db, &pubkey).await? {
-        Some((client_id, nonce)) => (client_id, nonce),
-        None => return Err(Error::NotRegistered),
-    };
-
-    challenge_client(props, pubkey, nonce).await?;
-
-    Ok((pubkey, client_id))
-}
-
-pub async fn authenticate_and_create(mut props: ClientConnection) -> Result<ClientSession, Error> {
-    match authenticate(&mut props).await {
-        Ok((_pubkey, client_id)) => Ok(ClientSession::new(props, client_id)),
-        Err(err) => {
-            let code = connect_error_code(&err);
-            let _ = props
-                .transport
-                .send(Ok(ClientResponse {
-                    payload: Some(ClientResponsePayload::ClientConnectError(
-                        ClientConnectError { code: code.into() },
-                    )),
-                }))
-                .await;
-            Err(err)
-        }
-    }
-}

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

@@ -1,58 +0,0 @@
-use arbiter_proto::{
-    proto::client::{ClientRequest, ClientResponse},
-    transport::Bi,
-};
-use kameo::actor::Spawn;
-use tracing::{error, info};
-
-use crate::{
-    actors::{GlobalActors, client::session::ClientSession},
-    db,
-};
-
-#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
-pub enum ClientError {
-    #[error("Expected message with payload")]
-    MissingRequestPayload,
-    #[error("Unexpected request payload")]
-    UnexpectedRequestPayload,
-    #[error("State machine error")]
-    StateTransitionFailed,
-    #[error("Connection registration failed")]
-    ConnectionRegistrationFailed,
-    #[error(transparent)]
-    Auth(#[from] auth::Error),
-}
-
-pub type Transport = Box<dyn Bi<ClientRequest, Result<ClientResponse, ClientError>> + Send>;
-
-pub struct ClientConnection {
-    pub(crate) db: db::DatabasePool,
-    pub(crate) transport: Transport,
-    pub(crate) actors: GlobalActors,
-}
-
-impl ClientConnection {
-    pub fn new(db: db::DatabasePool, transport: Transport, actors: GlobalActors) -> Self {
-        Self {
-            db,
-            transport,
-            actors,
-        }
-    }
-}
-
-pub mod auth;
-pub mod session;
-
-pub async fn connect_client(props: ClientConnection) {
-    match auth::authenticate_and_create(props).await {
-        Ok(session) => {
-            ClientSession::spawn(session);
-            info!("Client authenticated, session started");
-        }
-        Err(err) => {
-            error!(?err, "Authentication failed, closing connection");
-        }
-    }
-}

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

@@ -1,151 +0,0 @@
-use alloy::{consensus::TxEip1559, primitives::Address, rlp::Decodable};
-use arbiter_proto::proto::{
-    client::{
-        ClientRequest, ClientResponse, client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    },
-    evm::{
-        EvmError, EvmSignTransactionResponse, evm_sign_transaction_response::Result as SignResult,
-    },
-};
-use kameo::Actor;
-use tokio::select;
-use tracing::{error, info};
-
-use crate::{
-    actors::{
-        GlobalActors,
-        client::{ClientConnection, ClientError},
-        evm::ClientSignTransaction,
-        router::RegisterClient,
-    },
-    db,
-};
-
-pub struct ClientSession {
-    props: ClientConnection,
-    client_id: i32,
-}
-
-impl ClientSession {
-    pub(crate) fn new(props: ClientConnection, client_id: i32) -> Self {
-        Self { props, client_id }
-    }
-
-    pub async fn process_transport_inbound(&mut self, req: ClientRequest) -> Output {
-        let msg = req.payload.ok_or_else(|| {
-            error!(actor = "client", "Received message with no payload");
-            ClientError::MissingRequestPayload
-        })?;
-
-        match msg {
-            ClientRequestPayload::EvmSignTransaction(sign_req) => {
-                let wallet_address: [u8; 20] = sign_req
-                    .wallet_address
-                    .try_into()
-                    .map_err(|_| ClientError::UnexpectedRequestPayload)?;
-
-                let mut rlp_bytes: &[u8] = &sign_req.rlp_transaction;
-                let tx = TxEip1559::decode(&mut rlp_bytes)
-                    .map_err(|_| ClientError::UnexpectedRequestPayload)?;
-
-                let result = self
-                    .props
-                    .actors
-                    .evm
-                    .ask(ClientSignTransaction {
-                        client_id: self.client_id,
-                        wallet_address: Address::from_slice(&wallet_address),
-                        transaction: tx,
-                    })
-                    .await;
-
-                let response_result = match result {
-                    Ok(signature) => SignResult::Signature(signature.as_bytes().to_vec()),
-                    Err(err) => {
-                        error!(?err, "client sign transaction failed");
-                        SignResult::Error(EvmError::Internal.into())
-                    }
-                };
-
-                Ok(ClientResponse {
-                    payload: Some(ClientResponsePayload::EvmSignTransaction(
-                        EvmSignTransactionResponse {
-                            result: Some(response_result),
-                        },
-                    )),
-                })
-            }
-            _ => Err(ClientError::UnexpectedRequestPayload),
-        }
-    }
-}
-
-type Output = Result<ClientResponse, ClientError>;
-
-impl Actor for ClientSession {
-    type Args = Self;
-
-    type Error = ClientError;
-
-    async fn on_start(
-        args: Self::Args,
-        this: kameo::prelude::ActorRef<Self>,
-    ) -> Result<Self, Self::Error> {
-        args.props
-            .actors
-            .router
-            .ask(RegisterClient { actor: this })
-            .await
-            .map_err(|_| ClientError::ConnectionRegistrationFailed)?;
-        Ok(args)
-    }
-
-    async fn next(
-        &mut self,
-        _actor_ref: kameo::prelude::WeakActorRef<Self>,
-        mailbox_rx: &mut kameo::prelude::MailboxReceiver<Self>,
-    ) -> Option<kameo::mailbox::Signal<Self>> {
-        loop {
-            select! {
-                signal = mailbox_rx.recv() => {
-                    return signal;
-                }
-                msg = self.props.transport.recv() => {
-                    match msg {
-                        Some(request) => {
-                            match self.process_transport_inbound(request).await {
-                                Ok(resp) => {
-                                    if self.props.transport.send(Ok(resp)).await.is_err() {
-                                        error!(actor = "client", reason = "channel closed", "send.failed");
-                                        return Some(kameo::mailbox::Signal::Stop);
-                                    }
-                                }
-                                Err(err) => {
-                                    let _ = self.props.transport.send(Err(err)).await;
-                                    return Some(kameo::mailbox::Signal::Stop);
-                                }
-                            }
-                        }
-                        None => {
-                            info!(actor = "client", "transport.closed");
-                            return Some(kameo::mailbox::Signal::Stop);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl ClientSession {
-    pub fn new_test(db: db::DatabasePool, actors: GlobalActors) -> Self {
-        use arbiter_proto::transport::DummyTransport;
-        let transport: super::Transport = Box::new(DummyTransport::new());
-        let props = ClientConnection::new(db, transport, actors);
-        Self {
-            props,
-            client_id: 0,
-        }
-    }
-}

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

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

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

@@ -1,4 +1,3 @@
-use chrono::Utc;
 use diesel::{
     ExpressionMethods as _, OptionalExtension, QueryDsl, SelectableHelper,
     dsl::{insert_into, update},
@@ -313,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)

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

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

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

@@ -1,76 +0,0 @@
-use std::{collections::HashMap, ops::ControlFlow};
-
-use kameo::{
-    Actor,
-    actor::{ActorId, ActorRef},
-    messages,
-    prelude::{ActorStopReason, Context, WeakActorRef},
-};
-use tracing::info;
-
-use crate::actors::{client::session::ClientSession, user_agent::session::UserAgentSession};
-
-#[derive(Default)]
-pub struct MessageRouter {
-    pub user_agents: HashMap<ActorId, ActorRef<UserAgentSession>>,
-    pub clients: HashMap<ActorId, ActorRef<ClientSession>>,
-}
-
-impl Actor for MessageRouter {
-    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 = "MessageRouter",
-                event = "useragent.disconnected"
-            );
-        } else if self.clients.remove(&id).is_some() {
-            info!(?id, actor = "MessageRouter", event = "client.disconnected");
-        } else {
-            info!(
-                ?id,
-                actor = "MessageRouter",
-                event = "unknown.actor.disconnected"
-            );
-        }
-        Ok(ControlFlow::Continue(()))
-    }
-}
-
-#[messages]
-impl MessageRouter {
-    #[message(ctx)]
-    pub async fn register_user_agent(
-        &mut self,
-        actor: ActorRef<UserAgentSession>,
-        ctx: &mut Context<Self, ()>,
-    ) {
-        info!(id = %actor.id(), actor = "MessageRouter", 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 = "MessageRouter", event = "client.connected");
-        ctx.actor_ref().link(&actor).await;
-        self.clients.insert(actor.id(), actor);
-    }
-}

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

@@ -1,141 +0,0 @@
-use arbiter_proto::proto::user_agent::{
-    AuthChallengeRequest, AuthChallengeSolution, KeyType as ProtoKeyType, UserAgentRequest,
-    user_agent_request::Payload as UserAgentRequestPayload,
-};
-use tracing::error;
-
-use crate::actors::user_agent::{
-    UserAgentConnection,
-    auth::state::{AuthContext, AuthPublicKey, AuthStateMachine},
-    session::UserAgentSession,
-};
-
-#[derive(thiserror::Error, Debug, PartialEq)]
-pub enum Error {
-    #[error("Unexpected message payload")]
-    UnexpectedMessagePayload,
-    #[error("Invalid client public key length")]
-    InvalidClientPubkeyLength,
-    #[error("Invalid client public key encoding")]
-    InvalidAuthPubkeyEncoding,
-    #[error("Database pool unavailable")]
-    DatabasePoolUnavailable,
-    #[error("Database operation failed")]
-    DatabaseOperationFailed,
-    #[error("Public key not registered")]
-    PublicKeyNotRegistered,
-    #[error("Transport error")]
-    Transport,
-    #[error("Invalid bootstrap token")]
-    InvalidBootstrapToken,
-    #[error("Bootstrapper actor unreachable")]
-    BootstrapperActorUnreachable,
-    #[error("Invalid challenge solution")]
-    InvalidChallengeSolution,
-}
-
-mod state;
-use state::*;
-
-fn parse_pubkey(key_type: ProtoKeyType, pubkey: Vec<u8>) -> Result<AuthPublicKey, Error> {
-    match key_type {
-        // UNSPECIFIED treated as Ed25519 for backward compatibility
-        ProtoKeyType::Unspecified | ProtoKeyType::Ed25519 => {
-            let pubkey_bytes = pubkey.as_array().ok_or(Error::InvalidClientPubkeyLength)?;
-            let key = ed25519_dalek::VerifyingKey::from_bytes(pubkey_bytes)
-                .map_err(|_| Error::InvalidAuthPubkeyEncoding)?;
-            Ok(AuthPublicKey::Ed25519(key))
-        }
-        ProtoKeyType::EcdsaSecp256k1 => {
-            // Public key is sent as 33-byte SEC1 compressed point
-            let key = k256::ecdsa::VerifyingKey::from_sec1_bytes(&pubkey)
-                .map_err(|_| Error::InvalidAuthPubkeyEncoding)?;
-            Ok(AuthPublicKey::EcdsaSecp256k1(key))
-        }
-        ProtoKeyType::Rsa => {
-            use rsa::pkcs8::DecodePublicKey as _;
-            let key = rsa::RsaPublicKey::from_public_key_der(&pubkey)
-                .map_err(|_| Error::InvalidAuthPubkeyEncoding)?;
-            Ok(AuthPublicKey::Rsa(key))
-        }
-    }
-}
-
-fn parse_auth_event(payload: UserAgentRequestPayload) -> Result<AuthEvents, Error> {
-    match payload {
-        UserAgentRequestPayload::AuthChallengeRequest(AuthChallengeRequest {
-            pubkey,
-            bootstrap_token: None,
-            key_type,
-        }) => {
-            let kt = ProtoKeyType::try_from(key_type).unwrap_or(ProtoKeyType::Unspecified);
-            Ok(AuthEvents::AuthRequest(ChallengeRequest {
-                pubkey: parse_pubkey(kt, pubkey)?,
-            }))
-        }
-        UserAgentRequestPayload::AuthChallengeRequest(AuthChallengeRequest {
-            pubkey,
-            bootstrap_token: Some(token),
-            key_type,
-        }) => {
-            let kt = ProtoKeyType::try_from(key_type).unwrap_or(ProtoKeyType::Unspecified);
-            Ok(AuthEvents::BootstrapAuthRequest(BootstrapAuthRequest {
-                pubkey: parse_pubkey(kt, pubkey)?,
-                token,
-            }))
-        }
-        UserAgentRequestPayload::AuthChallengeSolution(AuthChallengeSolution { signature }) => {
-            Ok(AuthEvents::ReceivedSolution(ChallengeSolution {
-                solution: signature,
-            }))
-        }
-        _ => Err(Error::UnexpectedMessagePayload),
-    }
-}
-
-pub async fn authenticate(props: &mut UserAgentConnection) -> Result<AuthPublicKey, Error> {
-    let mut state = AuthStateMachine::new(AuthContext::new(props));
-
-    loop {
-        // `state` holds a mutable reference to `props` so we can't access it directly here
-        let transport = state.context_mut().conn.transport.as_mut();
-        let Some(UserAgentRequest {
-            payload: Some(payload),
-        }) = transport.recv().await
-        else {
-            return Err(Error::Transport);
-        };
-
-        let event = parse_auth_event(payload)?;
-
-        match state.process_event(event).await {
-            Ok(AuthStates::AuthOk(key)) => return Ok(key.clone()),
-            Err(AuthError::ActionFailed(err)) => {
-                error!(?err, "State machine action failed");
-                return Err(err);
-            }
-            Err(AuthError::GuardFailed(err)) => {
-                error!(?err, "State machine guard failed");
-                return Err(err);
-            }
-            Err(AuthError::InvalidEvent) => {
-                error!("Invalid event for current state");
-                return Err(Error::InvalidChallengeSolution);
-            }
-            Err(AuthError::TransitionsFailed) => {
-                error!("Invalid state transition");
-                return Err(Error::InvalidChallengeSolution);
-            }
-
-            _ => (),
-        }
-    }
-}
-
-pub async fn authenticate_and_create(
-    mut props: UserAgentConnection,
-) -> Result<UserAgentSession, Error> {
-    let _key = authenticate(&mut props).await?;
-    let session = UserAgentSession::new(props);
-    Ok(session)
-}

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

@@ -1,297 +0,0 @@
-use arbiter_proto::proto::user_agent::{
-    AuthChallenge, UserAgentResponse, user_agent_response::Payload as UserAgentResponsePayload,
-};
-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::UserAgentConnection},
-    db::{models::KeyType, schema},
-};
-
-/// Abstraction over Ed25519 / ECDSA-secp256k1 / RSA public keys used during the auth handshake.
-#[derive(Clone)]
-pub enum AuthPublicKey {
-    Ed25519(ed25519_dalek::VerifyingKey),
-    /// Compressed SEC1 public key; signature bytes are raw 64-byte (r||s).
-    EcdsaSecp256k1(k256::ecdsa::VerifyingKey),
-    /// RSA-2048+ public key (Windows Hello / KeyCredentialManager); signature bytes are PSS+SHA-256.
-    Rsa(rsa::RsaPublicKey),
-}
-
-impl AuthPublicKey {
-    /// Canonical bytes stored in DB and echoed back in the challenge.
-    /// Ed25519: raw 32 bytes. ECDSA: SEC1 compressed 33 bytes. RSA: DER-encoded SPKI.
-    pub fn to_stored_bytes(&self) -> Vec<u8> {
-        match self {
-            AuthPublicKey::Ed25519(k) => k.to_bytes().to_vec(),
-            // SEC1 compressed (33 bytes) is the natural compact format for secp256k1
-            AuthPublicKey::EcdsaSecp256k1(k) => k.to_encoded_point(true).as_bytes().to_vec(),
-            AuthPublicKey::Rsa(k) => {
-                use rsa::pkcs8::EncodePublicKey as _;
-                k.to_public_key_der()
-                    .expect("rsa SPKI encoding is infallible")
-                    .to_vec()
-            }
-        }
-    }
-
-    pub fn key_type(&self) -> KeyType {
-        match self {
-            AuthPublicKey::Ed25519(_) => KeyType::Ed25519,
-            AuthPublicKey::EcdsaSecp256k1(_) => KeyType::EcdsaSecp256k1,
-            AuthPublicKey::Rsa(_) => KeyType::Rsa,
-        }
-    }
-}
-
-pub struct ChallengeRequest {
-    pub pubkey: AuthPublicKey,
-}
-
-pub struct BootstrapAuthRequest {
-    pub pubkey: AuthPublicKey,
-    pub token: String,
-}
-
-pub struct ChallengeContext {
-    pub challenge: AuthChallenge,
-    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] / provide_key_bootstrap = AuthOk(AuthPublicKey),
-        SentChallenge(ChallengeContext) + ReceivedSolution(ChallengeSolution) [async verify_solution] / provide_key = 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::DatabasePoolUnavailable
-    })?;
-    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::DatabaseOperationFailed
-        })?
-        .ok_or_else(|| {
-            error!(?pubkey_bytes, "Public key not found in database");
-            Error::PublicKeyNotRegistered
-        })
-}
-
-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::DatabasePoolUnavailable
-    })?;
-
-    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::DatabaseOperationFailed
-        })?;
-
-    Ok(())
-}
-
-pub struct AuthContext<'a> {
-    pub(super) conn: &'a mut UserAgentConnection,
-}
-
-impl<'a> AuthContext<'a> {
-    pub fn new(conn: &'a mut UserAgentConnection) -> Self {
-        Self { conn }
-    }
-}
-
-impl AuthStateMachineContext for AuthContext<'_> {
-    type Error = Error;
-
-    async fn verify_solution(
-        &self,
-        ChallengeContext { challenge, key }: &ChallengeContext,
-        ChallengeSolution { solution }: &ChallengeSolution,
-    ) -> Result<bool, Self::Error> {
-        let formatted = arbiter_proto::format_challenge(challenge.nonce, &challenge.pubkey);
-
-        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()
-            }
-        };
-
-        Ok(valid)
-    }
-
-    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?;
-
-        let challenge = AuthChallenge {
-            pubkey: stored_bytes,
-            nonce,
-        };
-
-        self.conn
-            .transport
-            .send(Ok(UserAgentResponse {
-                payload: Some(UserAgentResponsePayload::AuthChallenge(challenge.clone())),
-            }))
-            .await
-            .map_err(|e| {
-                error!(?e, "Failed to send auth challenge");
-                Error::Transport
-            })?;
-
-        Ok(ChallengeContext {
-            challenge,
-            key: pubkey,
-        })
-    }
-
-    #[allow(missing_docs)]
-    #[allow(clippy::result_unit_err)]
-    async fn verify_bootstrap_token(
-        &self,
-        BootstrapAuthRequest { pubkey, token }: &BootstrapAuthRequest,
-    ) -> Result<bool, 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::BootstrapperActorUnreachable
-            })?;
-
-        if !token_ok {
-            error!("Invalid bootstrap token provided");
-            return Err(Error::InvalidBootstrapToken);
-        }
-
-        register_key(&self.conn.db, pubkey).await?;
-
-        Ok(true)
-    }
-
-    fn provide_key_bootstrap(
-        &mut self,
-        event_data: BootstrapAuthRequest,
-    ) -> Result<AuthPublicKey, Self::Error> {
-        Ok(event_data.pubkey)
-    }
-
-    fn provide_key(
-        &mut self,
-        state_data: &ChallengeContext,
-        _: ChallengeSolution,
-    ) -> Result<AuthPublicKey, Self::Error> {
-        // ChallengeContext.key cannot be taken by value because smlang passes it by ref;
-        // we reconstruct stored bytes and return them wrapped in Ed25519 placeholder.
-        // Session uses only the raw bytes, so we carry them via a Vec<u8>.
-        // IMPORTANT: do NOT simplify this by storing the key type separately — the
-        // `AuthPublicKey` enum IS the source of truth for key bytes and type.
-        //
-        // smlang state-machine trait requires returning an owned value from `provide_key`,
-        // but `state_data` is only available by shared reference here.  We extract the
-        // stored bytes and re-wrap as the correct variant so the caller can call
-        // `to_stored_bytes()` / `key_type()` without losing information.
-        let bytes = state_data.challenge.pubkey.clone();
-        let key_type = state_data.key.key_type();
-        let rebuilt = match key_type {
-            crate::db::models::KeyType::Ed25519 => {
-                let arr: &[u8; 32] = bytes
-                    .as_slice()
-                    .try_into()
-                    .expect("ed25519 pubkey must be 32 bytes in challenge");
-                AuthPublicKey::Ed25519(
-                    ed25519_dalek::VerifyingKey::from_bytes(arr)
-                        .expect("key was already validated in parse_auth_event"),
-                )
-            }
-            crate::db::models::KeyType::EcdsaSecp256k1 => {
-                // bytes are SEC1 compressed (33 bytes produced by to_encoded_point(true))
-                AuthPublicKey::EcdsaSecp256k1(
-                    k256::ecdsa::VerifyingKey::from_sec1_bytes(&bytes)
-                        .expect("ecdsa key was already validated in parse_auth_event"),
-                )
-            }
-            crate::db::models::KeyType::Rsa => {
-                use rsa::pkcs8::DecodePublicKey as _;
-                AuthPublicKey::Rsa(
-                    rsa::RsaPublicKey::from_public_key_der(&bytes)
-                        .expect("rsa key was already validated in parse_auth_event"),
-                )
-            }
-        };
-        Ok(rebuilt)
-    }
-}

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,65 +1,401 @@
-use arbiter_proto::{
-    proto::user_agent::{UserAgentRequest, UserAgentResponse},
-    transport::Bi,
+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 kameo::actor::Spawn as _;
+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, user_agent::session::UserAgentSession},
-    db::{self},
+    ServerContext,
+    actors::{
+        GlobalActors,
+        bootstrap::ConsumeToken,
+        keyholder::{self, TryUnseal},
+        user_agent::state::{
+            ChallengeContext, DummyContext, UnsealContext, UserAgentEvents, UserAgentStateMachine,
+            UserAgentStates,
+        },
+    },
+    db::{self, schema},
 };
 
-#[derive(Debug, thiserror::Error, PartialEq)]
-pub enum TransportResponseError {
-    #[error("Expected message with payload")]
-    MissingRequestPayload,
-    #[error("Unexpected request payload")]
-    UnexpectedRequestPayload,
-    #[error("Invalid state for unseal encrypted key")]
-    InvalidStateForUnsealEncryptedKey,
-    #[error("client_pubkey must be 32 bytes")]
-    InvalidClientPubkeyLength,
-    #[error("State machine error")]
-    StateTransitionFailed,
-    #[error("Vault is not available")]
-    KeyHolderActorUnreachable,
-    #[error(transparent)]
-    Auth(#[from] auth::Error),
-    #[error("Failed registering connection")]
-    ConnectionRegistrationFailed,
-}
+mod error;
+mod state;
 
-pub type Transport =
-    Box<dyn Bi<UserAgentRequest, Result<UserAgentResponse, TransportResponseError>> + Send>;
+pub use error::UserAgentError;
 
-pub struct UserAgentConnection {
+#[derive(Actor)]
+pub struct UserAgentActor {
     db: db::DatabasePool,
     actors: GlobalActors,
-    transport: Transport,
+    state: UserAgentStateMachine<DummyContext>,
+    transport: Recipient<Result<UserAgentResponse, UserAgentError>>,
 }
 
-impl UserAgentConnection {
-    pub fn new(db: db::DatabasePool, actors: GlobalActors, transport: Transport) -> Self {
+impl UserAgentActor {
+    pub(crate) fn new(
+        context: ServerContext,
+        transport: Recipient<Result<UserAgentResponse, UserAgentError>>,
+    ) -> Self {
         Self {
-            db,
-            actors,
+            db: context.db.clone(),
+            actors: context.actors.clone(),
+            state: UserAgentStateMachine::new(DummyContext),
             transport,
         }
     }
+
+    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))
+    }
 }
 
-pub mod auth;
-pub mod session;
+type Output = Result<UserAgentResponse, UserAgentError>;
 
-pub async fn connect_user_agent(props: UserAgentConnection) {
-    match auth::authenticate_and_create(props).await {
-        Ok(session) => {
-            UserAgentSession::spawn(session);
-            info!("User authenticated, session started");
+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(),
+                )))
+            }
         }
-        Err(err) => {
-            error!(?err, "Authentication failed, closing connection");
+    }
+
+    #[message]
+    pub async fn handle_auth_challenge_request(&mut self, req: AuthChallengeRequest) -> Output {
+        let pubkey = req
+            .pubkey
+            .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 Message<UserAgentRequest> for UserAgentActor {
+    type Reply = ();
+
+    async fn handle(
+        &mut self,
+        msg: UserAgentRequest,
+        _ctx: &mut kameo::prelude::Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+        let result = self.process_request(msg).await;
+        if let Err(e) = self.transport.tell(result).await {
+            error!(actor = "useragent", "Failed to send response to transport: {}", e);
         }
     }
 }

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

@@ -1,587 +0,0 @@
-use std::{ops::DerefMut, sync::Mutex};
-
-use arbiter_proto::proto::{
-    evm as evm_proto,
-    user_agent::{
-        SdkClientApproveRequest, SdkClientApproveResponse, SdkClientEntry,
-        SdkClientError as ProtoSdkClientError, SdkClientList, SdkClientListResponse,
-        SdkClientRevokeRequest, SdkClientRevokeResponse, UnsealEncryptedKey, UnsealResult,
-        UnsealStart, UnsealStartResponse, UserAgentRequest, UserAgentResponse,
-        sdk_client_approve_response, sdk_client_list_response, sdk_client_revoke_response,
-        user_agent_request::Payload as UserAgentRequestPayload,
-        user_agent_response::Payload as UserAgentResponsePayload,
-    },
-};
-use chacha20poly1305::{AeadInPlace, XChaCha20Poly1305, XNonce, aead::KeyInit};
-use diesel::{ExpressionMethods as _, QueryDsl as _, dsl::insert_into};
-use diesel_async::RunQueryDsl as _;
-use kameo::{Actor, error::SendError, prelude::Context};
-use memsafe::MemSafe;
-use tokio::select;
-use tracing::{error, info};
-use x25519_dalek::{EphemeralSecret, PublicKey};
-
-use crate::{
-    actors::{
-        evm::{Generate, ListWallets},
-        keyholder::{self, TryUnseal},
-        router::RegisterUserAgent,
-        user_agent::{TransportResponseError, UserAgentConnection},
-    },
-    db::schema::program_client,
-};
-
-mod state;
-use state::{DummyContext, UnsealContext, UserAgentEvents, UserAgentStateMachine, UserAgentStates};
-
-// Error for consumption by other actors
-#[derive(Debug, thiserror::Error, PartialEq)]
-pub enum Error {
-    #[error("User agent session ended due to connection loss")]
-    ConnectionLost,
-
-    #[error("User agent session ended due to unexpected message")]
-    UnexpectedMessage,
-}
-
-pub struct UserAgentSession {
-    props: UserAgentConnection,
-    state: UserAgentStateMachine<DummyContext>,
-}
-
-impl UserAgentSession {
-    pub(crate) fn new(props: UserAgentConnection) -> Self {
-        Self {
-            props,
-            state: UserAgentStateMachine::new(DummyContext),
-        }
-    }
-
-    fn transition(&mut self, event: UserAgentEvents) -> Result<(), TransportResponseError> {
-        self.state.process_event(event).map_err(|e| {
-            error!(?e, "State transition failed");
-            TransportResponseError::StateTransitionFailed
-        })?;
-        Ok(())
-    }
-
-    async fn send_msg<Reply: kameo::Reply>(
-        &mut self,
-        msg: UserAgentResponsePayload,
-        _ctx: &mut Context<Self, Reply>,
-    ) -> Result<(), Error> {
-        self.props
-            .transport
-            .send(Ok(response(msg)))
-            .await
-            .map_err(|_| {
-                error!(
-                    actor = "useragent",
-                    reason = "channel closed",
-                    "send.failed"
-                );
-                Error::ConnectionLost
-            })
-    }
-
-    async fn expect_msg<Extractor, Msg, Reply>(
-        &mut self,
-        extractor: Extractor,
-        ctx: &mut Context<Self, Reply>,
-    ) -> Result<Msg, Error>
-    where
-        Extractor: FnOnce(UserAgentRequestPayload) -> Option<Msg>,
-        Reply: kameo::Reply,
-    {
-        let msg = self.props.transport.recv().await.ok_or_else(|| {
-            error!(
-                actor = "useragent",
-                reason = "channel closed",
-                "recv.failed"
-            );
-            ctx.stop();
-            Error::ConnectionLost
-        })?;
-
-        msg.payload.and_then(extractor).ok_or_else(|| {
-            error!(
-                actor = "useragent",
-                reason = "unexpected message",
-                "recv.failed"
-            );
-            ctx.stop();
-            Error::UnexpectedMessage
-        })
-    }
-}
-
-impl UserAgentSession {
-    pub async fn process_transport_inbound(&mut self, req: UserAgentRequest) -> Output {
-        let msg = req.payload.ok_or_else(|| {
-            error!(actor = "useragent", "Received message with no payload");
-            TransportResponseError::MissingRequestPayload
-        })?;
-
-        match msg {
-            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
-            }
-            UserAgentRequestPayload::EvmWalletCreate(_) => self.handle_evm_wallet_create().await,
-            UserAgentRequestPayload::EvmWalletList(_) => self.handle_evm_wallet_list().await,
-            UserAgentRequestPayload::SdkClientApprove(req) => {
-                self.handle_sdk_client_approve(req).await
-            }
-            UserAgentRequestPayload::SdkClientRevoke(req) => {
-                self.handle_sdk_client_revoke(req).await
-            }
-            UserAgentRequestPayload::SdkClientList(_) => self.handle_sdk_client_list().await,
-            _ => Err(TransportResponseError::UnexpectedRequestPayload),
-        }
-    }
-}
-
-type Output = Result<UserAgentResponse, TransportResponseError>;
-
-fn response(payload: UserAgentResponsePayload) -> UserAgentResponse {
-    UserAgentResponse {
-        payload: Some(payload),
-    }
-}
-
-impl UserAgentSession {
-    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(|_| TransportResponseError::InvalidClientPubkeyLength)?;
-
-        let client_public_key = PublicKey::from(client_pubkey_bytes);
-
-        self.transition(UserAgentEvents::UnsealRequest(UnsealContext {
-            secret: Mutex::new(Some(secret)),
-            client_public_key,
-        }))?;
-
-        Ok(response(UserAgentResponsePayload::UnsealStartResponse(
-            UnsealStartResponse {
-                server_pubkey: public_key.as_bytes().to_vec(),
-            },
-        )))
-    }
-
-    async fn handle_unseal_encrypted_key(&mut self, req: UnsealEncryptedKey) -> Output {
-        let UserAgentStates::WaitingForUnsealKey(unseal_context) = self.state.state() else {
-            error!("Received unseal encrypted key in invalid state");
-            return Err(TransportResponseError::InvalidStateForUnsealEncryptedKey);
-        };
-        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(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
-                    .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(response(UserAgentResponsePayload::UnsealResult(
-                            UnsealResult::Success.into(),
-                        )))
-                    }
-                    Err(SendError::HandlerError(keyholder::Error::InvalidKey)) => {
-                        self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                        Ok(response(UserAgentResponsePayload::UnsealResult(
-                            UnsealResult::InvalidKey.into(),
-                        )))
-                    }
-                    Err(SendError::HandlerError(err)) => {
-                        error!(?err, "Keyholder failed to unseal key");
-                        self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                        Ok(response(UserAgentResponsePayload::UnsealResult(
-                            UnsealResult::InvalidKey.into(),
-                        )))
-                    }
-                    Err(err) => {
-                        error!(?err, "Failed to send unseal request to keyholder");
-                        self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                        Err(TransportResponseError::KeyHolderActorUnreachable)
-                    }
-                }
-            }
-            Err(err) => {
-                error!(?err, "Failed to decrypt unseal key");
-                self.transition(UserAgentEvents::ReceivedInvalidKey)?;
-                Ok(response(UserAgentResponsePayload::UnsealResult(
-                    UnsealResult::InvalidKey.into(),
-                )))
-            }
-        }
-    }
-}
-
-impl UserAgentSession {
-    async fn handle_evm_wallet_create(&mut self) -> Output {
-        use evm_proto::wallet_create_response::Result as CreateResult;
-
-        let result = match self.props.actors.evm.ask(Generate {}).await {
-            Ok(address) => CreateResult::Wallet(evm_proto::WalletEntry {
-                address: address.as_slice().to_vec(),
-            }),
-            Err(err) => CreateResult::Error(map_evm_error("wallet create", err).into()),
-        };
-
-        Ok(response(UserAgentResponsePayload::EvmWalletCreate(
-            evm_proto::WalletCreateResponse {
-                result: Some(result),
-            },
-        )))
-    }
-
-    async fn handle_evm_wallet_list(&mut self) -> Output {
-        use evm_proto::wallet_list_response::Result as ListResult;
-
-        let result = match self.props.actors.evm.ask(ListWallets {}).await {
-            Ok(wallets) => ListResult::Wallets(evm_proto::WalletList {
-                wallets: wallets
-                    .into_iter()
-                    .map(|addr| evm_proto::WalletEntry {
-                        address: addr.as_slice().to_vec(),
-                    })
-                    .collect(),
-            }),
-            Err(err) => ListResult::Error(map_evm_error("wallet list", err).into()),
-        };
-
-        Ok(response(UserAgentResponsePayload::EvmWalletList(
-            evm_proto::WalletListResponse {
-                result: Some(result),
-            },
-        )))
-    }
-}
-
-impl UserAgentSession {
-    async fn handle_sdk_client_approve(&mut self, req: SdkClientApproveRequest) -> Output {
-        use sdk_client_approve_response::Result as ApproveResult;
-
-        if req.pubkey.len() != 32 {
-            return Ok(response(UserAgentResponsePayload::SdkClientApprove(
-                SdkClientApproveResponse {
-                    result: Some(ApproveResult::Error(ProtoSdkClientError::Internal.into())),
-                },
-            )));
-        }
-
-        let now = std::time::SystemTime::now()
-            .duration_since(std::time::UNIX_EPOCH)
-            .unwrap_or_default()
-            .as_secs() as i32;
-
-        let mut conn = match self.props.db.get().await {
-            Ok(c) => c,
-            Err(e) => {
-                error!(?e, "Failed to get DB connection for sdk_client_approve");
-                return Ok(response(UserAgentResponsePayload::SdkClientApprove(
-                    SdkClientApproveResponse {
-                        result: Some(ApproveResult::Error(ProtoSdkClientError::Internal.into())),
-                    },
-                )));
-            }
-        };
-
-        let pubkey_bytes = req.pubkey.clone();
-        let insert_result = insert_into(program_client::table)
-            .values((
-                program_client::public_key.eq(&pubkey_bytes),
-                program_client::nonce.eq(1), // pre-incremented; challenge will use nonce=0
-                program_client::created_at.eq(now),
-                program_client::updated_at.eq(now),
-            ))
-            .execute(&mut conn)
-            .await;
-
-        match insert_result {
-            Ok(_) => {
-                match program_client::table
-                    .filter(program_client::public_key.eq(&pubkey_bytes))
-                    .order(program_client::id.desc())
-                    .select((
-                        program_client::id,
-                        program_client::public_key,
-                        program_client::created_at,
-                    ))
-                    .first::<(i32, Vec<u8>, i32)>(&mut conn)
-                    .await
-                {
-                    Ok((id, pubkey, created_at)) => Ok(response(
-                        UserAgentResponsePayload::SdkClientApprove(SdkClientApproveResponse {
-                            result: Some(ApproveResult::Client(SdkClientEntry {
-                                id,
-                                pubkey,
-                                created_at,
-                            })),
-                        }),
-                    )),
-                    Err(e) => {
-                        error!(?e, "Failed to fetch inserted SDK client");
-                        Ok(response(UserAgentResponsePayload::SdkClientApprove(
-                            SdkClientApproveResponse {
-                                result: Some(ApproveResult::Error(
-                                    ProtoSdkClientError::Internal.into(),
-                                )),
-                            },
-                        )))
-                    }
-                }
-            }
-            Err(diesel::result::Error::DatabaseError(
-                diesel::result::DatabaseErrorKind::UniqueViolation,
-                _,
-            )) => Ok(response(UserAgentResponsePayload::SdkClientApprove(
-                SdkClientApproveResponse {
-                    result: Some(ApproveResult::Error(
-                        ProtoSdkClientError::AlreadyExists.into(),
-                    )),
-                },
-            ))),
-            Err(e) => {
-                error!(?e, "Failed to insert SDK client");
-                Ok(response(UserAgentResponsePayload::SdkClientApprove(
-                    SdkClientApproveResponse {
-                        result: Some(ApproveResult::Error(ProtoSdkClientError::Internal.into())),
-                    },
-                )))
-            }
-        }
-    }
-
-    async fn handle_sdk_client_list(&mut self) -> Output {
-        let mut conn = match self.props.db.get().await {
-            Ok(c) => c,
-            Err(e) => {
-                error!(?e, "Failed to get DB connection for sdk_client_list");
-                return Ok(response(UserAgentResponsePayload::SdkClientList(
-                    SdkClientListResponse {
-                        result: Some(sdk_client_list_response::Result::Error(
-                            ProtoSdkClientError::Internal.into(),
-                        )),
-                    },
-                )));
-            }
-        };
-
-        match program_client::table
-            .select((
-                program_client::id,
-                program_client::public_key,
-                program_client::created_at,
-            ))
-            .load::<(i32, Vec<u8>, i32)>(&mut conn)
-            .await
-        {
-            Ok(rows) => Ok(response(UserAgentResponsePayload::SdkClientList(
-                SdkClientListResponse {
-                    result: Some(sdk_client_list_response::Result::Clients(SdkClientList {
-                        clients: rows
-                            .into_iter()
-                            .map(|(id, pubkey, created_at)| SdkClientEntry {
-                                id,
-                                pubkey,
-                                created_at,
-                            })
-                            .collect(),
-                    })),
-                },
-            ))),
-            Err(e) => {
-                error!(?e, "Failed to list SDK clients");
-                Ok(response(UserAgentResponsePayload::SdkClientList(
-                    SdkClientListResponse {
-                        result: Some(sdk_client_list_response::Result::Error(
-                            ProtoSdkClientError::Internal.into(),
-                        )),
-                    },
-                )))
-            }
-        }
-    }
-
-    async fn handle_sdk_client_revoke(&mut self, req: SdkClientRevokeRequest) -> Output {
-        use sdk_client_revoke_response::Result as RevokeResult;
-
-        let mut conn = match self.props.db.get().await {
-            Ok(c) => c,
-            Err(e) => {
-                error!(?e, "Failed to get DB connection for sdk_client_revoke");
-                return Ok(response(UserAgentResponsePayload::SdkClientRevoke(
-                    SdkClientRevokeResponse {
-                        result: Some(RevokeResult::Error(ProtoSdkClientError::Internal.into())),
-                    },
-                )));
-            }
-        };
-
-        match diesel::delete(program_client::table)
-            .filter(program_client::id.eq(req.client_id))
-            .execute(&mut conn)
-            .await
-        {
-            Ok(0) => Ok(response(UserAgentResponsePayload::SdkClientRevoke(
-                SdkClientRevokeResponse {
-                    result: Some(RevokeResult::Error(ProtoSdkClientError::NotFound.into())),
-                },
-            ))),
-            Ok(_) => Ok(response(UserAgentResponsePayload::SdkClientRevoke(
-                SdkClientRevokeResponse {
-                    result: Some(RevokeResult::Ok(())),
-                },
-            ))),
-            Err(diesel::result::Error::DatabaseError(
-                diesel::result::DatabaseErrorKind::ForeignKeyViolation,
-                _,
-            )) => Ok(response(UserAgentResponsePayload::SdkClientRevoke(
-                SdkClientRevokeResponse {
-                    result: Some(RevokeResult::Error(
-                        ProtoSdkClientError::HasRelatedData.into(),
-                    )),
-                },
-            ))),
-            Err(e) => {
-                error!(?e, "Failed to delete SDK client");
-                Ok(response(UserAgentResponsePayload::SdkClientRevoke(
-                    SdkClientRevokeResponse {
-                        result: Some(RevokeResult::Error(ProtoSdkClientError::Internal.into())),
-                    },
-                )))
-            }
-        }
-    }
-}
-
-fn map_evm_error<M>(op: &str, err: SendError<M, crate::actors::evm::Error>) -> evm_proto::EvmError {
-    use crate::actors::{evm::Error as EvmError, keyholder::Error as KhError};
-    match err {
-        SendError::HandlerError(EvmError::Keyholder(KhError::NotBootstrapped)) => {
-            evm_proto::EvmError::VaultSealed
-        }
-        SendError::HandlerError(err) => {
-            error!(?err, "EVM {op} failed");
-            evm_proto::EvmError::Internal
-        }
-        _ => {
-            error!("EVM actor unreachable during {op}");
-            evm_proto::EvmError::Internal
-        }
-    }
-}
-
-impl Actor for UserAgentSession {
-    type Args = Self;
-
-    type Error = TransportResponseError;
-
-    async fn on_start(
-        args: Self::Args,
-        this: kameo::prelude::ActorRef<Self>,
-    ) -> Result<Self, Self::Error> {
-        args.props
-            .actors
-            .router
-            .ask(RegisterUserAgent {
-                actor: this.clone(),
-            })
-            .await
-            .map_err(|err| {
-                error!(?err, "Failed to register user agent connection with router");
-                TransportResponseError::ConnectionRegistrationFailed
-            })?;
-        Ok(args)
-    }
-
-    async fn next(
-        &mut self,
-        _actor_ref: kameo::prelude::WeakActorRef<Self>,
-        mailbox_rx: &mut kameo::prelude::MailboxReceiver<Self>,
-    ) -> Option<kameo::mailbox::Signal<Self>> {
-        loop {
-            select! {
-                signal = mailbox_rx.recv() => {
-                    return signal;
-                }
-                msg = self.props.transport.recv() => {
-                    match msg {
-                        Some(request) => {
-                            match self.process_transport_inbound(request).await {
-                                Ok(response) => {
-                                    if self.props.transport.send(Ok(response)).await.is_err() {
-                                        error!(actor = "useragent", reason = "channel closed", "send.failed");
-                                        return Some(kameo::mailbox::Signal::Stop);
-                                    }
-                                }
-                                Err(err) => {
-                                    let _ = self.props.transport.send(Err(err)).await;
-                                    return Some(kameo::mailbox::Signal::Stop);
-                                }
-                            }
-                        }
-                        None => {
-                            info!(actor = "useragent", "transport.closed");
-                            return Some(kameo::mailbox::Signal::Stop);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-impl UserAgentSession {
-    pub fn new_test(db: crate::db::DatabasePool, actors: crate::actors::GlobalActors) -> Self {
-        use arbiter_proto::transport::DummyTransport;
-        let transport: super::Transport = Box::new(DummyTransport::new());
-        let props = UserAgentConnection::new(db, actors, transport);
-        Self {
-            props,
-            state: UserAgentStateMachine::new(DummyContext),
-        }
-    }
-}

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

@@ -135,10 +135,10 @@ 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);
-    let url = file
-        .to_str()
-        .expect("temp file path is not valid UTF-8")
-        .to_string();
+    let url = format!(
+        "{}?mode=rwc",
+        file.to_str().expect("temp file path is not valid UTF-8")
+    );
 
     create_pool(Some(&url))
         .await

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

@@ -1,113 +1,14 @@
 #![allow(unused)]
 #![allow(clippy::all)]
 
-use crate::db::schema::{
-    self, aead_encrypted, arbiter_settings, evm_basic_grant, evm_ether_transfer_grant,
-    evm_ether_transfer_grant_target, evm_ether_transfer_limit, evm_token_transfer_grant,
-    evm_token_transfer_log, evm_token_transfer_volume_limit, evm_transaction_log, evm_wallet,
-    root_key_history, tls_history,
-};
-use chrono::{DateTime, Utc};
+use crate::db::schema::{self, aead_encrypted, arbiter_settings, root_key_history, tls_history};
 use diesel::{prelude::*, sqlite::Sqlite};
 use restructed::Models;
 
 pub mod types {
     use chrono::{DateTime, Utc};
-    use diesel::{
-        deserialize::{FromSql, FromSqlRow},
-        expression::AsExpression,
-        serialize::{IsNull, ToSql},
-        sql_types::Integer,
-        sqlite::{Sqlite, SqliteType},
-    };
-
-    #[derive(Debug, FromSqlRow, AsExpression)]
-    #[diesel(sql_type = Integer)]
-    #[repr(transparent)] // hint compiler to optimize the wrapper struct away
-    pub struct SqliteTimestamp(pub DateTime<Utc>);
-    impl SqliteTimestamp {
-        pub fn now() -> Self {
-            SqliteTimestamp(Utc::now())
-        }
-    }
-
-    impl From<chrono::DateTime<Utc>> for SqliteTimestamp {
-        fn from(dt: chrono::DateTime<Utc>) -> Self {
-            SqliteTimestamp(dt)
-        }
-    }
-    impl 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 struct SqliteTimestamp(DateTime<Utc>);
 }
-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_key: String,   // PEM Encoded public key for cert signing
-    pub created_at: SqliteTimestamp,
+    pub ca_cert: String, // PEM Encoded certificate for cert signing
+    pub ca_key: String, // PEM Encoded public key for cert signing
+    pub created_at: i32,
 }
 
 #[derive(Queryable, Debug, Insertable, Selectable)]
@@ -167,173 +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)]
-#[diesel(table_name = evm_wallet, check_for_backend(Sqlite))]
-#[view(
-    NewEvmWallet,
-    derive(Insertable),
-    omit(id, created_at),
-    attributes_with = "deriveless"
-)]
-pub struct EvmWallet {
-    pub id: i32,
-    pub address: Vec<u8>,
-    pub aead_encrypted_id: i32,
-    pub created_at: SqliteTimestamp,
-}
-
-#[derive(Queryable, Debug, Insertable, Selectable)]
+#[derive(Queryable, Debug)]
 #[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 created_at: SqliteTimestamp,
-    pub updated_at: SqliteTimestamp,
+    pub nonce: i32,
+    pub created_at: i32,
+    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 updated_at: SqliteTimestamp,
-    pub key_type: KeyType,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_ether_transfer_limit, check_for_backend(Sqlite))]
-#[view(
-    NewEvmEtherTransferLimit,
-    derive(Insertable),
-    omit(id, created_at),
-    attributes_with = "deriveless"
-)]
-pub struct EvmEtherTransferLimit {
-    pub id: i32,
-    pub window_secs: i32,
-    pub max_volume: Vec<u8>,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_basic_grant, check_for_backend(Sqlite))]
-#[view(
-    NewEvmBasicGrant,
-    derive(Insertable),
-    omit(id, created_at),
-    attributes_with = "deriveless"
-)]
-pub struct EvmBasicGrant {
-    pub id: i32,
-    pub wallet_id: i32, // references evm_wallet.id
-    pub client_id: i32, // references program_client.id
-    pub chain_id: i32,
-    pub valid_from: Option<SqliteTimestamp>,
-    pub valid_until: Option<SqliteTimestamp>,
-    pub max_gas_fee_per_gas: Option<Vec<u8>>,
-    pub max_priority_fee_per_gas: Option<Vec<u8>>,
-    pub rate_limit_count: Option<i32>,
-    pub rate_limit_window_secs: Option<i32>,
-    pub revoked_at: Option<SqliteTimestamp>,
-    pub created_at: SqliteTimestamp,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_transaction_log, check_for_backend(Sqlite))]
-#[view(
-    NewEvmTransactionLog,
-    derive(Insertable),
-    omit(id),
-    attributes_with = "deriveless"
-)]
-pub struct EvmTransactionLog {
-    pub id: i32,
-    pub grant_id: i32,
-    pub client_id: i32,
-    pub wallet_id: i32,
-    pub chain_id: i32,
-    pub eth_value: Vec<u8>,
-    pub signed_at: SqliteTimestamp,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_ether_transfer_grant, check_for_backend(Sqlite))]
-#[view(
-    NewEvmEtherTransferGrant,
-    derive(Insertable),
-    omit(id),
-    attributes_with = "deriveless"
-)]
-pub struct EvmEtherTransferGrant {
-    pub id: i32,
-    pub basic_grant_id: i32,
-    pub limit_id: i32, // references evm_ether_transfer_limit.id
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_ether_transfer_grant_target, check_for_backend(Sqlite))]
-#[view(
-    NewEvmEtherTransferGrantTarget,
-    derive(Insertable),
-    omit(id),
-    attributes_with = "deriveless"
-)]
-pub struct EvmEtherTransferGrantTarget {
-    pub id: i32,
-    pub grant_id: i32,
-    pub address: Vec<u8>,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_token_transfer_grant, check_for_backend(Sqlite))]
-#[view(
-    NewEvmTokenTransferGrant,
-    derive(Insertable),
-    omit(id),
-    attributes_with = "deriveless"
-)]
-pub struct EvmTokenTransferGrant {
-    pub id: i32,
-    pub basic_grant_id: i32,
-    pub token_contract: Vec<u8>,
-    pub receiver: Option<Vec<u8>>,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_token_transfer_volume_limit, check_for_backend(Sqlite))]
-#[view(
-    NewEvmTokenTransferVolumeLimit,
-    derive(Insertable),
-    omit(id),
-    attributes_with = "deriveless"
-)]
-pub struct EvmTokenTransferVolumeLimit {
-    pub id: i32,
-    pub grant_id: i32,
-    pub window_secs: i32,
-    pub max_volume: Vec<u8>,
-}
-
-#[derive(Models, Queryable, Debug, Insertable, Selectable)]
-#[diesel(table_name = evm_token_transfer_log, check_for_backend(Sqlite))]
-#[view(
-    NewEvmTokenTransferLog,
-    derive(Insertable),
-    omit(id, created_at),
-    attributes_with = "deriveless"
-)]
-pub struct EvmTokenTransferLog {
-    pub id: i32,
-    pub grant_id: i32,
-    pub log_id: i32,
-    pub chain_id: i32,
-    pub token_contract: Vec<u8>,
-    pub recipient_address: Vec<u8>,
-    pub value: Vec<u8>,
-    pub created_at: SqliteTimestamp,
+    pub nonce: i32,
+    pub created_at: i32,
+    pub updated_at: i32,
 }

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

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

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

@@ -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,340 +0,0 @@
-pub mod abi;
-pub mod safe_signer;
-
-use alloy::{
-    consensus::TxEip1559,
-    primitives::{TxKind, U256},
-};
-use chrono::Utc;
-use diesel::{ExpressionMethods as _, QueryDsl, QueryResult, insert_into, sqlite::Sqlite};
-use diesel_async::{AsyncConnection, RunQueryDsl};
-
-use crate::{
-    db::{
-        self,
-        models::{EvmBasicGrant, NewEvmBasicGrant, NewEvmTransactionLog, SqliteTimestamp},
-        schema::{self, evm_transaction_log},
-    },
-    evm::policies::{
-        DatabaseID, EvalContext, EvalViolation, FullGrant, Grant, Policy, SharedGrantSettings,
-        SpecificGrant, SpecificMeaning, ether_transfer::EtherTransfer,
-        token_transfers::TokenTransfer,
-    },
-};
-
-pub mod policies;
-mod utils;
-
-/// Errors that can only occur once the transaction meaning is known (during policy evaluation)
-#[derive(Debug, thiserror::Error, miette::Diagnostic)]
-pub enum PolicyError {
-    #[error("Database connection pool error")]
-    #[diagnostic(code(arbiter_server::evm::policy_error::pool))]
-    Pool(#[from] db::PoolError),
-    #[error("Database returned error")]
-    #[diagnostic(code(arbiter_server::evm::policy_error::database))]
-    Database(#[from] diesel::result::Error),
-    #[error("Transaction violates policy: {0:?}")]
-    #[diagnostic(code(arbiter_server::evm::policy_error::violation))]
-    Violations(Vec<EvalViolation>),
-    #[error("No matching grant found")]
-    #[diagnostic(code(arbiter_server::evm::policy_error::no_matching_grant))]
-    NoMatchingGrant,
-}
-
-#[derive(Debug, thiserror::Error, miette::Diagnostic)]
-pub enum VetError {
-    #[error("Contract creation transactions are not supported")]
-    #[diagnostic(code(arbiter_server::evm::vet_error::contract_creation_unsupported))]
-    ContractCreationNotSupported,
-    #[error("Engine can't classify this transaction")]
-    #[diagnostic(code(arbiter_server::evm::vet_error::unsupported))]
-    UnsupportedTransactionType,
-    #[error("Policy evaluation failed: {1}")]
-    #[diagnostic(code(arbiter_server::evm::vet_error::evaluated))]
-    Evaluated(SpecificMeaning, #[source] PolicyError),
-}
-
-#[derive(Debug, thiserror::Error, miette::Diagnostic)]
-pub enum SignError {
-    #[error("Database connection pool error")]
-    #[diagnostic(code(arbiter_server::evm::database_error))]
-    Pool(#[from] db::PoolError),
-    #[error("Database returned error")]
-    #[diagnostic(code(arbiter_server::evm::database_error))]
-    Database(#[from] diesel::result::Error),
-}
-
-#[derive(Debug, thiserror::Error, miette::Diagnostic)]
-pub enum AnalyzeError {
-    #[error("Engine doesn't support granting permissions for contract creation")]
-    #[diagnostic(code(arbiter_server::evm::analyze_error::contract_creation_not_supported))]
-    ContractCreationNotSupported,
-
-    #[error("Unsupported transaction type")]
-    #[diagnostic(code(arbiter_server::evm::analyze_error::unsupported_transaction_type))]
-    UnsupportedTransactionType,
-}
-
-#[derive(Debug, thiserror::Error, miette::Diagnostic)]
-pub enum CreationError {
-    #[error("Database connection pool error")]
-    #[diagnostic(code(arbiter_server::evm::creation_error::database_error))]
-    Pool(#[from] db::PoolError),
-
-    #[error("Database returned error")]
-    #[diagnostic(code(arbiter_server::evm::creation_error::database_error))]
-    Database(#[from] diesel::result::Error),
-}
-
-#[derive(Debug, thiserror::Error, miette::Diagnostic)]
-pub enum ListGrantsError {
-    #[error("Database connection pool error")]
-    #[diagnostic(code(arbiter_server::evm::list_grants_error::pool))]
-    Pool(#[from] db::PoolError),
-
-    #[error("Database returned error")]
-    #[diagnostic(code(arbiter_server::evm::list_grants_error::database))]
-    Database(#[from] diesel::result::Error),
-}
-
-/// Controls whether a transaction should be executed or only validated
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum RunKind {
-    /// Validate and record the transaction
-    Execution,
-    /// Validate only, do not record
-    CheckOnly,
-}
-
-async fn check_shared_constraints(
-    context: &EvalContext,
-    shared: &SharedGrantSettings,
-    shared_grant_id: DatabaseID,
-    conn: &mut impl AsyncConnection<Backend = Sqlite>,
-) -> QueryResult<Vec<EvalViolation>> {
-    let mut violations = Vec::new();
-    let now = Utc::now();
-
-    // Validity window
-    if shared.valid_from.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?;
-
-        let grant = P::try_find_grant(&context, &mut conn)
-            .await?
-            .ok_or(PolicyError::NoMatchingGrant)?;
-
-        let mut violations =
-            check_shared_constraints(&context, &grant.shared, grant.shared_grant_id, &mut conn)
-                .await?;
-        violations.extend(P::evaluate(&context, meaning, &grant, &mut conn).await?);
-
-        if !violations.is_empty() {
-            return Err(PolicyError::Violations(violations));
-        } else if run_kind == RunKind::Execution {
-            conn.transaction(|conn| {
-                Box::pin(async move {
-                    let log_id: i32 = insert_into(evm_transaction_log::table)
-                        .values(&NewEvmTransactionLog {
-                            grant_id: grant.shared_grant_id,
-                            client_id: context.client_id,
-                            wallet_id: context.wallet_id,
-                            chain_id: context.chain as i32,
-                            eth_value: utils::u256_to_bytes(context.value).to_vec(),
-                            signed_at: Utc::now().into(),
-                        })
-                        .returning(evm_transaction_log::id)
-                        .get_result(conn)
-                        .await?;
-
-                    P::record_transaction(&context, meaning, log_id, &grant, conn).await?;
-
-                    QueryResult::Ok(())
-                })
-            })
-            .await?;
-        }
-
-        Ok(())
-    }
-}
-
-impl Engine {
-    pub fn new(db: db::DatabasePool) -> Self {
-        Self { db }
-    }
-
-    pub async fn create_grant<P: Policy>(
-        &self,
-        client_id: i32,
-        full_grant: FullGrant<P::Settings>,
-    ) -> Result<i32, CreationError> {
-        let mut conn = self.db.get().await?;
-
-        let id = conn
-            .transaction(|conn| {
-                Box::pin(async move {
-                    use schema::evm_basic_grant;
-
-                    let basic_grant: EvmBasicGrant = insert_into(evm_basic_grant::table)
-                        .values(&NewEvmBasicGrant {
-                            wallet_id: full_grant.basic.wallet_id,
-                            chain_id: full_grant.basic.chain as i32,
-                            client_id,
-                            valid_from: full_grant.basic.valid_from.map(SqliteTimestamp),
-                            valid_until: full_grant.basic.valid_until.map(SqliteTimestamp),
-                            max_gas_fee_per_gas: full_grant
-                                .basic
-                                .max_gas_fee_per_gas
-                                .map(|fee| utils::u256_to_bytes(fee).to_vec()),
-                            max_priority_fee_per_gas: full_grant
-                                .basic
-                                .max_priority_fee_per_gas
-                                .map(|fee| utils::u256_to_bytes(fee).to_vec()),
-                            rate_limit_count: full_grant
-                                .basic
-                                .rate_limit
-                                .as_ref()
-                                .map(|rl| rl.count as i32),
-                            rate_limit_window_secs: full_grant
-                                .basic
-                                .rate_limit
-                                .as_ref()
-                                .map(|rl| rl.window.num_seconds() as i32),
-                            revoked_at: None,
-                        })
-                        .returning(evm_basic_grant::all_columns)
-                        .get_result(conn)
-                        .await?;
-
-                    P::create_grant(&basic_grant, &full_grant.specific, conn).await
-                })
-            })
-            .await?;
-
-        Ok(id)
-    }
-
-    pub async fn list_all_grants(&self) -> Result<Vec<Grant<SpecificGrant>>, ListGrantsError> {
-        let mut conn = self.db.get().await?;
-
-        let mut grants: Vec<Grant<SpecificGrant>> = Vec::new();
-
-        grants.extend(
-            EtherTransfer::find_all_grants(&mut conn)
-                .await?
-                .into_iter()
-                .map(|g| Grant {
-                    id: g.id,
-                    shared_grant_id: g.shared_grant_id,
-                    shared: g.shared,
-                    settings: SpecificGrant::EtherTransfer(g.settings),
-                }),
-        );
-        grants.extend(
-            TokenTransfer::find_all_grants(&mut conn)
-                .await?
-                .into_iter()
-                .map(|g| Grant {
-                    id: g.id,
-                    shared_grant_id: g.shared_grant_id,
-                    shared: g.shared,
-                    settings: SpecificGrant::TokenTransfer(g.settings),
-                }),
-        );
-
-        Ok(grants)
-    }
-
-    pub async fn evaluate_transaction(
-        &self,
-        wallet_id: i32,
-        client_id: i32,
-        transaction: TxEip1559,
-        run_kind: RunKind,
-    ) -> Result<SpecificMeaning, VetError> {
-        let TxKind::Call(to) = transaction.to else {
-            return Err(VetError::ContractCreationNotSupported);
-        };
-        let context = policies::EvalContext {
-            wallet_id,
-            client_id,
-            chain: transaction.chain_id,
-            to,
-            value: transaction.value,
-            calldata: transaction.input.clone(),
-            max_fee_per_gas: transaction.max_fee_per_gas,
-            max_priority_fee_per_gas: transaction.max_priority_fee_per_gas,
-        };
-
-        if let Some(meaning) = EtherTransfer::analyze(&context) {
-            return match self
-                .vet_transaction::<EtherTransfer>(context, &meaning, run_kind)
-                .await
-            {
-                Ok(()) => Ok(meaning.into()),
-                Err(e) => Err(VetError::Evaluated(meaning.into(), e)),
-            };
-        }
-        if let Some(meaning) = TokenTransfer::analyze(&context) {
-            return match self
-                .vet_transaction::<TokenTransfer>(context, &meaning, run_kind)
-                .await
-            {
-                Ok(()) => Ok(meaning.into()),
-                Err(e) => Err(VetError::Evaluated(meaning.into(), e)),
-            };
-        }
-
-        Err(VetError::UnsupportedTransactionType)
-    }
-}

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

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

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

@@ -1,347 +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 {
-    to: Address,
-    value: U256,
-}
-impl Display for Meaning {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "Ether transfer of {} to {}", self.value, self.to)
-    }
-}
-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
-pub struct Settings {
-    target: Vec<Address>,
-    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>,
-    db: &mut impl AsyncConnection<Backend = Sqlite>,
-) -> QueryResult<Vec<EvalViolation>> {
-    let mut violations = Vec::new();
-    let window = grant.settings.limit.window;
-
-    let past_transaction = query_relevant_past_transaction(grant.id, window, db).await?;
-
-    let window_start = chrono::Utc::now() - grant.settings.limit.window;
-    let cumulative_volume: U256 = past_transaction
-        .iter()
-        .filter(|(_, timestamp)| timestamp >= &window_start)
-        .fold(U256::default(), |acc, (value, _)| acc + *value);
-
-    if cumulative_volume > grant.settings.limit.max_volume {
-        violations.push(EvalViolation::VolumetricLimitExceeded);
-    }
-
-    Ok(violations)
-}
-
-pub struct EtherTransfer;
-impl Policy for EtherTransfer {
-    type Settings = Settings;
-
-    type Meaning = Meaning;
-
-    fn analyze(context: &EvalContext) -> Option<Self::Meaning> {
-        if !context.calldata.is_empty() {
-            return None;
-        }
-
-        Some(Meaning {
-            to: context.to,
-            value: context.value,
-        })
-    }
-
-    async fn evaluate(
-        _: &EvalContext,
-        meaning: &Self::Meaning,
-        grant: &Grant<Self::Settings>,
-        db: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<Vec<EvalViolation>> {
-        let mut violations = Vec::new();
-
-        // Check if the target address is within the grant's allowed targets
-        if !grant.settings.target.contains(&meaning.to) {
-            violations.push(EvalViolation::InvalidTarget { target: meaning.to });
-        }
-
-        let rate_violations = check_rate_limits(grant, db).await?;
-        violations.extend(rate_violations);
-
-        Ok(violations)
-    }
-
-    async fn create_grant(
-        basic: &models::EvmBasicGrant,
-        grant: &Self::Settings,
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> diesel::result::QueryResult<DatabaseID> {
-        let limit_id: i32 = insert_into(evm_ether_transfer_limit::table)
-            .values(NewEvmEtherTransferLimit {
-                window_secs: grant.limit.window.num_seconds() as i32,
-                max_volume: utils::u256_to_bytes(grant.limit.max_volume).to_vec(),
-            })
-            .returning(evm_ether_transfer_limit::id)
-            .get_result(conn)
-            .await?;
-
-        let grant_id: i32 = insert_into(evm_ether_transfer_grant::table)
-            .values(&NewEvmEtherTransferGrant {
-                basic_grant_id: basic.id,
-                limit_id,
-            })
-            .returning(evm_ether_transfer_grant::id)
-            .get_result(conn)
-            .await?;
-
-        for target in &grant.target {
-            insert_into(evm_ether_transfer_grant_target::table)
-                .values(NewEvmEtherTransferGrantTarget {
-                    grant_id,
-                    address: target.to_vec(),
-                })
-                .execute(conn)
-                .await?;
-        }
-
-        Ok(grant_id)
-    }
-
-    async fn try_find_grant(
-        context: &EvalContext,
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> diesel::result::QueryResult<Option<Grant<Self::Settings>>> {
-        let target_bytes = context.to.to_vec();
-
-        // Find a grant where:
-        // 1. The basic grant's wallet_id and client_id match the context
-        // 2. Any of the grant's targets match the context's `to` address
-        let grant: Option<(EvmBasicGrant, EvmEtherTransferGrant)> = evm_ether_transfer_grant::table
-            .inner_join(evm_basic_grant::table)
-            .inner_join(evm_ether_transfer_grant_target::table)
-            .filter(
-                evm_basic_grant::wallet_id
-                    .eq(context.wallet_id)
-                    .and(evm_basic_grant::client_id.eq(context.client_id))
-                    .and(evm_basic_grant::revoked_at.is_null())
-                    .and(evm_ether_transfer_grant_target::address.eq(&target_bytes)),
-            )
-            .select((
-                EvmBasicGrant::as_select(),
-                EvmEtherTransferGrant::as_select(),
-            ))
-            .first(conn)
-            .await
-            .optional()?;
-
-        let Some((basic_grant, grant)) = grant else {
-            return Ok(None);
-        };
-
-        let target_bytes: Vec<EvmEtherTransferGrantTarget> = evm_ether_transfer_grant_target::table
-            .select(EvmEtherTransferGrantTarget::as_select())
-            .filter(evm_ether_transfer_grant_target::grant_id.eq(grant.id))
-            .load(conn)
-            .await?;
-
-        let limit: EvmEtherTransferLimit = evm_ether_transfer_limit::table
-            .filter(evm_ether_transfer_limit::id.eq(grant.limit_id))
-            .select(EvmEtherTransferLimit::as_select())
-            .first::<EvmEtherTransferLimit>(conn)
-            .await?;
-
-        // Convert bytes back to Address
-        let targets: Vec<Address> = target_bytes
-            .into_iter()
-            .filter_map(|target| {
-                // TODO: Handle invalid addresses more gracefully
-                let arr: [u8; 20] = target.address.try_into().ok()?;
-                Some(Address::from(arr))
-            })
-            .collect();
-
-        let settings = Settings {
-            target: targets,
-            limit: VolumeRateLimit {
-                max_volume: utils::try_bytes_to_u256(&limit.max_volume)
-                    .map_err(|err| diesel::result::Error::DeserializationError(Box::new(err)))?,
-                window: chrono::Duration::seconds(limit.window_secs as i64),
-            },
-        };
-
-        Ok(Some(Grant {
-            id: grant.id,
-            shared_grant_id: grant.basic_grant_id,
-            shared: SharedGrantSettings::try_from_model(basic_grant)?,
-            settings,
-        }))
-    }
-
-    async fn record_transaction(
-        _context: &EvalContext,
-        _: &Self::Meaning,
-        _log_id: i32,
-        _grant: &Grant<Self::Settings>,
-        _conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> diesel::result::QueryResult<()> {
-        // Basic log is sufficient
-
-        Ok(())
-    }
-
-    async fn find_all_grants(
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<Vec<Grant<Self::Settings>>> {
-        let grants: Vec<(EvmBasicGrant, EvmEtherTransferGrant)> = grant_join()
-            .filter(evm_basic_grant::revoked_at.is_null())
-            .select((
-                EvmBasicGrant::as_select(),
-                EvmEtherTransferGrant::as_select(),
-            ))
-            .load(conn)
-            .await?;
-
-        if grants.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        let grant_ids: Vec<i32> = grants.iter().map(|(_, g)| g.id).collect();
-        let limit_ids: Vec<i32> = grants.iter().map(|(_, g)| g.limit_id).collect();
-
-        let all_targets: Vec<EvmEtherTransferGrantTarget> = evm_ether_transfer_grant_target::table
-            .filter(evm_ether_transfer_grant_target::grant_id.eq_any(&grant_ids))
-            .select(EvmEtherTransferGrantTarget::as_select())
-            .load(conn)
-            .await?;
-
-        let all_limits: Vec<EvmEtherTransferLimit> = evm_ether_transfer_limit::table
-            .filter(evm_ether_transfer_limit::id.eq_any(&limit_ids))
-            .select(EvmEtherTransferLimit::as_select())
-            .load(conn)
-            .await?;
-
-        let mut targets_by_grant: HashMap<i32, Vec<EvmEtherTransferGrantTarget>> = HashMap::new();
-        for target in all_targets {
-            targets_by_grant
-                .entry(target.grant_id)
-                .or_default()
-                .push(target);
-        }
-
-        let limits_by_id: HashMap<i32, EvmEtherTransferLimit> =
-            all_limits.into_iter().map(|l| (l.id, l)).collect();
-
-        grants
-            .into_iter()
-            .map(|(basic, specific)| {
-                let targets: Vec<Address> = targets_by_grant
-                    .get(&specific.id)
-                    .map(|v| v.as_slice())
-                    .unwrap_or_default()
-                    .iter()
-                    .filter_map(|t| {
-                        let arr: [u8; 20] = t.address.clone().try_into().ok()?;
-                        Some(Address::from(arr))
-                    })
-                    .collect();
-
-                let limit = limits_by_id
-                    .get(&specific.limit_id)
-                    .ok_or(diesel::result::Error::NotFound)?;
-
-                Ok(Grant {
-                    id: specific.id,
-                    shared_grant_id: specific.basic_grant_id,
-                    shared: SharedGrantSettings::try_from_model(basic)?,
-                    settings: Settings {
-                        target: targets,
-                        limit: VolumeRateLimit {
-                            max_volume: utils::try_bytes_to_u256(&limit.max_volume).map_err(
-                                |e| diesel::result::Error::DeserializationError(Box::new(e)),
-                            )?,
-                            window: Duration::seconds(limit.window_secs as i64),
-                        },
-                    },
-                })
-            })
-            .collect()
-    }
-}
-
-#[cfg(test)]
-mod tests;

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

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

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

@@ -1,385 +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 {
-    token: &'static TokenInfo,
-    to: Address,
-    value: U256,
-}
-impl std::fmt::Display for Meaning {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "Transfer of {} {} to {}",
-            self.value, self.token.symbol, self.to
-        )
-    }
-}
-impl 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
-pub struct Settings {
-    token_contract: Address,
-    target: Option<Address>,
-    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>,
-    db: &mut impl AsyncConnection<Backend = Sqlite>,
-) -> QueryResult<Vec<EvalViolation>> {
-    let mut violations = Vec::new();
-
-    let Some(longest_window) = grant.settings.volume_limits.iter().map(|l| l.window).max() else {
-        return Ok(violations);
-    };
-
-    let past_transfers = query_relevant_past_transfers(grant.id, longest_window, db).await?;
-
-    for limit in &grant.settings.volume_limits {
-        let window_start = chrono::Utc::now() - limit.window;
-        let cumulative_volume: U256 = past_transfers
-            .iter()
-            .filter(|(_, timestamp)| timestamp >= &window_start)
-            .fold(U256::default(), |acc, (value, _)| acc + *value);
-
-        if cumulative_volume > limit.max_volume {
-            violations.push(EvalViolation::VolumetricLimitExceeded);
-            break;
-        }
-    }
-
-    Ok(violations)
-}
-
-pub struct TokenTransfer;
-impl Policy for TokenTransfer {
-    type Settings = Settings;
-    type Meaning = Meaning;
-
-    fn analyze(context: &EvalContext) -> Option<Self::Meaning> {
-        let token = nonfungible::get_token(context.chain, context.to)?;
-        let decoded = transferCall::abi_decode_raw_validate(&context.calldata).ok()?;
-
-        Some(Meaning {
-            token,
-            to: decoded.to,
-            value: decoded.value,
-        })
-    }
-
-    async fn evaluate(
-        context: &EvalContext,
-        meaning: &Self::Meaning,
-        grant: &Grant<Self::Settings>,
-        db: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<Vec<EvalViolation>> {
-        let mut violations = Vec::new();
-
-        // erc20 transfer shouldn't carry eth value
-        if !context.value.is_zero() {
-            violations.push(EvalViolation::InvalidTransactionType);
-            return Ok(violations);
-        }
-
-        if let Some(allowed) = grant.settings.target
-            && allowed != meaning.to
-        {
-            violations.push(EvalViolation::InvalidTarget { target: meaning.to });
-        }
-
-        let rate_violations = check_volume_rate_limits(grant, db).await?;
-        violations.extend(rate_violations);
-
-        Ok(violations)
-    }
-
-    async fn create_grant(
-        basic: &EvmBasicGrant,
-        grant: &Self::Settings,
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<DatabaseID> {
-        // Store the specific receiver as bytes (None means any receiver is allowed)
-        let receiver: Option<Vec<u8>> = grant.target.map(|addr| addr.to_vec());
-
-        let grant_id: i32 = insert_into(evm_token_transfer_grant::table)
-            .values(NewEvmTokenTransferGrant {
-                basic_grant_id: basic.id,
-                token_contract: grant.token_contract.to_vec(),
-                receiver,
-            })
-            .returning(evm_token_transfer_grant::id)
-            .get_result(conn)
-            .await?;
-
-        for limit in &grant.volume_limits {
-            insert_into(evm_token_transfer_volume_limit::table)
-                .values(NewEvmTokenTransferVolumeLimit {
-                    grant_id,
-                    window_secs: limit.window.num_seconds() as i32,
-                    max_volume: utils::u256_to_bytes(limit.max_volume).to_vec(),
-                })
-                .execute(conn)
-                .await?;
-        }
-
-        Ok(grant_id)
-    }
-
-    async fn try_find_grant(
-        context: &EvalContext,
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<Option<Grant<Self::Settings>>> {
-        let token_contract_bytes = context.to.to_vec();
-
-        let grant: Option<(EvmBasicGrant, EvmTokenTransferGrant)> = grant_join()
-            .filter(evm_basic_grant::revoked_at.is_null())
-            .filter(evm_basic_grant::wallet_id.eq(context.wallet_id))
-            .filter(evm_basic_grant::client_id.eq(context.client_id))
-            .filter(evm_token_transfer_grant::token_contract.eq(&token_contract_bytes))
-            .select((
-                EvmBasicGrant::as_select(),
-                EvmTokenTransferGrant::as_select(),
-            ))
-            .first(conn)
-            .await
-            .optional()?;
-
-        let Some((basic_grant, token_grant)) = grant else {
-            return Ok(None);
-        };
-
-        let volume_limits_db: Vec<EvmTokenTransferVolumeLimit> =
-            evm_token_transfer_volume_limit::table
-                .filter(evm_token_transfer_volume_limit::grant_id.eq(token_grant.id))
-                .select(EvmTokenTransferVolumeLimit::as_select())
-                .load(conn)
-                .await?;
-
-        let volume_limits: Vec<VolumeRateLimit> = volume_limits_db
-            .into_iter()
-            .map(|row| {
-                Ok(VolumeRateLimit {
-                    max_volume: utils::try_bytes_to_u256(&row.max_volume).map_err(|err| {
-                        diesel::result::Error::DeserializationError(Box::new(err))
-                    })?,
-                    window: Duration::seconds(row.window_secs as i64),
-                })
-            })
-            .collect::<QueryResult<Vec<_>>>()?;
-
-        let token_contract: [u8; 20] = token_grant.token_contract.try_into().map_err(|_| {
-            diesel::result::Error::DeserializationError(
-                "Invalid token contract address length".into(),
-            )
-        })?;
-
-        let target: Option<Address> = match token_grant.receiver {
-            None => None,
-            Some(bytes) => {
-                let arr: [u8; 20] = bytes.try_into().map_err(|_| {
-                    diesel::result::Error::DeserializationError(
-                        "Invalid receiver address length".into(),
-                    )
-                })?;
-                Some(Address::from(arr))
-            }
-        };
-
-        let settings = Settings {
-            token_contract: Address::from(token_contract),
-            target,
-            volume_limits,
-        };
-
-        Ok(Some(Grant {
-            id: token_grant.id,
-            shared_grant_id: token_grant.basic_grant_id,
-            shared: SharedGrantSettings::try_from_model(basic_grant)?,
-            settings,
-        }))
-    }
-
-    async fn record_transaction(
-        context: &EvalContext,
-        meaning: &Self::Meaning,
-        log_id: i32,
-        grant: &Grant<Self::Settings>,
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<()> {
-        insert_into(evm_token_transfer_log::table)
-            .values(NewEvmTokenTransferLog {
-                grant_id: grant.id,
-                log_id,
-                chain_id: context.chain as i32,
-                token_contract: context.to.to_vec(),
-                recipient_address: meaning.to.to_vec(),
-                value: utils::u256_to_bytes(meaning.value).to_vec(),
-            })
-            .execute(conn)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn find_all_grants(
-        conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    ) -> QueryResult<Vec<Grant<Self::Settings>>> {
-        let grants: Vec<(EvmBasicGrant, EvmTokenTransferGrant)> = grant_join()
-            .filter(evm_basic_grant::revoked_at.is_null())
-            .select((
-                EvmBasicGrant::as_select(),
-                EvmTokenTransferGrant::as_select(),
-            ))
-            .load(conn)
-            .await?;
-
-        if grants.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        let grant_ids: Vec<i32> = grants.iter().map(|(_, g)| g.id).collect();
-
-        let all_volume_limits: Vec<EvmTokenTransferVolumeLimit> =
-            evm_token_transfer_volume_limit::table
-                .filter(evm_token_transfer_volume_limit::grant_id.eq_any(&grant_ids))
-                .select(EvmTokenTransferVolumeLimit::as_select())
-                .load(conn)
-                .await?;
-
-        let mut limits_by_grant: HashMap<i32, Vec<EvmTokenTransferVolumeLimit>> = HashMap::new();
-        for limit in all_volume_limits {
-            limits_by_grant
-                .entry(limit.grant_id)
-                .or_default()
-                .push(limit);
-        }
-
-        grants
-            .into_iter()
-            .map(|(basic, specific)| {
-                let volume_limits: Vec<VolumeRateLimit> = limits_by_grant
-                    .get(&specific.id)
-                    .map(|v| v.as_slice())
-                    .unwrap_or_default()
-                    .iter()
-                    .map(|row| {
-                        Ok(VolumeRateLimit {
-                            max_volume: utils::try_bytes_to_u256(&row.max_volume).map_err(|e| {
-                                diesel::result::Error::DeserializationError(Box::new(e))
-                            })?,
-                            window: Duration::seconds(row.window_secs as i64),
-                        })
-                    })
-                    .collect::<QueryResult<Vec<_>>>()?;
-
-                let token_contract: [u8; 20] =
-                    specific.token_contract.clone().try_into().map_err(|_| {
-                        diesel::result::Error::DeserializationError(
-                            "Invalid token contract address length".into(),
-                        )
-                    })?;
-
-                let target: Option<Address> = match &specific.receiver {
-                    None => None,
-                    Some(bytes) => {
-                        let arr: [u8; 20] = bytes.clone().try_into().map_err(|_| {
-                            diesel::result::Error::DeserializationError(
-                                "Invalid receiver address length".into(),
-                            )
-                        })?;
-                        Some(Address::from(arr))
-                    }
-                };
-
-                Ok(Grant {
-                    id: specific.id,
-                    shared_grant_id: specific.basic_grant_id,
-                    shared: SharedGrantSettings::try_from_model(basic)?,
-                    settings: Settings {
-                        token_contract: Address::from(token_contract),
-                        target,
-                        volume_limits,
-                    },
-                })
-            })
-            .collect()
-    }
-}
-
-#[cfg(test)]
-mod tests;

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

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

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

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

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

@@ -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/lib.rs

@@ -1,22 +1,19 @@
 #![forbid(unsafe_code)]
 use arbiter_proto::{
-    proto::{
-        client::{ClientRequest, ClientResponse},
-        user_agent::{UserAgentRequest, UserAgentResponse},
-    },
-    transport::{IdentityRecvConverter, SendConverter, grpc},
+    proto::{ClientRequest, ClientResponse, UserAgentRequest, UserAgentResponse},
+    transport::{BiStream, GrpcTransportActor, wire},
 };
 use async_trait::async_trait;
+use kameo::actor::PreparedActor;
 use tokio_stream::wrappers::ReceiverStream;
 
 use tokio::sync::mpsc;
 use tonic::{Request, Response, Status};
-use tracing::info;
 
 use crate::{
     actors::{
-        client::{self, ClientConnection as ClientConnectionProps, ClientError, connect_client},
-        user_agent::{self, TransportResponseError, UserAgentConnection, connect_user_agent},
+        client::handle_client,
+        user_agent::UserAgentActor,
     },
     context::ServerContext,
 };
@@ -24,114 +21,9 @@ use crate::{
 pub mod actors;
 pub mod context;
 pub mod db;
-pub mod evm;
 
 const DEFAULT_CHANNEL_SIZE: usize = 1000;
 
-struct UserAgentGrpcSender;
-
-impl SendConverter for UserAgentGrpcSender {
-    type Input = Result<UserAgentResponse, TransportResponseError>;
-    type Output = Result<UserAgentResponse, Status>;
-
-    fn convert(&self, item: Self::Input) -> Self::Output {
-        match item {
-            Ok(message) => Ok(message),
-            Err(err) => Err(user_agent_error_status(err)),
-        }
-    }
-}
-
-struct ClientGrpcSender;
-
-impl SendConverter for ClientGrpcSender {
-    type Input = Result<ClientResponse, ClientError>;
-    type Output = Result<ClientResponse, Status>;
-
-    fn convert(&self, item: Self::Input) -> Self::Output {
-        match item {
-            Ok(message) => Ok(message),
-            Err(err) => Err(client_error_status(err)),
-        }
-    }
-}
-
-fn client_error_status(value: ClientError) -> Status {
-    match value {
-        ClientError::MissingRequestPayload | ClientError::UnexpectedRequestPayload => {
-            Status::invalid_argument("Expected message with payload")
-        }
-        ClientError::StateTransitionFailed => Status::internal("State machine error"),
-        ClientError::Auth(ref err) => client_auth_error_status(err),
-        ClientError::ConnectionRegistrationFailed => {
-            Status::internal("Connection registration failed")
-        }
-    }
-}
-
-fn client_auth_error_status(value: &client::auth::Error) -> Status {
-    use client::auth::Error;
-    match value {
-        Error::UnexpectedMessagePayload | Error::InvalidClientPubkeyLength => {
-            Status::invalid_argument(value.to_string())
-        }
-        Error::InvalidAuthPubkeyEncoding => {
-            Status::invalid_argument("Failed to convert pubkey to VerifyingKey")
-        }
-        Error::InvalidChallengeSolution => Status::unauthenticated(value.to_string()),
-        Error::NotRegistered => Status::permission_denied(value.to_string()),
-        Error::Transport => Status::internal("Transport error"),
-        Error::DatabasePoolUnavailable => Status::internal("Database pool error"),
-        Error::DatabaseOperationFailed => Status::internal("Database error"),
-        Error::InternalError => Status::internal("Internal error"),
-    }
-}
-
-fn user_agent_error_status(value: TransportResponseError) -> Status {
-    match value {
-        TransportResponseError::MissingRequestPayload
-        | TransportResponseError::UnexpectedRequestPayload => {
-            Status::invalid_argument("Expected message with payload")
-        }
-        TransportResponseError::InvalidStateForUnsealEncryptedKey => {
-            Status::failed_precondition("Invalid state for unseal encrypted key")
-        }
-        TransportResponseError::InvalidClientPubkeyLength => {
-            Status::invalid_argument("client_pubkey must be 32 bytes")
-        }
-        TransportResponseError::StateTransitionFailed => Status::internal("State machine error"),
-        TransportResponseError::KeyHolderActorUnreachable => {
-            Status::internal("Vault is not available")
-        }
-        TransportResponseError::Auth(ref err) => auth_error_status(err),
-        TransportResponseError::ConnectionRegistrationFailed => {
-            Status::internal("Failed registering connection")
-        }
-    }
-}
-
-fn auth_error_status(value: &user_agent::auth::Error) -> Status {
-    use user_agent::auth::Error;
-    match value {
-        Error::UnexpectedMessagePayload | Error::InvalidClientPubkeyLength => {
-            Status::invalid_argument(value.to_string())
-        }
-        Error::InvalidAuthPubkeyEncoding => {
-            Status::invalid_argument("Failed to convert pubkey to VerifyingKey")
-        }
-        Error::PublicKeyNotRegistered | Error::InvalidChallengeSolution => {
-            Status::unauthenticated(value.to_string())
-        }
-        Error::InvalidBootstrapToken => Status::invalid_argument("Invalid bootstrap token"),
-        Error::Transport => Status::internal("Transport error"),
-        Error::BootstrapperActorUnreachable => {
-            Status::internal("Bootstrap token consumption failed")
-        }
-        Error::DatabasePoolUnavailable => Status::internal("Database pool error"),
-        Error::DatabaseOperationFailed => Status::internal("Database error"),
-    }
-}
-
 pub struct Server {
     context: ServerContext,
 }
@@ -147,54 +39,44 @@ impl arbiter_proto::proto::arbiter_service_server::ArbiterService for 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 (tx, rx) = mpsc::channel(DEFAULT_CHANNEL_SIZE);
-
-        let transport = grpc::GrpcAdapter::new(
-            tx,
-            req_stream,
-            IdentityRecvConverter::<ClientRequest>::new(),
-            ClientGrpcSender,
-        );
-        let props = ClientConnectionProps::new(
-            self.context.db.clone(),
-            Box::new(transport),
-            self.context.actors.clone(),
-        );
-        tokio::spawn(connect_client(props));
-
-        info!(event = "connection established", "grpc.client");
+        tokio::spawn(handle_client(
+            self.context.clone(),
+            BiStream {
+                request_stream: req_stream,
+                response_sender: tx,
+            },
+        ));
 
         Ok(Response::new(ReceiverStream::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 (tx, rx) = mpsc::channel(DEFAULT_CHANNEL_SIZE);
+        let context = self.context.clone();
 
-        let transport = grpc::GrpcAdapter::new(
-            tx,
-            req_stream,
-            IdentityRecvConverter::<UserAgentRequest>::new(),
-            UserAgentGrpcSender,
-        );
-        let props = UserAgentConnection::new(
-            self.context.db.clone(),
-            self.context.actors.clone(),
-            Box::new(transport),
-        );
-        tokio::spawn(connect_user_agent(props));
-
-        info!(event = "connection established", "grpc.user_agent");
+        wire(
+            |prepared: PreparedActor<UserAgentActor>, recipient| {
+                prepared.spawn(UserAgentActor::new(context, recipient));
+            },
+            |prepared: PreparedActor<GrpcTransportActor<_, _, _>>, business_recipient| {
+                prepared.spawn(GrpcTransportActor::new(
+                    tx,
+                    req_stream,
+                    business_recipient,
+                ));
+            },
+        )
+        .await;
 
         Ok(Response::new(ReceiverStream::new(rx)))
     }

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

@@ -1,4 +0,0 @@
-mod common;
-
-#[path = "client/auth.rs"]
-mod auth;

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

@@ -1,222 +0,0 @@
-use alloy::{
-    consensus::TxEip1559,
-    primitives::{Address, Bytes, TxKind, U256},
-    rlp::Encodable,
-};
-use arbiter_proto::proto::{
-    client::{
-        AuthChallengeRequest, AuthChallengeSolution, ClientRequest,
-        client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    },
-    evm::EvmSignTransactionRequest,
-};
-use arbiter_proto::transport::Bi;
-use arbiter_server::actors::GlobalActors;
-use arbiter_server::{
-    actors::client::{ClientConnection, connect_client},
-    db::{self, schema},
-};
-use diesel::{ExpressionMethods as _, insert_into};
-use diesel_async::RunQueryDsl;
-use ed25519_dalek::Signer as _;
-
-use super::common::ChannelTransport;
-
-#[tokio::test]
-#[test_log::test]
-pub async fn test_unregistered_pubkey_rejected() {
-    let db = db::create_test_pool().await;
-
-    let (server_transport, mut test_transport) = ChannelTransport::new();
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
-    let props = ClientConnection::new(db.clone(), Box::new(server_transport), actors);
-    let task = tokio::spawn(connect_client(props));
-
-    let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
-    let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
-
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes,
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    // Auth fails, connect_client returns, transport drops
-    task.await.unwrap();
-}
-
-#[tokio::test]
-#[test_log::test]
-pub async fn test_challenge_auth() {
-    let db = db::create_test_pool().await;
-
-    let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
-    let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
-
-    {
-        let mut conn = db.get().await.unwrap();
-        insert_into(schema::program_client::table)
-            .values(schema::program_client::public_key.eq(pubkey_bytes.clone()))
-            .execute(&mut conn)
-            .await
-            .unwrap();
-    }
-
-    let (server_transport, mut test_transport) = ChannelTransport::new();
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
-
-    let props = ClientConnection::new(db.clone(), Box::new(server_transport), actors);
-    let task = tokio::spawn(connect_client(props));
-
-    // Send challenge request
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes,
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    // Read the challenge response
-    let response = test_transport
-        .recv()
-        .await
-        .expect("should receive challenge");
-    let challenge = match response {
-        Ok(resp) => match resp.payload {
-            Some(ClientResponsePayload::AuthChallenge(c)) => c,
-            other => panic!("Expected AuthChallenge, got {other:?}"),
-        },
-        Err(err) => panic!("Expected Ok response, got Err({err:?})"),
-    };
-
-    // Sign the challenge and send solution
-    let formatted_challenge = arbiter_proto::format_challenge(challenge.nonce, &challenge.pubkey);
-    let signature = new_key.sign(&formatted_challenge);
-
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeSolution(
-                AuthChallengeSolution {
-                    signature: signature.to_bytes().to_vec(),
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    // Auth completes, session spawned
-    task.await.unwrap();
-}
-
-#[tokio::test]
-#[test_log::test]
-pub async fn test_evm_sign_request_payload_is_handled() {
-    let db = db::create_test_pool().await;
-
-    let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
-    let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
-
-    {
-        let mut conn = db.get().await.unwrap();
-        insert_into(schema::program_client::table)
-            .values(schema::program_client::public_key.eq(pubkey_bytes.clone()))
-            .execute(&mut conn)
-            .await
-            .unwrap();
-    }
-
-    let (server_transport, mut test_transport) = ChannelTransport::new();
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
-
-    let props = ClientConnection::new(db.clone(), Box::new(server_transport), actors);
-    let task = tokio::spawn(connect_client(props));
-
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes,
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    let response = test_transport
-        .recv()
-        .await
-        .expect("should receive challenge");
-    let challenge = match response {
-        Ok(resp) => match resp.payload {
-            Some(ClientResponsePayload::AuthChallenge(c)) => c,
-            other => panic!("Expected AuthChallenge, got {other:?}"),
-        },
-        Err(err) => panic!("Expected Ok response, got Err({err:?})"),
-    };
-
-    let formatted_challenge = arbiter_proto::format_challenge(challenge.nonce, &challenge.pubkey);
-    let signature = new_key.sign(&formatted_challenge);
-
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeSolution(
-                AuthChallengeSolution {
-                    signature: signature.to_bytes().to_vec(),
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    task.await.unwrap();
-
-    let tx = TxEip1559 {
-        chain_id: 1,
-        nonce: 0,
-        gas_limit: 21_000,
-        max_fee_per_gas: 1,
-        max_priority_fee_per_gas: 1,
-        to: TxKind::Call(Address::from_slice(&[0x11; 20])),
-        value: U256::ZERO,
-        input: Bytes::new(),
-        access_list: Default::default(),
-    };
-
-    let mut rlp_transaction = Vec::new();
-    tx.encode(&mut rlp_transaction);
-
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::EvmSignTransaction(
-                EvmSignTransactionRequest {
-                    wallet_address: [0x22; 20].to_vec(),
-                    rlp_transaction,
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    let response = test_transport
-        .recv()
-        .await
-        .expect("should receive sign response");
-
-    match response {
-        Ok(resp) => match resp.payload {
-            Some(ClientResponsePayload::EvmSignTransaction(_)) => {}
-            other => panic!("Expected EvmSignTransaction response, got {other:?}"),
-        },
-        Err(err) => panic!("Expected Ok response, got Err({err:?})"),
-    }
-}

server/crates/arbiter-server/tests/common/mod.rs

@@ -1,13 +1,10 @@
-use arbiter_proto::transport::{Bi, Error};
 use arbiter_server::{
     actors::keyholder::KeyHolder,
     db::{self, schema},
 };
-use async_trait::async_trait;
 use diesel::QueryDsl;
 use diesel_async::RunQueryDsl;
 use memsafe::MemSafe;
-use tokio::sync::mpsc;
 
 #[allow(dead_code)]
 pub async fn bootstrapped_keyholder(db: &db::DatabasePool) -> KeyHolder {
@@ -29,45 +26,3 @@ pub async fn root_key_history_id(db: &db::DatabasePool) -> i32 {
         .unwrap();
     id.expect("root_key_id should be set after bootstrap")
 }
-
-#[allow(dead_code)]
-pub struct ChannelTransport<T, Y> {
-    receiver: mpsc::Receiver<T>,
-    sender: mpsc::Sender<Y>,
-}
-
-impl<T, Y> ChannelTransport<T, Y> {
-    #[allow(dead_code)]
-    pub fn new() -> (Self, ChannelTransport<Y, T>) {
-        let (tx1, rx1) = mpsc::channel(10);
-        let (tx2, rx2) = mpsc::channel(10);
-        (
-            Self {
-                receiver: rx1,
-                sender: tx2,
-            },
-            ChannelTransport {
-                receiver: rx2,
-                sender: tx1,
-            },
-        )
-    }
-}
-
-#[async_trait]
-impl<T, Y> Bi<T, Y> for ChannelTransport<T, Y>
-where
-    T: Send + 'static,
-    Y: Send + 'static,
-{
-    async fn send(&mut self, item: Y) -> Result<(), Error> {
-        self.sender
-            .send(item)
-            .await
-            .map_err(|_| Error::ChannelClosed)
-    }
-
-    async fn recv(&mut self) -> Option<T> {
-        self.receiver.recv().await
-    }
-}

server/crates/arbiter-server/tests/user_agent.rs

@@ -1,8 +1,31 @@
 mod common;
 
+use arbiter_proto::proto::UserAgentResponse;
+use arbiter_server::actors::user_agent::UserAgentError;
+use kameo::{Actor, actor::Recipient, actor::Spawn, prelude::Message};
+
+/// A no-op actor that discards any messages it receives.
+#[derive(Actor)]
+struct NullSink;
+
+impl Message<Result<UserAgentResponse, UserAgentError>> for NullSink {
+    type Reply = ();
+
+    async fn handle(
+        &mut self,
+        _msg: Result<UserAgentResponse, UserAgentError>,
+        _ctx: &mut kameo::prelude::Context<Self, Self::Reply>,
+    ) -> Self::Reply {
+    }
+}
+
+/// Creates a `Recipient` that silently discards all messages.
+fn null_recipient() -> Recipient<Result<UserAgentResponse, UserAgentError>> {
+    let actor_ref = NullSink::spawn(NullSink);
+    actor_ref.recipient()
+}
+
 #[path = "user_agent/auth.rs"]
 mod auth;
-#[path = "user_agent/sdk_client.rs"]
-mod sdk_client;
 #[path = "user_agent/unseal.rs"]
 mod unseal;

server/crates/arbiter-server/tests/user_agent/auth.rs

@@ -1,51 +1,57 @@
-use arbiter_proto::proto::user_agent::{
-    AuthChallengeRequest, AuthChallengeSolution, KeyType as ProtoKeyType, UserAgentRequest,
-    user_agent_request::Payload as UserAgentRequestPayload,
+use arbiter_proto::proto::{
+    UserAgentResponse,
+    auth::{self, AuthChallengeRequest, AuthOk},
     user_agent_response::Payload as UserAgentResponsePayload,
 };
-use arbiter_proto::transport::Bi;
 use arbiter_server::{
     actors::{
         GlobalActors,
         bootstrap::GetToken,
-        user_agent::{UserAgentConnection, connect_user_agent},
+        user_agent::{HandleAuthChallengeRequest, HandleAuthChallengeSolution, UserAgentActor},
     },
     db::{self, schema},
 };
 use diesel::{ExpressionMethods as _, QueryDsl, insert_into};
 use diesel_async::RunQueryDsl;
 use ed25519_dalek::Signer as _;
-
-use super::common::ChannelTransport;
+use kameo::actor::Spawn;
 
 #[tokio::test]
 #[test_log::test]
 pub async fn test_bootstrap_token_auth() {
-    let db = db::create_test_pool().await;
+    let db =db::create_test_pool().await;
+
     let actors = GlobalActors::spawn(db.clone()).await.unwrap();
     let token = actors.bootstrapper.ask(GetToken).await.unwrap().unwrap();
-
-    let (server_transport, mut test_transport) = ChannelTransport::new();
-    let props = UserAgentConnection::new(db.clone(), actors, Box::new(server_transport));
-    let task = tokio::spawn(connect_user_agent(props));
+    let user_agent =
+        UserAgentActor::new_manual(db.clone(), actors, super::null_recipient());
+    let user_agent_ref = UserAgentActor::spawn(user_agent);
 
     let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
     let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
 
-    test_transport
-        .send(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes,
-                    bootstrap_token: Some(token),
-                    key_type: ProtoKeyType::Ed25519.into(),
-                },
-            )),
+    let result = user_agent_ref
+        .ask(HandleAuthChallengeRequest {
+            req: AuthChallengeRequest {
+                pubkey: pubkey_bytes,
+                bootstrap_token: Some(token),
+            },
         })
         .await
-        .unwrap();
+        .expect("Shouldn't fail to send message");
 
-    task.await.unwrap();
+    assert_eq!(
+        result,
+        UserAgentResponse {
+            payload: Some(UserAgentResponsePayload::AuthMessage(
+                arbiter_proto::proto::auth::ServerMessage {
+                    payload: Some(arbiter_proto::proto::auth::server_message::Payload::AuthOk(
+                        AuthOk {},
+                    )),
+                },
+            )),
+        }
+    );
 
     let mut conn = db.get().await.unwrap();
     let stored_pubkey: Vec<u8> = schema::useragent_client::table
@@ -60,109 +66,106 @@ pub async fn test_bootstrap_token_auth() {
 #[test_log::test]
 pub async fn test_bootstrap_invalid_token_auth() {
     let db = db::create_test_pool().await;
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
 
-    let (server_transport, mut test_transport) = ChannelTransport::new();
-    let props = UserAgentConnection::new(db.clone(), actors, Box::new(server_transport));
-    let task = tokio::spawn(connect_user_agent(props));
+    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
+    let user_agent =
+        UserAgentActor::new_manual(db.clone(), actors, super::null_recipient());
+    let user_agent_ref = UserAgentActor::spawn(user_agent);
 
     let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
     let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
 
-    test_transport
-        .send(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes,
-                    bootstrap_token: Some("invalid_token".to_string()),
-                    key_type: ProtoKeyType::Ed25519.into(),
-                },
-            )),
+    let result = user_agent_ref
+        .ask(HandleAuthChallengeRequest {
+            req: AuthChallengeRequest {
+                pubkey: pubkey_bytes,
+                bootstrap_token: Some("invalid_token".to_string()),
+            },
         })
-        .await
-        .unwrap();
+        .await;
 
-    // Auth fails, connect_user_agent returns, transport drops
-    task.await.unwrap();
-
-    // Verify no key was registered
-    let mut conn = db.get().await.unwrap();
-    let count: i64 = schema::useragent_client::table
-        .count()
-        .get_result::<i64>(&mut conn)
-        .await
-        .unwrap();
-    assert_eq!(count, 0);
+    match result {
+        Err(kameo::error::SendError::HandlerError(err)) => {
+            assert!(
+                matches!(err, arbiter_server::actors::user_agent::UserAgentError::InvalidBootstrapToken),
+                "Expected InvalidBootstrapToken, got {err:?}"
+            );
+        }
+        Err(other) => {
+            panic!("Expected SendError::HandlerError, got {other:?}");
+        }
+        Ok(_) => {
+            panic!("Expected error due to invalid bootstrap token, but got success");
+        }
+    }
 }
 
 #[tokio::test]
 #[test_log::test]
 pub async fn test_challenge_auth() {
     let db = db::create_test_pool().await;
+
     let actors = GlobalActors::spawn(db.clone()).await.unwrap();
+    let user_agent =
+        UserAgentActor::new_manual(db.clone(), actors, super::null_recipient());
+    let user_agent_ref = UserAgentActor::spawn(user_agent);
 
     let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
     let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
 
-    // Pre-register key with key_type
     {
         let mut conn = db.get().await.unwrap();
         insert_into(schema::useragent_client::table)
-            .values((
-                schema::useragent_client::public_key.eq(pubkey_bytes.clone()),
-                schema::useragent_client::key_type.eq(1i32),
-            ))
+            .values(schema::useragent_client::public_key.eq(pubkey_bytes.clone()))
             .execute(&mut conn)
             .await
             .unwrap();
     }
 
-    let (server_transport, mut test_transport) = ChannelTransport::new();
-    let props = UserAgentConnection::new(db.clone(), actors, Box::new(server_transport));
-    let task = tokio::spawn(connect_user_agent(props));
-
-    // Send challenge request
-    test_transport
-        .send(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes,
-                    bootstrap_token: None,
-                    key_type: ProtoKeyType::Ed25519.into(),
-                },
-            )),
+    let result = user_agent_ref
+        .ask(HandleAuthChallengeRequest {
+            req: AuthChallengeRequest {
+                pubkey: pubkey_bytes,
+                bootstrap_token: None,
+            },
         })
         .await
-        .unwrap();
+        .expect("Shouldn't fail to send message");
 
-    // Read the challenge response
-    let response = test_transport
-        .recv()
-        .await
-        .expect("should receive challenge");
-    let challenge = match response {
-        Ok(resp) => match resp.payload {
-            Some(UserAgentResponsePayload::AuthChallenge(c)) => c,
-            other => panic!("Expected AuthChallenge, got {other:?}"),
-        },
-        Err(err) => panic!("Expected Ok response, got Err({err:?})"),
+    let UserAgentResponse {
+        payload:
+            Some(UserAgentResponsePayload::AuthMessage(arbiter_proto::proto::auth::ServerMessage {
+                payload:
+                    Some(arbiter_proto::proto::auth::server_message::Payload::AuthChallenge(challenge)),
+            })),
+    } = result
+    else {
+        panic!("Expected auth challenge response, got {result:?}");
     };
 
-    // Sign the challenge and send solution
-    let formatted_challenge = arbiter_proto::format_challenge(challenge.nonce, &challenge.pubkey);
+    let formatted_challenge = arbiter_proto::format_challenge(&challenge);
     let signature = new_key.sign(&formatted_challenge);
+    let serialized_signature = signature.to_bytes().to_vec();
 
-    test_transport
-        .send(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::AuthChallengeSolution(
-                AuthChallengeSolution {
-                    signature: signature.to_bytes().to_vec(),
-                },
-            )),
+    let result = user_agent_ref
+        .ask(HandleAuthChallengeSolution {
+            solution: auth::AuthChallengeSolution {
+                signature: serialized_signature,
+            },
         })
         .await
-        .unwrap();
+        .expect("Shouldn't fail to send message");
 
-    // Auth completes, session spawned
-    task.await.unwrap();
+    assert_eq!(
+        result,
+        UserAgentResponse {
+            payload: Some(UserAgentResponsePayload::AuthMessage(
+                arbiter_proto::proto::auth::ServerMessage {
+                    payload: Some(arbiter_proto::proto::auth::server_message::Payload::AuthOk(
+                        AuthOk {},
+                    )),
+                },
+            )),
+        }
+    );
 }

server/crates/arbiter-server/tests/user_agent/sdk_client.rs

@@ -1,270 +0,0 @@
-use arbiter_proto::proto::user_agent::{
-    SdkClientApproveRequest, SdkClientError as ProtoSdkClientError, SdkClientRevokeRequest,
-    UserAgentRequest, sdk_client_approve_response, sdk_client_list_response,
-    sdk_client_revoke_response, user_agent_request::Payload as UserAgentRequestPayload,
-    user_agent_response::Payload as UserAgentResponsePayload,
-};
-use arbiter_server::{
-    actors::{GlobalActors, user_agent::session::UserAgentSession},
-    db,
-};
-
-/// Shared helper: create a session and register a client pubkey via sdk_client_approve.
-async fn make_session(db: &db::DatabasePool) -> UserAgentSession {
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
-    UserAgentSession::new_test(db.clone(), actors)
-}
-
-#[tokio::test]
-#[test_log::test]
-async fn test_sdk_client_approve_registers_client() {
-    let db = db::create_test_pool().await;
-    let mut session = make_session(&db).await;
-
-    let pubkey = [0x42u8; 32];
-
-    let response = session
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::SdkClientApprove(
-                SdkClientApproveRequest {
-                    pubkey: pubkey.to_vec(),
-                },
-            )),
-        })
-        .await
-        .expect("handler should succeed");
-
-    let entry = match response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientApprove(resp) => match resp.result.unwrap() {
-            sdk_client_approve_response::Result::Client(e) => e,
-            sdk_client_approve_response::Result::Error(e) => {
-                panic!("Expected Client, got error {:?}", e)
-            }
-        },
-        other => panic!("Expected SdkClientApprove, got {other:?}"),
-    };
-
-    assert_eq!(entry.pubkey, pubkey.to_vec());
-    assert!(entry.id > 0);
-}
-
-#[tokio::test]
-#[test_log::test]
-async fn test_sdk_client_approve_duplicate_returns_already_exists() {
-    let db = db::create_test_pool().await;
-    let mut session = make_session(&db).await;
-
-    let pubkey = [0x11u8; 32];
-    let req = UserAgentRequest {
-        payload: Some(UserAgentRequestPayload::SdkClientApprove(
-            SdkClientApproveRequest {
-                pubkey: pubkey.to_vec(),
-            },
-        )),
-    };
-
-    session
-        .process_transport_inbound(req.clone())
-        .await
-        .unwrap();
-
-    let response = session
-        .process_transport_inbound(req)
-        .await
-        .expect("second insert should not panic");
-
-    match response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientApprove(resp) => match resp.result.unwrap() {
-            sdk_client_approve_response::Result::Error(code) => {
-                assert_eq!(code, ProtoSdkClientError::AlreadyExists as i32);
-            }
-            sdk_client_approve_response::Result::Client(_) => {
-                panic!("Expected AlreadyExists error for duplicate pubkey")
-            }
-        },
-        other => panic!("Expected SdkClientApprove, got {other:?}"),
-    }
-}
-
-#[tokio::test]
-#[test_log::test]
-async fn test_sdk_client_list_shows_registered_clients() {
-    let db = db::create_test_pool().await;
-    let mut session = make_session(&db).await;
-
-    let pubkey_a = [0x0Au8; 32];
-    let pubkey_b = [0x0Bu8; 32];
-
-    for pubkey in [pubkey_a, pubkey_b] {
-        session
-            .process_transport_inbound(UserAgentRequest {
-                payload: Some(UserAgentRequestPayload::SdkClientApprove(
-                    SdkClientApproveRequest {
-                        pubkey: pubkey.to_vec(),
-                    },
-                )),
-            })
-            .await
-            .unwrap();
-    }
-
-    let response = session
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::SdkClientList(())),
-        })
-        .await
-        .expect("list should succeed");
-
-    let clients = match response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientList(resp) => match resp.result.unwrap() {
-            sdk_client_list_response::Result::Clients(list) => list.clients,
-            sdk_client_list_response::Result::Error(e) => {
-                panic!("Expected Clients, got error {:?}", e)
-            }
-        },
-        other => panic!("Expected SdkClientList, got {other:?}"),
-    };
-
-    assert_eq!(clients.len(), 2);
-    let pubkeys: Vec<Vec<u8>> = clients.into_iter().map(|e| e.pubkey).collect();
-    assert!(pubkeys.contains(&pubkey_a.to_vec()));
-    assert!(pubkeys.contains(&pubkey_b.to_vec()));
-}
-
-#[tokio::test]
-#[test_log::test]
-async fn test_sdk_client_revoke_removes_client() {
-    let db = db::create_test_pool().await;
-    let mut session = make_session(&db).await;
-
-    let pubkey = [0xBBu8; 32];
-
-    // Register a client and get its id
-    let approve_response = session
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::SdkClientApprove(
-                SdkClientApproveRequest {
-                    pubkey: pubkey.to_vec(),
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    let client_id = match approve_response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientApprove(resp) => match resp.result.unwrap() {
-            sdk_client_approve_response::Result::Client(e) => e.id,
-            sdk_client_approve_response::Result::Error(e) => panic!("approve failed: {:?}", e),
-        },
-        other => panic!("{other:?}"),
-    };
-
-    // Revoke the client
-    let revoke_response = session
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::SdkClientRevoke(
-                SdkClientRevokeRequest { client_id },
-            )),
-        })
-        .await
-        .expect("revoke should succeed");
-
-    match revoke_response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientRevoke(resp) => match resp.result.unwrap() {
-            sdk_client_revoke_response::Result::Ok(_) => {}
-            sdk_client_revoke_response::Result::Error(e) => {
-                panic!("Expected Ok, got error {:?}", e)
-            }
-        },
-        other => panic!("Expected SdkClientRevoke, got {other:?}"),
-    }
-
-    // List should now be empty
-    let list_response = session
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::SdkClientList(())),
-        })
-        .await
-        .unwrap();
-
-    let clients = match list_response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientList(resp) => match resp.result.unwrap() {
-            sdk_client_list_response::Result::Clients(list) => list.clients,
-            sdk_client_list_response::Result::Error(e) => panic!("list error: {:?}", e),
-        },
-        other => panic!("{other:?}"),
-    };
-    assert!(clients.is_empty(), "client should be removed after revoke");
-}
-
-#[tokio::test]
-#[test_log::test]
-async fn test_sdk_client_revoke_not_found_returns_error() {
-    let db = db::create_test_pool().await;
-    let mut session = make_session(&db).await;
-
-    let response = session
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::SdkClientRevoke(
-                SdkClientRevokeRequest { client_id: 9999 },
-            )),
-        })
-        .await
-        .unwrap();
-
-    match response.payload.unwrap() {
-        UserAgentResponsePayload::SdkClientRevoke(resp) => match resp.result.unwrap() {
-            sdk_client_revoke_response::Result::Error(code) => {
-                assert_eq!(code, ProtoSdkClientError::NotFound as i32);
-            }
-            sdk_client_revoke_response::Result::Ok(_) => {
-                panic!("Expected NotFound error for missing client_id")
-            }
-        },
-        other => panic!("Expected SdkClientRevoke, got {other:?}"),
-    }
-}
-
-#[tokio::test]
-#[test_log::test]
-async fn test_sdk_client_approve_rejected_client_cannot_auth() {
-    // Verify the core flow: only pre-approved clients can authenticate
-    use arbiter_proto::proto::client::{
-        AuthChallengeRequest, ClientRequest, client_request::Payload as ClientRequestPayload,
-        client_response::Payload as ClientResponsePayload,
-    };
-    use arbiter_proto::transport::Bi as _;
-    use arbiter_server::actors::client::{ClientConnection, connect_client};
-
-    let db = db::create_test_pool().await;
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
-
-    let new_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
-    let pubkey_bytes = new_key.verifying_key().to_bytes().to_vec();
-
-    let (server_transport, mut test_transport) = super::common::ChannelTransport::<_, _>::new();
-    let props = ClientConnection::new(db.clone(), Box::new(server_transport), actors.clone());
-    let task = tokio::spawn(connect_client(props));
-
-    test_transport
-        .send(ClientRequest {
-            payload: Some(ClientRequestPayload::AuthChallengeRequest(
-                AuthChallengeRequest {
-                    pubkey: pubkey_bytes.clone(),
-                },
-            )),
-        })
-        .await
-        .unwrap();
-
-    let response = test_transport.recv().await.unwrap().unwrap();
-    assert!(
-        matches!(
-            response.payload.unwrap(),
-            ClientResponsePayload::ClientConnectError(_)
-        ),
-        "unregistered client should be rejected"
-    );
-
-    task.await.unwrap();
-}

server/crates/arbiter-server/tests/user_agent/unseal.rs

@@ -1,26 +1,30 @@
-use arbiter_proto::proto::user_agent::{
-    UnsealEncryptedKey, UnsealResult, UnsealStart, UserAgentRequest,
-    user_agent_request::Payload as UserAgentRequestPayload,
+use arbiter_proto::proto::{
+    UnsealEncryptedKey, UnsealResult, UnsealStart, auth::AuthChallengeRequest,
     user_agent_response::Payload as UserAgentResponsePayload,
 };
 use arbiter_server::{
     actors::{
         GlobalActors,
+        bootstrap::GetToken,
         keyholder::{Bootstrap, Seal},
-        user_agent::session::UserAgentSession,
+        user_agent::{
+            HandleAuthChallengeRequest, HandleUnsealEncryptedKey, HandleUnsealRequest,
+            UserAgentActor,
+        },
     },
     db,
 };
 use chacha20poly1305::{AeadInPlace, XChaCha20Poly1305, XNonce, aead::KeyInit};
+use kameo::actor::{ActorRef, Spawn};
 use memsafe::MemSafe;
 use x25519_dalek::{EphemeralSecret, PublicKey};
 
-async fn setup_sealed_user_agent(
+async fn setup_authenticated_user_agent(
     seal_key: &[u8],
-) -> (db::DatabasePool, UserAgentSession) {
+) -> (arbiter_server::db::DatabasePool, ActorRef<UserAgentActor>) {
     let db = db::create_test_pool().await;
-    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
 
+    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
     actors
         .key_holder
         .ask(Bootstrap {
@@ -30,23 +34,37 @@ async fn setup_sealed_user_agent(
         .unwrap();
     actors.key_holder.ask(Seal).await.unwrap();
 
-    let session = UserAgentSession::new_test(db.clone(), actors);
+    let user_agent =
+        UserAgentActor::new_manual(db.clone(), actors.clone(), super::null_recipient());
+    let user_agent_ref = UserAgentActor::spawn(user_agent);
 
-    (db, session)
+    let token = actors.bootstrapper.ask(GetToken).await.unwrap().unwrap();
+    let auth_key = ed25519_dalek::SigningKey::generate(&mut rand::rng());
+    user_agent_ref
+        .ask(HandleAuthChallengeRequest {
+            req: AuthChallengeRequest {
+                pubkey: auth_key.verifying_key().to_bytes().to_vec(),
+                bootstrap_token: Some(token),
+            },
+        })
+        .await
+        .unwrap();
+
+    (db, user_agent_ref)
 }
 
 async fn client_dh_encrypt(
-    user_agent: &mut UserAgentSession,
+    user_agent_ref: &ActorRef<UserAgentActor>,
     key_to_send: &[u8],
 ) -> UnsealEncryptedKey {
     let client_secret = EphemeralSecret::random();
     let client_public = PublicKey::from(&client_secret);
 
-    let response = user_agent
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::UnsealStart(UnsealStart {
+    let response = user_agent_ref
+        .ask(HandleUnsealRequest {
+            req: UnsealStart {
                 client_pubkey: client_public.as_bytes().to_vec(),
-            })),
+            },
         })
         .await
         .unwrap();
@@ -73,22 +91,16 @@ async fn client_dh_encrypt(
     }
 }
 
-fn unseal_key_request(req: UnsealEncryptedKey) -> UserAgentRequest {
-    UserAgentRequest {
-        payload: Some(UserAgentRequestPayload::UnsealEncryptedKey(req)),
-    }
-}
-
 #[tokio::test]
 #[test_log::test]
 pub async fn test_unseal_success() {
     let seal_key = b"test-seal-key";
-    let (_db, mut user_agent) = setup_sealed_user_agent(seal_key).await;
+    let (_db, user_agent_ref) = setup_authenticated_user_agent(seal_key).await;
 
-    let encrypted_key = client_dh_encrypt(&mut user_agent, seal_key).await;
+    let encrypted_key = client_dh_encrypt(&user_agent_ref, seal_key).await;
 
-    let response = user_agent
-        .process_transport_inbound(unseal_key_request(encrypted_key))
+    let response = user_agent_ref
+        .ask(HandleUnsealEncryptedKey { req: encrypted_key })
         .await
         .unwrap();
 
@@ -101,12 +113,12 @@ pub async fn test_unseal_success() {
 #[tokio::test]
 #[test_log::test]
 pub async fn test_unseal_wrong_seal_key() {
-    let (_db, mut user_agent) = setup_sealed_user_agent(b"correct-key").await;
+    let (_db, user_agent_ref) = setup_authenticated_user_agent(b"correct-key").await;
 
-    let encrypted_key = client_dh_encrypt(&mut user_agent, b"wrong-key").await;
+    let encrypted_key = client_dh_encrypt(&user_agent_ref, b"wrong-key").await;
 
-    let response = user_agent
-        .process_transport_inbound(unseal_key_request(encrypted_key))
+    let response = user_agent_ref
+        .ask(HandleUnsealEncryptedKey { req: encrypted_key })
         .await
         .unwrap();
 
@@ -119,26 +131,28 @@ pub async fn test_unseal_wrong_seal_key() {
 #[tokio::test]
 #[test_log::test]
 pub async fn test_unseal_corrupted_ciphertext() {
-    let (_db, mut user_agent) = setup_sealed_user_agent(b"test-key").await;
+    let (_db, user_agent_ref) = setup_authenticated_user_agent(b"test-key").await;
 
     let client_secret = EphemeralSecret::random();
     let client_public = PublicKey::from(&client_secret);
 
-    user_agent
-        .process_transport_inbound(UserAgentRequest {
-            payload: Some(UserAgentRequestPayload::UnsealStart(UnsealStart {
+    user_agent_ref
+        .ask(HandleUnsealRequest {
+            req: UnsealStart {
                 client_pubkey: client_public.as_bytes().to_vec(),
-            })),
+            },
         })
         .await
         .unwrap();
 
-    let response = user_agent
-        .process_transport_inbound(unseal_key_request(UnsealEncryptedKey {
-            nonce: vec![0u8; 24],
-            ciphertext: vec![0u8; 32],
-            associated_data: vec![],
-        }))
+    let response = user_agent_ref
+        .ask(HandleUnsealEncryptedKey {
+            req: UnsealEncryptedKey {
+                nonce: vec![0u8; 24],
+                ciphertext: vec![0u8; 32],
+                associated_data: vec![],
+            },
+        })
         .await
         .unwrap();
 
@@ -148,17 +162,49 @@ pub async fn test_unseal_corrupted_ciphertext() {
     );
 }
 
+#[tokio::test]
+#[test_log::test]
+pub async fn test_unseal_start_without_auth_fails() {
+    let db = db::create_test_pool().await;
+
+    let actors = GlobalActors::spawn(db.clone()).await.unwrap();
+    let user_agent =
+        UserAgentActor::new_manual(db.clone(), actors, super::null_recipient());
+    let user_agent_ref = UserAgentActor::spawn(user_agent);
+
+    let client_secret = EphemeralSecret::random();
+    let client_public = PublicKey::from(&client_secret);
+
+    let result = user_agent_ref
+        .ask(HandleUnsealRequest {
+            req: UnsealStart {
+                client_pubkey: client_public.as_bytes().to_vec(),
+            },
+        })
+        .await;
+
+    match result {
+        Err(kameo::error::SendError::HandlerError(err)) => {
+            assert!(
+                matches!(err, arbiter_server::actors::user_agent::UserAgentError::InvalidState),
+                "Expected InvalidState, got {err:?}"
+            );
+        }
+        other => panic!("Expected state machine error, got {other:?}"),
+    }
+}
+
 #[tokio::test]
 #[test_log::test]
 pub async fn test_unseal_retry_after_invalid_key() {
     let seal_key = b"real-seal-key";
-    let (_db, mut user_agent) = setup_sealed_user_agent(seal_key).await;
+    let (_db, user_agent_ref) = setup_authenticated_user_agent(seal_key).await;
 
     {
-        let encrypted_key = client_dh_encrypt(&mut user_agent, b"wrong-key").await;
+        let encrypted_key = client_dh_encrypt(&user_agent_ref, b"wrong-key").await;
 
-        let response = user_agent
-            .process_transport_inbound(unseal_key_request(encrypted_key))
+        let response = user_agent_ref
+            .ask(HandleUnsealEncryptedKey { req: encrypted_key })
             .await
             .unwrap();
 
@@ -169,10 +215,10 @@ pub async fn test_unseal_retry_after_invalid_key() {
     }
 
     {
-        let encrypted_key = client_dh_encrypt(&mut user_agent, seal_key).await;
+        let encrypted_key = client_dh_encrypt(&user_agent_ref, seal_key).await;
 
-        let response = user_agent
-            .process_transport_inbound(unseal_key_request(encrypted_key))
+        let response = user_agent_ref
+            .ask(HandleUnsealEncryptedKey { req: encrypted_key })
             .await
             .unwrap();
 

server/crates/arbiter-terrors-poc/Cargo.toml

@@ -1,7 +0,0 @@
-[package]
-name = "arbiter-terrors-poc"
-version = "0.1.0"
-edition = "2024"
-
-[dependencies]
-terrors = "0.3"

server/crates/arbiter-terrors-poc/src/auth.rs

@@ -1,139 +0,0 @@
-use crate::errors::{InternalError1, InternalError2, InvalidSignature, NotRegistered};
-use terrors::OneOf;
-
-use crate::errors::ProtoError;
-
-// Each sub-call's error type already implements DrainInto<ProtoError>, so we convert
-// directly to ProtoError without broaden — no turbofish needed anywhere.
-//
-// Call chain:
-//   load_config()  → OneOf<(InternalError2,)>          → ProtoError::from
-//   get_nonce()    → OneOf<(InternalError1, InternalError2)> → ProtoError::from
-//   verify_sig()   → OneOf<(InvalidSignature,)>         → ProtoError::from
-pub fn process_request(id: u32, sig: &str) -> Result<String, ProtoError> {
-    if id == 0 {
-        return Err(ProtoError::NotRegistered);
-    }
-
-    let config = load_config(id).map_err(ProtoError::from)?;
-    let nonce = crate::db::get_nonce(id).map_err(ProtoError::from)?;
-    verify_signature(nonce, sig).map_err(ProtoError::from)?;
-
-    Ok(format!("config={config} nonce={nonce} sig={sig}"))
-}
-
-// Simulates loading a config value.
-// id=97 triggers InternalError2 ("config read failed").
-fn load_config(id: u32) -> Result<String, OneOf<(InternalError2,)>> {
-    if id == 97 {
-        return Err(OneOf::new(InternalError2("config read failed".to_owned())));
-    }
-    Ok(format!("cfg-{id}"))
-}
-
-pub fn verify_signature(_nonce: u32, sig: &str) -> Result<(), OneOf<(InvalidSignature,)>> {
-    if sig != "ok" {
-        return Err(OneOf::new(InvalidSignature));
-    }
-    Ok(())
-}
-
-type AuthError = OneOf<(
-    NotRegistered,
-    InvalidSignature,
-    InternalError1,
-    InternalError2,
-)>;
-
-pub fn authenticate(id: u32, sig: &str) -> Result<u32, AuthError> {
-    if id == 0 {
-        return Err(OneOf::new(NotRegistered));
-    }
-
-    // Return type AuthError lets the compiler infer the broaden target.
-    let nonce = crate::db::get_nonce(id).map_err(OneOf::broaden)?;
-    verify_signature(nonce, sig).map_err(OneOf::broaden)?;
-
-    Ok(nonce)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn verify_signature_ok() {
-        assert!(verify_signature(42, "ok").is_ok());
-    }
-
-    #[test]
-    fn verify_signature_bad() {
-        let err = verify_signature(42, "bad").unwrap_err();
-        assert!(err.narrow::<crate::errors::InvalidSignature, _>().is_ok());
-    }
-
-    #[test]
-    fn authenticate_success() {
-        assert_eq!(authenticate(1, "ok").unwrap(), 42);
-    }
-
-    #[test]
-    fn authenticate_not_registered() {
-        let err = authenticate(0, "ok").unwrap_err();
-        assert!(err.narrow::<crate::errors::NotRegistered, _>().is_ok());
-    }
-
-    #[test]
-    fn authenticate_invalid_signature() {
-        let err = authenticate(1, "bad").unwrap_err();
-        assert!(err.narrow::<crate::errors::InvalidSignature, _>().is_ok());
-    }
-
-    #[test]
-    fn authenticate_internal_error1() {
-        let err = authenticate(99, "ok").unwrap_err();
-        assert!(err.narrow::<crate::errors::InternalError1, _>().is_ok());
-    }
-
-    #[test]
-    fn authenticate_internal_error2() {
-        let err = authenticate(98, "ok").unwrap_err();
-        assert!(err.narrow::<crate::errors::InternalError2, _>().is_ok());
-    }
-
-    #[test]
-    fn process_request_success() {
-        let result = process_request(1, "ok").unwrap();
-        assert!(result.contains("nonce=42"));
-    }
-
-    #[test]
-    fn process_request_not_registered() {
-        let err = process_request(0, "ok").unwrap_err();
-        assert!(matches!(err, crate::errors::ProtoError::NotRegistered));
-    }
-
-    #[test]
-    fn process_request_invalid_signature() {
-        let err = process_request(1, "bad").unwrap_err();
-        assert!(matches!(err, crate::errors::ProtoError::InvalidSignature));
-    }
-
-    #[test]
-    fn process_request_internal_from_config() {
-        // id=97 → load_config returns InternalError2
-        let err = process_request(97, "ok").unwrap_err();
-        assert!(
-            matches!(err, crate::errors::ProtoError::Internal(ref msg) if msg == "config read failed")
-        );
-    }
-
-    #[test]
-    fn process_request_internal_from_db() {
-        // id=99 → get_nonce returns InternalError1
-        let err = process_request(99, "ok").unwrap_err();
-        assert!(
-            matches!(err, crate::errors::ProtoError::Internal(ref msg) if msg == "db pool unavailable")
-        );
-    }
-}

server/crates/arbiter-terrors-poc/src/db.rs

@@ -1,38 +0,0 @@
-use crate::errors::{InternalError1, InternalError2};
-use terrors::OneOf;
-
-// Simulates fetching a nonce from a database.
-// id=99 → InternalError1 (pool unavailable)
-// id=98 → InternalError2 (query timeout)
-pub fn get_nonce(id: u32) -> Result<u32, OneOf<(InternalError1, InternalError2)>> {
-    match id {
-        99 => Err(OneOf::new(InternalError1("db pool unavailable".to_owned()))),
-        98 => Err(OneOf::new(InternalError2("query timeout".to_owned()))),
-        _ => Ok(42),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn get_nonce_returns_nonce_for_valid_id() {
-        assert_eq!(get_nonce(1).unwrap(), 42);
-    }
-
-    #[test]
-    fn get_nonce_returns_internal_error1_for_sentinel() {
-        let err = get_nonce(99).unwrap_err();
-        let internal = err.narrow::<crate::errors::InternalError1, _>().unwrap();
-        assert_eq!(internal.0, "db pool unavailable");
-    }
-
-    #[test]
-    fn get_nonce_returns_internal_error2_for_sentinel() {
-        let err = get_nonce(98).unwrap_err();
-        let e = err.narrow::<crate::errors::InternalError1, _>().unwrap_err();
-        let internal = e.take::<crate::errors::InternalError2>();
-        assert_eq!(internal.0, "query timeout");
-    }
-}

server/crates/arbiter-terrors-poc/src/errors.rs

@@ -1,130 +0,0 @@
-use terrors::OneOf;
-
-// Wire boundary type — what would go into a proto response
-#[derive(Debug)]
-pub enum ProtoError {
-    NotRegistered,
-    InvalidSignature,
-    Internal(String), // Or Box<dyn Error>, who cares?
-}
-
-// Internal terrors types
-#[derive(Debug)]
-pub struct NotRegistered;
-#[derive(Debug)]
-pub struct InvalidSignature;
-#[derive(Debug)]
-pub struct InternalError1(pub String);
-#[derive(Debug)]
-pub struct InternalError2(pub String);
-
-// Errors can be scattered across the codebase as long as they implement Into<ProtoError>
-impl From<NotRegistered> for ProtoError {
-    fn from(_: NotRegistered) -> Self {
-        ProtoError::NotRegistered
-    }
-}
-
-impl From<InvalidSignature> for ProtoError {
-    fn from(_: InvalidSignature) -> Self {
-        ProtoError::InvalidSignature
-    }
-}
-
-impl From<InternalError1> for ProtoError {
-    fn from(e: InternalError1) -> Self {
-        ProtoError::Internal(e.0)
-    }
-}
-impl From<InternalError2> for ProtoError {
-    fn from(e: InternalError2) -> Self {
-        ProtoError::Internal(e.0)
-    }
-}
-
-/// Private helper trait for converting from OneOf<T...> where each T can be converted
-/// into the target type `O` by recursively narrowing until a match is found.
-/// 
-/// IDK why this isn't already in terrors.
-trait DrainInto<O>: terrors::TypeSet + Sized {
-    fn drain(e: OneOf<Self>) -> O;
-}
-
-macro_rules! impl_drain_into {
-    ($head:ident) => {
-        impl<$head, O> DrainInto<O> for ($head,)
-        where
-            $head: Into<O> + 'static,
-        {
-            fn drain(e: OneOf<($head,)>) -> O {
-                e.take().into()
-            }
-        }
-    };
-    ($head:ident, $($tail:ident),+) => {
-        impl<$head, $($tail),+, O> DrainInto<O> for ($head, $($tail),+)
-        where
-            $head: Into<O> + 'static,
-            ($($tail,)+): DrainInto<O>,
-        {
-            fn drain(e: OneOf<($head, $($tail),+)>) -> O {
-                match e.narrow::<$head, _>() {
-                    Ok(h) => h.into(),
-                    Err(rest) => <($($tail,)+)>::drain(rest),
-                }
-            }
-        }
-        impl_drain_into!($($tail),+);
-    };
-}
-
-// Generates impls for all tuple sizes from 1 up to 7 (restricted by terrors internal impl).
-// Each invocation produces one impl then recurses on the tail.
-impl_drain_into!(A, B, C, D, E, F, G, H, I);
-
-// Blanket From impl: body delegates to the recursive drain.
-impl<E: DrainInto<ProtoError>> From<OneOf<E>> for ProtoError {
-    fn from(e: OneOf<E>) -> Self {
-        E::drain(e)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn not_registered_converts_to_proto() {
-        let e: ProtoError = NotRegistered.into();
-        assert!(matches!(e, ProtoError::NotRegistered));
-    }
-
-    #[test]
-    fn invalid_signature_converts_to_proto() {
-        let e: ProtoError = InvalidSignature.into();
-        assert!(matches!(e, ProtoError::InvalidSignature));
-    }
-
-    #[test]
-    fn internal_converts_to_proto() {
-        let e: ProtoError = InternalError1("boom".into()).into();
-        assert!(matches!(e, ProtoError::Internal(msg) if msg == "boom"));
-    }
-
-    #[test]
-    fn one_of_remainder_converts_to_proto_invalid_signature() {
-        use terrors::OneOf;
-        let e: OneOf<(InvalidSignature, InternalError1)> = OneOf::new(InvalidSignature);
-        let proto = ProtoError::from(e);
-        assert!(matches!(proto, ProtoError::InvalidSignature));
-    }
-
-    #[test]
-    fn one_of_remainder_converts_to_proto_internal() {
-        use terrors::OneOf;
-        let e: OneOf<(InvalidSignature, InternalError1)> =
-            OneOf::new(InternalError1("db fail".into()));
-        let proto = ProtoError::from(e);
-        assert!(matches!(proto, ProtoError::Internal(msg) if msg == "db fail"));
-    }
-}

server/crates/arbiter-terrors-poc/src/main.rs

@@ -1,43 +0,0 @@
-mod auth;
-mod db;
-mod errors;
-
-use errors::ProtoError;
-
-fn run(id: u32, sig: &str) {
-    print!("authenticate(id={id}, sig={sig:?}) => ");
-    match auth::authenticate(id, sig) {
-        Ok(nonce) => println!("Ok(nonce={nonce})"),
-        Err(e) => match e.narrow::<errors::NotRegistered, _>() {
-            Ok(_) => println!("Err(NotRegistered) — handled locally"),
-            Err(remaining) => {
-                let proto = ProtoError::from(remaining);
-                println!("Err(ProtoError::{proto:?}) — forwarded to wire");
-            }
-        },
-    }
-}
-
-fn run_process(id: u32, sig: &str) {
-    print!("process_request(id={id}, sig={sig:?}) => ");
-    match auth::process_request(id, sig) {
-        Ok(s) => println!("Ok({s})"),
-        Err(e) => println!("Err(ProtoError::{e:?})"),
-    }
-}
-
-fn main() {
-    println!("=== authenticate ===");
-    run(0, "ok");   // NotRegistered
-    run(1, "bad");  // InvalidSignature
-    run(99, "ok");  // InternalError1
-    run(98, "ok");  // InternalError2
-    run(1, "ok");   // success
-
-    println!("\n=== process_request (Try chain) ===");
-    run_process(0, "ok");   // NotRegistered (guard, no I/O)
-    run_process(97, "ok");  // InternalError2 from load_config
-    run_process(99, "ok");  // InternalError1 from get_nonce
-    run_process(1, "bad");  // InvalidSignature from verify_signature
-    run_process(1, "ok");   // success
-}

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

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

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

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

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

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

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

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

server/crates/arbiter-useragent/Cargo.toml

@@ -4,26 +4,12 @@ version = "0.1.0"
 edition = "2024"
 license = "Apache-2.0"
 
-[lints]
-workspace = true
-
 [dependencies]
 arbiter-proto.path = "../arbiter-proto"
 kameo.workspace = true
 tokio = {workspace = true, features = ["net"]}
 tonic.workspace = true
-tonic.features = ["tls-aws-lc"]
 tracing.workspace = true
 ed25519-dalek.workspace = true
 smlang.workspace = true
 x25519-dalek.workspace = true
-k256.workspace = true
-rsa.workspace = true
-sha2.workspace = true
-spki.workspace = true
-rand.workspace = true
-thiserror.workspace = true
-tokio-stream.workspace = true
-http = "1.4.0"
-rustls-webpki = { version = "0.103.9", features = ["aws-lc-rs"] }
-async-trait.workspace = true

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

@@ -1,70 +0,0 @@
-use arbiter_proto::{
-    proto::{
-        arbiter_service_client::ArbiterServiceClient,
-        user_agent::{UserAgentRequest, UserAgentResponse},
-    },
-    transport::{IdentityRecvConverter, IdentitySendConverter, grpc},
-    url::ArbiterUrl,
-};
-use kameo::actor::{ActorRef, Spawn};
-
-use tokio::sync::mpsc;
-use tokio_stream::wrappers::ReceiverStream;
-
-use tonic::transport::ClientTlsConfig;
-
-use super::{SigningKeyEnum, UserAgentActor};
-
-#[derive(Debug, thiserror::Error)]
-pub enum ConnectError {
-    #[error("Could 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("gRPC error")]
-    Grpc(#[from] tonic::Status),
-}
-
-pub type UserAgentGrpc = ActorRef<
-    UserAgentActor<
-        grpc::GrpcAdapter<
-            IdentityRecvConverter<UserAgentResponse>,
-            IdentitySendConverter<UserAgentRequest>,
-        >,
-    >,
->;
-pub async fn connect_grpc(
-    url: ArbiterUrl,
-    key: SigningKeyEnum,
-) -> Result<UserAgentGrpc, ConnectError> {
-    let bootstrap_token = url.bootstrap_token.clone();
-    let anchor = webpki::anchor_from_trusted_cert(&url.ca_cert)?.to_owned();
-    let tls = ClientTlsConfig::new().trust_anchor(anchor);
-
-    // TODO: if `host` is localhost, we need to verify server's process authenticity
-    let channel = tonic::transport::Channel::from_shared(format!("{}:{}", url.host, url.port))?
-        .tls_config(tls)?
-        .connect()
-        .await?;
-
-    let mut client = ArbiterServiceClient::new(channel);
-    let (tx, rx) = mpsc::channel(16);
-    let bistream = client.user_agent(ReceiverStream::new(rx)).await?;
-    let bistream = bistream.into_inner();
-
-    let adapter = grpc::GrpcAdapter::new(
-        tx,
-        bistream,
-        IdentityRecvConverter::new(),
-        IdentitySendConverter::new(),
-    );
-
-    let actor = UserAgentActor::spawn(UserAgentActor::new(key, bootstrap_token, adapter));
-
-    Ok(actor)
-}

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

@@ -1,257 +1,66 @@
-use arbiter_proto::{
-    format_challenge,
-    proto::user_agent::{
-        AuthChallengeRequest, AuthChallengeSolution, AuthOk, KeyType as ProtoKeyType,
-        UserAgentRequest, UserAgentResponse,
-        user_agent_request::Payload as UserAgentRequestPayload,
-        user_agent_response::Payload as UserAgentResponsePayload,
-    },
-    transport::Bi,
+use arbiter_proto::{proto::UserAgentRequest, transport::TransportActor};
+use ed25519_dalek::SigningKey;
+use kameo::{
+    Actor, Reply,
+    actor::{ActorRef, WeakActorRef},
+    prelude::Message,
 };
-use kameo::{Actor, actor::ActorRef};
 use smlang::statemachine;
-use tokio::select;
-use tracing::{error, info};
+use tonic::transport::CertificateDer;
+use tracing::{debug, error};
 
-/// Signing key variants supported by the user-agent auth protocol.
-pub enum SigningKeyEnum {
-    Ed25519(ed25519_dalek::SigningKey),
-    /// secp256k1 ECDSA; public key is sent as SEC1 compressed 33 bytes; signature is raw 64-byte (r||s).
-    EcdsaSecp256k1(k256::ecdsa::SigningKey),
-    /// RSA for Windows Hello (KeyCredentialManager); public key is DER SPKI; signature is PSS+SHA-256.
-    Rsa(rsa::RsaPrivateKey),
+struct Storage {
+    pub identity: SigningKey,
+    pub server_ca_cert: CertificateDer<'static>,
 }
 
-impl SigningKeyEnum {
-    /// Returns the canonical public key bytes to include in `AuthChallengeRequest.pubkey`.
-    pub fn pubkey_bytes(&self) -> Vec<u8> {
-        match self {
-            SigningKeyEnum::Ed25519(k) => k.verifying_key().to_bytes().to_vec(),
-            // 33-byte SEC1 compressed point — compact and natively supported by secp256k1 tooling
-            SigningKeyEnum::EcdsaSecp256k1(k) => {
-                k.verifying_key().to_encoded_point(true).as_bytes().to_vec()
-            }
-            SigningKeyEnum::Rsa(k) => {
-                use rsa::pkcs8::EncodePublicKey as _;
-                k.to_public_key()
-                    .to_public_key_der()
-                    .expect("rsa SPKI encoding is infallible")
-                    .to_vec()
-            }
-        }
-    }
-
-    /// Returns the proto `KeyType` discriminant to send in `AuthChallengeRequest.key_type`.
-    pub fn proto_key_type(&self) -> ProtoKeyType {
-        match self {
-            SigningKeyEnum::Ed25519(_) => ProtoKeyType::Ed25519,
-            SigningKeyEnum::EcdsaSecp256k1(_) => ProtoKeyType::EcdsaSecp256k1,
-            SigningKeyEnum::Rsa(_) => ProtoKeyType::Rsa,
-        }
-    }
-
-    /// Signs `msg` and returns raw signature bytes matching the server-side verification.
-    pub fn sign(&self, msg: &[u8]) -> Vec<u8> {
-        match self {
-            SigningKeyEnum::Ed25519(k) => {
-                use ed25519_dalek::Signer as _;
-                k.sign(msg).to_bytes().to_vec()
-            }
-            SigningKeyEnum::EcdsaSecp256k1(k) => {
-                use k256::ecdsa::signature::Signer as _;
-                let sig: k256::ecdsa::Signature = k.sign(msg);
-                sig.to_bytes().to_vec()
-            }
-            SigningKeyEnum::Rsa(k) => {
-                use rsa::signature::RandomizedSigner as _;
-                let signing_key = rsa::pss::BlindedSigningKey::<sha2::Sha256>::new(k.clone());
-                // Use rand_core OsRng from the rsa crate's re-exported rand_core (0.6.x),
-                // which is the version rsa's signature API expects.
-                let sig = signing_key.sign_with_rng(&mut rsa::rand_core::OsRng, msg);
-                use rsa::signature::SignatureEncoding as _;
-                sig.to_vec()
-            }
-        }
-    }
+#[derive(Debug)]
+pub enum InitError {
+    StorageError,
+    Other(String),
 }
 
 statemachine! {
-    name: UserAgent,
+    name: UserAgentStateMachine,
     custom_error: false,
     transitions: {
-        *Init + SentAuthChallengeRequest = WaitingForServerAuth,
-        WaitingForServerAuth + ReceivedAuthChallenge = WaitingForAuthOk,
-        WaitingForServerAuth + ReceivedAuthOk = Authenticated,
-        WaitingForAuthOk + ReceivedAuthOk = Authenticated,
+        *Init + SendAuthChallenge = WaitingForAuthSolution
     }
 }
 
-pub struct DummyContext;
-impl UserAgentStateMachineContext for DummyContext {}
 
-#[derive(Debug, thiserror::Error)]
-pub enum InboundError {
-    #[error("Invalid user agent response")]
-    InvalidResponse,
-    #[error("Expected response payload")]
-    MissingResponsePayload,
-    #[error("Unexpected response payload")]
-    UnexpectedResponsePayload,
-    #[error("Invalid state for auth challenge")]
-    InvalidStateForAuthChallenge,
-    #[error("Invalid state for auth ok")]
-    InvalidStateForAuthOk,
-    #[error("State machine error")]
-    StateTransitionFailed,
-    #[error("Transport send failed")]
-    TransportSendFailed,
+
+pub struct UserAgentActor<A: TransportActor<UserAgentRequest>> {
+    key: SigningKey,
+    server_ca_cert: CertificateDer<'static>,
+    sender: ActorRef<A>,
 }
-
-pub struct UserAgentActor<Transport>
-where
-    Transport: Bi<UserAgentResponse, UserAgentRequest>,
-{
-    key: SigningKeyEnum,
-    bootstrap_token: Option<String>,
-    state: UserAgentStateMachine<DummyContext>,
-    transport: Transport,
-}
-
-impl<Transport> UserAgentActor<Transport>
-where
-    Transport: Bi<UserAgentResponse, UserAgentRequest>,
-{
-    pub fn new(key: SigningKeyEnum, bootstrap_token: Option<String>, transport: Transport) -> Self {
-        Self {
-            key,
-            bootstrap_token,
-            state: UserAgentStateMachine::new(DummyContext),
-            transport,
-        }
-    }
-
-    fn transition(&mut self, event: UserAgentEvents) -> Result<(), InboundError> {
-        self.state.process_event(event).map_err(|e| {
-            error!(?e, "useragent state transition failed");
-            InboundError::StateTransitionFailed
-        })?;
-        Ok(())
-    }
-
-    async fn send_auth_challenge_request(&mut self) -> Result<(), InboundError> {
-        let req = AuthChallengeRequest {
-            pubkey: self.key.pubkey_bytes(),
-            bootstrap_token: self.bootstrap_token.take(),
-            key_type: self.key.proto_key_type().into(),
-        };
-
-        self.transition(UserAgentEvents::SentAuthChallengeRequest)?;
-
-        self.transport
-            .send(UserAgentRequest {
-                payload: Some(UserAgentRequestPayload::AuthChallengeRequest(req)),
-            })
-            .await
-            .map_err(|_| InboundError::TransportSendFailed)?;
-
-        info!(actor = "useragent", "auth.request.sent");
-        Ok(())
-    }
-
-    async fn handle_auth_challenge(
-        &mut self,
-        challenge: arbiter_proto::proto::user_agent::AuthChallenge,
-    ) -> Result<(), InboundError> {
-        self.transition(UserAgentEvents::ReceivedAuthChallenge)?;
-
-        let formatted = format_challenge(challenge.nonce, &challenge.pubkey);
-        let signature_bytes = self.key.sign(&formatted);
-        let solution = AuthChallengeSolution {
-            signature: signature_bytes,
-        };
-
-        self.transport
-            .send(UserAgentRequest {
-                payload: Some(UserAgentRequestPayload::AuthChallengeSolution(solution)),
-            })
-            .await
-            .map_err(|_| InboundError::TransportSendFailed)?;
-
-        info!(actor = "useragent", "auth.solution.sent");
-        Ok(())
-    }
-
-    fn handle_auth_ok(&mut self, _ok: AuthOk) -> Result<(), InboundError> {
-        self.transition(UserAgentEvents::ReceivedAuthOk)?;
-        info!(actor = "useragent", "auth.ok");
-        Ok(())
-    }
-
-    pub async fn process_inbound_transport(
-        &mut self,
-        inbound: UserAgentResponse,
-    ) -> Result<(), InboundError> {
-        let payload = inbound
-            .payload
-            .ok_or(InboundError::MissingResponsePayload)?;
-
-        match payload {
-            UserAgentResponsePayload::AuthChallenge(challenge) => {
-                self.handle_auth_challenge(challenge).await
-            }
-            UserAgentResponsePayload::AuthOk(ok) => self.handle_auth_ok(ok),
-            _ => Err(InboundError::UnexpectedResponsePayload),
-        }
-    }
-}
-
-impl<Transport> Actor for UserAgentActor<Transport>
-where
-    Transport: Bi<UserAgentResponse, UserAgentRequest>,
-{
+impl<A: TransportActor<UserAgentRequest>> Actor for UserAgentActor<A> {
     type Args = Self;
 
-    type Error = ();
+    type Error = InitError;
 
-    async fn on_start(
-        mut args: Self::Args,
-        _actor_ref: ActorRef<Self>,
-    ) -> Result<Self, Self::Error> {
-        if let Err(err) = args.send_auth_challenge_request().await {
-            error!(?err, actor = "useragent", "auth.start.failed");
-            return Err(());
-        }
-        Ok(args)
+    async fn on_start(args: Self::Args, actor_ref: ActorRef<Self>) -> Result<Self, Self::Error> {
+        todo!()
     }
 
-    async fn next(
+    async fn on_link_died(
         &mut self,
-        _actor_ref: kameo::prelude::WeakActorRef<Self>,
-        mailbox_rx: &mut kameo::prelude::MailboxReceiver<Self>,
-    ) -> Option<kameo::mailbox::Signal<Self>> {
-        loop {
-            select! {
-                signal = mailbox_rx.recv() => {
-                    return signal;
-                }
-                inbound = self.transport.recv() => {
-                    match inbound {
-                        Some(inbound) => {
-                            if let Err(err) = self.process_inbound_transport(inbound).await {
-                                error!(?err, actor = "useragent", "transport.inbound.failed");
-                                return Some(kameo::mailbox::Signal::Stop);
-                            }
-                        }
-                        None => {
-                            info!(actor = "useragent", "transport.closed");
-                            return Some(kameo::mailbox::Signal::Stop);
-                        }
-                    }
-                }
-            }
+        _: WeakActorRef<Self>,
+        id: kameo::prelude::ActorId,
+        _: kameo::prelude::ActorStopReason,
+    ) -> Result<std::ops::ControlFlow<kameo::prelude::ActorStopReason>, Self::Error> {
+        if id == self.sender.id() {
+            error!("Transport actor died, stopping UserAgentActor");
+            Ok(std::ops::ControlFlow::Break(
+                kameo::prelude::ActorStopReason::Normal,
+            ))
+        } else {
+            debug!(
+                "Linked actor {} died, but it's not the transport actor, ignoring",
+                id
+            );
+            Ok(std::ops::ControlFlow::Continue(()))
         }
     }
 }
-
-mod grpc;
-pub use grpc::{ConnectError, connect_grpc};

server/crates/arbiter-useragent/tests/auth.rs

@@ -1,146 +0,0 @@
-use arbiter_proto::{
-    format_challenge,
-    proto::user_agent::{
-        AuthChallenge, AuthOk, UserAgentRequest, UserAgentResponse,
-        user_agent_request::Payload as UserAgentRequestPayload,
-        user_agent_response::Payload as UserAgentResponsePayload,
-    },
-    transport::Bi,
-};
-use arbiter_useragent::{SigningKeyEnum, UserAgentActor};
-use async_trait::async_trait;
-use ed25519_dalek::SigningKey;
-use kameo::actor::Spawn;
-use tokio::sync::mpsc;
-use tokio::time::{Duration, timeout};
-
-struct TestTransport {
-    inbound_rx: mpsc::Receiver<UserAgentResponse>,
-    outbound_tx: mpsc::Sender<UserAgentRequest>,
-}
-
-#[async_trait]
-impl Bi<UserAgentResponse, UserAgentRequest> for TestTransport {
-    async fn send(
-        &mut self,
-        item: UserAgentRequest,
-    ) -> Result<(), arbiter_proto::transport::Error> {
-        self.outbound_tx
-            .send(item)
-            .await
-            .map_err(|_| arbiter_proto::transport::Error::ChannelClosed)
-    }
-
-    async fn recv(&mut self) -> Option<UserAgentResponse> {
-        self.inbound_rx.recv().await
-    }
-}
-
-fn make_transport() -> (
-    TestTransport,
-    mpsc::Sender<UserAgentResponse>,
-    mpsc::Receiver<UserAgentRequest>,
-) {
-    let (inbound_tx, inbound_rx) = mpsc::channel(8);
-    let (outbound_tx, outbound_rx) = mpsc::channel(8);
-    (
-        TestTransport {
-            inbound_rx,
-            outbound_tx,
-        },
-        inbound_tx,
-        outbound_rx,
-    )
-}
-
-fn test_key() -> SigningKeyEnum {
-    SigningKeyEnum::Ed25519(SigningKey::from_bytes(&[7u8; 32]))
-}
-
-#[tokio::test]
-async fn sends_auth_request_on_start_with_bootstrap_token() {
-    let key = test_key();
-    let pubkey = key.pubkey_bytes();
-    let bootstrap_token = Some("bootstrap-123".to_string());
-    let (transport, inbound_tx, mut outbound_rx) = make_transport();
-
-    let actor = UserAgentActor::spawn(UserAgentActor::new(key, bootstrap_token.clone(), transport));
-
-    let outbound = timeout(Duration::from_secs(1), outbound_rx.recv())
-        .await
-        .expect("timed out waiting for auth request")
-        .expect("channel closed before auth request");
-
-    let UserAgentRequest {
-        payload: Some(UserAgentRequestPayload::AuthChallengeRequest(req)),
-    } = outbound
-    else {
-        panic!("expected auth challenge request");
-    };
-
-    assert_eq!(req.pubkey, pubkey);
-    assert_eq!(req.bootstrap_token, bootstrap_token);
-
-    drop(inbound_tx);
-    drop(actor);
-}
-
-#[tokio::test]
-async fn challenge_flow_sends_solution_from_transport_inbound() {
-    let key = test_key();
-    let pubkey_bytes = key.pubkey_bytes();
-    let (transport, inbound_tx, mut outbound_rx) = make_transport();
-
-    let actor = UserAgentActor::spawn(UserAgentActor::new(key, None, transport));
-
-    let _initial_auth_request = timeout(Duration::from_secs(1), outbound_rx.recv())
-        .await
-        .expect("timed out waiting for initial auth request")
-        .expect("missing initial auth request");
-
-    let challenge = AuthChallenge {
-        pubkey: pubkey_bytes.clone(),
-        nonce: 42,
-    };
-    inbound_tx
-        .send(UserAgentResponse {
-            payload: Some(UserAgentResponsePayload::AuthChallenge(challenge.clone())),
-        })
-        .await
-        .unwrap();
-
-    let outbound = timeout(Duration::from_secs(1), outbound_rx.recv())
-        .await
-        .expect("timed out waiting for challenge solution")
-        .expect("missing challenge solution");
-
-    let UserAgentRequest {
-        payload: Some(UserAgentRequestPayload::AuthChallengeSolution(solution)),
-    } = outbound
-    else {
-        panic!("expected auth challenge solution");
-    };
-
-    // Verify the signature using the Ed25519 verifying key
-    let formatted = format_challenge(challenge.nonce, &challenge.pubkey);
-    let raw_key = SigningKey::from_bytes(&[7u8; 32]);
-    let sig: ed25519_dalek::Signature = solution
-        .signature
-        .as_slice()
-        .try_into()
-        .expect("signature bytes length");
-    raw_key
-        .verifying_key()
-        .verify_strict(&formatted, &sig)
-        .expect("solution signature should verify");
-
-    inbound_tx
-        .send(UserAgentResponse {
-            payload: Some(UserAgentResponsePayload::AuthOk(AuthOk {})),
-        })
-        .await
-        .unwrap();
-
-    drop(inbound_tx);
-    drop(actor);
-}

server/supply-chain/audits.toml

@@ -1,41 +1,6 @@
 
 # cargo-vet audits file
 
-[[audits.alloy-primitives]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-deploy"
-version = "1.5.7"
-
-[[audits.console]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-deploy"
-version = "0.15.11"
-
-[[audits.encode_unicode]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-deploy"
-version = "0.3.6"
-
-[[audits.futures-timer]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-run"
-version = "3.0.3"
-
-[[audits.insta]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-run"
-version = "1.46.3"
-
-[[audits.pin-project]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-deploy"
-version = "0.2.16"
-
-[[audits.protoc-bin-vendored]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-deploy"
-version = "3.2.0"
-
 [[audits.similar]]
 who = "hdbg <httpdebugger@protonmail.com>"
 criteria = "safe-to-deploy"
@@ -51,214 +16,11 @@ who = "hdbg <httpdebugger@protonmail.com>"
 criteria = "safe-to-deploy"
 delta = "0.2.18 -> 0.2.19"
 
-[[audits.wasm-bindgen]]
-who = "CleverWild <cleverwilddev@gmail.com>"
-criteria = "safe-to-deploy"
-delta = "0.2.100 -> 0.2.114"
-
-[[trusted.addr2line]]
-criteria = "safe-to-deploy"
-user-id = 4415 # Philip Craig (philipc)
-start = "2019-05-01"
-end = "2027-03-14"
-
-[[trusted.aho-corasick]]
-criteria = "safe-to-deploy"
-user-id = 189 # Andrew Gallant (BurntSushi)
-start = "2019-03-28"
-end = "2027-03-14"
-
-[[trusted.anyhow]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-10-05"
-end = "2027-03-14"
-
-[[trusted.async-stream]]
-criteria = "safe-to-deploy"
-user-id = 10 # Carl Lerche (carllerche)
-start = "2019-06-07"
-end = "2027-03-14"
-
-[[trusted.async-stream]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2021-04-21"
-end = "2027-03-14"
-
-[[trusted.async-stream-impl]]
-criteria = "safe-to-deploy"
-user-id = 10 # Carl Lerche (carllerche)
-start = "2019-08-13"
-end = "2027-03-14"
-
-[[trusted.async-stream-impl]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2021-04-21"
-end = "2027-03-14"
-
-[[trusted.async-trait]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-07-23"
-end = "2027-03-14"
-
-[[trusted.auto_impl]]
-criteria = "safe-to-deploy"
-user-id = 3204 # Ashley Mannix (KodrAus)
-start = "2022-06-01"
-end = "2027-03-14"
-
-[[trusted.aws-lc-rs]]
-criteria = "safe-to-deploy"
-user-id = 156764 # Justin W Smith (justsmth)
-start = "2023-04-11"
-end = "2027-03-14"
-
-[[trusted.aws-lc-sys]]
-criteria = "safe-to-deploy"
-user-id = 156764 # Justin W Smith (justsmth)
-start = "2022-11-09"
-end = "2027-03-14"
-
-[[trusted.backtrace]]
-criteria = "safe-to-deploy"
-user-id = 55123 # rust-lang-owner
-start = "2025-05-06"
-end = "2027-03-14"
-
-[[trusted.bitflags]]
-criteria = "safe-to-deploy"
-user-id = 3204 # Ashley Mannix (KodrAus)
-start = "2019-05-02"
-end = "2027-03-14"
-
-[[trusted.bytes]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-11-27"
-end = "2027-03-14"
-
-[[trusted.bytes]]
-criteria = "safe-to-deploy"
-user-id = 6741 # Alice Ryhl (Darksonn)
-start = "2021-01-11"
-end = "2027-03-14"
-
 [[trusted.cc]]
 criteria = "safe-to-deploy"
 user-id = 55123 # rust-lang-owner
 start = "2022-10-29"
-end = "2027-03-14"
-
-[[trusted.cmake]]
-criteria = "safe-to-deploy"
-user-id = 55123 # rust-lang-owner
-start = "2022-10-29"
-end = "2027-03-14"
-
-[[trusted.crossbeam-utils]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-12"
-end = "2027-03-14"
-
-[[trusted.derive_more]]
-criteria = "safe-to-deploy"
-user-id = 3797 # Jelte Fennema-Nio (JelteF)
-start = "2019-05-25"
-end = "2027-03-14"
-
-[[trusted.derive_more-impl]]
-criteria = "safe-to-deploy"
-user-id = 3797 # Jelte Fennema-Nio (JelteF)
-start = "2023-07-23"
-end = "2027-03-14"
-
-[[trusted.dyn-clone]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-12-23"
-end = "2027-03-14"
-
-[[trusted.ff]]
-criteria = "safe-to-deploy"
-user-id = 6289 # Jack Grigg (str4d)
-start = "2021-08-11"
-end = "2027-03-14"
-
-[[trusted.find-msvc-tools]]
-criteria = "safe-to-deploy"
-user-id = 539 # Josh Stone (cuviper)
-start = "2025-08-29"
-end = "2027-03-14"
-
-[[trusted.flate2]]
-criteria = "safe-to-deploy"
-user-id = 980 # Sebastian Thiel (Byron)
-start = "2023-08-15"
-end = "2027-03-14"
-
-[[trusted.futures]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-channel]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-core]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-executor]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-io]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-macro]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-sink]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.futures-task]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2019-07-29"
-end = "2027-03-14"
-
-[[trusted.futures-util]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2020-10-05"
-end = "2027-03-14"
-
-[[trusted.group]]
-criteria = "safe-to-deploy"
-user-id = 1244 # ebfull
-start = "2019-10-08"
-end = "2027-03-14"
+end = "2027-02-16"
 
 [[trusted.h2]]
 criteria = "safe-to-deploy"
@@ -266,372 +28,36 @@ user-id = 359 # Sean McArthur (seanmonstar)
 start = "2019-03-13"
 end = "2027-02-14"
 
-[[trusted.hashbrown]]
-criteria = "safe-to-deploy"
-user-id = 2915 # Amanieu d'Antras (Amanieu)
-start = "2019-04-02"
-end = "2027-03-14"
-
 [[trusted.hashbrown]]
 criteria = "safe-to-deploy"
 user-id = 55123 # rust-lang-owner
 start = "2025-04-30"
 end = "2027-02-14"
 
-[[trusted.http]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-04-05"
-end = "2027-03-14"
-
-[[trusted.http-body-util]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2022-10-25"
-end = "2027-03-14"
-
-[[trusted.httparse]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-07-03"
-end = "2027-03-14"
-
-[[trusted.hyper]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-03-01"
-end = "2027-03-14"
-
 [[trusted.hyper-util]]
 criteria = "safe-to-deploy"
 user-id = 359 # Sean McArthur (seanmonstar)
 start = "2022-01-15"
 end = "2027-02-14"
 
-[[trusted.id-arena]]
-criteria = "safe-to-deploy"
-user-id = 696 # Nick Fitzgerald (fitzgen)
-start = "2026-01-14"
-end = "2027-03-14"
-
-[[trusted.indexmap]]
-criteria = "safe-to-deploy"
-user-id = 539 # Josh Stone (cuviper)
-start = "2020-01-15"
-end = "2027-03-14"
-
-[[trusted.itoa]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-05-02"
-end = "2027-03-14"
-
-[[trusted.jobserver]]
-criteria = "safe-to-deploy"
-user-id = 55123 # rust-lang-owner
-start = "2024-07-23"
-end = "2027-03-14"
-
-[[trusted.js-sys]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
 [[trusted.libc]]
 criteria = "safe-to-deploy"
 user-id = 55123 # rust-lang-owner
 start = "2024-08-15"
 end = "2027-02-16"
 
-[[trusted.libm]]
-criteria = "safe-to-deploy"
-user-id = 55123 # rust-lang-owner
-start = "2024-10-26"
-end = "2027-03-14"
-
-[[trusted.linux-raw-sys]]
-criteria = "safe-to-deploy"
-user-id = 6825 # Dan Gohman (sunfishcode)
-start = "2021-06-12"
-end = "2027-03-14"
-
-[[trusted.lock_api]]
-criteria = "safe-to-deploy"
-user-id = 2915 # Amanieu d'Antras (Amanieu)
-start = "2019-05-04"
-end = "2027-03-14"
-
-[[trusted.log]]
-criteria = "safe-to-deploy"
-user-id = 3204 # Ashley Mannix (KodrAus)
-start = "2019-07-10"
-end = "2027-03-14"
-
-[[trusted.macro-string]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2025-02-02"
-end = "2027-03-14"
-
-[[trusted.memchr]]
-criteria = "safe-to-deploy"
-user-id = 189 # Andrew Gallant (BurntSushi)
-start = "2019-07-07"
-end = "2027-03-14"
-
-[[trusted.mime]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-09-09"
-end = "2027-03-14"
-
-[[trusted.mio]]
-criteria = "safe-to-deploy"
-user-id = 6025 # Thomas de Zeeuw (Thomasdezeeuw)
-start = "2019-12-17"
-end = "2027-03-14"
-
-[[trusted.num-bigint]]
-criteria = "safe-to-deploy"
-user-id = 539 # Josh Stone (cuviper)
-start = "2019-09-04"
-end = "2027-03-14"
-
-[[trusted.num_cpus]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-06-10"
-end = "2027-03-14"
-
-[[trusted.object]]
-criteria = "safe-to-deploy"
-user-id = 4415 # Philip Craig (philipc)
-start = "2019-04-26"
-end = "2027-03-14"
-
-[[trusted.parking_lot]]
-criteria = "safe-to-deploy"
-user-id = 2915 # Amanieu d'Antras (Amanieu)
-start = "2019-05-04"
-end = "2027-03-14"
-
-[[trusted.parking_lot_core]]
-criteria = "safe-to-deploy"
-user-id = 2915 # Amanieu d'Antras (Amanieu)
-start = "2019-05-04"
-end = "2027-03-14"
-
-[[trusted.paste]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-03-19"
-end = "2027-03-14"
-
-[[trusted.pin-project]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2019-03-02"
-end = "2027-03-14"
-
-[[trusted.pin-project-internal]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2019-08-11"
-end = "2027-03-14"
-
-[[trusted.pin-project-lite]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2019-10-22"
-end = "2027-03-14"
-
-[[trusted.portable-atomic]]
-criteria = "safe-to-deploy"
-user-id = 33035 # Taiki Endo (taiki-e)
-start = "2022-02-24"
-end = "2027-03-14"
-
-[[trusted.prettyplease]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2022-01-04"
-end = "2027-03-14"
-
-[[trusted.proc-macro2]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-04-23"
-end = "2027-03-14"
-
-[[trusted.prost]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2021-07-08"
-end = "2027-03-14"
-
-[[trusted.prost-build]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2021-07-08"
-end = "2027-03-14"
-
-[[trusted.prost-derive]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2021-07-08"
-end = "2027-03-14"
-
-[[trusted.prost-types]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2021-07-08"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-linux-aarch_64]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2022-02-07"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-linux-ppcle_64]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2022-02-07"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-linux-s390_64]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2025-07-21"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-linux-x86_32]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2022-02-07"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-linux-x86_64]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2022-02-07"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-macos-aarch_64]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2024-09-30"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-macos-x86_64]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2022-02-07"
-end = "2027-03-14"
-
-[[trusted.protoc-bin-vendored-win32]]
-criteria = "safe-to-deploy"
-user-id = 220 # Stepan Koltsov (stepancheg)
-start = "2022-02-07"
-end = "2027-03-14"
-
-[[trusted.pulldown-cmark-to-cmark]]
-criteria = "safe-to-deploy"
-user-id = 980 # Sebastian Thiel (Byron)
-start = "2019-07-03"
-end = "2027-03-14"
-
-[[trusted.quote]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-04-09"
-end = "2027-03-14"
-
-[[trusted.ref-cast]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-05-05"
-end = "2027-03-14"
-
-[[trusted.ref-cast-impl]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-05-05"
-end = "2027-03-14"
-
-[[trusted.regex]]
-criteria = "safe-to-deploy"
-user-id = 189 # Andrew Gallant (BurntSushi)
-start = "2019-02-27"
-end = "2027-03-14"
-
-[[trusted.regex-automata]]
-criteria = "safe-to-deploy"
-user-id = 189 # Andrew Gallant (BurntSushi)
-start = "2019-02-25"
-end = "2027-03-14"
-
-[[trusted.regex-syntax]]
-criteria = "safe-to-deploy"
-user-id = 189 # Andrew Gallant (BurntSushi)
-start = "2019-03-30"
-end = "2027-03-14"
-
-[[trusted.reqwest]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.rustc-demangle]]
-criteria = "safe-to-deploy"
-user-id = 55123 # rust-lang-owner
-start = "2023-03-23"
-end = "2027-03-14"
-
 [[trusted.rustix]]
 criteria = "safe-to-deploy"
 user-id = 6825 # Dan Gohman (sunfishcode)
 start = "2021-10-29"
 end = "2027-02-14"
 
-[[trusted.ryu]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2019-05-02"
-end = "2027-03-14"
-
-[[trusted.scopeguard]]
-criteria = "safe-to-deploy"
-user-id = 2915 # Amanieu d'Antras (Amanieu)
-start = "2020-02-16"
-end = "2027-03-14"
-
-[[trusted.semver]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2021-05-25"
-end = "2027-03-14"
-
 [[trusted.serde_json]]
 criteria = "safe-to-deploy"
 user-id = 3618 # David Tolnay (dtolnay)
 start = "2019-02-28"
 end = "2027-02-14"
 
-[[trusted.slab]]
-criteria = "safe-to-deploy"
-user-id = 6741 # Alice Ryhl (Darksonn)
-start = "2021-10-13"
-end = "2027-03-14"
-
-[[trusted.socket2]]
-criteria = "safe-to-deploy"
-user-id = 6025 # Thomas de Zeeuw (Thomasdezeeuw)
-start = "2020-09-09"
-end = "2027-03-14"
-
 [[trusted.syn]]
 criteria = "safe-to-deploy"
 user-id = 3618 # David Tolnay (dtolnay)
@@ -644,350 +70,26 @@ user-id = 2915 # Amanieu d'Antras (Amanieu)
 start = "2019-09-07"
 end = "2027-02-16"
 
-[[trusted.time]]
-criteria = "safe-to-deploy"
-user-id = 15682 # Jacob Pratt (jhpratt)
-start = "2019-12-19"
-end = "2027-03-14"
-
-[[trusted.tinystr]]
-criteria = "safe-to-deploy"
-user-id = 1139 # Manish Goregaokar (Manishearth)
-start = "2021-01-14"
-end = "2027-03-14"
-
-[[trusted.tokio]]
-criteria = "safe-to-deploy"
-user-id = 6741 # Alice Ryhl (Darksonn)
-start = "2020-12-25"
-end = "2027-03-14"
-
-[[trusted.tokio-macros]]
-criteria = "safe-to-deploy"
-user-id = 6741 # Alice Ryhl (Darksonn)
-start = "2020-10-26"
-end = "2027-03-14"
-
-[[trusted.tokio-stream]]
-criteria = "safe-to-deploy"
-user-id = 6741 # Alice Ryhl (Darksonn)
-start = "2021-01-04"
-end = "2027-03-14"
-
-[[trusted.tokio-util]]
-criteria = "safe-to-deploy"
-user-id = 6741 # Alice Ryhl (Darksonn)
-start = "2021-01-12"
-end = "2027-03-14"
-
 [[trusted.toml]]
 criteria = "safe-to-deploy"
 user-id = 6743 # Ed Page (epage)
 start = "2022-12-14"
 end = "2027-02-16"
 
-[[trusted.toml_datetime]]
-criteria = "safe-to-deploy"
-user-id = 6743 # Ed Page (epage)
-start = "2022-10-21"
-end = "2027-03-14"
-
-[[trusted.toml_edit]]
-criteria = "safe-to-deploy"
-user-id = 6743 # Ed Page (epage)
-start = "2021-09-13"
-end = "2027-03-14"
-
 [[trusted.toml_parser]]
 criteria = "safe-to-deploy"
 user-id = 6743 # Ed Page (epage)
 start = "2025-07-08"
 end = "2027-02-16"
 
-[[trusted.tonic]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2019-10-02"
-end = "2027-03-14"
-
 [[trusted.tonic-build]]
 criteria = "safe-to-deploy"
-user-id = 10 # Carl Lerche (carllerche)
+user-id = 10
 start = "2019-09-10"
-end = "2027-03-14"
-
-[[trusted.tonic-build]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2019-10-02"
-end = "2027-03-14"
-
-[[trusted.tonic-prost]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2025-07-28"
-end = "2027-03-14"
-
-[[trusted.tonic-prost-build]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2025-07-28"
-end = "2027-03-14"
-
-[[trusted.tower]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2024-09-09"
-end = "2027-03-14"
-
-[[trusted.tower-http]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2024-09-23"
-end = "2027-03-14"
-
-[[trusted.tower-layer]]
-criteria = "safe-to-deploy"
-user-id = 10 # Carl Lerche (carllerche)
-start = "2019-04-27"
-end = "2027-03-14"
-
-[[trusted.tower-layer]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2019-09-11"
-end = "2027-03-14"
-
-[[trusted.tower-service]]
-criteria = "safe-to-deploy"
-user-id = 3959 # Lucio Franco (LucioFranco)
-start = "2019-08-20"
-end = "2027-03-14"
-
-[[trusted.tracing-subscriber]]
-criteria = "safe-to-deploy"
-user-id = 10 # Carl Lerche (carllerche)
-start = "2025-08-29"
-end = "2027-03-14"
-
-[[trusted.ucd-trie]]
-criteria = "safe-to-deploy"
-user-id = 189 # Andrew Gallant (BurntSushi)
-start = "2019-07-21"
-end = "2027-03-14"
-
-[[trusted.unicase]]
-criteria = "safe-to-deploy"
-user-id = 359 # Sean McArthur (seanmonstar)
-start = "2019-03-05"
-end = "2027-03-14"
-
-[[trusted.unicode-ident]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2021-10-02"
-end = "2027-03-14"
-
-[[trusted.url]]
-criteria = "safe-to-deploy"
-user-id = 1139 # Manish Goregaokar (Manishearth)
-start = "2021-02-18"
-end = "2027-03-14"
-
-[[trusted.uuid]]
-criteria = "safe-to-deploy"
-user-id = 3204 # Ashley Mannix (KodrAus)
-start = "2019-10-18"
-end = "2027-03-14"
-
-[[trusted.valuable]]
-criteria = "safe-to-deploy"
-user-id = 10 # Carl Lerche (carllerche)
-start = "2022-01-03"
-end = "2027-03-14"
-
-[[trusted.wait-timeout]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2025-02-03"
-end = "2027-03-14"
-
-[[trusted.wasi]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2020-06-03"
-end = "2027-03-14"
-
-[[trusted.wasi]]
-criteria = "safe-to-deploy"
-user-id = 6825 # Dan Gohman (sunfishcode)
-start = "2019-07-22"
-end = "2027-03-14"
-
-[[trusted.wasm-bindgen]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.wasm-bindgen-futures]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.wasm-bindgen-macro]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.wasm-bindgen-macro-support]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.wasm-bindgen-shared]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.web-sys]]
-criteria = "safe-to-deploy"
-user-id = 1 # Alex Crichton (alexcrichton)
-start = "2019-03-04"
-end = "2027-03-14"
-
-[[trusted.windows-core]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2021-11-15"
-end = "2027-03-14"
-
-[[trusted.windows-implement]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2022-01-27"
-end = "2027-03-14"
-
-[[trusted.windows-interface]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2022-02-18"
-end = "2027-03-14"
-
-[[trusted.windows-result]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2024-02-02"
-end = "2027-03-14"
-
-[[trusted.windows-strings]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2024-02-02"
-end = "2027-03-14"
+end = "2027-02-16"
 
 [[trusted.windows-sys]]
 criteria = "safe-to-deploy"
 user-id = 64539 # Kenny Kerr (kennykerr)
 start = "2021-11-15"
 end = "2027-02-16"
-
-[[trusted.windows-targets]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2022-09-09"
-end = "2027-03-14"
-
-[[trusted.windows_aarch64_gnullvm]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2022-09-01"
-end = "2027-03-14"
-
-[[trusted.windows_aarch64_msvc]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2021-11-05"
-end = "2027-03-14"
-
-[[trusted.windows_i686_gnu]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2021-10-28"
-end = "2027-03-14"
-
-[[trusted.windows_i686_gnullvm]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2024-04-02"
-end = "2027-03-14"
-
-[[trusted.windows_i686_msvc]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2021-10-27"
-end = "2027-03-14"
-
-[[trusted.windows_x86_64_gnu]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2021-10-28"
-end = "2027-03-14"
-
-[[trusted.windows_x86_64_gnullvm]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2022-09-01"
-end = "2027-03-14"
-
-[[trusted.windows_x86_64_msvc]]
-criteria = "safe-to-deploy"
-user-id = 64539 # Kenny Kerr (kennykerr)
-start = "2021-10-27"
-end = "2027-03-14"
-
-[[trusted.winnow]]
-criteria = "safe-to-deploy"
-user-id = 6743 # Ed Page (epage)
-start = "2023-02-22"
-end = "2027-03-14"
-
-[[trusted.yoke]]
-criteria = "safe-to-deploy"
-user-id = 1139 # Manish Goregaokar (Manishearth)
-start = "2021-05-01"
-end = "2027-03-14"
-
-[[trusted.zerocopy]]
-criteria = "safe-to-deploy"
-user-id = 7178 # Joshua Liebow-Feeser (joshlf)
-start = "2019-02-28"
-end = "2027-03-14"
-
-[[trusted.zerocopy-derive]]
-criteria = "safe-to-deploy"
-user-id = 7178 # Joshua Liebow-Feeser (joshlf)
-start = "2019-02-28"
-end = "2027-03-14"
-
-[[trusted.zerotrie]]
-criteria = "safe-to-deploy"
-user-id = 1139 # Manish Goregaokar (Manishearth)
-start = "2023-10-03"
-end = "2027-03-14"
-
-[[trusted.zerovec]]
-criteria = "safe-to-deploy"
-user-id = 1139 # Manish Goregaokar (Manishearth)
-start = "2021-04-19"
-end = "2027-03-14"
-
-[[trusted.zmij]]
-criteria = "safe-to-deploy"
-user-id = 3618 # David Tolnay (dtolnay)
-start = "2025-12-18"
-end = "2027-03-14"

server/supply-chain/config.toml

@@ -4,27 +4,30 @@
 [cargo-vet]
 version = "0.10"
 
-[imports.OpenDevicePartnership]
-url = "https://raw.githubusercontent.com/OpenDevicePartnership/rust-crate-audits/refs/heads/main/audits.toml"
-
 [imports.bytecode-alliance]
 url = "https://raw.githubusercontent.com/bytecodealliance/wasmtime/main/supply-chain/audits.toml"
 
-[imports.embark-studios]
-url = "https://raw.githubusercontent.com/EmbarkStudios/rust-ecosystem/main/audits.toml"
-
 [imports.google]
 url = "https://raw.githubusercontent.com/google/supply-chain/main/audits.toml"
 
-[imports.isrg]
-url = "https://raw.githubusercontent.com/divviup/libprio-rs/main/supply-chain/audits.toml"
-
 [imports.mozilla]
 url = "https://raw.githubusercontent.com/mozilla/supply-chain/main/audits.toml"
 
 [imports.zcash]
 url = "https://raw.githubusercontent.com/zcash/rust-ecosystem/main/supply-chain/audits.toml"
 
+[[exemptions.addr2line]]
+version = "0.25.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.aho-corasick]]
+version = "1.1.4"
+criteria = "safe-to-deploy"
+
+[[exemptions.anyhow]]
+version = "1.0.101"
+criteria = "safe-to-deploy"
+
 [[exemptions.asn1-rs]]
 version = "0.7.1"
 criteria = "safe-to-deploy"
@@ -37,6 +40,18 @@ criteria = "safe-to-deploy"
 version = "0.2.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.async-trait]]
+version = "0.1.89"
+criteria = "safe-to-deploy"
+
+[[exemptions.aws-lc-rs]]
+version = "1.15.4"
+criteria = "safe-to-deploy"
+
+[[exemptions.aws-lc-sys]]
+version = "0.37.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.axum]]
 version = "0.8.8"
 criteria = "safe-to-deploy"
@@ -45,6 +60,10 @@ criteria = "safe-to-deploy"
 version = "0.5.6"
 criteria = "safe-to-deploy"
 
+[[exemptions.backtrace]]
+version = "0.3.76"
+criteria = "safe-to-deploy"
+
 [[exemptions.backtrace-ext]]
 version = "0.2.1"
 criteria = "safe-to-deploy"
@@ -53,14 +72,26 @@ criteria = "safe-to-deploy"
 version = "0.9.1"
 criteria = "safe-to-deploy"
 
+[[exemptions.bitflags]]
+version = "2.10.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.block-buffer]]
 version = "0.11.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.bytes]]
+version = "1.11.1"
+criteria = "safe-to-deploy"
+
 [[exemptions.cc]]
 version = "1.2.55"
 criteria = "safe-to-deploy"
 
+[[exemptions.cfg-if]]
+version = "1.0.4"
+criteria = "safe-to-deploy"
+
 [[exemptions.chacha20]]
 version = "0.10.0"
 criteria = "safe-to-deploy"
@@ -69,14 +100,26 @@ criteria = "safe-to-deploy"
 version = "0.4.43"
 criteria = "safe-to-deploy"
 
+[[exemptions.cmake]]
+version = "0.1.57"
+criteria = "safe-to-deploy"
+
 [[exemptions.cpufeatures]]
 version = "0.2.17"
 criteria = "safe-to-deploy"
 
+[[exemptions.cpufeatures]]
+version = "0.3.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.crc32fast]]
 version = "1.5.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.crossbeam-utils]]
+version = "0.8.21"
+criteria = "safe-to-deploy"
+
 [[exemptions.crypto-common]]
 version = "0.2.0"
 criteria = "safe-to-deploy"
@@ -113,6 +156,10 @@ criteria = "safe-to-deploy"
 version = "10.0.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.deranged]]
+version = "0.5.5"
+criteria = "safe-to-deploy"
+
 [[exemptions.diesel]]
 version = "2.3.6"
 criteria = "safe-to-deploy"
@@ -145,6 +192,10 @@ criteria = "safe-to-deploy"
 version = "0.2.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.dyn-clone]]
+version = "1.0.20"
+criteria = "safe-to-deploy"
+
 [[exemptions.ed25519]]
 version = "3.0.0-rc.4"
 criteria = "safe-to-deploy"
@@ -153,6 +204,10 @@ criteria = "safe-to-deploy"
 version = "3.0.0-pre.6"
 criteria = "safe-to-deploy"
 
+[[exemptions.fiat-crypto]]
+version = "0.3.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.find-msvc-tools]]
 version = "0.1.9"
 criteria = "safe-to-deploy"
@@ -161,10 +216,22 @@ criteria = "safe-to-deploy"
 version = "0.5.7"
 criteria = "safe-to-deploy"
 
+[[exemptions.flate2]]
+version = "1.1.9"
+criteria = "safe-to-deploy"
+
 [[exemptions.fs_extra]]
 version = "1.3.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.futures-task]]
+version = "0.3.31"
+criteria = "safe-to-deploy"
+
+[[exemptions.futures-util]]
+version = "0.3.31"
+criteria = "safe-to-deploy"
+
 [[exemptions.getrandom]]
 version = "0.2.17"
 criteria = "safe-to-deploy"
@@ -177,10 +244,30 @@ criteria = "safe-to-deploy"
 version = "0.4.1"
 criteria = "safe-to-deploy"
 
+[[exemptions.hashbrown]]
+version = "0.14.5"
+criteria = "safe-to-deploy"
+
+[[exemptions.http]]
+version = "1.4.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.http-body-util]]
+version = "0.1.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.httparse]]
+version = "1.10.1"
+criteria = "safe-to-deploy"
+
 [[exemptions.hybrid-array]]
 version = "0.4.7"
 criteria = "safe-to-deploy"
 
+[[exemptions.hyper]]
+version = "1.8.1"
+criteria = "safe-to-deploy"
+
 [[exemptions.hyper-timeout]]
 version = "0.5.2"
 criteria = "safe-to-deploy"
@@ -189,6 +276,18 @@ criteria = "safe-to-deploy"
 version = "0.1.65"
 criteria = "safe-to-deploy"
 
+[[exemptions.id-arena]]
+version = "2.3.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.ident_case]]
+version = "1.0.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.indexmap]]
+version = "2.13.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.is_ci]]
 version = "1.2.0"
 criteria = "safe-to-deploy"
@@ -197,6 +296,14 @@ criteria = "safe-to-deploy"
 version = "0.14.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.itoa]]
+version = "1.0.17"
+criteria = "safe-to-deploy"
+
+[[exemptions.jobserver]]
+version = "0.1.34"
+criteria = "safe-to-deploy"
+
 [[exemptions.js-sys]]
 version = "0.3.85"
 criteria = "safe-to-deploy"
@@ -213,10 +320,26 @@ criteria = "safe-to-deploy"
 version = "0.35.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.linux-raw-sys]]
+version = "0.11.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.lock_api]]
+version = "0.4.14"
+criteria = "safe-to-deploy"
+
+[[exemptions.log]]
+version = "0.4.29"
+criteria = "safe-to-deploy"
+
 [[exemptions.matchit]]
 version = "0.8.4"
 criteria = "safe-to-deploy"
 
+[[exemptions.memchr]]
+version = "2.8.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.memsafe]]
 version = "0.4.0"
 criteria = "safe-to-deploy"
@@ -237,14 +360,34 @@ criteria = "safe-to-deploy"
 version = "2.3.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.mime]]
+version = "0.3.17"
+criteria = "safe-to-deploy"
+
 [[exemptions.minimal-lexical]]
 version = "0.2.1"
 criteria = "safe-to-deploy"
 
+[[exemptions.mio]]
+version = "1.1.1"
+criteria = "safe-to-deploy"
+
 [[exemptions.multimap]]
 version = "0.10.1"
 criteria = "safe-to-deploy"
 
+[[exemptions.num-bigint]]
+version = "0.4.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.num-conv]]
+version = "0.2.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.object]]
+version = "0.37.3"
+criteria = "safe-to-deploy"
+
 [[exemptions.oid-registry]]
 version = "0.8.1"
 criteria = "safe-to-deploy"
@@ -257,6 +400,14 @@ criteria = "safe-to-deploy"
 version = "4.2.3"
 criteria = "safe-to-deploy"
 
+[[exemptions.parking_lot]]
+version = "0.12.5"
+criteria = "safe-to-deploy"
+
+[[exemptions.parking_lot_core]]
+version = "0.9.12"
+criteria = "safe-to-deploy"
+
 [[exemptions.pem]]
 version = "3.0.6"
 criteria = "safe-to-deploy"
@@ -273,14 +424,58 @@ criteria = "safe-to-deploy"
 version = "1.1.10"
 criteria = "safe-to-deploy"
 
+[[exemptions.portable-atomic]]
+version = "1.13.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.prettyplease]]
+version = "0.2.37"
+criteria = "safe-to-deploy"
+
+[[exemptions.proc-macro2]]
+version = "1.0.106"
+criteria = "safe-to-deploy"
+
+[[exemptions.prost]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.prost-build]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.prost-derive]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.prost-types]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
 [[exemptions.pulldown-cmark]]
 version = "0.13.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.pulldown-cmark-to-cmark]]
+version = "22.0.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.quote]]
+version = "1.0.44"
+criteria = "safe-to-deploy"
+
 [[exemptions.r-efi]]
 version = "5.3.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.rand]]
+version = "0.10.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.rand_core]]
+version = "0.10.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.rcgen]]
 version = "0.14.7"
 criteria = "safe-to-deploy"
@@ -289,6 +484,18 @@ criteria = "safe-to-deploy"
 version = "0.5.18"
 criteria = "safe-to-deploy"
 
+[[exemptions.regex]]
+version = "1.12.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.regex-automata]]
+version = "0.4.14"
+criteria = "safe-to-deploy"
+
+[[exemptions.regex-syntax]]
+version = "0.8.9"
+criteria = "safe-to-deploy"
+
 [[exemptions.ring]]
 version = "0.17.14"
 criteria = "safe-to-deploy"
@@ -297,6 +504,10 @@ criteria = "safe-to-deploy"
 version = "0.1.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.rustc-demangle]]
+version = "0.1.27"
+criteria = "safe-to-deploy"
+
 [[exemptions.rusticata-macros]]
 version = "4.1.0"
 criteria = "safe-to-deploy"
@@ -317,6 +528,10 @@ criteria = "safe-to-deploy"
 version = "0.1.4"
 criteria = "safe-to-deploy"
 
+[[exemptions.scopeguard]]
+version = "1.2.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.secrecy]]
 version = "0.10.3"
 criteria = "safe-to-deploy"
@@ -325,6 +540,18 @@ criteria = "safe-to-deploy"
 version = "1.0.27"
 criteria = "safe-to-deploy"
 
+[[exemptions.serde]]
+version = "1.0.228"
+criteria = "safe-to-deploy"
+
+[[exemptions.serde_core]]
+version = "1.0.228"
+criteria = "safe-to-deploy"
+
+[[exemptions.serde_derive]]
+version = "1.0.228"
+criteria = "safe-to-deploy"
+
 [[exemptions.sha2]]
 version = "0.11.0-rc.5"
 criteria = "safe-to-deploy"
@@ -341,6 +568,10 @@ criteria = "safe-to-deploy"
 version = "0.3.8"
 criteria = "safe-to-deploy"
 
+[[exemptions.slab]]
+version = "0.4.12"
+criteria = "safe-to-deploy"
+
 [[exemptions.smlang]]
 version = "0.8.0"
 criteria = "safe-to-deploy"
@@ -349,6 +580,10 @@ criteria = "safe-to-deploy"
 version = "0.8.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.socket2]]
+version = "0.6.2"
+criteria = "safe-to-deploy"
+
 [[exemptions.sqlite-wasm-rs]]
 version = "0.5.2"
 criteria = "safe-to-deploy"
@@ -357,6 +592,10 @@ criteria = "safe-to-deploy"
 version = "0.1.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.subtle]]
+version = "2.6.1"
+criteria = "safe-to-deploy"
+
 [[exemptions.supports-color]]
 version = "3.0.2"
 criteria = "safe-to-deploy"
@@ -381,10 +620,74 @@ criteria = "safe-to-deploy"
 version = "0.4.3"
 criteria = "safe-to-deploy"
 
+[[exemptions.thiserror]]
+version = "2.0.18"
+criteria = "safe-to-deploy"
+
+[[exemptions.thiserror-impl]]
+version = "2.0.18"
+criteria = "safe-to-deploy"
+
+[[exemptions.time]]
+version = "0.3.47"
+criteria = "safe-to-deploy"
+
+[[exemptions.time-core]]
+version = "0.1.8"
+criteria = "safe-to-deploy"
+
+[[exemptions.time-macros]]
+version = "0.2.27"
+criteria = "safe-to-deploy"
+
+[[exemptions.tokio]]
+version = "1.49.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.tokio-macros]]
+version = "2.6.0"
+criteria = "safe-to-deploy"
+
 [[exemptions.tokio-rustls]]
 version = "0.26.4"
 criteria = "safe-to-deploy"
 
+[[exemptions.tokio-stream]]
+version = "0.1.18"
+criteria = "safe-to-deploy"
+
+[[exemptions.tokio-util]]
+version = "0.7.18"
+criteria = "safe-to-deploy"
+
+[[exemptions.tonic]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.tonic-build]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.tonic-prost]]
+version = "0.14.4"
+criteria = "safe-to-deploy"
+
+[[exemptions.tonic-prost-build]]
+version = "0.14.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.tower]]
+version = "0.5.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.tower-layer]]
+version = "0.3.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.tower-service]]
+version = "0.3.3"
+criteria = "safe-to-deploy"
+
 [[exemptions.tracing]]
 version = "0.1.44"
 criteria = "safe-to-deploy"
@@ -405,10 +708,34 @@ criteria = "safe-to-run"
 version = "1.19.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.unicase]]
+version = "2.9.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.unicode-ident]]
+version = "1.0.23"
+criteria = "safe-to-deploy"
+
+[[exemptions.untrusted]]
+version = "0.7.1"
+criteria = "safe-to-deploy"
+
 [[exemptions.untrusted]]
 version = "0.9.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.uuid]]
+version = "1.20.0"
+criteria = "safe-to-deploy"
+
+[[exemptions.wasi]]
+version = "0.11.1+wasi-snapshot-preview1"
+criteria = "safe-to-deploy"
+
+[[exemptions.wasm-bindgen]]
+version = "0.2.108"
+criteria = "safe-to-deploy"
+
 [[exemptions.wasm-bindgen-macro]]
 version = "0.2.108"
 criteria = "safe-to-deploy"
@@ -433,6 +760,102 @@ criteria = "safe-to-deploy"
 version = "0.4.0"
 criteria = "safe-to-deploy"
 
+[[exemptions.windows-core]]
+version = "0.62.2"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows-implement]]
+version = "0.60.2"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows-interface]]
+version = "0.59.3"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows-result]]
+version = "0.4.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows-strings]]
+version = "0.5.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows-targets]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows-targets]]
+version = "0.53.5"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_aarch64_gnullvm]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_aarch64_gnullvm]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_aarch64_msvc]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_aarch64_msvc]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_i686_gnu]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_i686_gnu]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_i686_gnullvm]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_i686_gnullvm]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_i686_msvc]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_i686_msvc]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_x86_64_gnu]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_x86_64_gnu]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_x86_64_gnullvm]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_x86_64_gnullvm]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_x86_64_msvc]]
+version = "0.52.6"
+criteria = "safe-to-deploy"
+
+[[exemptions.windows_x86_64_msvc]]
+version = "0.53.1"
+criteria = "safe-to-deploy"
+
+[[exemptions.winnow]]
+version = "0.7.14"
+criteria = "safe-to-deploy"
+
 [[exemptions.x509-parser]]
 version = "0.18.1"
 criteria = "safe-to-deploy"
@@ -441,6 +864,10 @@ criteria = "safe-to-deploy"
 version = "0.5.2"
 criteria = "safe-to-deploy"
 
+[[exemptions.zmij]]
+version = "1.0.20"
+criteria = "safe-to-deploy"
+
 [[exemptions.zstd]]
 version = "0.13.3"
 criteria = "safe-to-deploy"

useragent/.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.

useragent/.dart_tool/extension_discovery/vs_code.json

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

useragent/.dart_tool/package_config.json

@@ -1,172 +0,0 @@
-{
-  "configVersion": 2,
-  "packages": [
-    {
-      "name": "async",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/async-2.13.0",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "boolean_selector",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/boolean_selector-2.1.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.1"
-    },
-    {
-      "name": "characters",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/characters-1.4.0",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "clock",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/clock-1.1.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "collection",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/collection-1.19.1",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "fake_async",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/fake_async-1.3.3",
-      "packageUri": "lib/",
-      "languageVersion": "3.3"
-    },
-    {
-      "name": "flutter",
-      "rootUri": "file:///Users/kaska/.local/share/mise/installs/flutter/3.38.9-stable/packages/flutter",
-      "packageUri": "lib/",
-      "languageVersion": "3.8"
-    },
-    {
-      "name": "flutter_lints",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/flutter_lints-6.0.0",
-      "packageUri": "lib/",
-      "languageVersion": "3.8"
-    },
-    {
-      "name": "flutter_test",
-      "rootUri": "file:///Users/kaska/.local/share/mise/installs/flutter/3.38.9-stable/packages/flutter_test",
-      "packageUri": "lib/",
-      "languageVersion": "3.8"
-    },
-    {
-      "name": "leak_tracker",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/leak_tracker-11.0.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.2"
-    },
-    {
-      "name": "leak_tracker_flutter_testing",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/leak_tracker_flutter_testing-3.0.10",
-      "packageUri": "lib/",
-      "languageVersion": "3.2"
-    },
-    {
-      "name": "leak_tracker_testing",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/leak_tracker_testing-3.0.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.2"
-    },
-    {
-      "name": "lints",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/lints-6.1.0",
-      "packageUri": "lib/",
-      "languageVersion": "3.8"
-    },
-    {
-      "name": "matcher",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/matcher-0.12.17",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "material_color_utilities",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/material_color_utilities-0.11.1",
-      "packageUri": "lib/",
-      "languageVersion": "2.17"
-    },
-    {
-      "name": "meta",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/meta-1.17.0",
-      "packageUri": "lib/",
-      "languageVersion": "3.5"
-    },
-    {
-      "name": "path",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/path-1.9.1",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "sky_engine",
-      "rootUri": "file:///Users/kaska/.local/share/mise/installs/flutter/3.38.9-stable/bin/cache/pkg/sky_engine",
-      "packageUri": "lib/",
-      "languageVersion": "3.8"
-    },
-    {
-      "name": "source_span",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/source_span-1.10.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.1"
-    },
-    {
-      "name": "stack_trace",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/stack_trace-1.12.1",
-      "packageUri": "lib/",
-      "languageVersion": "3.4"
-    },
-    {
-      "name": "stream_channel",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/stream_channel-2.1.4",
-      "packageUri": "lib/",
-      "languageVersion": "3.3"
-    },
-    {
-      "name": "string_scanner",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/string_scanner-1.4.1",
-      "packageUri": "lib/",
-      "languageVersion": "3.1"
-    },
-    {
-      "name": "term_glyph",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/term_glyph-1.2.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.1"
-    },
-    {
-      "name": "test_api",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/test_api-0.7.7",
-      "packageUri": "lib/",
-      "languageVersion": "3.5"
-    },
-    {
-      "name": "vector_math",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/vector_math-2.2.0",
-      "packageUri": "lib/",
-      "languageVersion": "3.1"
-    },
-    {
-      "name": "vm_service",
-      "rootUri": "file:///Users/kaska/.pub-cache/hosted/pub.dev/vm_service-15.0.2",
-      "packageUri": "lib/",
-      "languageVersion": "3.5"
-    },
-    {
-      "name": "arbiter",
-      "rootUri": "../",
-      "packageUri": "lib/",
-      "languageVersion": "3.10"
-    }
-  ],
-  "generator": "pub",
-  "generatorVersion": "3.10.8",
-  "flutterRoot": "file:///Users/kaska/.local/share/mise/installs/flutter/3.38.9-stable",
-  "flutterVersion": "3.38.9",
-  "pubCache": "file:///Users/kaska/.pub-cache"
-}

useragent/.dart_tool/package_graph.json

@@ -1,224 +0,0 @@
-{
-  "roots": [
-    "arbiter"
-  ],
-  "packages": [
-    {
-      "name": "arbiter",
-      "version": "0.1.0",
-      "dependencies": [
-        "flutter"
-      ],
-      "devDependencies": [
-        "flutter_lints",
-        "flutter_test"
-      ]
-    },
-    {
-      "name": "flutter_lints",
-      "version": "6.0.0",
-      "dependencies": [
-        "lints"
-      ]
-    },
-    {
-      "name": "flutter_test",
-      "version": "0.0.0",
-      "dependencies": [
-        "clock",
-        "collection",
-        "fake_async",
-        "flutter",
-        "leak_tracker_flutter_testing",
-        "matcher",
-        "meta",
-        "path",
-        "stack_trace",
-        "stream_channel",
-        "test_api",
-        "vector_math"
-      ]
-    },
-    {
-      "name": "flutter",
-      "version": "0.0.0",
-      "dependencies": [
-        "characters",
-        "collection",
-        "material_color_utilities",
-        "meta",
-        "sky_engine",
-        "vector_math"
-      ]
-    },
-    {
-      "name": "lints",
-      "version": "6.1.0",
-      "dependencies": []
-    },
-    {
-      "name": "stream_channel",
-      "version": "2.1.4",
-      "dependencies": [
-        "async"
-      ]
-    },
-    {
-      "name": "meta",
-      "version": "1.17.0",
-      "dependencies": []
-    },
-    {
-      "name": "collection",
-      "version": "1.19.1",
-      "dependencies": []
-    },
-    {
-      "name": "leak_tracker_flutter_testing",
-      "version": "3.0.10",
-      "dependencies": [
-        "flutter",
-        "leak_tracker",
-        "leak_tracker_testing",
-        "matcher",
-        "meta"
-      ]
-    },
-    {
-      "name": "vector_math",
-      "version": "2.2.0",
-      "dependencies": []
-    },
-    {
-      "name": "stack_trace",
-      "version": "1.12.1",
-      "dependencies": [
-        "path"
-      ]
-    },
-    {
-      "name": "clock",
-      "version": "1.1.2",
-      "dependencies": []
-    },
-    {
-      "name": "fake_async",
-      "version": "1.3.3",
-      "dependencies": [
-        "clock",
-        "collection"
-      ]
-    },
-    {
-      "name": "path",
-      "version": "1.9.1",
-      "dependencies": []
-    },
-    {
-      "name": "matcher",
-      "version": "0.12.17",
-      "dependencies": [
-        "async",
-        "meta",
-        "stack_trace",
-        "term_glyph",
-        "test_api"
-      ]
-    },
-    {
-      "name": "test_api",
-      "version": "0.7.7",
-      "dependencies": [
-        "async",
-        "boolean_selector",
-        "collection",
-        "meta",
-        "source_span",
-        "stack_trace",
-        "stream_channel",
-        "string_scanner",
-        "term_glyph"
-      ]
-    },
-    {
-      "name": "sky_engine",
-      "version": "0.0.0",
-      "dependencies": []
-    },
-    {
-      "name": "material_color_utilities",
-      "version": "0.11.1",
-      "dependencies": [
-        "collection"
-      ]
-    },
-    {
-      "name": "characters",
-      "version": "1.4.0",
-      "dependencies": []
-    },
-    {
-      "name": "async",
-      "version": "2.13.0",
-      "dependencies": [
-        "collection",
-        "meta"
-      ]
-    },
-    {
-      "name": "leak_tracker_testing",
-      "version": "3.0.2",
-      "dependencies": [
-        "leak_tracker",
-        "matcher",
-        "meta"
-      ]
-    },
-    {
-      "name": "leak_tracker",
-      "version": "11.0.2",
-      "dependencies": [
-        "clock",
-        "collection",
-        "meta",
-        "path",
-        "vm_service"
-      ]
-    },
-    {
-      "name": "term_glyph",
-      "version": "1.2.2",
-      "dependencies": []
-    },
-    {
-      "name": "string_scanner",
-      "version": "1.4.1",
-      "dependencies": [
-        "source_span"
-      ]
-    },
-    {
-      "name": "source_span",
-      "version": "1.10.2",
-      "dependencies": [
-        "collection",
-        "path",
-        "term_glyph"
-      ]
-    },
-    {
-      "name": "boolean_selector",
-      "version": "2.1.2",
-      "dependencies": [
-        "source_span",
-        "string_scanner"
-      ]
-    },
-    {
-      "name": "vm_service",
-      "version": "15.0.2",
-      "dependencies": []
-    }
-  ],
-  "configVersion": 1
-}

useragent/.dart_tool/version

@@ -1 +0,0 @@
-3.38.9

useragent/macos/Flutter/ephemeral/Flutter-Generated.xcconfig

@@ -1,11 +0,0 @@
-// This is a generated file; do not edit or check into version control.
-FLUTTER_ROOT=/Users/kaska/.local/share/mise/installs/flutter/3.38.9-stable
-FLUTTER_APPLICATION_PATH=/Users/kaska/Documents/Projects/Major/arbiter/useragent
-COCOAPODS_PARALLEL_CODE_SIGN=true
-FLUTTER_BUILD_DIR=build
-FLUTTER_BUILD_NAME=0.1.0
-FLUTTER_BUILD_NUMBER=0.1.0
-DART_OBFUSCATION=false
-TRACK_WIDGET_CREATION=true
-TREE_SHAKE_ICONS=false
-PACKAGE_CONFIG=.dart_tool/package_config.json

useragent/macos/Flutter/ephemeral/flutter_export_environment.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-# This is a generated file; do not edit or check into version control.
-export "FLUTTER_ROOT=/Users/kaska/.local/share/mise/installs/flutter/3.38.9-stable"
-export "FLUTTER_APPLICATION_PATH=/Users/kaska/Documents/Projects/Major/arbiter/useragent"
-export "COCOAPODS_PARALLEL_CODE_SIGN=true"
-export "FLUTTER_BUILD_DIR=build"
-export "FLUTTER_BUILD_NAME=0.1.0"
-export "FLUTTER_BUILD_NUMBER=0.1.0"
-export "DART_OBFUSCATION=false"
-export "TRACK_WIDGET_CREATION=true"
-export "TREE_SHAKE_ICONS=false"
-export "PACKAGE_CONFIG=.dart_tool/package_config.json"