merge: feat-lints into main

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

@@ -1,15 +1,5 @@
-use alloy::{
-    consensus::TxEip1559, network::TxSignerSync as _, primitives::Address, signers::Signature,
-};
-use diesel::{
-    ExpressionMethods, OptionalExtension as _, QueryDsl, SelectableHelper as _, dsl::insert_into,
-};
-use diesel_async::RunQueryDsl;
-use kameo::{Actor, actor::ActorRef, messages};
-use rand::{SeedableRng, rng, rngs::StdRng};
-
 use crate::{
-    actors::keyholder::{CreateNew, Decrypt, KeyHolder},
+    actors::vault::{CreateNew, Decrypt, Vault},
     crypto::integrity,
     db::{
         DatabaseError, DatabasePool,
@@ -26,6 +16,16 @@ use crate::{
 };
 use arbiter_crypto::safecell::{SafeCell, SafeCellHandle as _};
 
+use alloy::{
+    consensus::TxEip1559, network::TxSignerSync as _, primitives::Address, signers::Signature,
+};
+use diesel::{
+    ExpressionMethods, OptionalExtension as _, QueryDsl, SelectableHelper as _, dsl::insert_into,
+};
+use diesel_async::RunQueryDsl;
+use kameo::{Actor, actor::ActorRef, messages};
+use rand::{SeedableRng, rng, rngs::StdRng};
+
 pub use crate::evm::safe_signer;
 
 #[derive(Debug, thiserror::Error)]
@@ -36,11 +36,11 @@ pub enum SignTransactionError {
     #[error("Database error: {0}")]
     Database(#[from] DatabaseError),
 
-    #[error("Keyholder error: {0}")]
-    Keyholder(#[from] crate::actors::keyholder::KeyHolderError),
+    #[error("Vault error: {0}")]
+    Vault(#[from] crate::actors::vault::Error),
 
-    #[error("Keyholder mailbox error")]
-    KeyholderSend,
+    #[error("Vault mailbox error")]
+    VaultSend,
 
     #[error("Signing error: {0}")]
     Signing(#[from] alloy::signers::Error),
@@ -50,36 +50,36 @@ pub enum SignTransactionError {
 }
 
 #[derive(Debug, thiserror::Error)]
-pub enum EvmActorError {
-    #[error("Keyholder error: {0}")]
-    Keyholder(#[from] crate::actors::keyholder::KeyHolderError),
+pub enum Error {
+    #[error("Vault error: {0}")]
+    Vault(#[from] crate::actors::vault::Error),
 
-    #[error("Keyholder mailbox error")]
-    KeyholderSend,
+    #[error("Vault mailbox error")]
+    VaultSend,
 
     #[error("Database error: {0}")]
     Database(#[from] DatabaseError),
 
     #[error("Integrity violation: {0}")]
-    Integrity(#[from] integrity::IntegrityError),
+    Integrity(#[from] integrity::Error),
 }
 
 #[derive(Actor)]
 pub struct EvmActor {
-    pub keyholder: ActorRef<KeyHolder>,
+    pub vault: ActorRef<Vault>,
     pub db: DatabasePool,
     pub rng: StdRng,
     pub engine: evm::Engine,
 }
 
 impl EvmActor {
-    pub fn new(keyholder: ActorRef<KeyHolder>, db: DatabasePool) -> Self {
+    pub fn new(vault: ActorRef<Vault>, db: DatabasePool) -> Self {
         // is it safe to seed rng from system once?
         // todo: audit
         let rng = StdRng::from_rng(&mut rng());
-        let engine = evm::Engine::new(db.clone(), keyholder.clone());
+        let engine = evm::Engine::new(db.clone(), vault.clone());
         Self {
-            keyholder,
+            vault,
             db,
             rng,
             engine,
@@ -90,16 +90,16 @@ impl EvmActor {
 #[messages]
 impl EvmActor {
     #[message]
-    pub async fn generate(&mut self) -> Result<(i32, Address), EvmActorError> {
+    pub async fn generate(&mut self) -> Result<(i32, Address), Error> {
         let (mut key_cell, address) = safe_signer::generate(&mut self.rng);
 
         let plaintext = key_cell.read_inline(|reader| SafeCell::new(reader.to_vec()));
 
         let aead_id: i32 = self
-            .keyholder
+            .vault
             .ask(CreateNew { plaintext })
             .await
-            .map_err(|_| EvmActorError::KeyholderSend)?;
+            .map_err(|_| Error::VaultSend)?;
 
         let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
         let wallet_id = insert_into(schema::evm_wallet::table)
@@ -116,7 +116,7 @@ impl EvmActor {
     }
 
     #[message]
-    pub async fn list_wallets(&self) -> Result<Vec<(i32, Address)>, EvmActorError> {
+    pub async fn list_wallets(&self) -> Result<Vec<(i32, Address)>, Error> {
         let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
         let rows: Vec<models::EvmWallet> = schema::evm_wallet::table
             .select(models::EvmWallet::as_select())
@@ -138,7 +138,7 @@ impl EvmActor {
         &mut self,
         basic: SharedGrantSettings,
         grant: SpecificGrant,
-    ) -> Result<i32, EvmActorError> {
+    ) -> Result<i32, Error> {
         match grant {
             SpecificGrant::EtherTransfer(settings) => self
                 .engine
@@ -147,7 +147,7 @@ impl EvmActor {
                     specific: settings,
                 })
                 .await
-                .map_err(EvmActorError::from),
+                .map_err(Error::from),
             SpecificGrant::TokenTransfer(settings) => self
                 .engine
                 .create_grant::<TokenTransfer>(CombinedSettings {
@@ -155,15 +155,15 @@ impl EvmActor {
                     specific: settings,
                 })
                 .await
-                .map_err(EvmActorError::from),
+                .map_err(Error::from),
         }
     }
 
     #[message]
     #[expect(clippy::unused_async, reason = "reserved for impl")]
-    pub async fn useragent_delete_grant(&mut self, _grant_id: i32) -> Result<(), EvmActorError> {
+    pub async fn useragent_delete_grant(&mut self, _grant_id: i32) -> Result<(), Error> {
         // let mut conn = self.db.get().await.map_err(DatabaseError::from)?;
-        // let keyholder = self.keyholder.clone();
+        // let vault = self.vault.clone();
 
         // diesel_async::AsyncConnection::transaction(&mut conn, |conn| {
         //     Box::pin(async move {
@@ -186,15 +186,11 @@ impl EvmActor {
     }
 
     #[message]
-    pub async fn useragent_list_grants(
-        &mut self,
-    ) -> Result<Vec<Grant<SpecificGrant>>, EvmActorError> {
+    pub async fn useragent_list_grants(&mut self) -> Result<Vec<Grant<SpecificGrant>>, Error> {
         match self.engine.list_all_grants().await {
             Ok(grants) => Ok(grants),
-            Err(ListError::Database(db_err)) => Err(EvmActorError::Database(db_err)),
-            Err(ListError::Integrity(integrity_err)) => {
-                Err(EvmActorError::Integrity(integrity_err))
-            }
+            Err(ListError::Database(db_err)) => Err(Error::Database(db_err)),
+            Err(ListError::Integrity(integrity_err)) => Err(Error::Integrity(integrity_err)),
         }
     }
 
@@ -261,12 +257,12 @@ impl EvmActor {
         drop(conn);
 
         let raw_key: SafeCell<Vec<u8>> = self
-            .keyholder
+            .vault
             .ask(Decrypt {
                 aead_id: wallet.aead_encrypted_id,
             })
             .await
-            .map_err(|_| SignTransactionError::KeyholderSend)?;
+            .map_err(|_| SignTransactionError::VaultSend)?;
 
         let signer = safe_signer::SafeSigner::from_cell(raw_key)?;