refactor(server): rework envelopes and integrity check

2026-04-05 10:47:21 +02:00
parent 9fab945a00
commit b122aa464c
28 changed files with 926 additions and 1209 deletions
--- a/server/Cargo.lock
+++ b/server/Cargo.lock
@@ -744,6 +744,7 @@ dependencies = [
 "kameo",
 "memsafe",
 "pem",
+ "postcard",
 "prost",
 "prost-types",
 "rand 0.10.0",
@@ -752,6 +753,8 @@ dependencies = [
 "rsa",
 "rustls",
 "secrecy",
+ "serde",
+ "serde_with",
 "sha2 0.10.9",
 "smlang",
 "spki",
@@ -1054,6 +1057,15 @@ dependencies = [
 "syn 2.0.117",
 ]

+[[package]]
+name = "atomic-polyfill"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cf2bce30dfe09ef0bfaef228b9d414faaf7e563035494d7fe092dba54b300f4"
+dependencies = [
+ "critical-section",
+]
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
@@ -1444,6 +1456,15 @@ dependencies = [
 "cc",
 ]

+[[package]]
+name = "cobs"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fa961b519f0b462e3a3b4a34b64d119eeaca1d59af726fe450bbba07a9fc0a1"
+dependencies = [
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "console"
 version = "0.15.11"
@@ -1551,6 +1572,12 @@ dependencies = [
 "cfg-if",
 ]

+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
@@ -1956,6 +1983,7 @@ version = "3.0.0-rc.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c6e914c7c52decb085cea910552e24c63ac019e3ab8bf001ff736da9a9d9d890"
 dependencies = [
+ "serde",
 "signature 3.0.0-rc.10",
 ]

@@ -1968,6 +1996,7 @@ dependencies = [
 "curve25519-dalek 5.0.0-pre.6",
 "ed25519",
 "rand_core 0.10.0",
+ "serde",
 "sha2 0.11.0-rc.5",
 "subtle",
 "zeroize",
@@ -2014,6 +2043,18 @@ dependencies = [
 "zeroize",
 ]

+[[package]]
+name = "embedded-io"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef1a6892d9eef45c8fa6b9e0086428a2cca8491aca8f787c534a3d6d0bcb3ced"
+
+[[package]]
+name = "embedded-io"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edd0f118536f44f5ccd48bcb8b111bdc3de888b58c74639dfb034a357d0f206d"
+
 [[package]]
 name = "encode_unicode"
 version = "1.0.0"
@@ -2053,7 +2094,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
 "libc",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -2431,6 +2472,15 @@ dependencies = [
 "tracing",
 ]

+[[package]]
+name = "hash32"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0c35f58762feb77d74ebe43bdbc3210f09be9fe6742234d573bacc26ed92b67"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.12.3"
@@ -2465,6 +2515,20 @@ dependencies = [
 "serde_core",
 ]

+[[package]]
+name = "heapless"
+version = "0.7.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdc6457c0eb62c71aac4bc17216026d8410337c4126773b9c5daba343f17964f"
+dependencies = [
+ "atomic-polyfill",
+ "hash32",
+ "rustc_version 0.4.1",
+ "serde",
+ "spin",
+ "stable_deref_trait",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -3188,7 +3252,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -3213,6 +3277,7 @@ dependencies = [
 "num-iter",
 "num-traits",
 "rand 0.8.5",
+ "serde",
 "smallvec",
 "zeroize",
 ]
@@ -3524,6 +3589,19 @@ version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"

+[[package]]
+name = "postcard"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6764c3b5dd454e283a30e6dfe78e9b31096d9e32036b5d1eaac7a6119ccb9a24"
+dependencies = [
+ "cobs",
+ "embedded-io 0.4.0",
+ "embedded-io 0.6.1",
+ "heapless",
+ "serde",
+]
+
 [[package]]
 name = "potential_utf"
 version = "0.1.4"
@@ -4152,6 +4230,7 @@ dependencies = [
 "pkcs1",
 "pkcs8",
 "rand_core 0.6.4",
+ "serde",
 "sha2 0.10.9",
 "signature 2.2.0",
 "spki",
@@ -4287,7 +4366,7 @@ dependencies = [
 "errno",
 "libc",
 "linux-raw-sys",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4703,7 +4782,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
 "libc",
- "windows-sys 0.60.2",
+ "windows-sys 0.61.2",
 ]

 [[package]]
@@ -4711,6 +4790,9 @@ name = "spin"
 version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+dependencies = [
+ "lock_api",
+]

 [[package]]
 name = "spki"
@@ -4897,7 +4979,7 @@ dependencies = [
 "getrandom 0.4.2",
 "once_cell",
 "rustix",
- "windows-sys 0.52.0",
+ "windows-sys 0.61.2",
 ]

 [[package]]
--- a/server/crates/arbiter-proto/src/lib.rs
+++ b/server/crates/arbiter-proto/src/lib.rs
@@ -61,10 +61,6 @@ pub mod proto {
    pub mod evm {
        tonic::include_proto!("arbiter.evm");
    }
-
-    pub mod integrity {
-        tonic::include_proto!("arbiter.integrity");
-    }
 }

 #[derive(Debug, Clone, PartialEq, Eq)]
--- a/server/crates/arbiter-server/Cargo.toml
+++ b/server/crates/arbiter-server/Cargo.toml
@@ -17,6 +17,7 @@ diesel-async = { version = "0.8.0", features = [
    "tokio",
 ] }
 ed25519-dalek.workspace = true
+ed25519-dalek.features = ["serde"]
 arbiter-proto.path = "../arbiter-proto"
 tracing.workspace = true
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
@@ -46,7 +47,9 @@ restructed = "0.2.2"
 strum = { version = "0.28.0", features = ["derive"] }
 pem = "3.0.6"
 k256.workspace = true
+k256.features = ["serde"]
 rsa.workspace = true
+rsa.features = ["serde"]
 sha2.workspace = true
 hmac = "0.12"
 spki.workspace = true
@@ -55,6 +58,9 @@ prost-types.workspace = true
 prost.workspace = true
 arbiter-tokens-registry.path = "../arbiter-tokens-registry"
 anyhow = "1.0.102"
+postcard = { version = "1.1.3", features = ["use-std"] }
+serde = { version = "1.0.228", features = ["derive"] }
+serde_with = "3.18.0"

 [dev-dependencies]
 insta = "1.46.3"
--- a/server/crates/arbiter-server/migrations/2026-02-14-171124-0000_init/up.sql
+++ b/server/crates/arbiter-server/migrations/2026-02-14-171124-0000_init/up.sql
@@ -47,7 +47,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,
-    pubkey_integrity_tag blob,
    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'))
--- a/server/crates/arbiter-server/src/actors/evm/mod.rs
+++ b/server/crates/arbiter-server/src/actors/evm/mod.rs
@@ -8,19 +8,18 @@ use rand::{SeedableRng, rng, rngs::StdRng};

 use crate::{
    actors::keyholder::{CreateNew, Decrypt, GetState, KeyHolder, KeyHolderState},
+    crypto::integrity,
    db::{
        DatabaseError, DatabasePool,
        models::{self, SqliteTimestamp},
        schema,
    },
    evm::{
-        self, RunKind,
-        policies::{
-            FullGrant, Grant, SharedGrantSettings, SpecificGrant, SpecificMeaning,
+        self, ListError, RunKind, policies::{
+            CombinedSettings, Grant, SharedGrantSettings, SpecificGrant, SpecificMeaning,
            ether_transfer::EtherTransfer, token_transfers::TokenTransfer,
+        }
    },
-    },
-    integrity,
    safe_cell::{SafeCell, SafeCellHandle as _},
 };

@@ -58,8 +57,8 @@ pub enum Error {
    #[error("Database error: {0}")]
    Database(#[from] DatabaseError),

-    #[error("Vault is sealed")]
-    VaultSealed,
+    #[error("Integrity violation: {0}")]
+    Integrity(#[from] integrity::Error),
 }

 #[derive(Actor)]
@@ -83,20 +82,6 @@ impl EvmActor {
            engine,
        }
    }
-
-    async fn ensure_unsealed(&self) -> Result<(), Error> {
-        let state = self
-            .keyholder
-            .ask(GetState)
-            .await
-            .map_err(|_| Error::KeyholderSend)?;
-
-        if state != KeyHolderState::Unsealed {
-            return Err(Error::VaultSealed);
-        }
-
-        Ok(())
-    }
 }

 #[messages]
@@ -151,62 +136,58 @@ impl EvmActor {
        basic: SharedGrantSettings,
        grant: SpecificGrant,
    ) -> Result<i32, Error> {
-        self.ensure_unsealed().await?;
-
        match grant {
-            SpecificGrant::EtherTransfer(settings) => {
-                self.engine
-                    .create_grant::<EtherTransfer>(FullGrant {
-                        basic,
+            SpecificGrant::EtherTransfer(settings) => self
+                .engine
+                .create_grant::<EtherTransfer>(CombinedSettings {
+                    shared: basic,
                    specific: settings,
                })
                .await
-                    .map_err(Error::from)
-            }
-            SpecificGrant::TokenTransfer(settings) => {
-                self.engine
-                    .create_grant::<TokenTransfer>(FullGrant {
-                        basic,
+                .map_err(Error::from),
+            SpecificGrant::TokenTransfer(settings) => self
+                .engine
+                .create_grant::<TokenTransfer>(CombinedSettings {
+                    shared: basic,
                    specific: settings,
                })
                .await
-                    .map_err(Error::from)
-            }
+                .map_err(Error::from),
        }
    }

    #[message]
    pub async fn useragent_delete_grant(&mut self, grant_id: i32) -> Result<(), Error> {
-        self.ensure_unsealed().await?;
+        // let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
+        // let keyholder = self.keyholder.clone();

-        let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
-        let keyholder = self.keyholder.clone();
+        // diesel_async::AsyncConnection::transaction(&mut conn, |conn| {
+        //     Box::pin(async move {
+        //         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(conn)
+        //             .await?;

-        diesel_async::AsyncConnection::transaction(&mut conn, |conn| {
-            Box::pin(async move {
-                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(conn)
-                    .await?;
+        //         let signed = integrity::evm::load_signed_grant_by_basic_id(conn, grant_id).await?;

-                let signed = integrity::evm::load_signed_grant_by_basic_id(conn, grant_id).await?;
-                integrity::sign_entity(conn, &keyholder, &signed)
-                    .await
-                    .map_err(|_| diesel::result::Error::RollbackTransaction)?;
+        //         diesel::result::QueryResult::Ok(())
+        //     })
+        // })
+        // .await
+        // .map_err(DatabaseError::from)?;

-                diesel::result::QueryResult::Ok(())
-            })
-        })
-        .await
-        .map_err(DatabaseError::from)?;
-
-        Ok(())
+        // Ok(())
+        todo!()
    }

    #[message]
    pub async fn useragent_list_grants(&mut self) -> Result<Vec<Grant<SpecificGrant>>, Error> {
-        Ok(self.engine.list_all_grants().await?)
+        match self.engine.list_all_grants().await {
+            Ok(grants) => Ok(grants),
+            Err(ListError::Database(db_err)) => Err(Error::Database(db_err)),
+            Err(ListError::Integrity(integrity_err)) => Err(Error::Integrity(integrity_err)),
+        }
    }

    #[message]
--- a/server/crates/arbiter-server/src/actors/keyholder/mod.rs
+++ b/server/crates/arbiter-server/src/actors/keyholder/mod.rs
@@ -4,9 +4,8 @@ use diesel::{
    dsl::{insert_into, update},
 };
 use diesel_async::{AsyncConnection, RunQueryDsl};
-use hmac::{Hmac, Mac as _};
+use hmac::Mac as _;
 use kameo::{Actor, Reply, messages};
-use sha2::Sha256;
 use strum::{EnumDiscriminants, IntoDiscriminant};
 use tracing::{error, info};

@@ -14,7 +13,7 @@ use crate::{
    crypto::{
        KeyCell, derive_key,
        encryption::v1::{self, Nonce},
-        integrity::v1::compute_integrity_tag,
+        integrity::v1::HmacSha256,
    },
    safe_cell::SafeCell,
 };
@@ -26,13 +25,6 @@ use crate::{
    },
    safe_cell::SafeCellHandle as _,
 };
-use encryption::v1::{self, KeyCell, Nonce};
-
-type HmacSha256 = Hmac<Sha256>;
-
-const INTEGRITY_SUBKEY_TAG: &[u8] = b"arbiter/db-integrity-key/v1";
-
-pub mod encryption;

 #[derive(Default, EnumDiscriminants)]
 #[strum_discriminants(derive(Reply), vis(pub), name(KeyHolderState))]
@@ -142,19 +134,6 @@ impl KeyHolder {
        Ok(nonce)
    }

-    fn derive_integrity_key(root_key: &mut KeyCell) -> [u8; 32] {
-        root_key.0.read_inline(|root_key_bytes| {
-            let mut hmac = match HmacSha256::new_from_slice(root_key_bytes.as_slice()) {
-                Ok(v) => v,
-                Err(_) => unreachable!("HMAC accepts keys of any size"),
-            };
-            hmac.update(INTEGRITY_SUBKEY_TAG);
-            let mut out = [0u8; 32];
-            out.copy_from_slice(&hmac.finalize().into_bytes());
-            out
-        })
-    }
-
    #[message]
    pub async fn bootstrap(&mut self, seal_key_raw: SafeCell<Vec<u8>>) -> Result<(), Error> {
        if !matches!(self.state, State::Unbootstrapped) {
@@ -272,22 +251,6 @@ impl KeyHolder {
        Ok(())
    }

-    // Signs a generic integrity payload using the vault-derived integrity key
-    #[message]
-    pub fn sign_integrity_tag(
-        &mut self,
-        purpose_tag: Vec<u8>,
-        data_parts: Vec<Vec<u8>>,
-    ) -> Result<Vec<u8>, Error> {
-        let State::Unsealed { root_key, .. } = &mut self.state else {
-            return Err(Error::NotBootstrapped);
-        };
-
-        let tag =
-            compute_integrity_tag(root_key, &purpose_tag, data_parts.iter().map(Vec::as_slice));
-        Ok(tag.to_vec())
-    }
-
    #[message]
    pub async fn decrypt(&mut self, aead_id: i32) -> Result<SafeCell<Vec<u8>>, Error> {
        let State::Unsealed { root_key, .. } = &mut self.state else {
@@ -371,12 +334,12 @@ impl KeyHolder {
            return Err(Error::NotBootstrapped);
        };

-        let integrity_key = Self::derive_integrity_key(root_key);
-
-        let mut hmac = match HmacSha256::new_from_slice(&integrity_key) {
+        let mut hmac = root_key
+            .0
+            .read_inline(|k| match HmacSha256::new_from_slice(k) {
                Ok(v) => v,
                Err(_) => unreachable!("HMAC accepts keys of any size"),
-        };
+            });
        hmac.update(&root_key_history_id.to_be_bytes());
        hmac.update(&mac_input);

@@ -403,11 +366,12 @@ impl KeyHolder {
            return Ok(false);
        }

-        let integrity_key = Self::derive_integrity_key(root_key);
-        let mut hmac = match HmacSha256::new_from_slice(&integrity_key) {
+        let mut hmac = root_key
+            .0
+            .read_inline(|k| match HmacSha256::new_from_slice(k) {
                Ok(v) => v,
                Err(_) => unreachable!("HMAC accepts keys of any size"),
-        };
+            });
        hmac.update(&key_version.to_be_bytes());
        hmac.update(&mac_input);

--- a/server/crates/arbiter-server/src/actors/user_agent/auth.rs
+++ b/server/crates/arbiter-server/src/actors/user_agent/auth.rs
@@ -37,6 +37,13 @@ impl Error {
    }
 }

+impl From<diesel::result::Error> for Error {
+    fn from(e: diesel::result::Error) -> Self {
+        error!(?e, "Database error");
+        Self::internal("Database error")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum Outbound {
    AuthChallenge { nonce: i32 },
--- a/server/crates/arbiter-server/src/actors/user_agent/auth/state.rs
+++ b/server/crates/arbiter-server/src/actors/user_agent/auth/state.rs
@@ -1,27 +1,20 @@
 use arbiter_proto::transport::Bi;
 use diesel::{ExpressionMethods as _, OptionalExtension as _, QueryDsl, update};
-use diesel_async::RunQueryDsl;
-use kameo::error::SendError;
+use diesel_async::{AsyncConnection, RunQueryDsl};
+use kameo::{actor::ActorRef, error::SendError};
 use tracing::error;

 use super::Error;
 use crate::{
    actors::{
        bootstrap::ConsumeToken,
-        keyholder::{self, SignIntegrityTag},
-        user_agent::{AuthPublicKey, UserAgentConnection, auth::Outbound},
+        keyholder::KeyHolder,
+        user_agent::{AuthPublicKey, UserAgentConnection, UserAgentCredentials, auth::Outbound},
    },
-    crypto::integrity::v1::USERAGENT_INTEGRITY_TAG,
-    db::schema,
+    crypto::integrity::{self, AttestationStatus},
+    db::{DatabasePool, schema::useragent_client},
 };

-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AttestationStatus {
-    Attested,
-    NotAttested,
-    Unavailable,
-}
-
 pub struct ChallengeRequest {
    pub pubkey: AuthPublicKey,
 }
@@ -50,11 +43,11 @@ smlang::statemachine!(
    }
 );

-async fn create_nonce(
-    db: &crate::db::DatabasePool,
-    pubkey_bytes: &[u8],
-    key_type: crate::db::models::KeyType,
-) -> Result<i32, Error> {
+/// Returns the current nonce, ready to use for the challenge nonce.
+async fn get_current_nonce_and_id(
+    db: &DatabasePool,
+    key: &AuthPublicKey,
+) -> Result<(i32, i32), Error> {
    let mut db_conn = db.get().await.map_err(|e| {
        error!(error = ?e, "Database pool error");
        Error::internal("Database unavailable")
@@ -62,21 +55,12 @@ async fn create_nonce(
    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()))
-                    .filter(schema::useragent_client::key_type.eq(key_type))
-                    .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()))
-                    .filter(schema::useragent_client::key_type.eq(key_type))
-                    .set(schema::useragent_client::nonce.eq(current_nonce + 1))
-                    .execute(conn)
-                    .await?;
-
-                Result::<_, diesel::result::Error>::Ok(current_nonce)
+                useragent_client::table
+                    .filter(useragent_client::public_key.eq(key.to_stored_bytes()))
+                    .filter(useragent_client::key_type.eq(key.key_type()))
+                    .select((useragent_client::id, useragent_client::nonce))
+                    .first::<(i32, i32)>(conn)
+                    .await
            })
        })
        .await
@@ -86,15 +70,98 @@ async fn create_nonce(
            Error::internal("Database operation failed")
        })?
        .ok_or_else(|| {
-            error!(?pubkey_bytes, "Public key not found in database");
+            error!(?key, "Public key not found in database");
            Error::UnregisteredPublicKey
        })
 }

-async fn register_key(
-    db: &crate::db::DatabasePool,
+async fn verify_integrity(
+    db: &DatabasePool,
+    keyholder: &ActorRef<KeyHolder>,
+    pubkey: &AuthPublicKey,
+) -> Result<(), Error> {
+    let mut db_conn = db.get().await.map_err(|e| {
+        error!(error = ?e, "Database pool error");
+        Error::internal("Database unavailable")
+    })?;
+
+    let (id, nonce) = get_current_nonce_and_id(db, pubkey).await?;
+
+    let result = integrity::verify_entity(
+        &mut db_conn,
+        keyholder,
+        &UserAgentCredentials {
+            pubkey: pubkey.clone(),
+            nonce,
+        },
+        id,
+    )
+    .await
+    .map_err(|e| {
+        error!(?e, "Integrity verification failed");
+        Error::internal("Integrity verification failed")
+    })?;
+
+    match result {
+        AttestationStatus::Attested | AttestationStatus::Unavailable => Ok(()),
+        AttestationStatus::NotAttested => {
+            error!(?pubkey, "Integrity verification failed: not attested");
+            Err(Error::internal("Database tampering detected"))
+        }
+    }
+
+}
+
+async fn create_nonce(
+    db: &DatabasePool,
+    keyholder: &ActorRef<KeyHolder>,
+    pubkey: &AuthPublicKey,
+) -> Result<i32, Error> {
+    let mut db_conn = db.get().await.map_err(|e| {
+        error!(error = ?e, "Database pool error");
+        Error::internal("Database unavailable")
+    })?;
+    let new_nonce = db_conn
+        .exclusive_transaction(|conn| {
+            Box::pin(async move {
+                let (id, new_nonce): (i32, i32) = update(useragent_client::table)
+                    .filter(useragent_client::public_key.eq(pubkey.to_stored_bytes()))
+                    .filter(useragent_client::key_type.eq(pubkey.key_type()))
+                    .set(useragent_client::nonce.eq(useragent_client::nonce + 1))
+                    .returning((useragent_client::id, useragent_client::nonce))
+                    .get_result(conn)
+                    .await
+                    .map_err(|e| {
+                        error!(error = ?e, "Database error");
+                        Error::internal("Database operation failed")
+                    })?;
+
+                integrity::sign_entity(
+                    conn,
+                    keyholder,
+                    &UserAgentCredentials {
+                        pubkey: pubkey.clone(),
+                        nonce: new_nonce,
+                    },
+                    id,
+                )
+                .await
+                .map_err(|e| {
+                    error!(?e, "Integrity signature update failed");
+                    Error::internal("Database error")
+                })?;
+
+                Result::<_, Error>::Ok(new_nonce)
+            })
+        })
+        .await?;
+    Ok(new_nonce)
+}
+
+async fn register_key(
+    db: &DatabasePool,
+    keyholder: &ActorRef<KeyHolder>,
    pubkey: &AuthPublicKey,
-    integrity_tag: Option<Vec<u8>>,
 ) -> Result<(), Error> {
    let pubkey_bytes = pubkey.to_stored_bytes();
    let key_type = pubkey.key_type();
@@ -103,20 +170,41 @@ async fn register_key(
        Error::internal("Database unavailable")
    })?;

-    diesel::insert_into(schema::useragent_client::table)
+    conn.transaction(|conn| {
+        Box::pin(async move {
+            const NONCE_START: i32 = 1;
+
+            let id: i32 = diesel::insert_into(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),
-            schema::useragent_client::pubkey_integrity_tag.eq(integrity_tag),
+                    useragent_client::public_key.eq(pubkey_bytes),
+                    useragent_client::nonce.eq(NONCE_START),
+                    useragent_client::key_type.eq(key_type),
                ))
-        .execute(&mut conn)
+                .returning(useragent_client::id)
+                .get_result(conn)
                .await
                .map_err(|e| {
                    error!(error = ?e, "Database error");
                    Error::internal("Database operation failed")
                })?;

+            let entity = UserAgentCredentials {
+                pubkey: pubkey.clone(),
+                nonce: NONCE_START,
+            };
+
+            integrity::sign_entity(conn, &keyholder, &entity, id)
+                .await
+                .map_err(|e| {
+                    error!(error = ?e, "Failed to sign integrity tag for new user-agent key");
+                    Error::internal("Failed to register public key")
+                })?;
+
+            Result::<_, Error>::Ok(())
+        })
+    })
+    .await?;
+
    Ok(())
 }

@@ -141,15 +229,9 @@ where
        &mut self,
        ChallengeRequest { pubkey }: ChallengeRequest,
    ) -> Result<ChallengeContext, Self::Error> {
-        match self.verify_pubkey_attestation_status(&pubkey).await? {
-            AttestationStatus::Attested | AttestationStatus::Unavailable => {}
-            AttestationStatus::NotAttested => {
-                return Err(Error::InvalidChallengeSolution);
-            }
-        }
+        verify_integrity(&self.conn.db, &self.conn.actors.key_holder, &pubkey).await?;

-        let stored_bytes = pubkey.to_stored_bytes();
-        let nonce = create_nonce(&self.conn.db, &stored_bytes, pubkey.key_type()).await?;
+        let nonce = create_nonce(&self.conn.db, &self.conn.actors.key_holder, &pubkey).await?;

        self.transport
            .send(Ok(Outbound::AuthChallenge { nonce }))
@@ -189,23 +271,25 @@ where
            return Err(Error::InvalidBootstrapToken);
        }

-        let integrity_tag = self
-            .try_sign_pubkey_integrity_tag(&pubkey)
-            .await
-            .map_err(|err| {
-                error!(?err, "Failed to sign user-agent pubkey integrity tag");
-                Error::internal("Failed to sign user-agent pubkey integrity tag")
-            })?;
-
-        register_key(&self.conn.db, &pubkey, integrity_tag).await?;
-
+        match token_ok {
+            true => {
+                register_key(&self.conn.db, &self.conn.actors.key_holder, &pubkey).await?;
                self.transport
                    .send(Ok(Outbound::AuthSuccess))
                    .await
                    .map_err(|_| Error::Transport)?;
-
                Ok(pubkey)
            }
+            false => {
+                error!("Invalid bootstrap token provided");
+                self.transport
+                    .send(Err(Error::InvalidBootstrapToken))
+                    .await
+                    .map_err(|_| Error::Transport)?;
+                Err(Error::InvalidBootstrapToken)
+            }
+        }
+    }

    #[allow(missing_docs)]
    #[allow(clippy::unused_unit)]
@@ -264,93 +348,3 @@ where
        }
    }
 }
-
-impl<T> AuthContext<'_, T>
-where
-    T: Bi<super::Inbound, Result<super::Outbound, Error>> + Send,
-{
-    async fn try_sign_pubkey_integrity_tag(
-        &self,
-        pubkey: &AuthPublicKey,
-    ) -> Result<Option<Vec<u8>>, Error> {
-        let signed = self
-            .conn
-            .actors
-            .key_holder
-            .ask(SignIntegrityTag {
-                purpose_tag: USERAGENT_INTEGRITY_TAG.to_vec(),
-                data_parts: vec![
-                    (pubkey.key_type() as i32).to_be_bytes().to_vec(),
-                    pubkey.to_stored_bytes(),
-                ],
-            })
-            .await;
-
-        match signed {
-            Ok(tag) => Ok(Some(tag)),
-            Err(SendError::HandlerError(keyholder::Error::NotBootstrapped)) => Ok(None),
-            Err(SendError::HandlerError(err)) => {
-                error!(
-                    ?err,
-                    "Keyholder failed to sign user-agent pubkey integrity tag"
-                );
-                Err(Error::internal(
-                    "Keyholder failed to sign user-agent pubkey integrity tag",
-                ))
-            }
-            Err(err) => {
-                error!(
-                    ?err,
-                    "Failed to contact keyholder for user-agent pubkey integrity tag"
-                );
-                Err(Error::internal(
-                    "Failed to contact keyholder for user-agent pubkey integrity tag",
-                ))
-            }
-        }
-    }
-
-    async fn verify_pubkey_attestation_status(
-        &self,
-        pubkey: &AuthPublicKey,
-    ) -> Result<AttestationStatus, Error> {
-        let stored_tag: Option<Option<Vec<u8>>> = {
-            let mut conn = self.conn.db.get().await.map_err(|e| {
-                error!(error = ?e, "Database pool error");
-                Error::internal("Database unavailable")
-            })?;
-
-            schema::useragent_client::table
-                .filter(schema::useragent_client::public_key.eq(pubkey.to_stored_bytes()))
-                .filter(schema::useragent_client::key_type.eq(pubkey.key_type()))
-                .select(schema::useragent_client::pubkey_integrity_tag)
-                .first::<Option<Vec<u8>>>(&mut conn)
-                .await
-                .optional()
-                .map_err(|e| {
-                    error!(error = ?e, "Database error");
-                    Error::internal("Database operation failed")
-                })?
-        };
-
-        let Some(stored_tag) = stored_tag else {
-            return Err(Error::UnregisteredPublicKey);
-        };
-
-        let Some(expected_tag) = self.try_sign_pubkey_integrity_tag(pubkey).await? else {
-            return Ok(AttestationStatus::Unavailable);
-        };
-
-        match stored_tag {
-            Some(stored_tag) if stored_tag == expected_tag => Ok(AttestationStatus::Attested),
-            Some(_) => {
-                error!("User-agent pubkey integrity tag mismatch");
-                Ok(AttestationStatus::NotAttested)
-            }
-            None => {
-                error!("Missing pubkey integrity tag for registered key while vault is unsealed");
-                Ok(AttestationStatus::NotAttested)
-            }
-        }
-    }
-}
--- a/server/crates/arbiter-server/src/actors/user_agent/mod.rs
+++ b/server/crates/arbiter-server/src/actors/user_agent/mod.rs
@@ -1,18 +1,65 @@
 use crate::{
-    actors::{GlobalActors, client::ClientProfile},
-    db::{self, models::KeyType},
+    actors::{GlobalActors, client::ClientProfile}, crypto::integrity::Integrable, db::{self, models::KeyType}
 };

+fn serialize_ecdsa<S>(key: &k256::ecdsa::VerifyingKey, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    // Serialize as hex string for easier debugging (33 bytes compressed SEC1 format)
+    let key = key.to_encoded_point(true);
+    let bytes = key.as_bytes();
+    serializer.serialize_bytes(bytes)
+}
+
+fn deserialize_ecdsa<'de, D>(deserializer: D) -> Result<k256::ecdsa::VerifyingKey, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    struct EcdsaVisitor;
+
+    impl<'de> serde::de::Visitor<'de> for EcdsaVisitor {
+        type Value = k256::ecdsa::VerifyingKey;
+
+        fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+            formatter.write_str("a compressed SEC1-encoded ECDSA public key")
+        }
+
+        fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+        where
+            E: serde::de::Error,
+        {
+            let point = k256::EncodedPoint::from_bytes(v)
+                .map_err(|_| E::custom("invalid compressed SEC1 format"))?;
+            k256::ecdsa::VerifyingKey::from_encoded_point(&point)
+                .map_err(|_| E::custom("invalid ECDSA public key"))
+        }
+    }
+
+    deserializer.deserialize_bytes(EcdsaVisitor)
+}
+
 /// Abstraction over Ed25519 / ECDSA-secp256k1 / RSA public keys used during the auth handshake.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize)]
 pub enum AuthPublicKey {
    Ed25519(ed25519_dalek::VerifyingKey),
    /// Compressed SEC1 public key; signature bytes are raw 64-byte (r||s).
+    #[serde(serialize_with = "serialize_ecdsa", deserialize_with = "deserialize_ecdsa")]
    EcdsaSecp256k1(k256::ecdsa::VerifyingKey),
    /// RSA-2048+ public key (Windows Hello / KeyCredentialManager); signature bytes are PSS+SHA-256.
    Rsa(rsa::RsaPublicKey),
 }

