fix(db): enable foreign key enforcement on pooled connections

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

@@ -352,16 +352,17 @@ impl Engine {
 mod tests {
     use alloy::primitives::{Address, Bytes, U256, address};
     use chrono::{Duration, Utc};
-    use diesel::{SelectableHelper, insert_into};
+    use diesel::{ExpressionMethods as _, SelectableHelper, insert_into};
     use diesel_async::RunQueryDsl;
     use rstest::rstest;
 
     use crate::db::{
-        self, DatabaseConnection,
+        self, DatabaseConnection, models,
         models::{
             EvmBasicGrant, EvmWalletAccess, EvmWalletId, NewEvmBasicGrant, NewEvmTransactionLog,
             SqliteTimestamp,
         },
+        schema,
         schema::{evm_basic_grant, evm_transaction_log},
     };
     use crate::evm::policies::{
@@ -403,10 +404,82 @@ mod tests {
         }
     }
 
+    /// Creates the parent chain a fresh `evm_wallet_access` row needs under foreign-key
+    /// enforcement (a root key, an aead-encrypted secret, a wallet, and a client) and
+    /// returns the new access row's id.
+    async fn seed_wallet_access(conn: &mut DatabaseConnection) -> i32 {
+        let root_key_id: models::RootKeyHistoryId = insert_into(schema::root_key_history::table)
+            .values(&models::NewRootKeyHistory {
+                ciphertext: vec![0u8; 32],
+                tag: vec![0u8; 16],
+                root_key_encryption_nonce: vec![0u8; 24],
+                data_encryption_nonce: vec![0u8; 24],
+                schema_version: 1,
+                salt: vec![0u8; 16],
+            })
+            .returning(schema::root_key_history::id)
+            .get_result(conn)
+            .await
+            .unwrap();
+
+        let aead_id: i32 = insert_into(schema::aead_encrypted::table)
+            .values(&models::NewAeadEncrypted {
+                ciphertext: vec![0u8; 32],
+                tag: vec![0u8; 16],
+                current_nonce: vec![0u8; 24],
+                schema_version: 1,
+                associated_root_key_id: root_key_id,
+                created_at: Utc::now().into(),
+            })
+            .returning(schema::aead_encrypted::id)
+            .get_result(conn)
+            .await
+            .unwrap();
+
+        let wallet_id: EvmWalletId = insert_into(schema::evm_wallet::table)
+            .values((
+                schema::evm_wallet::address.eq(rand::random::<[u8; 20]>().to_vec()),
+                schema::evm_wallet::aead_encrypted_id.eq(aead_id),
+            ))
+            .returning(schema::evm_wallet::id)
+            .get_result(conn)
+            .await
+            .unwrap();
+
+        let metadata_id: i32 = insert_into(schema::client_metadata::table)
+            .values(schema::client_metadata::name.eq("test"))
+            .returning(schema::client_metadata::id)
+            .get_result(conn)
+            .await
+            .unwrap();
+
+        let client_id: i32 = insert_into(schema::program_client::table)
+            .values((
+                schema::program_client::public_key.eq(rand::random::<[u8; 32]>().to_vec()),
+                schema::program_client::metadata_id.eq(metadata_id),
+            ))
+            .returning(schema::program_client::id)
+            .get_result(conn)
+            .await
+            .unwrap();
+
+        insert_into(schema::evm_wallet_access::table)
+            .values((
+                schema::evm_wallet_access::wallet_id.eq(wallet_id),
+                schema::evm_wallet_access::client_id.eq(client_id),
+            ))
+            .returning(schema::evm_wallet_access::id)
+            .get_result(conn)
+            .await
+            .unwrap()
+    }
+
     async fn insert_basic_grant(
         conn: &mut DatabaseConnection,
         shared: &SharedGrantSettings,
     ) -> EvmBasicGrant {
+        let wallet_access_id = seed_wallet_access(conn).await;
+
         #[expect(
             clippy::cast_possible_truncation,
             clippy::cast_possible_wrap,
@@ -415,7 +488,7 @@ mod tests {
         )]
         insert_into(evm_basic_grant::table)
             .values(NewEvmBasicGrant {
-                wallet_access_id: shared.wallet_access_id,
+                wallet_access_id,
                 chain_id: shared.chain.into(),
                 valid_from: shared.valid_from.map(SqliteTimestamp),
                 valid_until: shared.valid_until.map(SqliteTimestamp),
@@ -579,7 +652,7 @@ mod tests {
         insert_into(evm_transaction_log::table)
             .values(NewEvmTransactionLog {
                 grant_id: basic_grant.id,
-                wallet_access_id: WALLET_ACCESS_ID,
+                wallet_access_id: basic_grant.wallet_access_id,
                 chain_id: CHAIN_ID.into(),
                 eth_value: super::utils::u256_to_bytes(U256::ZERO).to_vec(),
                 signed_at: SqliteTimestamp(Utc::now()),