Merge branch 'main' into security-hash-revoke_at

2026-06-09 20:58:07 +02:00
parent 32f317384d 3c482da917
commit 303120c9ac
233 changed files with 16624 additions and 4885 deletions
--- a/server/crates/arbiter-server/src/grpc/client.rs
+++ b/server/crates/arbiter-server/src/grpc/client.rs
@@ -1,3 +1,7 @@
+use crate::{
+    grpc::request_tracker::RequestTracker,
+    peers::client::{ClientConnection, session::ClientSession},
+};
 use arbiter_proto::{
    proto::client::{
        ClientRequest, ClientResponse, client_request::Payload as ClientRequestPayload,
@@ -5,15 +9,11 @@ use arbiter_proto::{
    },
    transport::{Receiver, Sender, grpc::GrpcBi},
 };
+
 use kameo::actor::{ActorRef, Spawn as _};
 use tonic::Status;
 use tracing::{info, warn};

-use crate::{
-    actors::client::{ClientConnection, session::ClientSession},
-    grpc::request_tracker::RequestTracker,
-};
-
 mod auth;
 mod evm;
 mod inbound;
@@ -98,8 +98,7 @@ pub async fn start(mut conn: ClientConnection, mut bi: GrpcBi<ClientRequest, Cli
        Err(err) => {
            let _ = bi
                .send(Err(Status::unauthenticated(format!(
-                    "Authentication failed: {}",
-                    err
+                    "Authentication failed: {err}",
                ))))
                .await;
            warn!(error = ?err, "Client authentication failed");
--- a/server/crates/arbiter-server/src/grpc/client/auth.rs
+++ b/server/crates/arbiter-server/src/grpc/client/auth.rs
@@ -1,3 +1,7 @@
+use crate::{
+    grpc::{Convert, request_tracker::RequestTracker},
+    peers::client::{ClientConnection, auth},
+};
 use arbiter_crypto::authn;
 use arbiter_proto::{
    ClientMetadata,
@@ -17,22 +21,18 @@ use arbiter_proto::{
    },
    transport::{Bi, Error as TransportError, Receiver, Sender, grpc::GrpcBi},
 };
+
 use async_trait::async_trait;
 use tonic::Status;
 use tracing::warn;

-use crate::{
-    actors::client::{self, ClientConnection, auth},
-    grpc::request_tracker::RequestTracker,
-};
-
-pub struct AuthTransportAdapter<'a> {
+pub(super) struct AuthTransportAdapter<'a> {
    bi: &'a mut GrpcBi<ClientRequest, ClientResponse>,
    request_tracker: &'a mut RequestTracker,
 }

 impl<'a> AuthTransportAdapter<'a> {
-    pub fn new(
+    pub(super) const fn new(
        bi: &'a mut GrpcBi<ClientRequest, ClientResponse>,
        request_tracker: &'a mut RequestTracker,
    ) -> Self {
@@ -42,40 +42,6 @@ impl<'a> AuthTransportAdapter<'a> {
        }
    }

-    fn response_to_proto(response: auth::Outbound) -> AuthResponsePayload {
-        match response {
-            auth::Outbound::AuthChallenge { pubkey, nonce } => {
-                AuthResponsePayload::Challenge(ProtoAuthChallenge {
-                    pubkey: pubkey.to_bytes(),
-                    nonce,
-                })
-            }
-            auth::Outbound::AuthSuccess => {
-                AuthResponsePayload::Result(ProtoAuthResult::Success.into())
-            }
-        }
-    }
-
-    fn error_to_proto(error: auth::Error) -> AuthResponsePayload {
-        AuthResponsePayload::Result(
-            match error {
-                auth::Error::InvalidChallengeSolution => ProtoAuthResult::InvalidSignature,
-                auth::Error::ApproveError(auth::ApproveError::Denied) => {
-                    ProtoAuthResult::ApprovalDenied
-                }
-                auth::Error::ApproveError(auth::ApproveError::Upstream(
-                    crate::actors::flow_coordinator::ApprovalError::NoUserAgentsConnected,
-                )) => ProtoAuthResult::NoUserAgentsOnline,
-                auth::Error::ApproveError(auth::ApproveError::Internal)
-                | auth::Error::DatabasePoolUnavailable
-                | auth::Error::DatabaseOperationFailed
-                | auth::Error::IntegrityCheckFailed
-                | auth::Error::Transport => ProtoAuthResult::Internal,
-            }
-            .into(),
-        )
-    }
-
    async fn send_client_response(
        &mut self,
        payload: AuthResponsePayload,
@@ -103,8 +69,8 @@ impl Sender<Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {
        item: Result<auth::Outbound, auth::Error>,
    ) -> Result<(), TransportError> {
        let payload = match item {
-            Ok(message) => AuthTransportAdapter::response_to_proto(message),
-            Err(err) => AuthTransportAdapter::error_to_proto(err),
+            Ok(message) => message.convert(),
+            Err(err) => err.convert(),
        };

        self.send_client_response(payload).await
@@ -167,7 +133,7 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
                };
                Some(auth::Inbound::AuthChallengeRequest {
                    pubkey,
-                    metadata: client_metadata_from_proto(client_info),
+                    metadata: client_info.convert(),
                })
            }
            AuthRequestPayload::ChallengeSolution(ProtoAuthChallengeSolution { signature }) => {
@@ -185,19 +151,69 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {

 impl Bi<auth::Inbound, Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {}

-fn client_metadata_from_proto(metadata: ProtoClientInfo) -> ClientMetadata {
-    ClientMetadata {
-        name: metadata.name,
-        description: metadata.description,
-        version: metadata.version,
+impl Convert for ProtoClientInfo {
+    type Output = ClientMetadata;
+
+    fn convert(self) -> Self::Output {
+        ClientMetadata {
+            name: self.name,
+            description: self.description,
+            version: self.version,
+        }
    }
 }

-pub async fn start(
+impl Convert for auth::Error {
+    type Output = AuthResponsePayload;
+
+    fn convert(self) -> Self::Output {
+        use auth::Error::{
+            ApproveError, DatabaseOperationFailed, DatabasePoolUnavailable, IntegrityCheckFailed,
+            InvalidChallengeSolution, Transport,
+        };
+        AuthResponsePayload::Result(
+            match self {
+                InvalidChallengeSolution => ProtoAuthResult::InvalidSignature,
+                ApproveError(auth::ApproveError::Denied) => ProtoAuthResult::ApprovalDenied,
+                ApproveError(auth::ApproveError::Upstream(
+                    crate::actors::flow_coordinator::ApprovalError::NoOperatorsConnected,
+                )) => ProtoAuthResult::NoOperatorsOnline,
+                ApproveError(auth::ApproveError::Internal)
+                | DatabasePoolUnavailable
+                | DatabaseOperationFailed
+                | IntegrityCheckFailed
+                | Transport => ProtoAuthResult::Internal,
+            }
+            .into(),
+        )
+    }
+}
+
+impl Convert for auth::Outbound {
+    type Output = AuthResponsePayload;
+
+    fn convert(self) -> Self::Output {
+        match self {
+            Self::AuthChallenge { challenge } => {
+                AuthResponsePayload::Challenge(ProtoAuthChallenge {
+                    timestamp_nanos: challenge
+                        .timestamp
+                        .timestamp_nanos_opt()
+                        .expect("timestamp within range")
+                        as u64,
+                    random: challenge.nonce.to_vec(),
+                })
+            }
+            Self::AuthSuccess => AuthResponsePayload::Result(ProtoAuthResult::Success.into()),
+        }
+    }
+}
+
+pub(super) async fn start(
    conn: &mut ClientConnection,
    bi: &mut GrpcBi<ClientRequest, ClientResponse>,
    request_tracker: &mut RequestTracker,
 ) -> Result<i32, auth::Error> {
    let mut transport = AuthTransportAdapter::new(bi, request_tracker);
-    client::auth::authenticate(conn, &mut transport).await
+    auth::authenticate(conn, &mut transport).await
 }
--- a/server/crates/arbiter-server/src/grpc/client/evm.rs
+++ b/server/crates/arbiter-server/src/grpc/client/evm.rs
@@ -1,3 +1,10 @@
+use crate::{
+    grpc::{
+        Convert, TryConvert,
+        common::inbound::{RawEvmAddress, RawEvmTransaction},
+    },
+    peers::client::session::{ClientSession, HandleSignTransaction, SignTransactionRpcError},
+};
 use arbiter_proto::proto::{
    client::{
        client_response::Payload as ClientResponsePayload,
@@ -11,19 +18,12 @@ use arbiter_proto::proto::{
        evm_sign_transaction_response::Result as EvmSignTransactionResult,
    },
 };
+
 use kameo::actor::ActorRef;
 use tonic::Status;
 use tracing::warn;

-use crate::{
-    actors::client::session::{ClientSession, HandleSignTransaction, SignTransactionRpcError},
-    grpc::{
-        Convert, TryConvert,
-        common::inbound::{RawEvmAddress, RawEvmTransaction},
-    },
-};
-
-fn wrap_response(payload: EvmResponsePayload) -> ClientResponsePayload {
+const fn wrap_response(payload: EvmResponsePayload) -> ClientResponsePayload {
    ClientResponsePayload::Evm(proto_evm::Response {
        payload: Some(payload),
    })
--- a/server/crates/arbiter-server/src/grpc/client/vault.rs
+++ b/server/crates/arbiter-server/src/grpc/client/vault.rs
@@ -1,3 +1,7 @@
+use crate::{
+    actors::vault::VaultState,
+    peers::client::session::{ClientSession, Error, HandleQueryVaultState},
+};
 use arbiter_proto::proto::{
    client::{
        client_response::Payload as ClientResponsePayload,
@@ -8,15 +12,11 @@ use arbiter_proto::proto::{
    },
    shared::VaultState as ProtoVaultState,
 };
+
 use kameo::{actor::ActorRef, error::SendError};
 use tonic::Status;
 use tracing::warn;

-use crate::actors::{
-    client::session::{ClientSession, Error, HandleQueryVaultState},
-    keyholder::KeyHolderState,
-};
-
 pub(super) async fn dispatch(
    actor: &ActorRef<ClientSession>,
    req: proto_vault::Request,
@@ -28,11 +28,11 @@ pub(super) async fn dispatch(
    };

    match payload {
-        VaultRequestPayload::QueryState(_) => {
+        VaultRequestPayload::QueryState(()) => {
            let state = match actor.ask(HandleQueryVaultState {}).await {
-                Ok(KeyHolderState::Unbootstrapped) => ProtoVaultState::Unbootstrapped,
-                Ok(KeyHolderState::Sealed) => ProtoVaultState::Sealed,
-                Ok(KeyHolderState::Unsealed) => ProtoVaultState::Unsealed,
+                Ok(VaultState::Unbootstrapped) => ProtoVaultState::Unbootstrapped,
+                Ok(VaultState::Sealed) => ProtoVaultState::Sealed,
+                Ok(VaultState::Unsealed) => ProtoVaultState::Unsealed,
                Err(SendError::HandlerError(Error::Internal)) => ProtoVaultState::Error,
                Err(err) => {
                    warn!(error = ?err, "Failed to query vault state");
--- a/server/crates/arbiter-server/src/grpc/common.rs
+++ b/server/crates/arbiter-server/src/grpc/common.rs
@@ -1,2 +1,2 @@
-pub mod inbound;
-pub mod outbound;
+pub(super) mod inbound;
+pub(super) mod outbound;
--- a/server/crates/arbiter-server/src/grpc/common/inbound.rs
+++ b/server/crates/arbiter-server/src/grpc/common/inbound.rs
@@ -1,8 +1,8 @@
-use alloy::{consensus::TxEip1559, primitives::Address, rlp::Decodable as _};
-
 use crate::grpc::TryConvert;

-pub struct RawEvmAddress(pub Vec<u8>);
+use alloy::{consensus::TxEip1559, primitives::Address, rlp::Decodable as _};
+
+pub(in crate::grpc) struct RawEvmAddress(pub(in crate::grpc) Vec<u8>);
 impl TryConvert for RawEvmAddress {
    type Output = Address;

@@ -21,7 +21,7 @@ impl TryConvert for RawEvmAddress {
    }
 }

-pub struct RawEvmTransaction(pub Vec<u8>);
+pub(in crate::grpc) struct RawEvmTransaction(pub(in crate::grpc) Vec<u8>);
 impl TryConvert for RawEvmTransaction {
    type Output = TxEip1559;

--- a/server/crates/arbiter-server/src/grpc/common/outbound.rs
+++ b/server/crates/arbiter-server/src/grpc/common/outbound.rs
@@ -1,4 +1,10 @@
-use alloy::primitives::U256;
+use crate::{
+    evm::{
+        PolicyError, VetError,
+        policies::{EvalViolation, SpecificMeaning},
+    },
+    grpc::Convert,
+};
 use arbiter_proto::proto::{
    evm::{
        EvmError as ProtoEvmError,
@@ -14,13 +20,7 @@ use arbiter_proto::proto::{
    },
 };

-use crate::{
-    evm::{
-        PolicyError, VetError,
-        policies::{EvalViolation, SpecificMeaning},
-    },
-    grpc::Convert,
-};
+use alloy::primitives::U256;

 fn u256_to_proto_bytes(value: U256) -> Vec<u8> {
    value.to_be_bytes::<32>().to_vec()
@@ -31,16 +31,16 @@ impl Convert for SpecificMeaning {

    fn convert(self) -> Self::Output {
        let kind = match self {
-            SpecificMeaning::EtherTransfer(meaning) => ProtoSpecificMeaningKind::EtherTransfer(
+            Self::EtherTransfer(meaning) => ProtoSpecificMeaningKind::EtherTransfer(
                arbiter_proto::proto::shared::evm::EtherTransferMeaning {
                    to: meaning.to.to_vec(),
                    value: u256_to_proto_bytes(meaning.value),
                },
            ),
-            SpecificMeaning::TokenTransfer(meaning) => ProtoSpecificMeaningKind::TokenTransfer(
+            Self::TokenTransfer(meaning) => ProtoSpecificMeaningKind::TokenTransfer(
                arbiter_proto::proto::shared::evm::TokenTransferMeaning {
                    token: Some(ProtoTokenInfo {
-                        symbol: meaning.token.symbol.to_string(),
+                        symbol: meaning.token.symbol.to_owned(),
                        address: meaning.token.contract.to_vec(),
                        chain_id: meaning.token.chain,
                    }),
@@ -61,25 +61,21 @@ impl Convert for EvalViolation {

    fn convert(self) -> Self::Output {
        let kind = match self {
-            EvalViolation::InvalidTarget { target } => {
+            Self::InvalidTarget { target } => {
                ProtoEvalViolationKind::InvalidTarget(target.to_vec())
            }
-            EvalViolation::GasLimitExceeded {
+            Self::GasLimitExceeded {
                max_gas_fee_per_gas,
                max_priority_fee_per_gas,
            } => ProtoEvalViolationKind::GasLimitExceeded(GasLimitExceededViolation {
                max_gas_fee_per_gas: max_gas_fee_per_gas.map(u256_to_proto_bytes),
                max_priority_fee_per_gas: max_priority_fee_per_gas.map(u256_to_proto_bytes),
            }),
-            EvalViolation::RateLimitExceeded => ProtoEvalViolationKind::RateLimitExceeded(()),
-            EvalViolation::VolumetricLimitExceeded => {
-                ProtoEvalViolationKind::VolumetricLimitExceeded(())
-            }
-            EvalViolation::InvalidTime => ProtoEvalViolationKind::InvalidTime(()),
-            EvalViolation::InvalidTransactionType => {
-                ProtoEvalViolationKind::InvalidTransactionType(())
-            }
-            EvalViolation::MismatchingChainId { expected, actual } => {
+            Self::RateLimitExceeded => ProtoEvalViolationKind::RateLimitExceeded(()),
+            Self::VolumetricLimitExceeded => ProtoEvalViolationKind::VolumetricLimitExceeded(()),
+            Self::InvalidTime => ProtoEvalViolationKind::InvalidTime(()),
+            Self::InvalidTransactionType => ProtoEvalViolationKind::InvalidTransactionType(()),
+            Self::MismatchingChainId { expected, actual } => {
                ProtoEvalViolationKind::ChainIdMismatch(proto_eval_violation::ChainIdMismatch {
                    expected,
                    actual,
@@ -96,13 +92,13 @@ impl Convert for VetError {

    fn convert(self) -> Self::Output {
        let kind = match self {
-            VetError::ContractCreationNotSupported => {
+            Self::ContractCreationNotSupported => {
                ProtoTransactionEvalErrorKind::ContractCreationNotSupported(())
            }
-            VetError::UnsupportedTransactionType => {
+            Self::UnsupportedTransactionType => {
                ProtoTransactionEvalErrorKind::UnsupportedTransactionType(())
            }
-            VetError::Evaluated(meaning, policy_error) => match policy_error {
+            Self::Evaluated(meaning, policy_error) => match policy_error {
                PolicyError::NoMatchingGrant => {
                    ProtoTransactionEvalErrorKind::NoMatchingGrant(NoMatchingGrantError {
                        meaning: Some(meaning.convert()),
--- a/server/crates/arbiter-server/src/grpc/mod.rs
+++ b/server/crates/arbiter-server/src/grpc/mod.rs
@@ -1,23 +1,20 @@
+use crate::peers::{client::ClientConnection, operator::OperatorConnection};
 use arbiter_proto::{
    proto::{
        client::{ClientRequest, ClientResponse},
-        user_agent::{UserAgentRequest, UserAgentResponse},
+        operator::{OperatorRequest, OperatorResponse},
    },
    transport::grpc::GrpcBi,
 };
+
 use tokio_stream::wrappers::ReceiverStream;
 use tonic::{Request, Response, Status, async_trait};
 use tracing::info;

-use crate::{
-    actors::{client::ClientConnection, user_agent::UserAgentConnection},
-    grpc::user_agent::start,
-};
-
 mod request_tracker;

 pub mod client;
-pub mod user_agent;
+pub mod operator;

 mod common;

@@ -36,7 +33,7 @@ pub trait TryConvert {

 #[async_trait]
 impl arbiter_proto::proto::arbiter_service_server::ArbiterService for super::Server {
-    type UserAgentStream = ReceiverStream<Result<UserAgentResponse, Status>>;
+    type OperatorStream = ReceiverStream<Result<OperatorResponse, Status>>;
    type ClientStream = ReceiverStream<Result<ClientResponse, Status>>;

    #[tracing::instrument(level = "debug", skip(self))]
@@ -55,23 +52,23 @@ impl arbiter_proto::proto::arbiter_service_server::ArbiterService for super::Ser
    }

    #[tracing::instrument(level = "debug", skip(self))]
-    async fn user_agent(
+    async fn operator(
        &self,
-        request: Request<tonic::Streaming<UserAgentRequest>>,
-    ) -> Result<Response<Self::UserAgentStream>, Status> {
+        request: Request<tonic::Streaming<OperatorRequest>>,
+    ) -> Result<Response<Self::OperatorStream>, Status> {
        let req_stream = request.into_inner();

        let (bi, rx) = GrpcBi::from_bi_stream(req_stream);

-        tokio::spawn(start(
-            UserAgentConnection {
+        tokio::spawn(operator::start(
+            OperatorConnection {
                db: self.context.db.clone(),
                actors: self.context.actors.clone(),
            },
            bi,
        ));

-        info!(event = "connection established", "grpc.user_agent");
+        info!(event = "connection established", "grpc.operator");

        Ok(Response::new(rx))
    }
--- a/server/crates/arbiter-server/src/grpc/user_agent.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent.rs
@@ -1,29 +1,29 @@
-use tokio::sync::mpsc;
-
+use crate::{
+    grpc::request_tracker::RequestTracker,
+    peers::operator::{OutOfBand, OperatorConnection, OperatorSession},
+};
 use arbiter_proto::{
-    proto::user_agent::{
-        UserAgentRequest, UserAgentResponse,
-        user_agent_request::Payload as UserAgentRequestPayload,
-        user_agent_response::Payload as UserAgentResponsePayload,
+    proto::operator::{
+        OperatorRequest, OperatorResponse,
+        operator_request::Payload as OperatorRequestPayload,
+        operator_response::Payload as OperatorResponsePayload,
    },
    transport::{Error as TransportError, Receiver, Sender, grpc::GrpcBi},
 };
+
 use async_trait::async_trait;
-use kameo::actor::{ActorRef, Spawn as _};
+use kameo::actor::ActorRef;
+use tokio::sync::mpsc;
 use tonic::Status;
 use tracing::{error, info, warn};

-use crate::{
-    actors::user_agent::{OutOfBand, UserAgentConnection, UserAgentSession},
-    grpc::request_tracker::RequestTracker,
-};
-
 mod auth;
 mod evm;
 mod inbound;
 mod outbound;
 mod sdk_client;
 mod vault;
+mod vault_gate;

 pub struct OutOfBandAdapter(mpsc::Sender<OutOfBand>);

@@ -38,8 +38,8 @@ impl Sender<OutOfBand> for OutOfBandAdapter {
 }

 async fn dispatch_loop(
-    mut bi: GrpcBi<UserAgentRequest, UserAgentResponse>,
-    actor: ActorRef<UserAgentSession>,
+    mut bi: GrpcBi<OperatorRequest, OperatorResponse>,
+    actor: ActorRef<OperatorSession>,
    mut receiver: mpsc::Receiver<OutOfBand>,
    mut request_tracker: RequestTracker,
 ) {
@@ -53,7 +53,7 @@ async fn dispatch_loop(

                let payload = sdk_client::out_of_band_payload(oob);

-                if bi.send(Ok(UserAgentResponse { id: None, payload: Some(payload) })).await.is_err() {
+                if bi.send(Ok(OperatorResponse { id: None, payload: Some(payload) })).await.is_err() {
                    return;
                }
            }
@@ -64,7 +64,7 @@ async fn dispatch_loop(
                let conn = match message {
                    Ok(conn) => conn,
                    Err(err) => {
-                        warn!(error = ?err, "Failed to receive user agent request");
+                        warn!(error = ?err, "Failed to receive operator request");
                        return;
                    }
                };
@@ -78,13 +78,13 @@ async fn dispatch_loop(
                };

                let Some(payload) = conn.payload else {
-                    let _ = bi.send(Err(Status::invalid_argument("Missing user-agent request payload"))).await;
+                    let _ = bi.send(Err(Status::invalid_argument("Missing operator request payload"))).await;
                    return;
                };

                match dispatch_inner(&actor, payload).await {
                    Ok(Some(response)) => {
-                        if bi.send(Ok(UserAgentResponse {
+                        if bi.send(Ok(OperatorResponse {
                            id: Some(request_id),
                            payload: Some(response),
                        })).await.is_err() {
@@ -93,7 +93,7 @@ async fn dispatch_loop(
                    }
                    Ok(None) => {}
                    Err(status) => {
-                        error!(?status, "Failed to process user agent request");
+                        error!(?status, "Failed to process operator request");
                        let _ = bi.send(Err(status)).await;
                        return;
                    }
@@ -104,41 +104,42 @@ async fn dispatch_loop(
 }

 async fn dispatch_inner(
-    actor: &ActorRef<UserAgentSession>,
-    payload: UserAgentRequestPayload,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+    actor: &ActorRef<OperatorSession>,
+    payload: OperatorRequestPayload,
+) -> Result<Option<OperatorResponsePayload>, Status> {
    match payload {
-        UserAgentRequestPayload::Vault(req) => vault::dispatch(actor, req).await,
-        UserAgentRequestPayload::Evm(req) => evm::dispatch(actor, req).await,
-        UserAgentRequestPayload::SdkClient(req) => sdk_client::dispatch(actor, req).await,
-        UserAgentRequestPayload::Auth(..) => {
-            warn!("Unsupported post-auth user agent auth request");
-            Err(Status::invalid_argument("Unsupported user-agent request"))
+        OperatorRequestPayload::Vault(req) => vault::dispatch(actor, req).await,
+        OperatorRequestPayload::Evm(req) => evm::dispatch(actor, req).await,
+        OperatorRequestPayload::SdkClient(req) => sdk_client::dispatch(actor, req).await,
+        OperatorRequestPayload::Auth(..) => {
+            warn!("Unsupported post-auth operator auth request");
+            Err(Status::invalid_argument("Unsupported operator request"))
        }
    }
 }

 pub async fn start(
-    mut conn: UserAgentConnection,
-    mut bi: GrpcBi<UserAgentRequest, UserAgentResponse>,
+    mut conn: OperatorConnection,
+    mut bi: GrpcBi<OperatorRequest, OperatorResponse>,
 ) {
    let mut request_tracker = RequestTracker::default();

-    let pubkey = match auth::start(&mut conn, &mut bi, &mut request_tracker).await {
-        Ok(pubkey) => pubkey,
-        Err(e) => {
-            warn!(error = ?e, "Authentication failed");
-            return;
-        }
-    };
-
    let (oob_sender, oob_receiver) = mpsc::channel(16);
    let oob_adapter = OutOfBandAdapter(oob_sender);

-    let actor = UserAgentSession::spawn(UserAgentSession::new(conn, Box::new(oob_adapter)));
-    let actor_for_cleanup = actor.clone();
+    let actor = {
+        let transport = auth::AuthTransportAdapter::new(&mut bi, &mut request_tracker);
+        match crate::peers::operator::start(&mut conn, transport, Box::new(oob_adapter)).await {
+            Ok(actor) => actor,
+            Err(e) => {
+                warn!(error = ?e, "Operator connection failed");
+                return;
+            }
+        }
+    };

-    info!(?pubkey, "User authenticated successfully");
-    dispatch_loop(bi, actor, oob_receiver, request_tracker).await;
-    actor_for_cleanup.kill();
+    info!("Operator session established");
+
+    dispatch_loop(bi, actor.clone(), oob_receiver, request_tracker).await;
+    actor.kill();
 }
--- a/server/crates/arbiter-server/src/grpc/user_agent/auth.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/auth.rs
@@ -1,35 +1,32 @@
+use crate::{grpc::request_tracker::RequestTracker, peers::operator::auth};
 use arbiter_crypto::authn;
 use arbiter_proto::{
-    proto::user_agent::{
-        UserAgentRequest, UserAgentResponse,
+    proto::operator::{
+        OperatorRequest, OperatorResponse,
        auth::{
            self as proto_auth, AuthChallenge as ProtoAuthChallenge,
            AuthChallengeRequest as ProtoAuthChallengeRequest,
            AuthChallengeSolution as ProtoAuthChallengeSolution, AuthResult as ProtoAuthResult,
            request::Payload as AuthRequestPayload, response::Payload as AuthResponsePayload,
        },
-        user_agent_request::Payload as UserAgentRequestPayload,
-        user_agent_response::Payload as UserAgentResponsePayload,
+        operator_request::Payload as OperatorRequestPayload,
+        operator_response::Payload as OperatorResponsePayload,
    },
    transport::{Bi, Error as TransportError, Receiver, Sender, grpc::GrpcBi},
 };
+
 use async_trait::async_trait;
 use tonic::Status;
 use tracing::warn;

-use crate::{
-    actors::user_agent::{UserAgentConnection, auth},
-    grpc::request_tracker::RequestTracker,
-};
-
-pub struct AuthTransportAdapter<'a> {
-    bi: &'a mut GrpcBi<UserAgentRequest, UserAgentResponse>,
-    request_tracker: &'a mut RequestTracker,
+pub(super) struct AuthTransportAdapter<'a> {
+    pub(super) bi: &'a mut GrpcBi<OperatorRequest, OperatorResponse>,
+    pub(super) request_tracker: &'a mut RequestTracker,
 }

 impl<'a> AuthTransportAdapter<'a> {
-    pub fn new(
-        bi: &'a mut GrpcBi<UserAgentRequest, UserAgentResponse>,
+    pub(super) const fn new(
+        bi: &'a mut GrpcBi<OperatorRequest, OperatorResponse>,
        request_tracker: &'a mut RequestTracker,
    ) -> Self {
        Self {
@@ -38,18 +35,34 @@ impl<'a> AuthTransportAdapter<'a> {
        }
    }

-    async fn send_user_agent_response(
+    pub(super) const fn bi_mut(&mut self) -> &mut GrpcBi<OperatorRequest, OperatorResponse> {
+        self.bi
+    }
+
+    pub(super) const fn tracker_mut(&mut self) -> &mut RequestTracker {
+        self.request_tracker
+    }
+
+    pub(super) async fn send_response_payload(
+        &mut self,
+        payload: OperatorResponsePayload,
+    ) -> Result<(), TransportError> {
+        self.bi
+            .send(Ok(OperatorResponse {
+                id: Some(self.request_tracker.current_request_id()),
+                payload: Some(payload),
+            }))
+            .await
+    }
+
+    async fn send_operator_response(
        &mut self,
        payload: AuthResponsePayload,
    ) -> Result<(), TransportError> {
-        self.bi
-            .send(Ok(UserAgentResponse {
-                id: Some(self.request_tracker.current_request_id()),
-                payload: Some(UserAgentResponsePayload::Auth(proto_auth::Response {
-                    payload: Some(payload),
-                })),
-            }))
-            .await
+        self.send_response_payload(OperatorResponsePayload::Auth(proto_auth::Response {
+            payload: Some(payload),
+        }))
+        .await
    }
 }

@@ -61,8 +74,15 @@ impl Sender<Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {
    ) -> Result<(), TransportError> {
        use auth::{Error, Outbound};
        let payload = match item {
-            Ok(Outbound::AuthChallenge { nonce }) => {
-                AuthResponsePayload::Challenge(ProtoAuthChallenge { nonce })
+            Ok(Outbound::AuthChallenge { challenge }) => {
+                AuthResponsePayload::Challenge(ProtoAuthChallenge {
+                    timestamp_nanos: challenge
+                        .timestamp
+                        .timestamp_nanos_opt()
+                        .expect("timestamp within range")
+                        as u64,
+                    random: challenge.nonce.to_vec(),
+                })
            }
            Ok(Outbound::AuthSuccess) => {
                AuthResponsePayload::Result(ProtoAuthResult::Success.into())
@@ -87,7 +107,7 @@ impl Sender<Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {
            }
        };

-        self.send_user_agent_response(payload).await
+        self.send_operator_response(payload).await
    }
 }

@@ -97,7 +117,7 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
        let request = match self.bi.recv().await? {
            Ok(request) => request,
            Err(error) => {
-                warn!(error = ?error, "Failed to receive user agent auth request");
+                warn!(error = ?error, "Failed to receive operator auth request");
                return None;
            }
        };
@@ -113,16 +133,16 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
        let Some(payload) = request.payload else {
            warn!(
                event = "received request with empty payload",
-                "grpc.useragent.auth_adapter"
+                "grpc.operator.auth_adapter"
            );
            return None;
        };

-        let UserAgentRequestPayload::Auth(auth_request) = payload else {
+        let OperatorRequestPayload::Auth(auth_request) = payload else {
            let _ = self
                .bi
                .send(Err(Status::invalid_argument(
-                    "Unsupported user-agent auth request",
+                    "Unsupported operator auth request",
                )))
                .await;
            return None;
@@ -131,7 +151,7 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
        let Some(payload) = auth_request.payload else {
            warn!(
                event = "received auth request with empty payload",
-                "grpc.useragent.auth_adapter"
+                "grpc.operator.auth_adapter"
            );
            return None;
        };
@@ -140,12 +160,11 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
            AuthRequestPayload::ChallengeRequest(ProtoAuthChallengeRequest {
                pubkey,
                bootstrap_token,
-                key_type: _,
            }) => {
                let Ok(pubkey) = authn::PublicKey::try_from(pubkey.as_slice()) else {
                    warn!(
                        event = "received request with invalid public key",
-                        "grpc.useragent.auth_adapter"
+                        "grpc.operator.auth_adapter"
                    );
                    return None;
                };
@@ -163,12 +182,3 @@ impl Receiver<auth::Inbound> for AuthTransportAdapter<'_> {
 }

 impl Bi<auth::Inbound, Result<auth::Outbound, auth::Error>> for AuthTransportAdapter<'_> {}
-
-pub async fn start(
-    conn: &mut UserAgentConnection,
-    bi: &mut GrpcBi<UserAgentRequest, UserAgentResponse>,
-    request_tracker: &mut RequestTracker,
-) -> Result<authn::PublicKey, auth::Error> {
-    let transport = AuthTransportAdapter::new(bi, request_tracker);
-    auth::authenticate(conn, transport).await
-}
--- a/server/crates/arbiter-server/src/grpc/user_agent/evm.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/evm.rs
@@ -1,3 +1,17 @@
+use crate::{
+    grpc::{
+        Convert, TryConvert,
+        common::inbound::{RawEvmAddress, RawEvmTransaction},
+    },
+    peers::operator::{
+        OperatorSession,
+        session::handlers::{
+            GrantMutationError, HandleEvmWalletCreate, HandleEvmWalletList, HandleGrantCreate,
+            HandleGrantDelete, HandleGrantList, HandleSignTransaction,
+            SignTransactionError as SessionSignTransactionError,
+        },
+    },
+};
 use arbiter_proto::proto::{
    evm::{
        EvmError as ProtoEvmError, EvmGrantCreateRequest, EvmGrantCreateResponse,
@@ -10,50 +24,36 @@ use arbiter_proto::proto::{
        wallet_create_response::Result as WalletCreateResult,
        wallet_list_response::Result as WalletListResult,
    },
-    user_agent::{
+    operator::{
        evm::{
            self as proto_evm, SignTransactionRequest as ProtoSignTransactionRequest,
            request::Payload as EvmRequestPayload, response::Payload as EvmResponsePayload,
        },
-        user_agent_response::Payload as UserAgentResponsePayload,
+        operator_response::Payload as OperatorResponsePayload,
    },
 };
+
 use kameo::actor::ActorRef;
 use tonic::Status;
 use tracing::warn;

-use crate::{
-    actors::user_agent::{
-        UserAgentSession,
-        session::connection::{
-            GrantMutationError, HandleEvmWalletCreate, HandleEvmWalletList, HandleGrantCreate,
-            HandleGrantDelete, HandleGrantList, HandleSignTransaction,
-            SignTransactionError as SessionSignTransactionError,
-        },
-    },
-    grpc::{
-        Convert, TryConvert,
-        common::inbound::{RawEvmAddress, RawEvmTransaction},
-    },
-};
-
-fn wrap_evm_response(payload: EvmResponsePayload) -> UserAgentResponsePayload {
-    UserAgentResponsePayload::Evm(proto_evm::Response {
+const fn wrap_evm_response(payload: EvmResponsePayload) -> OperatorResponsePayload {
+    OperatorResponsePayload::Evm(proto_evm::Response {
        payload: Some(payload),
    })
 }

 pub(super) async fn dispatch(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: proto_evm::Request,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let Some(payload) = req.payload else {
        return Err(Status::invalid_argument("Missing EVM request payload"));
    };

    match payload {
-        EvmRequestPayload::WalletCreate(_) => handle_wallet_create(actor).await,
-        EvmRequestPayload::WalletList(_) => handle_wallet_list(actor).await,
+        EvmRequestPayload::WalletCreate(()) => handle_wallet_create(actor).await,
+        EvmRequestPayload::WalletList(()) => handle_wallet_list(actor).await,
        EvmRequestPayload::GrantCreate(req) => handle_grant_create(actor, req).await,
        EvmRequestPayload::GrantDelete(req) => handle_grant_delete(actor, req).await,
        EvmRequestPayload::GrantList(_) => handle_grant_list(actor).await,
@@ -62,8 +62,8 @@ pub(super) async fn dispatch(
 }

 async fn handle_wallet_create(
-    actor: &ActorRef<UserAgentSession>,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+    actor: &ActorRef<OperatorSession>,
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let result = match actor.ask(HandleEvmWalletCreate {}).await {
        Ok((wallet_id, address)) => WalletCreateResult::Wallet(WalletEntry {
            id: wallet_id,
@@ -82,8 +82,8 @@ async fn handle_wallet_create(
 }

 async fn handle_wallet_list(
-    actor: &ActorRef<UserAgentSession>,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+    actor: &ActorRef<OperatorSession>,
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let result = match actor.ask(HandleEvmWalletList {}).await {
        Ok(wallets) => WalletListResult::Wallets(WalletList {
            wallets: wallets
@@ -107,8 +107,8 @@ async fn handle_wallet_list(
 }

 async fn handle_grant_list(
-    actor: &ActorRef<UserAgentSession>,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+    actor: &ActorRef<OperatorSession>,
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let result = match actor.ask(HandleGrantList {}).await {
        Ok(grants) => EvmGrantListResult::Grants(EvmGrantList {
            grants: grants
@@ -134,9 +134,9 @@ async fn handle_grant_list(
 }

 async fn handle_grant_create(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: EvmGrantCreateRequest,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let basic = req
        .shared
        .ok_or_else(|| Status::invalid_argument("Missing shared grant settings"))?
@@ -164,9 +164,9 @@ async fn handle_grant_create(
 }

 async fn handle_grant_delete(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: EvmGrantDeleteRequest,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let result = match actor
        .ask(HandleGrantDelete {
            grant_id: req.grant_id,
@@ -190,9 +190,9 @@ async fn handle_grant_delete(
 }

 async fn handle_sign_transaction(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: ProtoSignTransactionRequest,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let request = req
        .request
        .ok_or_else(|| Status::invalid_argument("Missing sign transaction request"))?;
--- a/server/crates/arbiter-server/src/grpc/user_agent/inbound.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/inbound.rs
@@ -1,32 +1,32 @@
-use alloy::primitives::{Address, U256};
-use arbiter_proto::proto::evm::{
-    EtherTransferSettings as ProtoEtherTransferSettings, SharedSettings as ProtoSharedSettings,
-    SpecificGrant as ProtoSpecificGrant, TokenTransferSettings as ProtoTokenTransferSettings,
-    TransactionRateLimit as ProtoTransactionRateLimit, VolumeRateLimit as ProtoVolumeRateLimit,
-    specific_grant::Grant as ProtoSpecificGrantType,
-};
-use arbiter_proto::proto::user_agent::sdk_client::{
-    WalletAccess, WalletAccessEntry as SdkClientWalletAccess,
-};
-use chrono::{DateTime, TimeZone, Utc};
-use prost_types::Timestamp as ProtoTimestamp;
-use tonic::Status;
-
-use crate::db::models::{CoreEvmWalletAccess, NewEvmWalletAccess};
-use crate::grpc::Convert;
 use crate::{
+    db::models::{CoreEvmWalletAccess, NewEvmWalletAccess},
    evm::policies::{
        SharedGrantSettings, SpecificGrant, TransactionRateLimit, VolumeRateLimit, ether_transfer,
        token_transfers,
    },
+    grpc::Convert,
    grpc::TryConvert,
 };
+use arbiter_proto::{
+    proto::evm::{
+        EtherTransferSettings as ProtoEtherTransferSettings, SharedSettings as ProtoSharedSettings,
+        SpecificGrant as ProtoSpecificGrant, TokenTransferSettings as ProtoTokenTransferSettings,
+        TransactionRateLimit as ProtoTransactionRateLimit, VolumeRateLimit as ProtoVolumeRateLimit,
+        specific_grant::Grant as ProtoSpecificGrantType,
+    },
+    proto::operator::sdk_client::{WalletAccess, WalletAccessEntry as SdkClientWalletAccess},
+};

-fn address_from_bytes(bytes: Vec<u8>) -> Result<Address, Status> {
+use alloy::primitives::{Address, U256};
+use chrono::{DateTime, TimeZone, Utc};
+use prost_types::Timestamp as ProtoTimestamp;
+use tonic::Status;
+
+fn address_from_bytes(bytes: &[u8]) -> Result<Address, Status> {
    if bytes.len() != 20 {
        return Err(Status::invalid_argument("Invalid EVM address"));
    }
-    Ok(Address::from_slice(&bytes))
+    Ok(Address::from_slice(bytes))
 }

 fn u256_from_proto_bytes(bytes: &[u8]) -> Result<U256, Status> {
@@ -41,7 +41,7 @@ impl TryConvert for ProtoTimestamp {
    type Error = Status;

    fn try_convert(self) -> Result<DateTime<Utc>, Status> {
-        Utc.timestamp_opt(self.seconds, self.nanos as u32)
+        Utc.timestamp_opt(self.seconds, self.nanos.try_into().unwrap_or_default())
            .single()
            .ok_or_else(|| Status::invalid_argument("Invalid timestamp"))
    }
@@ -117,7 +117,8 @@ impl TryConvert for ProtoSpecificGrant {
                limit,
            })) => Ok(SpecificGrant::EtherTransfer(ether_transfer::Settings {
                target: targets
-                    .into_iter()
+                    .iter()
+                    .map(Vec::as_slice)
                    .map(address_from_bytes)
                    .collect::<Result<_, _>>()?,
                limit: limit
@@ -131,8 +132,10 @@ impl TryConvert for ProtoSpecificGrant {
                target,
                volume_limits,
            })) => Ok(SpecificGrant::TokenTransfer(token_transfers::Settings {
-                token_contract: address_from_bytes(token_contract)?,
-                target: target.map(address_from_bytes).transpose()?,
+                token_contract: address_from_bytes(&token_contract)?,
+                target: target
+                    .map(|target| address_from_bytes(&target))
+                    .transpose()?,
                volume_limits: volume_limits
                    .into_iter()
                    .map(ProtoVolumeRateLimit::try_convert)
--- a/server/crates/arbiter-server/src/grpc/user_agent/outbound.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/outbound.rs
@@ -1,3 +1,8 @@
+use crate::{
+    db::models::EvmWalletAccess,
+    evm::policies::{SharedGrantSettings, SpecificGrant, TransactionRateLimit, VolumeRateLimit},
+    grpc::Convert,
+};
 use arbiter_proto::proto::{
    evm::{
        EtherTransferSettings as ProtoEtherTransferSettings, SharedSettings as ProtoSharedSettings,
@@ -5,24 +10,19 @@ use arbiter_proto::proto::{
        TransactionRateLimit as ProtoTransactionRateLimit, VolumeRateLimit as ProtoVolumeRateLimit,
        specific_grant::Grant as ProtoSpecificGrantType,
    },
-    user_agent::sdk_client::{WalletAccess, WalletAccessEntry as ProtoSdkClientWalletAccess},
+    operator::sdk_client::{WalletAccess, WalletAccessEntry as ProtoSdkClientWalletAccess},
 };
+
 use chrono::{DateTime, Utc};
 use prost_types::Timestamp as ProtoTimestamp;

-use crate::{
-    db::models::EvmWalletAccess,
-    evm::policies::{SharedGrantSettings, SpecificGrant, TransactionRateLimit, VolumeRateLimit},
-    grpc::Convert,
-};
-
 impl Convert for DateTime<Utc> {
    type Output = ProtoTimestamp;

    fn convert(self) -> ProtoTimestamp {
        ProtoTimestamp {
            seconds: self.timestamp(),
-            nanos: self.timestamp_subsec_nanos() as i32,
+            nanos: self.timestamp_subsec_nanos().try_into().unwrap_or(i32::MAX),
        }
    }
 }
@@ -74,13 +74,13 @@ impl Convert for SpecificGrant {

    fn convert(self) -> ProtoSpecificGrant {
        let grant = match self {
-            SpecificGrant::EtherTransfer(s) => {
+            Self::EtherTransfer(s) => {
                ProtoSpecificGrantType::EtherTransfer(ProtoEtherTransferSettings {
                    targets: s.target.into_iter().map(|a| a.to_vec()).collect(),
                    limit: Some(s.limit.convert()),
                })
            }
-            SpecificGrant::TokenTransfer(s) => {
+            Self::TokenTransfer(s) => {
                ProtoSpecificGrantType::TokenTransfer(ProtoTokenTransferSettings {
                    token_contract: s.token_contract.to_vec(),
                    target: s.target.map(|a| a.to_vec()),
--- a/server/crates/arbiter-server/src/grpc/user_agent/sdk_client.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/sdk_client.rs
@@ -1,7 +1,18 @@
+use crate::{
+    db::models::NewEvmWalletAccess,
+    grpc::Convert,
+    peers::operator::{
+        OutOfBand, OperatorSession,
+        session::handlers::{
+            HandleGrantEvmWalletAccess, HandleListWalletAccess, HandleNewClientApprove,
+            HandleRevokeEvmWalletAccess, HandleSdkClientList,
+        },
+    },
+};
 use arbiter_crypto::authn;
 use arbiter_proto::proto::{
    shared::ClientInfo as ProtoClientMetadata,
-    user_agent::{
+    operator::{
        sdk_client::{
            self as proto_sdk_client, ConnectionCancel as ProtoSdkClientConnectionCancel,
            ConnectionRequest as ProtoSdkClientConnectionRequest,
@@ -13,32 +24,21 @@ use arbiter_proto::proto::{
            request::Payload as SdkClientRequestPayload,
            response::Payload as SdkClientResponsePayload,
        },
-        user_agent_response::Payload as UserAgentResponsePayload,
+        operator_response::Payload as OperatorResponsePayload,
    },
 };
+
 use kameo::actor::ActorRef;
 use tonic::Status;
 use tracing::{info, warn};

-use crate::{
-    actors::user_agent::{
-        OutOfBand, UserAgentSession,
-        session::connection::{
-            HandleGrantEvmWalletAccess, HandleListWalletAccess, HandleNewClientApprove,
-            HandleRevokeEvmWalletAccess, HandleSdkClientList,
-        },
-    },
-    db::models::NewEvmWalletAccess,
-    grpc::Convert,
-};
-
-fn wrap_sdk_client_response(payload: SdkClientResponsePayload) -> UserAgentResponsePayload {
-    UserAgentResponsePayload::SdkClient(proto_sdk_client::Response {
+const fn wrap_sdk_client_response(payload: SdkClientResponsePayload) -> OperatorResponsePayload {
+    OperatorResponsePayload::SdkClient(proto_sdk_client::Response {
        payload: Some(payload),
    })
 }

-pub(super) fn out_of_band_payload(oob: OutOfBand) -> UserAgentResponsePayload {
+pub(super) fn out_of_band_payload(oob: OutOfBand) -> OperatorResponsePayload {
    match oob {
        OutOfBand::ClientConnectionRequest { profile } => wrap_sdk_client_response(
            SdkClientResponsePayload::ConnectionRequest(ProtoSdkClientConnectionRequest {
@@ -59,9 +59,9 @@ pub(super) fn out_of_band_payload(oob: OutOfBand) -> UserAgentResponsePayload {
 }

 pub(super) async fn dispatch(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: proto_sdk_client::Request,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let Some(payload) = req.payload else {
        return Err(Status::invalid_argument(
            "Missing SDK client request payload",
@@ -75,23 +75,23 @@ pub(super) async fn dispatch(
        SdkClientRequestPayload::Revoke(_) => Err(Status::unimplemented(
            "SdkClientRevoke is not yet implemented",
        )),
-        SdkClientRequestPayload::List(_) => handle_list(actor).await,
+        SdkClientRequestPayload::List(()) => handle_list(actor).await,
        SdkClientRequestPayload::GrantWalletAccess(req) => {
            handle_grant_wallet_access(actor, req).await
        }
        SdkClientRequestPayload::RevokeWalletAccess(req) => {
            handle_revoke_wallet_access(actor, req).await
        }
-        SdkClientRequestPayload::ListWalletAccess(_) => handle_list_wallet_access(actor).await,
+        SdkClientRequestPayload::ListWalletAccess(()) => handle_list_wallet_access(actor).await,
    }
 }

 async fn handle_connection_response(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    resp: ProtoSdkClientConnectionResponse,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let pubkey = authn::PublicKey::try_from(resp.pubkey.as_slice())
-        .map_err(|_| Status::invalid_argument("Invalid ML-DSA public key"))?;
+        .map_err(|()| Status::invalid_argument("Invalid ML-DSA public key"))?;

    actor
        .ask(HandleNewClientApprove {
@@ -108,20 +108,25 @@ async fn handle_connection_response(
 }

 async fn handle_list(
-    actor: &ActorRef<UserAgentSession>,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+    actor: &ActorRef<OperatorSession>,
+) -> Result<Option<OperatorResponsePayload>, Status> {
    let result = match actor.ask(HandleSdkClientList {}).await {
        Ok(clients) => ProtoSdkClientListResult::Clients(ProtoSdkClientList {
            clients: clients
                .into_iter()
                .map(|(client, metadata)| ProtoSdkClientEntry {
                    id: client.id,
-                    pubkey: client.public_key.to_vec(),
+                    pubkey: client.public_key.clone(),
                    info: Some(ProtoClientMetadata {
                        name: metadata.name,
                        description: metadata.description,
                        version: metadata.version,
                    }),
+                    #[expect(
+                        clippy::cast_possible_truncation,
+                        clippy::as_conversions,
+                        reason = "fixme! #84"
+                    )]
                    created_at: client.created_at.0.timestamp() as i32,
                })
                .collect(),
@@ -139,10 +144,10 @@ async fn handle_list(
 }

 async fn handle_grant_wallet_access(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: ProtoSdkClientGrantWalletAccess,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let entries: Vec<NewEvmWalletAccess> = req.accesses.into_iter().map(|a| a.convert()).collect();
+) -> Result<Option<OperatorResponsePayload>, Status> {
+    let entries: Vec<NewEvmWalletAccess> = req.accesses.into_iter().map(Convert::convert).collect();
    match actor.ask(HandleGrantEvmWalletAccess { entries }).await {
        Ok(()) => {
            info!("Successfully granted wallet access");
@@ -156,9 +161,9 @@ async fn handle_grant_wallet_access(
 }

 async fn handle_revoke_wallet_access(
-    actor: &ActorRef<UserAgentSession>,
+    actor: &ActorRef<OperatorSession>,
    req: ProtoSdkClientRevokeWalletAccess,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+) -> Result<Option<OperatorResponsePayload>, Status> {
    match actor
        .ask(HandleRevokeEvmWalletAccess {
            entries: req.accesses,
@@ -177,12 +182,12 @@ async fn handle_revoke_wallet_access(
 }

 async fn handle_list_wallet_access(
-    actor: &ActorRef<UserAgentSession>,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
+    actor: &ActorRef<OperatorSession>,
+) -> Result<Option<OperatorResponsePayload>, Status> {
    match actor.ask(HandleListWalletAccess {}).await {
        Ok(accesses) => Ok(Some(wrap_sdk_client_response(
            SdkClientResponsePayload::ListWalletAccess(ListWalletAccessResponse {
-                accesses: accesses.into_iter().map(|a| a.convert()).collect(),
+                accesses: accesses.into_iter().map(Convert::convert).collect(),
            }),
        ))),
        Err(err) => {
--- a/server/crates/arbiter-server/src/grpc/operator/vault.rs
+++ b/server/crates/arbiter-server/src/grpc/operator/vault.rs
@@ -0,0 +1,59 @@
+use crate::{
+    actors::vault::VaultState,
+    peers::operator::{OperatorSession, session::handlers::HandleQueryVaultState},
+};
+use arbiter_proto::{
+    proto::shared::VaultState as ProtoVaultState,
+    proto::operator::{
+        operator_response::Payload as OperatorResponsePayload,
+        vault::{
+            self as proto_vault, request::Payload as VaultRequestPayload,
+            response::Payload as VaultResponsePayload,
+        },
+    },
+};
+
+use kameo::actor::ActorRef;
+use tonic::Status;
+use tracing::warn;
+
+const fn wrap_vault_response(payload: VaultResponsePayload) -> OperatorResponsePayload {
+    OperatorResponsePayload::Vault(proto_vault::Response {
+        payload: Some(payload),
+    })
+}
+
+pub(super) async fn dispatch(
+    actor: &ActorRef<OperatorSession>,
+    req: proto_vault::Request,
+) -> Result<Option<OperatorResponsePayload>, Status> {
+    let Some(payload) = req.payload else {
+        return Err(Status::invalid_argument("Missing vault request payload"));
+    };
+
+    match payload {
+        VaultRequestPayload::QueryState(()) => handle_query_vault_state(actor).await,
+        VaultRequestPayload::Unseal(_) | VaultRequestPayload::Bootstrap(_) => {
+            Err(Status::permission_denied(
+                "Vault is already unsealed; unseal/bootstrap not permitted in session",
+            ))
+        }
+    }
+}
+
+async fn handle_query_vault_state(
+    actor: &ActorRef<OperatorSession>,
+) -> Result<Option<OperatorResponsePayload>, Status> {
+    let state = match actor.ask(HandleQueryVaultState {}).await {
+        Ok(VaultState::Unbootstrapped) => ProtoVaultState::Unbootstrapped,
+        Ok(VaultState::Sealed) => ProtoVaultState::Sealed,
+        Ok(VaultState::Unsealed) => ProtoVaultState::Unsealed,
+        Err(err) => {
+            warn!(error = ?err, "Failed to query vault state");
+            ProtoVaultState::Error
+        }
+    };
+    Ok(Some(wrap_vault_response(VaultResponsePayload::State(
+        state.into(),
+    ))))
+}
--- a/server/crates/arbiter-server/src/grpc/operator/vault_gate.rs
+++ b/server/crates/arbiter-server/src/grpc/operator/vault_gate.rs
@@ -0,0 +1,79 @@
+use super::auth::AuthTransportAdapter;
+use crate::{
+    grpc::TryConvert,
+    peers::operator::vault_gate::{self as vault_gate},
+};
+use arbiter_proto::transport::{Bi, Error as TransportError, Receiver, Sender};
+
+use async_trait::async_trait;
+use tonic::Status;
+use tracing::warn;
+
+mod inbound;
+mod outbound;
+
+#[async_trait]
+impl Receiver<vault_gate::Inbound> for AuthTransportAdapter<'_> {
+    async fn recv(&mut self) -> Option<vault_gate::Inbound> {
+        let request = match self.bi_mut().recv().await? {
+            Ok(request) => request,
+            Err(error) => {
+                warn!(
+                    ?error,
+                    "Failed to receive operator request during vault gate"
+                );
+                return None;
+            }
+        };
+
+        if let Err(err) = self.tracker_mut().request(request.id) {
+            let _ = self.bi_mut().send(Err(err)).await;
+            return None;
+        }
+
+        let Some(payload) = request.payload else {
+            let _ = self
+                .bi_mut()
+                .send(Err(Status::invalid_argument("Missing request payload")))
+                .await;
+            return None;
+        };
+
+        match payload.try_convert() {
+            Ok(inbound) => Some(inbound),
+            Err(status) => {
+                let _ = self.bi_mut().send(Err(status)).await;
+                None
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl Sender<Result<vault_gate::Outbound, vault_gate::Error>> for AuthTransportAdapter<'_> {
+    async fn send(
+        &mut self,
+        item: Result<vault_gate::Outbound, vault_gate::Error>,
+    ) -> Result<(), TransportError> {
+        let outbound = match item {
+            Ok(outbound) => outbound,
+            Err(err) => {
+                warn!(?err, "vault gate produced transport-level error");
+                return self
+                    .bi_mut()
+                    .send(Err(Status::internal(err.to_string())))
+                    .await;
+            }
+        };
+
+        match outbound.try_convert() {
+            Ok(payload) => self.send_response_payload(payload).await,
+            Err(status) => self.bi_mut().send(Err(status)).await,
+        }
+    }
+}
+
+impl Bi<vault_gate::Inbound, Result<vault_gate::Outbound, vault_gate::Error>>
+    for AuthTransportAdapter<'_>
+{
+}
--- a/server/crates/arbiter-server/src/grpc/operator/vault_gate/inbound.rs
+++ b/server/crates/arbiter-server/src/grpc/operator/vault_gate/inbound.rs
@@ -0,0 +1,129 @@
+use crate::{
+    grpc::{Convert, TryConvert},
+    peers::operator::vault_gate::{
+        self as vault_gate, HandleBootstrapEncryptedKey, HandleHandshake, HandleUnsealEncryptedKey,
+    },
+};
+use arbiter_proto::proto::operator::{
+    operator_request::Payload as OperatorRequestPayload,
+    vault::{
+        self as proto_vault,
+        bootstrap::{self as proto_bootstrap},
+        request::Payload as VaultRequestPayload,
+        unseal::{self as proto_unseal, request::Payload as UnsealRequestPayload},
+    },
+};
+
+use tonic::Status;
+
+impl TryConvert for OperatorRequestPayload {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        match self {
+            Self::Vault(req) => req.try_convert(),
+            _ => Err(Status::permission_denied(
+                "Only vault operations are permitted before unsealing",
+            )),
+        }
+    }
+}
+
+impl TryConvert for proto_vault::Request {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        self.payload
+            .ok_or_else(|| Status::invalid_argument("Missing vault request payload"))?
+            .try_convert()
+    }
+}
+
+impl TryConvert for VaultRequestPayload {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        match self {
+            Self::QueryState(()) => Ok(vault_gate::Inbound::HandleVaultState),
+            Self::Unseal(req) => req.try_convert(),
+            Self::Bootstrap(req) => req.try_convert(),
+        }
+    }
+}
+
+impl TryConvert for proto_unseal::Request {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        self.payload
+            .ok_or_else(|| Status::invalid_argument("Missing unseal request payload"))?
+            .try_convert()
+    }
+}
+
+impl TryConvert for UnsealRequestPayload {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        match self {
+            Self::Start(start) => start.try_convert(),
+            Self::EncryptedKey(key) => Ok(key.convert()),
+        }
+    }
+}
+
+impl TryConvert for proto_unseal::UnsealStart {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        let bytes = <[u8; 32]>::try_from(self.client_pubkey)
+            .map_err(|_| Status::invalid_argument("Invalid X25519 public key"))?;
+        Ok(vault_gate::Inbound::HandleHandshake(HandleHandshake {
+            client_pubkey: x25519_dalek::PublicKey::from(bytes),
+        }))
+    }
+}
+
+impl Convert for proto_unseal::UnsealEncryptedKey {
+    type Output = vault_gate::Inbound;
+
+    fn convert(self) -> vault_gate::Inbound {
+        vault_gate::Inbound::HandleUnsealEncryptedKey(HandleUnsealEncryptedKey {
+            nonce: self.nonce,
+            ciphertext: self.ciphertext,
+            associated_data: self.associated_data,
+        })
+    }
+}
+
+impl TryConvert for proto_bootstrap::Request {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        self.encrypted_key
+            .ok_or_else(|| Status::invalid_argument("Missing bootstrap encrypted key"))?
+            .try_convert()
+    }
+}
+
+impl TryConvert for proto_bootstrap::BootstrapEncryptedKey {
+    type Output = vault_gate::Inbound;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<vault_gate::Inbound, Status> {
+        Ok(vault_gate::Inbound::HandleBootstrapEncryptedKey(
+            HandleBootstrapEncryptedKey {
+                nonce: self.nonce,
+                ciphertext: self.ciphertext,
+                associated_data: self.associated_data,
+            },
+        ))
+    }
+}
--- a/server/crates/arbiter-server/src/grpc/operator/vault_gate/outbound.rs
+++ b/server/crates/arbiter-server/src/grpc/operator/vault_gate/outbound.rs
@@ -0,0 +1,115 @@
+use crate::{
+    actors::vault::VaultState,
+    grpc::{Convert, TryConvert},
+    peers::operator::vault_gate::{self as vault_gate},
+};
+use arbiter_proto::proto::{
+    shared::VaultState as ProtoVaultState,
+    operator::{
+        operator_response::Payload as OperatorResponsePayload,
+        vault::{
+            self as proto_vault,
+            bootstrap::{self as proto_bootstrap, BootstrapResult as ProtoBootstrapResult},
+            response::Payload as VaultResponsePayload,
+            unseal::{
+                self as proto_unseal, UnsealResult as ProtoUnsealResult,
+                response::Payload as UnsealResponsePayload,
+            },
+        },
+    },
+};
+
+use tonic::Status;
+use tracing::warn;
+
+const fn wrap_vault_response(payload: VaultResponsePayload) -> OperatorResponsePayload {
+    OperatorResponsePayload::Vault(proto_vault::Response {
+        payload: Some(payload),
+    })
+}
+
+const fn wrap_unseal_response(payload: UnsealResponsePayload) -> OperatorResponsePayload {
+    wrap_vault_response(VaultResponsePayload::Unseal(proto_unseal::Response {
+        payload: Some(payload),
+    }))
+}
+
+fn wrap_bootstrap_response(result: ProtoBootstrapResult) -> OperatorResponsePayload {
+    wrap_vault_response(VaultResponsePayload::Bootstrap(proto_bootstrap::Response {
+        result: result.into(),
+    }))
+}
+
+impl Convert for VaultState {
+    type Output = OperatorResponsePayload;
+
+    fn convert(self) -> OperatorResponsePayload {
+        let proto_state = match self {
+            Self::Unbootstrapped => ProtoVaultState::Unbootstrapped,
+            Self::Sealed => ProtoVaultState::Sealed,
+            Self::Unsealed => ProtoVaultState::Unsealed,
+        };
+        wrap_vault_response(VaultResponsePayload::State(proto_state.into()))
+    }
+}
+
+impl Convert for vault_gate::HandshakeResponse {
+    type Output = OperatorResponsePayload;
+
+    fn convert(self) -> OperatorResponsePayload {
+        wrap_unseal_response(UnsealResponsePayload::Start(
+            proto_unseal::UnsealStartResponse {
+                server_pubkey: self.server_pubkey.as_bytes().to_vec(),
+            },
+        ))
+    }
+}
+
+impl TryConvert for vault_gate::Outbound {
+    type Output = OperatorResponsePayload;
+    type Error = Status;
+
+    fn try_convert(self) -> Result<OperatorResponsePayload, Status> {
+        match self {
+            Self::HandleVaultState(result) => result
+                .map_err(|err| {
+                    warn!(?err, "vault state query failed");
+                    Status::internal("Failed to query vault state")
+                })
+                .map(VaultState::convert),
+            Self::HandleHandshake(result) => result
+                .map_err(|err| {
+                    warn!(?err, "handshake failed");
+                    Status::internal("Failed to start unseal flow")
+                })
+                .map(vault_gate::HandshakeResponse::convert),
+            Self::HandleUnsealEncryptedKey(result) => {
+                let proto_result = match result {
+                    Ok(()) => ProtoUnsealResult::Success,
+                    Err(vault_gate::Error::InvalidKey) => ProtoUnsealResult::InvalidKey,
+                    Err(err) => {
+                        warn!(?err, "unseal failed");
+                        return Err(Status::internal("Failed to unseal vault"));
+                    }
+                };
+                Ok(wrap_unseal_response(UnsealResponsePayload::Result(
+                    proto_result.into(),
+                )))
+            }
+            Self::HandleBootstrapEncryptedKey(result) => {
+                let proto_result = match result {
+                    Ok(()) => ProtoBootstrapResult::Success,
+                    Err(vault_gate::Error::InvalidKey) => ProtoBootstrapResult::InvalidKey,
+                    Err(vault_gate::Error::AlreadyBootstrapped) => {
+                        ProtoBootstrapResult::AlreadyBootstrapped
+                    }
+                    Err(err) => {
+                        warn!(?err, "bootstrap failed");
+                        return Err(Status::internal("Failed to bootstrap vault"));
+                    }
+                };
+                Ok(wrap_bootstrap_response(proto_result))
+            }
+        }
+    }
+}
--- a/server/crates/arbiter-server/src/grpc/request_tracker.rs
+++ b/server/crates/arbiter-server/src/grpc/request_tracker.rs
@@ -1,12 +1,12 @@
 use tonic::Status;

 #[derive(Default)]
-pub struct RequestTracker {
+pub(super) struct RequestTracker {
    next_request_id: i32,
 }

 impl RequestTracker {
-    pub fn request(&mut self, id: i32) -> Result<i32, Status> {
+    pub(super) fn request(&mut self, id: i32) -> Result<i32, Status> {
        if id < self.next_request_id {
            return Err(Status::invalid_argument("Duplicate request id"));
        }
@@ -20,7 +20,7 @@ impl RequestTracker {

    // This is used to set the response id for auth responses, which need to match the request id of the auth challenge request.
    // -1 offset is needed because request() increments the next_request_id after returning the current request id.
-    pub fn current_request_id(&self) -> i32 {
+    pub(super) const fn current_request_id(&self) -> i32 {
        self.next_request_id - 1
    }
 }
--- a/server/crates/arbiter-server/src/grpc/user_agent/vault.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/vault.rs
@@ -1,180 +0,0 @@
-use arbiter_proto::proto::shared::VaultState as ProtoVaultState;
-use arbiter_proto::proto::user_agent::{
-    user_agent_response::Payload as UserAgentResponsePayload,
-    vault::{
-        self as proto_vault,
-        bootstrap::{
-            self as proto_bootstrap, BootstrapEncryptedKey as ProtoBootstrapEncryptedKey,
-            BootstrapResult as ProtoBootstrapResult,
-        },
-        request::Payload as VaultRequestPayload,
-        response::Payload as VaultResponsePayload,
-        unseal::{
-            self as proto_unseal, UnsealEncryptedKey as ProtoUnsealEncryptedKey,
-            UnsealResult as ProtoUnsealResult, UnsealStart,
-            request::Payload as UnsealRequestPayload, response::Payload as UnsealResponsePayload,
-        },
-    },
-};
-use kameo::{actor::ActorRef, error::SendError};
-use tonic::Status;
-use tracing::warn;
-
-use crate::actors::{
-    keyholder::KeyHolderState,
-    user_agent::{
-        UserAgentSession,
-        session::connection::{
-            BootstrapError, HandleBootstrapEncryptedKey, HandleQueryVaultState,
-            HandleUnsealEncryptedKey, HandleUnsealRequest, UnsealError,
-        },
-    },
-};
-
-fn wrap_vault_response(payload: VaultResponsePayload) -> UserAgentResponsePayload {
-    UserAgentResponsePayload::Vault(proto_vault::Response {
-        payload: Some(payload),
-    })
-}
-
-fn wrap_unseal_response(payload: UnsealResponsePayload) -> UserAgentResponsePayload {
-    wrap_vault_response(VaultResponsePayload::Unseal(proto_unseal::Response {
-        payload: Some(payload),
-    }))
-}
-
-fn wrap_bootstrap_response(result: ProtoBootstrapResult) -> UserAgentResponsePayload {
-    wrap_vault_response(VaultResponsePayload::Bootstrap(proto_bootstrap::Response {
-        result: result.into(),
-    }))
-}
-
-pub(super) async fn dispatch(
-    actor: &ActorRef<UserAgentSession>,
-    req: proto_vault::Request,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let Some(payload) = req.payload else {
-        return Err(Status::invalid_argument("Missing vault request payload"));
-    };
-
-    match payload {
-        VaultRequestPayload::QueryState(_) => handle_query_vault_state(actor).await,
-        VaultRequestPayload::Unseal(req) => dispatch_unseal_request(actor, req).await,
-        VaultRequestPayload::Bootstrap(req) => handle_bootstrap_request(actor, req).await,
-    }
-}
-
-async fn dispatch_unseal_request(
-    actor: &ActorRef<UserAgentSession>,
-    req: proto_unseal::Request,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let Some(payload) = req.payload else {
-        return Err(Status::invalid_argument("Missing unseal request payload"));
-    };
-
-    match payload {
-        UnsealRequestPayload::Start(req) => handle_unseal_start(actor, req).await,
-        UnsealRequestPayload::EncryptedKey(req) => handle_unseal_encrypted_key(actor, req).await,
-    }
-}
-
-async fn handle_unseal_start(
-    actor: &ActorRef<UserAgentSession>,
-    req: UnsealStart,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let client_pubkey = <[u8; 32]>::try_from(req.client_pubkey)
-        .map(x25519_dalek::PublicKey::from)
-        .map_err(|_| Status::invalid_argument("Invalid X25519 public key"))?;
-
-    let response = actor
-        .ask(HandleUnsealRequest { client_pubkey })
-        .await
-        .map_err(|err| {
-            warn!(error = ?err, "Failed to handle unseal start request");
-            Status::internal("Failed to start unseal flow")
-        })?;
-
-    Ok(Some(wrap_unseal_response(UnsealResponsePayload::Start(
-        proto_unseal::UnsealStartResponse {
-            server_pubkey: response.server_pubkey.as_bytes().to_vec(),
-        },
-    ))))
-}
-
-async fn handle_unseal_encrypted_key(
-    actor: &ActorRef<UserAgentSession>,
-    req: ProtoUnsealEncryptedKey,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let result = match actor
-        .ask(HandleUnsealEncryptedKey {
-            nonce: req.nonce,
-            ciphertext: req.ciphertext,
-            associated_data: req.associated_data,
-        })
-        .await
-    {
-        Ok(()) => ProtoUnsealResult::Success,
-        Err(SendError::HandlerError(UnsealError::InvalidKey)) => ProtoUnsealResult::InvalidKey,
-        Err(err) => {
-            warn!(error = ?err, "Failed to handle unseal request");
-            return Err(Status::internal("Failed to unseal vault"));
-        }
-    };
-    Ok(Some(wrap_unseal_response(UnsealResponsePayload::Result(
-        result.into(),
-    ))))
-}
-
-async fn handle_bootstrap_request(
-    actor: &ActorRef<UserAgentSession>,
-    req: proto_bootstrap::Request,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let encrypted_key = req
-        .encrypted_key
-        .ok_or_else(|| Status::invalid_argument("Missing bootstrap encrypted key"))?;
-    handle_bootstrap_encrypted_key(actor, encrypted_key).await
-}
-
-async fn handle_bootstrap_encrypted_key(
-    actor: &ActorRef<UserAgentSession>,
-    req: ProtoBootstrapEncryptedKey,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let result = match actor
-        .ask(HandleBootstrapEncryptedKey {
-            nonce: req.nonce,
-            ciphertext: req.ciphertext,
-            associated_data: req.associated_data,
-        })
-        .await
-    {
-        Ok(()) => ProtoBootstrapResult::Success,
-        Err(SendError::HandlerError(BootstrapError::InvalidKey)) => {
-            ProtoBootstrapResult::InvalidKey
-        }
-        Err(SendError::HandlerError(BootstrapError::AlreadyBootstrapped)) => {
-            ProtoBootstrapResult::AlreadyBootstrapped
-        }
-        Err(err) => {
-            warn!(error = ?err, "Failed to handle bootstrap request");
-            return Err(Status::internal("Failed to bootstrap vault"));
-        }
-    };
-    Ok(Some(wrap_bootstrap_response(result)))
-}
-
-async fn handle_query_vault_state(
-    actor: &ActorRef<UserAgentSession>,
-) -> Result<Option<UserAgentResponsePayload>, Status> {
-    let state = match actor.ask(HandleQueryVaultState {}).await {
-        Ok(KeyHolderState::Unbootstrapped) => ProtoVaultState::Unbootstrapped,
-        Ok(KeyHolderState::Sealed) => ProtoVaultState::Sealed,
-        Ok(KeyHolderState::Unsealed) => ProtoVaultState::Unsealed,
-        Err(err) => {
-            warn!(error = ?err, "Failed to query vault state");
-            ProtoVaultState::Error
-        }
-    };
-    Ok(Some(wrap_vault_response(VaultResponsePayload::State(
-        state.into(),
-    ))))
-}