+#[derive(Debug, Serialize)]
+pub struct UserAgentCredentials {
+    pub pubkey: AuthPublicKey,
+    pub nonce: i32
+}
+
+impl Integrable for UserAgentCredentials {
+    const KIND: &'static str = "useragent_credentials";
+}
+
 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.
@@ -91,4 +138,5 @@ pub mod auth;
 pub mod session;

 pub use auth::authenticate;
+use serde::Serialize;
 pub use session::UserAgentSession;
--- a/server/crates/arbiter-server/src/actors/user_agent/session/connection.rs
+++ b/server/crates/arbiter-server/src/actors/user_agent/session/connection.rs
@@ -349,9 +349,6 @@ impl UserAgentSession {
            .await
        {
            Ok(grant_id) => Ok(grant_id),
-            Err(SendError::HandlerError(crate::actors::evm::Error::VaultSealed)) => {
-                Err(GrantMutationError::VaultSealed)
-            }
            Err(err) => {
                error!(?err, "EVM grant create failed");
                Err(GrantMutationError::Internal)
@@ -372,9 +369,6 @@ impl UserAgentSession {
            .await
        {
            Ok(()) => Ok(()),
-            Err(SendError::HandlerError(crate::actors::evm::Error::VaultSealed)) => {
-                Err(GrantMutationError::VaultSealed)
-            }
            Err(err) => {
                error!(?err, "EVM grant delete failed");
                Err(GrantMutationError::Internal)
--- a/server/crates/arbiter-server/src/crypto/encryption/mod.rs
+++ b/server/crates/arbiter-server/src/crypto/encryption/mod.rs
@@ -1 +1,3 @@
 pub mod v1;
+
+pub use v1::*;
--- a/server/crates/arbiter-server/src/crypto/integrity/mod.rs
+++ b/server/crates/arbiter-server/src/crypto/integrity/mod.rs
@@ -1 +1,3 @@
 pub mod v1;
+
+pub use v1::*;
--- a/server/crates/arbiter-server/src/crypto/integrity/v1.rs
+++ b/server/crates/arbiter-server/src/crypto/integrity/v1.rs
@@ -1,78 +1,320 @@
-use crate::{crypto::KeyCell, safe_cell::SafeCellHandle as _};
+use crate::{actors::keyholder, crypto::KeyCell,safe_cell::SafeCellHandle as _};
 use chacha20poly1305::Key;
-use hmac::Mac as _;
+use hmac::{Hmac, Mac as _};
+use serde::Serialize;
+use sha2::Sha256;

-pub const USERAGENT_INTEGRITY_DERIVE_TAG: &[u8] = "arbiter/useragent/integrity-key/v1".as_bytes();
-pub const USERAGENT_INTEGRITY_TAG: &[u8] = "arbiter/useragent/pubkey-entry/v1".as_bytes();
+use diesel::{ExpressionMethods as _, QueryDsl, dsl::insert_into, sqlite::Sqlite};
+use diesel_async::{AsyncConnection, RunQueryDsl};
+use kameo::{actor::ActorRef, error::SendError};
+use sha2::Digest as _;

-/// Computes an integrity tag for a specific domain and payload shape.
-pub fn compute_integrity_tag<'a, I>(
-    integrity_key: &mut KeyCell,
-    purpose_tag: &[u8],
-    data_parts: I,
-) -> [u8; 32]
-where
-    I: IntoIterator<Item = &'a [u8]>,
-{
-    type HmacSha256 = hmac::Hmac<sha2::Sha256>;
+use crate::{
+    actors::keyholder::{KeyHolder, SignIntegrity, VerifyIntegrity},
+    db::{
+        self,
+        models::{IntegrityEnvelope, NewIntegrityEnvelope},
+        schema::integrity_envelope,
+    },
+};

-    let mut output_tag = [0u8; 32];
-    integrity_key.0.read_inline(|integrity_key_bytes: &Key| {
-        let mut mac = <HmacSha256 as hmac::Mac>::new_from_slice(integrity_key_bytes.as_ref())
-            .expect("HMAC key initialization must not fail for 32-byte key");
-        mac.update(purpose_tag);
-        for data_part in data_parts {
-            mac.update(data_part);
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Database error: {0}")]
+    Database(#[from] db::DatabaseError),
+
+    #[error("KeyHolder error: {0}")]
+    Keyholder(#[from] keyholder::Error),
+
+    #[error("KeyHolder mailbox error")]
+    KeyholderSend,
+
+    #[error("Integrity envelope is missing for entity {entity_kind}")]
+    MissingEnvelope { entity_kind: &'static str },
+
+    #[error(
+        "Integrity payload version mismatch for entity {entity_kind}: expected {expected}, found {found}"
+    )]
+    PayloadVersionMismatch {
+        entity_kind: &'static str,
+        expected: i32,
+        found: i32,
+    },
+
+    #[error("Integrity MAC mismatch for entity {entity_kind}")]
+    MacMismatch { entity_kind: &'static str },
+
+    #[error("Payload serialization error: {0}")]
+    PayloadSerialization(#[from] postcard::Error),
 }
-        output_tag.copy_from_slice(&mac.finalize().into_bytes());
-    });

-    output_tag
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AttestationStatus {
+    Attested,
+    NotAttested,
+    Unavailable,
+}
+
+pub const CURRENT_PAYLOAD_VERSION: i32 = 1;
+pub const INTEGRITY_SUBKEY_TAG: &[u8] = b"arbiter/db-integrity-key/v1";
+
+pub type HmacSha256 = Hmac<Sha256>;
+
+pub trait Integrable: Serialize {
+    const KIND: &'static str;
+    const VERSION: i32 = 1;
+}
+
+fn payload_hash(payload: &[u8]) -> [u8; 32] {
+    Sha256::digest(payload).into()
+}
+
+fn push_len_prefixed(out: &mut Vec<u8>, bytes: &[u8]) {
+    out.extend_from_slice(&(bytes.len() as u32).to_be_bytes());
+    out.extend_from_slice(bytes);
+}
+
+fn build_mac_input(
+    entity_kind: &str,
+    entity_id: &[u8],
+    payload_version: i32,
+    payload_hash: &[u8; 32],
+) -> Vec<u8> {
+    let mut out = Vec::with_capacity(8 + entity_kind.len() + entity_id.len() + 32);
+    push_len_prefixed(&mut out, entity_kind.as_bytes());
+    push_len_prefixed(&mut out, entity_id);
+    out.extend_from_slice(&payload_version.to_be_bytes());
+    out.extend_from_slice(payload_hash);
+    out
+}
+
+pub trait IntoId {
+    fn into_id(self) -> Vec<u8>;
+}
+
+impl IntoId for i32 {
+    fn into_id(self) -> Vec<u8> {
+        self.to_be_bytes().to_vec()
+    }
+}
+
+impl IntoId for &'_ [u8] {
+    fn into_id(self) -> Vec<u8> {
+        self.to_vec()
+    }
+}
+
+pub async fn sign_entity<E: Integrable>(
+    conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    keyholder: &ActorRef<KeyHolder>,
+    entity: &E,
+    entity_id: impl IntoId,
+) -> Result<(), Error> {
+    let payload = postcard::to_stdvec(entity)?;
+    let payload_hash = payload_hash(&payload);
+
+    let entity_id = entity_id.into_id();
+
+    let mac_input = build_mac_input(E::KIND, &entity_id, E::VERSION, &payload_hash);
+
+    let (key_version, mac) = keyholder
+        .ask(SignIntegrity { mac_input })
+        .await
+        .map_err(|err| match err {
+            kameo::error::SendError::HandlerError(inner) => Error::Keyholder(inner),
+            _ => Error::KeyholderSend,
+        })?;
+
+    insert_into(integrity_envelope::table)
+        .values(NewIntegrityEnvelope {
+            entity_kind: E::KIND.to_owned(),
+            entity_id: entity_id,
+            payload_version: E::VERSION ,
+            key_version,
+            mac: mac.to_vec(),
+        })
+        .on_conflict((
+            integrity_envelope::entity_id,
+            integrity_envelope::entity_kind,
+        ))
+        .do_update()
+        .set((
+            integrity_envelope::payload_version.eq(E::VERSION),
+            integrity_envelope::key_version.eq(key_version),
+            integrity_envelope::mac.eq(mac),
+        ))
+        .execute(conn)
+        .await
+        .map_err(db::DatabaseError::from)?;
+
+    Ok(())
+}
+
+pub async fn verify_entity<E: Integrable>(
+    conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    keyholder: &ActorRef<KeyHolder>,
+    entity: &E,
+    entity_id: impl IntoId,
+) -> Result<AttestationStatus, Error> {
+    let entity_id = entity_id.into_id();
+    let envelope: IntegrityEnvelope = integrity_envelope::table
+        .filter(integrity_envelope::entity_kind.eq(E::KIND))
+        .filter(integrity_envelope::entity_id.eq(&entity_id))
+        .first(conn)
+        .await
+        .map_err(|err| match err {
+            diesel::result::Error::NotFound => Error::MissingEnvelope { entity_kind: E::KIND },
+            other => Error::Database(db::DatabaseError::from(other)),
+        })?;
+
+    if envelope.payload_version != E::VERSION {
+        return Err(Error::PayloadVersionMismatch {
+            entity_kind: E::KIND,
+            expected: E::VERSION,
+            found: envelope.payload_version,
+        });
+    }
+
+    let payload = postcard::to_stdvec(entity)?;
+    let payload_hash = payload_hash(&payload);
+    let mac_input = build_mac_input(
+        E::KIND,
+        &entity_id,
+        envelope.payload_version,
+        &payload_hash,
+    );
+
+    let result = keyholder
+        .ask(VerifyIntegrity {
+            mac_input,
+            expected_mac: envelope.mac,
+            key_version: envelope.key_version,
+        })
+        .await
+        ;
+
+    match result {
+        Ok(true) => Ok(AttestationStatus::Attested),
+        Ok(false) => Ok(AttestationStatus::NotAttested),
+        Err(SendError::HandlerError(keyholder::Error::NotBootstrapped)) => Ok(AttestationStatus::Unavailable),
+        Err(_) => Err(Error::KeyholderSend),
+    }
 }

 #[cfg(test)]
 mod tests {
+    use diesel::{ExpressionMethods as _, QueryDsl};
+    use diesel_async::RunQueryDsl;
+    use kameo::{actor::ActorRef, prelude::Spawn};
+
    use crate::{
-        crypto::{derive_key, encryption::v1::generate_salt},
+        actors::keyholder::{Bootstrap, KeyHolder},
+        db::{self, schema},
        safe_cell::{SafeCell, SafeCellHandle as _},
    };

-    use super::{USERAGENT_INTEGRITY_TAG, compute_integrity_tag};
+    use super::{Error, Integrable, sign_entity, verify_entity};

-    #[test]
-    pub fn integrity_tag_deterministic() {
-        let salt = generate_salt();
-        let mut integrity_key = derive_key(SafeCell::new(b"password".to_vec()), &salt);
-        let key_type = 1i32.to_be_bytes();
-        let t1 = compute_integrity_tag(
-            &mut integrity_key,
-            USERAGENT_INTEGRITY_TAG,
-            [key_type.as_slice(), b"pubkey".as_ref()],
-        );
-        let t2 = compute_integrity_tag(
-            &mut integrity_key,
-            USERAGENT_INTEGRITY_TAG,
-            [key_type.as_slice(), b"pubkey".as_ref()],
-        );
-        assert_eq!(t1, t2);
+    #[derive(Clone, serde::Serialize)]
+    struct DummyEntity {
+        payload_version: i32,
+        payload: Vec<u8>,
    }

-    #[test]
-    pub fn integrity_tag_changes_with_payload() {
-        let salt = generate_salt();
-        let mut integrity_key = derive_key(SafeCell::new(b"password".to_vec()), &salt);
-        let key_type_1 = 1i32.to_be_bytes();
-        let key_type_2 = 2i32.to_be_bytes();
-        let t1 = compute_integrity_tag(
-            &mut integrity_key,
-            USERAGENT_INTEGRITY_TAG,
-            [key_type_1.as_slice(), b"pubkey".as_ref()],
-        );
-        let t2 = compute_integrity_tag(
-            &mut integrity_key,
-            USERAGENT_INTEGRITY_TAG,
-            [key_type_2.as_slice(), b"pubkey".as_ref()],
-        );
-        assert_ne!(t1, t2);
+    impl Integrable for DummyEntity {
+        const KIND: &'static str = "dummy_entity";
+    }
+
+    async fn bootstrapped_keyholder(db: &db::DatabasePool) -> ActorRef<KeyHolder> {
+        let actor = KeyHolder::spawn(KeyHolder::new(db.clone()).await.unwrap());
+        actor
+            .ask(Bootstrap {
+                seal_key_raw: SafeCell::new(b"integrity-test-seal-key".to_vec()),
+            })
+            .await
+            .unwrap();
+        actor
+    }
+
+    #[tokio::test]
+    async fn sign_writes_envelope_and_verify_passes() {
+        let db = db::create_test_pool().await;
+        let keyholder = bootstrapped_keyholder(&db).await;
+        let mut conn = db.get().await.unwrap();
+
+        const ENTITY_ID: &[u8] = b"entity-id-7";
+
+        let entity = DummyEntity {
+            payload_version: 1,
+            payload: b"payload-v1".to_vec(),
+        };
+
+        sign_entity(&mut conn, &keyholder, &entity, ENTITY_ID).await.unwrap();
+
+        let count: i64 = schema::integrity_envelope::table
+            .filter(schema::integrity_envelope::entity_kind.eq("dummy_entity"))
+            .filter(schema::integrity_envelope::entity_id.eq(ENTITY_ID))
+            .count()
+            .get_result(&mut conn)
+            .await
+            .unwrap();
+
+        assert_eq!(count, 1, "envelope row must be created exactly once");
+        verify_entity(&mut conn, &keyholder, &entity, ENTITY_ID).await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn tampered_mac_fails_verification() {
+        let db = db::create_test_pool().await;
+        let keyholder = bootstrapped_keyholder(&db).await;
+        let mut conn = db.get().await.unwrap();
+
+        const ENTITY_ID: &[u8] = b"entity-id-11";
+
+        let entity = DummyEntity {
+            payload_version: 1,
+            payload: b"payload-v1".to_vec(),
+        };
+
+        sign_entity(&mut conn, &keyholder, &entity, ENTITY_ID).await.unwrap();
+
+        diesel::update(schema::integrity_envelope::table)
+            .filter(schema::integrity_envelope::entity_kind.eq("dummy_entity"))
+            .filter(schema::integrity_envelope::entity_id.eq(ENTITY_ID))
+            .set(schema::integrity_envelope::mac.eq(vec![0u8; 32]))
+            .execute(&mut conn)
+            .await
+            .unwrap();
+
+        let err = verify_entity(&mut conn, &keyholder, &entity, ENTITY_ID)
+            .await
+            .unwrap_err();
+        assert!(matches!(err, Error::MacMismatch { .. }));
+    }
+
+    #[tokio::test]
+    async fn changed_payload_fails_verification() {
+        let db = db::create_test_pool().await;
+        let keyholder = bootstrapped_keyholder(&db).await;
+        let mut conn = db.get().await.unwrap();
+
+        const ENTITY_ID: &[u8] = b"entity-id-21";
+
+        let entity = DummyEntity {
+            payload_version: 1,
+            payload: b"payload-v1".to_vec(),
+        };
+
+        sign_entity(&mut conn, &keyholder, &entity, ENTITY_ID).await.unwrap();
+
+        let tampered = DummyEntity {
+            payload: b"payload-v1-but-tampered".to_vec(),
+            ..entity
+        };
+
+        let err = verify_entity(&mut conn, &keyholder, &tampered, ENTITY_ID)
+            .await
+            .unwrap_err();
+        assert!(matches!(err, Error::MacMismatch { .. }));
    }
 }
--- a/server/crates/arbiter-server/src/db/models.rs
+++ b/server/crates/arbiter-server/src/db/models.rs
@@ -242,7 +242,6 @@ pub struct UseragentClient {
    pub id: i32,
    pub nonce: i32,
    pub public_key: Vec<u8>,
-    pub pubkey_integrity_tag: Option<Vec<u8>>,
    pub created_at: SqliteTimestamp,
    pub updated_at: SqliteTimestamp,
    pub key_type: KeyType,
--- a/server/crates/arbiter-server/src/db/schema.rs
+++ b/server/crates/arbiter-server/src/db/schema.rs
@@ -191,7 +191,6 @@ diesel::table! {
        id -> Integer,
        nonce -> Integer,
        public_key -> Binary,
-        pubkey_integrity_tag -> Nullable<Binary>,
        key_type -> Integer,
        created_at -> Integer,
        updated_at -> Integer,
--- a/server/crates/arbiter-server/src/evm/mod.rs
+++ b/server/crates/arbiter-server/src/evm/mod.rs
@@ -12,6 +12,7 @@ use kameo::actor::ActorRef;

 use crate::{
    actors::keyholder::KeyHolder,
+    crypto::integrity,
    db::{
        self, DatabaseError,
        models::{
@@ -20,11 +21,10 @@ use crate::{
        schema::{self, evm_transaction_log},
    },
    evm::policies::{
-        DatabaseID, EvalContext, EvalViolation, FullGrant, Grant, Policy, SharedGrantSettings,
+        DatabaseID, EvalContext, EvalViolation, Grant, Policy, CombinedSettings, SharedGrantSettings,
        SpecificGrant, SpecificMeaning, ether_transfer::EtherTransfer,
        token_transfers::TokenTransfer,
    },
-    integrity,
 };

 pub mod policies;
@@ -63,6 +63,15 @@ pub enum AnalyzeError {
    UnsupportedTransactionType,
 }

+#[derive(Debug, thiserror::Error)]
+pub enum ListError {
+    #[error("Database error")]
+    Database(#[from] crate::db::DatabaseError),
+
+    #[error("Integrity verification failed for grant")]
+    Integrity(#[from] integrity::Error),
+}
+
 /// Controls whether a transaction should be executed or only validated
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum RunKind {
@@ -141,16 +150,14 @@ impl Engine {
            .map_err(DatabaseError::from)?
            .ok_or(PolicyError::NoMatchingGrant)?;

-        let signed_grant = integrity::evm::SignedEvmGrant::from_active_grant(&Grant {
-            id: grant.id,
-            shared_grant_id: grant.shared_grant_id,
-            shared: grant.shared.clone(),
-            settings: grant.settings.clone().into(),
-        });
-        integrity::verify_entity(&mut conn, &self.keyholder, &signed_grant).await?;
+        integrity::verify_entity(&mut conn, &self.keyholder, &grant.settings, grant.id).await?;

-        let mut violations =
-            check_shared_constraints(&context, &grant.shared, grant.shared_grant_id, &mut conn)
+        let mut violations = check_shared_constraints(
+            &context,
+            &grant.settings.shared,
+            grant.common_settings_id,
+            &mut conn,
+        )
        .await
        .map_err(DatabaseError::from)?;
        violations.extend(
@@ -168,7 +175,7 @@ impl Engine {
                Box::pin(async move {
                    let log_id: i32 = insert_into(evm_transaction_log::table)
                        .values(&NewEvmTransactionLog {
-                            grant_id: grant.shared_grant_id,
+                            grant_id: grant.common_settings_id,
                            wallet_access_id: context.target.id,
                            chain_id: context.chain as i32,
                            eth_value: utils::u256_to_bytes(context.value).to_vec(),
@@ -198,7 +205,7 @@ impl Engine {

    pub async fn create_grant<P: Policy>(
        &self,
-        full_grant: FullGrant<P::Settings>,
+        full_grant: CombinedSettings<P::Settings>,
    ) -> Result<i32, DatabaseError>
    where
        P::Settings: Clone,
@@ -213,25 +220,25 @@ impl Engine {

                    let basic_grant: EvmBasicGrant = insert_into(evm_basic_grant::table)
                        .values(&NewEvmBasicGrant {
-                            chain_id: full_grant.basic.chain as i32,
-                            wallet_access_id: full_grant.basic.wallet_access_id,
-                            valid_from: full_grant.basic.valid_from.map(SqliteTimestamp),
-                            valid_until: full_grant.basic.valid_until.map(SqliteTimestamp),
+                            chain_id: full_grant.shared.chain as i32,
+                            wallet_access_id: full_grant.shared.wallet_access_id,
+                            valid_from: full_grant.shared.valid_from.map(SqliteTimestamp),
+                            valid_until: full_grant.shared.valid_until.map(SqliteTimestamp),
                            max_gas_fee_per_gas: full_grant
-                                .basic
+                                .shared
                                .max_gas_fee_per_gas
                                .map(|fee| utils::u256_to_bytes(fee).to_vec()),
                            max_priority_fee_per_gas: full_grant
-                                .basic
+                                .shared
                                .max_priority_fee_per_gas
                                .map(|fee| utils::u256_to_bytes(fee).to_vec()),
                            rate_limit_count: full_grant
-                                .basic
+                                .shared
                                .rate_limit
                                .as_ref()
                                .map(|rl| rl.count as i32),
                            rate_limit_window_secs: full_grant
-                                .basic
+                                .shared
                                .rate_limit
                                .as_ref()
                                .map(|rl| rl.window.num_seconds() as i32),
@@ -243,14 +250,12 @@ impl Engine {

                    P::create_grant(&basic_grant, &full_grant.specific, conn).await?;

-                    let signed_grant = integrity::evm::SignedEvmGrant {
-                        basic_grant_id: basic_grant.id,
-                        shared: full_grant.basic.clone(),
-                        specific: full_grant.specific.clone().into(),
-                        revoked_at: basic_grant.revoked_at.map(Into::into),
-                    };
-
-                    integrity::sign_entity(conn, &keyholder, &signed_grant)
+                    integrity::sign_entity(
+                        conn,
+                        &keyholder,
+                        &full_grant,
+                    basic_grant.id,
+                    )
                    .await
                    .map_err(|_| diesel::result::Error::RollbackTransaction)?;

@@ -262,43 +267,36 @@ impl Engine {
        Ok(id)
    }

-    pub async fn list_all_grants(&self) -> Result<Vec<Grant<SpecificGrant>>, DatabaseError> {
-        let mut conn = self.db.get().await?;
+    async fn list_one_kind<Kind: Policy, Y>(
+        &self,
+        conn: &mut impl AsyncConnection<Backend = Sqlite>,
+    ) -> Result<impl Iterator<Item = Grant<Y>>, ListError>
+    where
+        Y: From<Kind::Settings>,
+    {
+        let all_grants = Kind::find_all_grants(conn)
+            .await
+            .map_err(DatabaseError::from)?;
+
+        // Verify integrity of all grants before returning any results
+        for grant in &all_grants {
+            integrity::verify_entity(conn, &self.keyholder, &grant.settings, grant.id).await?;
+        }
+
+        Ok(all_grants.into_iter().map(|g| Grant {
+            id: g.id,
+            common_settings_id: g.common_settings_id,
+            settings: g.settings.generalize(),
+        }))
+    }
+
+    pub async fn list_all_grants(&self) -> Result<Vec<Grant<SpecificGrant>>, ListError> {
+        let mut conn = self.db.get().await.map_err(DatabaseError::from)?;

        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),
-                }),
-        );
-
-        for grant in &grants {
-            let signed = integrity::evm::SignedEvmGrant::from_active_grant(grant);
-            integrity::verify_entity(&mut conn, &self.keyholder, &signed)
-                .await
-                .map_err(|err| match err {
-                    integrity::Error::Database(db_err) => db_err,
-                    _ => DatabaseError::Connection(diesel::result::Error::RollbackTransaction),
-                })?;
-        }
+        grants.extend(self.list_one_kind::<EtherTransfer, _>(&mut conn).await?);
+        grants.extend(self.list_one_kind::<TokenTransfer, _>(&mut conn).await?);

        Ok(grants)
    }
--- a/server/crates/arbiter-server/src/evm/policies.rs
+++ b/server/crates/arbiter-server/src/evm/policies.rs
@@ -7,11 +7,11 @@ use diesel::{
 };
 use diesel_async::{AsyncConnection, RunQueryDsl};

+use serde::Serialize;
 use thiserror::Error;

 use crate::{
-    db::models::{self, EvmBasicGrant, EvmWalletAccess},
-    evm::utils,
+    crypto::integrity::v1::Integrable, db::models::{self, EvmBasicGrant, EvmWalletAccess}, evm::utils
 };

 pub mod ether_transfer;
@@ -59,16 +59,15 @@ pub enum EvalViolation {

 pub type DatabaseID = i32;

-#[derive(Debug)]
+#[derive(Debug, Serialize)]
 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 common_settings_id: DatabaseID, // ID of the basic grant for shared-logic checks like rate limits and validity periods
+    pub settings: CombinedSettings<PolicySettings>,
 }

 pub trait Policy: Sized {
-    type Settings: Send + Sync + 'static + Into<SpecificGrant>;
+    type Settings: Send + Sync + 'static + Into<SpecificGrant> + Integrable;
    type Meaning: Display + std::fmt::Debug + Send + Sync + 'static + Into<SpecificMeaning>;

    fn analyze(context: &EvalContext) -> Option<Self::Meaning>;
@@ -124,19 +123,19 @@ pub enum SpecificMeaning {
    TokenTransfer(token_transfers::Meaning),
 }

-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
 pub struct TransactionRateLimit {
    pub count: u32,
    pub window: Duration,
 }

-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
 pub struct VolumeRateLimit {
    pub max_volume: U256,
    pub window: Duration,
 }

-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Serialize)]
 pub struct SharedGrantSettings {
    pub wallet_access_id: i32,
    pub chain: ChainId,
@@ -197,7 +196,23 @@ pub enum SpecificGrant {
    TokenTransfer(token_transfers::Settings),
 }

-pub struct FullGrant<PolicyGrant> {
-    pub basic: SharedGrantSettings,
+#[derive(Debug, Serialize)]
+pub struct CombinedSettings<PolicyGrant> {
+    pub shared: SharedGrantSettings,
    pub specific: PolicyGrant,
 }
+
+impl<P> CombinedSettings<P> {
+    pub fn generalize<Y: From<P>>(self) -> CombinedSettings<Y> {
+        CombinedSettings {
+            shared: self.shared,
+            specific: self.specific.into(),
+        }
+    }
+}
+
+impl<P: Integrable> Integrable for CombinedSettings<P> {
+    const KIND: &'static str = P::KIND;
+    const VERSION: i32 = P::VERSION;
+}
+
--- a/server/crates/arbiter-server/src/evm/policies/ether_transfer/mod.rs
+++ b/server/crates/arbiter-server/src/evm/policies/ether_transfer/mod.rs
@@ -8,13 +8,14 @@ use diesel::sqlite::Sqlite;
 use diesel::{ExpressionMethods, JoinOnDsl, prelude::*};
 use diesel_async::{AsyncConnection, RunQueryDsl};

+use crate::crypto::integrity::v1::Integrable;
 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,
+    CombinedSettings, Grant, SharedGrantSettings, SpecificGrant, SpecificMeaning, VolumeRateLimit,
 };
 use crate::{
    db::{
@@ -51,11 +52,14 @@ impl From<Meaning> for SpecificMeaning {
 }

 // A grant for ether transfers, which can be scoped to specific target addresses and volume limits
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, serde::Serialize)]
 pub struct Settings {
    pub target: Vec<Address>,
    pub limit: VolumeRateLimit,
 }
+impl Integrable for Settings {
+    const KIND: &'static str = "EtherTransfer";
+}

 impl From<Settings> for SpecificGrant {
    fn from(val: Settings) -> SpecificGrant {
@@ -95,17 +99,17 @@ async fn check_rate_limits(
    db: &mut impl AsyncConnection<Backend = Sqlite>,
 ) -> QueryResult<Vec<EvalViolation>> {
    let mut violations = Vec::new();
-    let window = grant.settings.limit.window;
+    let window = grant.settings.specific.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 window_start = chrono::Utc::now() - grant.settings.specific.limit.window;
    let prospective_cumulative_volume: U256 = past_transaction
        .iter()
        .filter(|(_, timestamp)| timestamp >= &window_start)
        .fold(current_transfer_value, |acc, (value, _)| acc + *value);

-    if prospective_cumulative_volume > grant.settings.limit.max_volume {
+    if prospective_cumulative_volume > grant.settings.specific.limit.max_volume {
        violations.push(EvalViolation::VolumetricLimitExceeded);
    }

@@ -138,7 +142,7 @@ impl Policy for EtherTransfer {
        let mut violations = Vec::new();

        // Check if the target address is within the grant's allowed targets
-        if !grant.settings.target.contains(&meaning.to) {
+        if !grant.settings.specific.target.contains(&meaning.to) {
            violations.push(EvalViolation::InvalidTarget { target: meaning.to });
        }

@@ -247,9 +251,11 @@ impl Policy for EtherTransfer {

        Ok(Some(Grant {
            id: grant.id,
-            shared_grant_id: grant.basic_grant_id,
+            common_settings_id: grant.basic_grant_id,
+            settings: CombinedSettings {
                shared: SharedGrantSettings::try_from_model(basic_grant)?,
-            settings,
+                specific: settings,
+            },
        }))
    }

@@ -327,9 +333,10 @@ impl Policy for EtherTransfer {

                Ok(Grant {
                    id: specific.id,
-                    shared_grant_id: specific.basic_grant_id,
+                    common_settings_id: specific.basic_grant_id,
+                    settings: CombinedSettings {
                        shared: SharedGrantSettings::try_from_model(basic)?,
-                    settings: Settings {
+                        specific: Settings {
                            target: targets,
                            limit: VolumeRateLimit {
                                max_volume: utils::try_bytes_to_u256(&limit.max_volume).map_err(
@@ -338,6 +345,7 @@ impl Policy for EtherTransfer {
                                window: Duration::seconds(limit.window_secs as i64),
                            },
                        },
+                    },
                })
            })
            .collect()
--- a/server/crates/arbiter-server/src/evm/policies/ether_transfer/tests.rs
+++ b/server/crates/arbiter-server/src/evm/policies/ether_transfer/tests.rs
@@ -11,7 +11,10 @@ use crate::db::{
    schema::{evm_basic_grant, evm_transaction_log},
 };
 use crate::evm::{
-    policies::{EvalContext, EvalViolation, Grant, Policy, SharedGrantSettings, VolumeRateLimit},
+    policies::{
+        CombinedSettings, EvalContext, EvalViolation, Grant, Policy, SharedGrantSettings,
+        VolumeRateLimit,
+    },
    utils,
 };

@@ -108,9 +111,11 @@ async fn evaluate_passes_for_allowed_target() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(vec![ALLOWED], 1_000_000),
+            specific: make_settings(vec![ALLOWED], 1_000_000),
+        },
    };
    let context = ctx(ALLOWED, U256::from(100u64));
    let m = EtherTransfer::analyze(&context).unwrap();
@@ -127,9 +132,11 @@ async fn evaluate_rejects_disallowed_target() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(vec![ALLOWED], 1_000_000),
+            specific: make_settings(vec![ALLOWED], 1_000_000),
+        },
    };
    let context = ctx(OTHER, U256::from(100u64));
    let m = EtherTransfer::analyze(&context).unwrap();
@@ -167,9 +174,11 @@ async fn evaluate_passes_when_volume_within_limit() {

    let grant = Grant {
        id: grant_id,
-        shared_grant_id: basic.id,
+        common_settings_id: basic.id,
+        settings: CombinedSettings {
            shared: shared(),
-        settings,
+            specific: settings,
+        },
    };
    let context = ctx(ALLOWED, U256::from(100u64));
    let m = EtherTransfer::analyze(&context).unwrap();
@@ -207,9 +216,11 @@ async fn evaluate_rejects_volume_over_limit() {

    let grant = Grant {
        id: grant_id,
-        shared_grant_id: basic.id,
+        common_settings_id: basic.id,
+        settings: CombinedSettings {
            shared: shared(),
-        settings,
+            specific: settings,
+        },
    };
    let context = ctx(ALLOWED, U256::from(1u64));
    let m = EtherTransfer::analyze(&context).unwrap();
@@ -248,9 +259,11 @@ async fn evaluate_passes_at_exactly_volume_limit() {

    let grant = Grant {
        id: grant_id,
-        shared_grant_id: basic.id,
+        common_settings_id: basic.id,
+        settings: CombinedSettings {
            shared: shared(),
-        settings,
+            specific: settings,
+        },
    };
    let context = ctx(ALLOWED, U256::from(100u64));
    let m = EtherTransfer::analyze(&context).unwrap();
@@ -282,8 +295,11 @@ async fn try_find_grant_roundtrip() {

    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));
+    assert_eq!(g.settings.specific.target, vec![ALLOWED]);
+    assert_eq!(
+        g.settings.specific.limit.max_volume,
+        U256::from(1_000_000u64)
+    );
 }

 #[tokio::test]
@@ -347,7 +363,7 @@ async fn find_all_grants_excludes_revoked() {

    let all = EtherTransfer::find_all_grants(&mut *conn).await.unwrap();
    assert_eq!(all.len(), 1);
-    assert_eq!(all[0].settings.target, vec![ALLOWED]);
+    assert_eq!(all[0].settings.specific.target, vec![ALLOWED]);
 }

 #[tokio::test]
@@ -363,8 +379,11 @@ async fn find_all_grants_multiple_targets() {

    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));
+    assert_eq!(all[0].settings.specific.target.len(), 2);
+    assert_eq!(
+        all[0].settings.specific.limit.max_volume,
+        U256::from(1_000_000u64)
+    );
 }

 #[tokio::test]
--- a/server/crates/arbiter-server/src/evm/policies/token_transfers/mod.rs
+++ b/server/crates/arbiter-server/src/evm/policies/token_transfers/mod.rs
@@ -10,11 +10,8 @@ use diesel::dsl::{auto_type, insert_into};
 use diesel::sqlite::Sqlite;
 use diesel::{ExpressionMethods, prelude::*};
 use diesel_async::{AsyncConnection, RunQueryDsl};
+use serde::Serialize;

-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,
@@ -26,6 +23,15 @@ use crate::evm::{
    },
    utils,
 };
+use crate::{
+    crypto::integrity::Integrable,
+    db::models::{
+        EvmBasicGrant, EvmTokenTransferGrant, EvmTokenTransferVolumeLimit,
+        NewEvmTokenTransferGrant, NewEvmTokenTransferLog, NewEvmTokenTransferVolumeLimit,
+        SqliteTimestamp,
+    },
+    evm::policies::CombinedSettings,
+};

 use super::{DatabaseID, EvalContext, EvalViolation};

@@ -38,9 +44,9 @@ fn grant_join() -> _ {

 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Meaning {
-    pub(crate) token: &'static TokenInfo,
-    pub(crate) to: Address,
-    pub(crate) value: U256,
+    pub token: &'static TokenInfo,
+    pub to: Address,
+    pub value: U256,
 }
 impl std::fmt::Display for Meaning {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -58,12 +64,15 @@ impl From<Meaning> for SpecificMeaning {
 }

 // A grant for token transfers, which can be scoped to specific target addresses and volume limits
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Serialize)]
 pub struct Settings {
    pub token_contract: Address,
    pub target: Option<Address>,
    pub volume_limits: Vec<VolumeRateLimit>,
 }
+impl Integrable for Settings {
+    const KIND: &'static str = "TokenTransfer";
+}
 impl From<Settings> for SpecificGrant {
    fn from(val: Settings) -> SpecificGrant {
        SpecificGrant::TokenTransfer(val)
@@ -106,13 +115,20 @@ async fn check_volume_rate_limits(
 ) -> QueryResult<Vec<EvalViolation>> {
    let mut violations = Vec::new();

-    let Some(longest_window) = grant.settings.volume_limits.iter().map(|l| l.window).max() else {
+    let Some(longest_window) = grant
+        .settings
+        .specific
+        .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 {
+    for limit in &grant.settings.specific.volume_limits {
        let window_start = chrono::Utc::now() - limit.window;
        let prospective_cumulative_volume: U256 = past_transfers
            .iter()
@@ -158,7 +174,7 @@ impl Policy for TokenTransfer {
            return Ok(violations);
        }

-        if let Some(allowed) = grant.settings.target
+        if let Some(allowed) = grant.settings.specific.target
            && allowed != meaning.to
        {
            violations.push(EvalViolation::InvalidTarget { target: meaning.to });
@@ -269,9 +285,11 @@ impl Policy for TokenTransfer {

        Ok(Some(Grant {
            id: token_grant.id,
-            shared_grant_id: token_grant.basic_grant_id,
+            common_settings_id: token_grant.basic_grant_id,
+            settings: CombinedSettings {
                shared: SharedGrantSettings::try_from_model(basic_grant)?,
-            settings,
+                specific: settings,
+            },
        }))
    }

@@ -369,13 +387,15 @@ impl Policy for TokenTransfer {

                Ok(Grant {
                    id: specific.id,
-                    shared_grant_id: specific.basic_grant_id,
+                    common_settings_id: specific.basic_grant_id,
+                    settings: CombinedSettings {
                        shared: SharedGrantSettings::try_from_model(basic)?,
-                    settings: Settings {
+                        specific: Settings {
                            token_contract: Address::from(token_contract),
                            target,
                            volume_limits,
                        },
+                    },
                })
            })
            .collect()
--- a/server/crates/arbiter-server/src/evm/policies/token_transfers/tests.rs
+++ b/server/crates/arbiter-server/src/evm/policies/token_transfers/tests.rs
@@ -11,7 +11,10 @@ use crate::db::{
 };
 use crate::evm::{
    abi::IERC20::transferCall,
-    policies::{EvalContext, EvalViolation, Grant, Policy, SharedGrantSettings, VolumeRateLimit},
+    policies::{
+        CombinedSettings, EvalContext, EvalViolation, Grant, Policy, SharedGrantSettings,
+        VolumeRateLimit,
+    },
    utils,
 };

@@ -134,9 +137,11 @@ async fn evaluate_rejects_nonzero_eth_value() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(None, None),
+            specific: make_settings(None, None),
+        },
    };
    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
    let mut context = ctx(DAI, calldata);
@@ -163,9 +168,11 @@ async fn evaluate_passes_any_recipient_when_no_restriction() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(None, None),
+            specific: make_settings(None, None),
+        },
    };
    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
    let context = ctx(DAI, calldata);
@@ -183,9 +190,11 @@ async fn evaluate_passes_matching_restricted_recipient() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(Some(RECIPIENT), None),
+            specific: make_settings(Some(RECIPIENT), None),
+        },
    };
    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
    let context = ctx(DAI, calldata);
@@ -203,9 +212,11 @@ async fn evaluate_rejects_wrong_restricted_recipient() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(Some(RECIPIENT), None),
+            specific: make_settings(Some(RECIPIENT), None),
+        },
    };
    let calldata = transfer_calldata(OTHER, U256::from(100u64));
    let context = ctx(DAI, calldata);
@@ -247,9 +258,11 @@ async fn evaluate_passes_volume_at_exact_limit() {

    let grant = Grant {
        id: grant_id,
-        shared_grant_id: basic.id,
+        common_settings_id: basic.id,
+        settings: CombinedSettings {
            shared: shared(),
-        settings,
+            specific: settings,
+        },
    };
    let calldata = transfer_calldata(RECIPIENT, U256::from(100u64));
    let context = ctx(DAI, calldata);
@@ -290,9 +303,11 @@ async fn evaluate_rejects_volume_over_limit() {

    let grant = Grant {
        id: grant_id,
-        shared_grant_id: basic.id,
+        common_settings_id: basic.id,
+        settings: CombinedSettings {
            shared: shared(),
-        settings,
+            specific: settings,
+        },
    };
    let calldata = transfer_calldata(RECIPIENT, U256::from(1u64));
    let context = ctx(DAI, calldata);
@@ -313,9 +328,11 @@ async fn evaluate_no_volume_limits_always_passes() {

    let grant = Grant {
        id: 999,
-        shared_grant_id: 999,
+        common_settings_id: 999,
+        settings: CombinedSettings {
            shared: shared(),
-        settings: make_settings(None, None), // no volume limits
+            specific: make_settings(None, None), // no volume limits
+        },
    };
    let calldata = transfer_calldata(RECIPIENT, U256::from(u64::MAX));
    let context = ctx(DAI, calldata);
@@ -349,10 +366,13 @@ async fn try_find_grant_roundtrip() {

    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));
+    assert_eq!(g.settings.specific.token_contract, DAI);
+    assert_eq!(g.settings.specific.target, Some(RECIPIENT));
+    assert_eq!(g.settings.specific.volume_limits.len(), 1);
+    assert_eq!(
+        g.settings.specific.volume_limits[0].max_volume,
+        U256::from(5_000u64)
+    );
 }

 #[tokio::test]
@@ -434,9 +454,9 @@ async fn find_all_grants_loads_volume_limits() {

    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.specific.volume_limits.len(), 1);
    assert_eq!(
-        all[0].settings.volume_limits[0].max_volume,
+        all[0].settings.specific.volume_limits[0].max_volume,
        U256::from(9_999u64)
    );
 }
--- a/server/crates/arbiter-server/src/grpc/user_agent/evm.rs
+++ b/server/crates/arbiter-server/src/grpc/user_agent/evm.rs
@@ -114,10 +114,10 @@ async fn handle_grant_list(
            grants: grants
                .into_iter()
                .map(|grant| GrantEntry {
-                    id: grant.shared_grant_id,
-                    wallet_access_id: grant.shared.wallet_access_id,
-                    shared: Some(grant.shared.convert()),
-                    specific: Some(grant.settings.convert()),
+                    id: grant.common_settings_id,
+                    wallet_access_id: grant.settings.shared.wallet_access_id,
+                    shared: Some(grant.settings.shared.convert()),
+                    specific: Some(grant.settings.specific.convert()),
                })
                .collect(),
        }),
--- a/server/crates/arbiter-server/src/integrity/evm.rs
+++ b/server/crates/arbiter-server/src/integrity/evm.rs
@@ -1,336 +0,0 @@
-use alloy::primitives::Address;
-use chrono::{DateTime, Utc};
-use diesel::sqlite::Sqlite;
-use diesel::{ExpressionMethods as _, OptionalExtension as _, QueryDsl, SelectableHelper as _};
-use diesel_async::{AsyncConnection, RunQueryDsl};
-use prost::Message;
-use prost_types::Timestamp;
-
-use crate::{
-    db::{models, schema},
-    evm::policies::{Grant, SharedGrantSettings, SpecificGrant, VolumeRateLimit},
-    integrity::IntegrityEntity,
-};
-
-pub const EVM_GRANT_ENTITY_KIND: &str = "evm_grant";
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegrityVolumeRateLimit {
-    #[prost(bytes, tag = "1")]
-    pub max_volume: Vec<u8>,
-    #[prost(int64, tag = "2")]
-    pub window_secs: i64,
-}
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegrityTransactionRateLimit {
-    #[prost(uint32, tag = "1")]
-    pub count: u32,
-    #[prost(int64, tag = "2")]
-    pub window_secs: i64,
-}
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegritySharedGrantSettings {
-    #[prost(int32, tag = "1")]
-    pub wallet_access_id: i32,
-    #[prost(uint64, tag = "2")]
-    pub chain_id: u64,
-    #[prost(message, optional, tag = "3")]
-    pub valid_from: Option<::prost_types::Timestamp>,
-    #[prost(message, optional, tag = "4")]
-    pub valid_until: Option<::prost_types::Timestamp>,
-    #[prost(bytes, optional, tag = "5")]
-    pub max_gas_fee_per_gas: Option<Vec<u8>>,
-    #[prost(bytes, optional, tag = "6")]
-    pub max_priority_fee_per_gas: Option<Vec<u8>>,
-    #[prost(message, optional, tag = "7")]
-    pub rate_limit: Option<IntegrityTransactionRateLimit>,
-}
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegrityEtherTransferSettings {
-    #[prost(bytes, repeated, tag = "1")]
-    pub targets: Vec<Vec<u8>>,
-    #[prost(message, optional, tag = "2")]
-    pub limit: Option<IntegrityVolumeRateLimit>,
-}
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegrityTokenTransferSettings {
-    #[prost(bytes, tag = "1")]
-    pub token_contract: Vec<u8>,
-    #[prost(bytes, optional, tag = "2")]
-    pub target: Option<Vec<u8>>,
-    #[prost(message, repeated, tag = "3")]
-    pub volume_limits: Vec<IntegrityVolumeRateLimit>,
-}
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegritySpecificGrant {
-    #[prost(oneof = "integrity_specific_grant::Grant", tags = "1, 2")]
-    pub grant: Option<integrity_specific_grant::Grant>,
-}
-
-pub mod integrity_specific_grant {
-    use super::*;
-
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Grant {
-        #[prost(message, tag = "1")]
-        EtherTransfer(IntegrityEtherTransferSettings),
-        #[prost(message, tag = "2")]
-        TokenTransfer(IntegrityTokenTransferSettings),
-    }
-}
-
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct IntegrityEvmGrantPayloadV1 {
-    #[prost(int32, tag = "1")]
-    pub basic_grant_id: i32,
-    #[prost(message, optional, tag = "2")]
-    pub shared: Option<IntegritySharedGrantSettings>,
-    #[prost(message, optional, tag = "3")]
-    pub specific: Option<IntegritySpecificGrant>,
-    #[prost(message, optional, tag = "4")]
-    pub revoked_at: Option<::prost_types::Timestamp>,
-}
-
-#[derive(Debug, Clone)]
-pub struct SignedEvmGrant {
-    pub basic_grant_id: i32,
-    pub shared: SharedGrantSettings,
-    pub specific: SpecificGrant,
-    pub revoked_at: Option<DateTime<Utc>>,
-}
-
-impl SignedEvmGrant {
-    pub fn from_active_grant(grant: &Grant<SpecificGrant>) -> Self {
-        Self {
-            basic_grant_id: grant.shared_grant_id,
-            shared: grant.shared.clone(),
-            specific: grant.settings.clone(),
-            revoked_at: None,
-        }
-    }
-}
-
-fn timestamp(value: DateTime<Utc>) -> Timestamp {
-    Timestamp {
-        seconds: value.timestamp(),
-        nanos: 0,
-    }
-}
-
-fn encode_shared(shared: &SharedGrantSettings) -> IntegritySharedGrantSettings {
-    IntegritySharedGrantSettings {
-        wallet_access_id: shared.wallet_access_id,
-        chain_id: shared.chain,
-        valid_from: shared.valid_from.map(timestamp),
-        valid_until: shared.valid_until.map(timestamp),
-        max_gas_fee_per_gas: shared
-            .max_gas_fee_per_gas
-            .map(|v| v.to_le_bytes::<32>().to_vec()),
-        max_priority_fee_per_gas: shared
-            .max_priority_fee_per_gas
-            .map(|v| v.to_le_bytes::<32>().to_vec()),
-        rate_limit: shared
-            .rate_limit
-            .as_ref()
-            .map(|rl| IntegrityTransactionRateLimit {
-                count: rl.count,
-                window_secs: rl.window.num_seconds(),
-            }),
-    }
-}
-
-fn encode_volume_limit(limit: &VolumeRateLimit) -> IntegrityVolumeRateLimit {
-    IntegrityVolumeRateLimit {
-        max_volume: limit.max_volume.to_le_bytes::<32>().to_vec(),
-        window_secs: limit.window.num_seconds(),
-    }
-}
-
-fn try_bytes_to_u256(bytes: &[u8]) -> diesel::result::QueryResult<alloy::primitives::U256> {
-    let bytes: [u8; 32] = bytes.try_into().map_err(|_| {
-        diesel::result::Error::DeserializationError(
-            format!("Expected 32-byte U256 payload, got {}", bytes.len()).into(),
-        )
-    })?;
-    Ok(alloy::primitives::U256::from_le_bytes(bytes))
-}
-
-fn encode_specific(specific: &SpecificGrant) -> IntegritySpecificGrant {
-    let grant = match specific {
-        SpecificGrant::EtherTransfer(settings) => {
-            let mut targets: Vec<Vec<u8>> =
-                settings.target.iter().map(|addr| addr.to_vec()).collect();
-            targets.sort_unstable();
-
-            integrity_specific_grant::Grant::EtherTransfer(IntegrityEtherTransferSettings {
-                targets,
-                limit: Some(encode_volume_limit(&settings.limit)),
-            })
-        }
-        SpecificGrant::TokenTransfer(settings) => {
-            let mut volume_limits: Vec<IntegrityVolumeRateLimit> = settings
-                .volume_limits
-                .iter()
-                .map(encode_volume_limit)
-                .collect();
-            volume_limits.sort_by(|left, right| {
-                left.window_secs
-                    .cmp(&right.window_secs)
-                    .then_with(|| left.max_volume.cmp(&right.max_volume))
-            });
-
-            integrity_specific_grant::Grant::TokenTransfer(IntegrityTokenTransferSettings {
-                token_contract: settings.token_contract.to_vec(),
-                target: settings.target.map(|a| a.to_vec()),
-                volume_limits,
-            })
-        }
-    };
-
-    IntegritySpecificGrant { grant: Some(grant) }
-}
-
-impl IntegrityEntity for SignedEvmGrant {
-    fn entity_kind(&self) -> &'static str {
-        EVM_GRANT_ENTITY_KIND
-    }
-
-    fn entity_id_bytes(&self) -> Vec<u8> {
-        self.basic_grant_id.to_be_bytes().to_vec()
-    }
-
-    fn payload_version(&self) -> i32 {
-        1
-    }
-
-    fn canonical_payload_bytes(&self) -> Vec<u8> {
-        IntegrityEvmGrantPayloadV1 {
-            basic_grant_id: self.basic_grant_id,
-            shared: Some(encode_shared(&self.shared)),
-            specific: Some(encode_specific(&self.specific)),
-            revoked_at: self.revoked_at.map(timestamp),
-        }
-        .encode_to_vec()
-    }
-}
-
-pub async fn load_signed_grant_by_basic_id(
-    conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    basic_grant_id: i32,
-) -> diesel::result::QueryResult<SignedEvmGrant> {
-    let basic: models::EvmBasicGrant = schema::evm_basic_grant::table
-        .filter(schema::evm_basic_grant::id.eq(basic_grant_id))
-        .select(models::EvmBasicGrant::as_select())
-        .first(conn)
-        .await?;
-
-    let specific_token: Option<models::EvmTokenTransferGrant> =
-        schema::evm_token_transfer_grant::table
-            .filter(schema::evm_token_transfer_grant::basic_grant_id.eq(basic_grant_id))
-            .select(models::EvmTokenTransferGrant::as_select())
-            .first(conn)
-            .await
-            .optional()?;
-
-    let revoked_at = basic.revoked_at.clone().map(Into::into);
-    let shared = SharedGrantSettings::try_from_model(basic)?;
-
-    if let Some(token) = specific_token {
-        let limits: Vec<models::EvmTokenTransferVolumeLimit> =
-            schema::evm_token_transfer_volume_limit::table
-                .filter(schema::evm_token_transfer_volume_limit::grant_id.eq(token.id))
-                .select(models::EvmTokenTransferVolumeLimit::as_select())
-                .load(conn)
-                .await?;
-
-        let token_contract: [u8; 20] = token.token_contract.try_into().map_err(|_| {
-            diesel::result::Error::DeserializationError(
-                "Invalid token contract address length".into(),
-            )
-        })?;
-
-        let target = match token.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 volume_limits = limits
-            .into_iter()
-            .map(|row| {
-                Ok(VolumeRateLimit {
-                    max_volume: try_bytes_to_u256(&row.max_volume)?,
-                    window: chrono::Duration::seconds(row.window_secs as i64),
-                })
-            })
-            .collect::<diesel::result::QueryResult<Vec<_>>>()?;
-
-        return Ok(SignedEvmGrant {
-            basic_grant_id,
-            shared,
-            specific: SpecificGrant::TokenTransfer(
-                crate::evm::policies::token_transfers::Settings {
-                    token_contract: Address::from(token_contract),
-                    target,
-                    volume_limits,
-                },
-            ),
-            revoked_at,
-        });
-    }
-
-    let ether: models::EvmEtherTransferGrant = schema::evm_ether_transfer_grant::table
-        .filter(schema::evm_ether_transfer_grant::basic_grant_id.eq(basic_grant_id))
-        .select(models::EvmEtherTransferGrant::as_select())
-        .first(conn)
-        .await?;
-
-    let targets_rows: Vec<models::EvmEtherTransferGrantTarget> =
-        schema::evm_ether_transfer_grant_target::table
-            .filter(schema::evm_ether_transfer_grant_target::grant_id.eq(ether.id))
-            .select(models::EvmEtherTransferGrantTarget::as_select())
-            .load(conn)
-            .await?;
-
-    let limit: models::EvmEtherTransferLimit = schema::evm_ether_transfer_limit::table
-        .filter(schema::evm_ether_transfer_limit::id.eq(ether.limit_id))
-        .select(models::EvmEtherTransferLimit::as_select())
-        .first(conn)
-        .await?;
-
-    let targets = targets_rows
-        .into_iter()
-        .map(|row| {
-            let arr: [u8; 20] = row.address.try_into().map_err(|_| {
-                diesel::result::Error::DeserializationError(
-                    "Invalid ether target address length".into(),
-                )
-            })?;
-            Ok(Address::from(arr))
-        })
-        .collect::<diesel::result::QueryResult<Vec<_>>>()?;
-
-    Ok(SignedEvmGrant {
-        basic_grant_id,
-        shared,
-        specific: SpecificGrant::EtherTransfer(crate::evm::policies::ether_transfer::Settings {
-            target: targets,
-            limit: VolumeRateLimit {
-                max_volume: try_bytes_to_u256(&limit.max_volume)?,
-                window: chrono::Duration::seconds(limit.window_secs as i64),
-            },
-        }),
-        revoked_at,
-    })
-}
--- a/server/crates/arbiter-server/src/integrity/mod.rs
+++ b/server/crates/arbiter-server/src/integrity/mod.rs
@@ -1,301 +0,0 @@
-use diesel::{ExpressionMethods as _, QueryDsl, dsl::insert_into, sqlite::Sqlite};
-use diesel_async::{AsyncConnection, RunQueryDsl};
-use kameo::actor::ActorRef;
-use sha2::{Digest as _, Sha256};
-
-use crate::{
-    actors::keyholder::{KeyHolder, SignIntegrity, VerifyIntegrity},
-    db::{
-        self,
-        models::{IntegrityEnvelope, NewIntegrityEnvelope},
-        schema::integrity_envelope,
-    },
-};
-
-pub const CURRENT_PAYLOAD_VERSION: i32 = 1;
-
-pub mod evm;
-
-pub trait IntegrityEntity {
-    fn entity_kind(&self) -> &'static str;
-    fn entity_id_bytes(&self) -> Vec<u8>;
-    fn payload_version(&self) -> i32;
-    fn canonical_payload_bytes(&self) -> Vec<u8>;
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error {
-    #[error("Database error: {0}")]
-    Database(#[from] db::DatabaseError),
-
-    #[error("KeyHolder error: {0}")]
-    Keyholder(#[from] crate::actors::keyholder::Error),
-
-    #[error("KeyHolder mailbox error")]
-    KeyholderSend,
-
-    #[error("Integrity envelope is missing for entity {entity_kind}")]
-    MissingEnvelope { entity_kind: &'static str },
-
-    #[error(
-        "Integrity payload version mismatch for entity {entity_kind}: expected {expected}, found {found}"
-    )]
-    PayloadVersionMismatch {
-        entity_kind: &'static str,
-        expected: i32,
-        found: i32,
-    },
-
-    #[error("Integrity MAC mismatch for entity {entity_kind}")]
-    MacMismatch { entity_kind: &'static str },
-}
-
-fn payload_hash(payload: &[u8]) -> [u8; 32] {
-    Sha256::digest(payload).into()
-}
-
-fn push_len_prefixed(out: &mut Vec<u8>, bytes: &[u8]) {
-    out.extend_from_slice(&(bytes.len() as u32).to_be_bytes());
-    out.extend_from_slice(bytes);
-}
-
-fn build_mac_input(
-    entity_kind: &str,
-    entity_id: &[u8],
-    payload_version: i32,
-    payload_hash: &[u8; 32],
-) -> Vec<u8> {
-    let mut out = Vec::with_capacity(8 + entity_kind.len() + entity_id.len() + 32);
-    push_len_prefixed(&mut out, entity_kind.as_bytes());
-    push_len_prefixed(&mut out, entity_id);
-    out.extend_from_slice(&payload_version.to_be_bytes());
-    out.extend_from_slice(payload_hash);
-    out
-}
-
-pub async fn sign_entity(
-    conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    keyholder: &ActorRef<KeyHolder>,
-    entity: &impl IntegrityEntity,
-) -> Result<(), Error> {
-    let entity_kind = entity.entity_kind();
-    let entity_id = entity.entity_id_bytes();
-    let payload_version = entity.payload_version();
-    let payload = entity.canonical_payload_bytes();
-    let payload_hash = payload_hash(&payload);
-    let mac_input = build_mac_input(entity_kind, &entity_id, payload_version, &payload_hash);
-
-    let (key_version, mac) = keyholder
-        .ask(SignIntegrity { mac_input })
-        .await
-        .map_err(|err| match err {
-            kameo::error::SendError::HandlerError(inner) => Error::Keyholder(inner),
-            _ => Error::KeyholderSend,
-        })?;
-
-    diesel::delete(integrity_envelope::table)
-        .filter(integrity_envelope::entity_kind.eq(entity_kind))
-        .filter(integrity_envelope::entity_id.eq(&entity_id))
-        .execute(conn)
-        .await
-        .map_err(db::DatabaseError::from)?;
-
-    insert_into(integrity_envelope::table)
-        .values(NewIntegrityEnvelope {
-            entity_kind: entity_kind.to_string(),
-            entity_id,
-            payload_version,
-            key_version,
-            mac,
-        })
-        .execute(conn)
-        .await
-        .map_err(db::DatabaseError::from)?;
-
-    Ok(())
-}
-
-pub async fn verify_entity(
-    conn: &mut impl AsyncConnection<Backend = Sqlite>,
-    keyholder: &ActorRef<KeyHolder>,
-    entity: &impl IntegrityEntity,
-) -> Result<(), Error> {
-    let entity_kind = entity.entity_kind();
-    let entity_id = entity.entity_id_bytes();
-    let expected_payload_version = entity.payload_version();
-
-    let envelope: IntegrityEnvelope = integrity_envelope::table
-        .filter(integrity_envelope::entity_kind.eq(entity_kind))
-        .filter(integrity_envelope::entity_id.eq(&entity_id))
-        .first(conn)
-        .await
-        .map_err(|err| match err {
-            diesel::result::Error::NotFound => Error::MissingEnvelope { entity_kind },
-            other => Error::Database(db::DatabaseError::from(other)),
-        })?;
-
-    if envelope.payload_version != expected_payload_version {
-        return Err(Error::PayloadVersionMismatch {
-            entity_kind,
-            expected: expected_payload_version,
-            found: envelope.payload_version,
-        });
-    }
-
-    let payload = entity.canonical_payload_bytes();
-    let payload_hash = payload_hash(&payload);
-    let mac_input = build_mac_input(
-        entity_kind,
-        &entity_id,
-        envelope.payload_version,
-        &payload_hash,
-    );
-
-    let ok = keyholder
-        .ask(VerifyIntegrity {
-            mac_input,
-            expected_mac: envelope.mac,
-            key_version: envelope.key_version,
-        })
-        .await
-        .map_err(|err| match err {
-            kameo::error::SendError::HandlerError(inner) => Error::Keyholder(inner),
-            _ => Error::KeyholderSend,
-        })?;
-
-    if !ok {
-        return Err(Error::MacMismatch { entity_kind });
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use diesel::{ExpressionMethods as _, QueryDsl};
-    use diesel_async::RunQueryDsl;
-    use kameo::{actor::ActorRef, prelude::Spawn};
-
-    use crate::{
-        actors::keyholder::{Bootstrap, KeyHolder},
-        db::{self, schema},
-        safe_cell::{SafeCell, SafeCellHandle as _},
-    };
-
-    use super::{Error, IntegrityEntity, sign_entity, verify_entity};
-
-    #[derive(Clone)]
-    struct DummyEntity {
-        id: i32,
-        payload_version: i32,
-        payload: Vec<u8>,
-    }
-
-    impl IntegrityEntity for DummyEntity {
-        fn entity_kind(&self) -> &'static str {
-            "dummy_entity"
-        }
-
-        fn entity_id_bytes(&self) -> Vec<u8> {
-            self.id.to_be_bytes().to_vec()
-        }
-
-        fn payload_version(&self) -> i32 {
-            self.payload_version
-        }
-
-        fn canonical_payload_bytes(&self) -> Vec<u8> {
-            self.payload.clone()
-        }
-    }
-
-    async fn bootstrapped_keyholder(db: &db::DatabasePool) -> ActorRef<KeyHolder> {
-        let actor = KeyHolder::spawn(KeyHolder::new(db.clone()).await.unwrap());
-        actor
-            .ask(Bootstrap {
-                seal_key_raw: SafeCell::new(b"integrity-test-seal-key".to_vec()),
-            })
-            .await
-            .unwrap();
-        actor
-    }
-
-    #[tokio::test]
-    async fn sign_writes_envelope_and_verify_passes() {
-        let db = db::create_test_pool().await;
-        let keyholder = bootstrapped_keyholder(&db).await;
-        let mut conn = db.get().await.unwrap();
-
-        let entity = DummyEntity {
-            id: 7,
-            payload_version: 1,
-            payload: b"payload-v1".to_vec(),
-        };
-
-        sign_entity(&mut conn, &keyholder, &entity).await.unwrap();
-
-        let count: i64 = schema::integrity_envelope::table
-            .filter(schema::integrity_envelope::entity_kind.eq("dummy_entity"))
-            .filter(schema::integrity_envelope::entity_id.eq(entity.entity_id_bytes()))
-            .count()
-            .get_result(&mut conn)
-            .await
-            .unwrap();
-
-        assert_eq!(count, 1, "envelope row must be created exactly once");
-        verify_entity(&mut conn, &keyholder, &entity).await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn tampered_mac_fails_verification() {
-        let db = db::create_test_pool().await;
-        let keyholder = bootstrapped_keyholder(&db).await;
-        let mut conn = db.get().await.unwrap();
-
-        let entity = DummyEntity {
-            id: 11,
-            payload_version: 1,
-            payload: b"payload-v1".to_vec(),
-        };
-
-        sign_entity(&mut conn, &keyholder, &entity).await.unwrap();
-
-        diesel::update(schema::integrity_envelope::table)
-            .filter(schema::integrity_envelope::entity_kind.eq("dummy_entity"))
-            .filter(schema::integrity_envelope::entity_id.eq(entity.entity_id_bytes()))
-            .set(schema::integrity_envelope::mac.eq(vec![0u8; 32]))
-            .execute(&mut conn)
-            .await
-            .unwrap();
-
-        let err = verify_entity(&mut conn, &keyholder, &entity)
-            .await
-            .unwrap_err();
-        assert!(matches!(err, Error::MacMismatch { .. }));
-    }
-
-    #[tokio::test]
-    async fn changed_payload_fails_verification() {
-        let db = db::create_test_pool().await;
-        let keyholder = bootstrapped_keyholder(&db).await;
-        let mut conn = db.get().await.unwrap();
-
-        let entity = DummyEntity {
-            id: 21,
-            payload_version: 1,
-            payload: b"payload-v1".to_vec(),
-        };
-
-        sign_entity(&mut conn, &keyholder, &entity).await.unwrap();
-
-        let tampered = DummyEntity {
-            payload: b"payload-v1-but-tampered".to_vec(),
-            ..entity
-        };
-
-        let err = verify_entity(&mut conn, &keyholder, &tampered)
-            .await
-            .unwrap_err();
-        assert!(matches!(err, Error::MacMismatch { .. }));
-    }
-}
--- a/server/crates/arbiter-server/src/lib.rs
+++ b/server/crates/arbiter-server/src/lib.rs
@@ -7,7 +7,6 @@ pub mod crypto;
 pub mod db;
 pub mod evm;
 pub mod grpc;
-pub mod integrity;
 pub mod safe_cell;
 pub mod utils;

--- a/server/crates/arbiter-server/tests/user_agent/auth.rs
+++ b/server/crates/arbiter-server/tests/user_agent/auth.rs
@@ -187,7 +187,6 @@ pub async fn test_challenge_auth_rejects_integrity_tag_mismatch_when_unsealed()
            .values((
                schema::useragent_client::public_key.eq(pubkey_bytes.clone()),
                schema::useragent_client::key_type.eq(1i32),
-                schema::useragent_client::pubkey_integrity_tag.eq(Some(vec![0u8; 32])),
            ))
            .execute(&mut conn)
            .await
--- a/server/crates/arbiter-server/tests/user_agent/unseal.rs
+++ b/server/crates/arbiter-server/tests/user_agent/unseal.rs
@@ -152,42 +152,3 @@ pub async fn test_unseal_retry_after_invalid_key() {
        assert!(matches!(response, Ok(())));
    }
 }
-
-#[tokio::test]
-#[test_log::test]
-pub async fn test_unseal_backfills_missing_pubkey_integrity_tags() {
-    let seal_key = b"test-seal-key";
-    let (db, user_agent) = setup_sealed_user_agent(seal_key).await;
-
-    {
-        let mut conn = db.get().await.unwrap();
-        insert_into(arbiter_server::db::schema::useragent_client::table)
-            .values((
-                arbiter_server::db::schema::useragent_client::public_key
-                    .eq(vec![1u8, 2u8, 3u8, 4u8]),
-                arbiter_server::db::schema::useragent_client::key_type.eq(1i32),
-                arbiter_server::db::schema::useragent_client::pubkey_integrity_tag
-                    .eq(Option::<Vec<u8>>::None),
-            ))
-            .execute(&mut conn)
-            .await
-            .unwrap();
-    }
-
-    let encrypted_key = client_dh_encrypt(&user_agent, seal_key).await;
-    let response = user_agent.ask(encrypted_key).await;
-    assert!(matches!(response, Ok(())));
-
-    {
-        let mut conn = db.get().await.unwrap();
-        let tags: Vec<Option<Vec<u8>>> = arbiter_server::db::schema::useragent_client::table
-            .select(arbiter_server::db::schema::useragent_client::pubkey_integrity_tag)
-            .load(&mut conn)
-            .await
-            .unwrap();
-        assert!(
-            tags.iter()
-                .all(|tag| matches!(tag, Some(v) if v.len() == 32))
-        );
-    }
-}