rrelayer_core 0.7.0

Core types and functionality for rrelayer - a powerful blockchain transaction relay service
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

use std::sync::Arc;

use alloy::dyn_abi::TypedData;
use alloy::{consensus::TypedTransaction, signers::Signature};
use async_trait::async_trait;

use crate::{
    network::ChainId,
    shared::common_types::EvmAddress,
    wallet::{WalletError, WalletManagerTrait},
};

/// A composite wallet manager that routes to different wallet managers based on wallet index
pub struct CompositeWalletManager {
    primary_manager: Arc<dyn WalletManagerTrait>,
    private_key_manager: Option<Arc<dyn WalletManagerTrait>>,
}

impl CompositeWalletManager {
    pub fn new(
        primary_manager: Arc<dyn WalletManagerTrait>,
        private_key_manager: Option<Arc<dyn WalletManagerTrait>>,
    ) -> Self {
        CompositeWalletManager { primary_manager, private_key_manager }
    }

    // TODO: not ideal route but only way i could find for now to work without a big refactor
    /// Determine if a wallet index is for a private key (high range)
    fn is_private_key_index(&self, wallet_index: u32) -> bool {
        wallet_index >= u32::MAX - 1000
    }

    /// Get the appropriate wallet manager for the given index
    fn get_manager_for_index(
        &self,
        wallet_index: u32,
    ) -> Result<&Arc<dyn WalletManagerTrait>, WalletError> {
        if self.is_private_key_index(wallet_index) {
            if let Some(ref manager) = self.private_key_manager {
                Ok(manager)
            } else {
                Err(WalletError::UnsupportedOperation(format!(
                    "Private key wallet index {} requested but no private key manager configured",
                    wallet_index
                )))
            }
        } else {
            Ok(&self.primary_manager)
        }
    }
}

#[async_trait]
impl WalletManagerTrait for CompositeWalletManager {
    async fn create_wallet(
        &self,
        wallet_index: u32,
        chain_id: &ChainId,
    ) -> Result<EvmAddress, WalletError> {
        let manager = self.get_manager_for_index(wallet_index)?;
        manager.create_wallet(wallet_index, chain_id).await
    }

    async fn get_address(
        &self,
        wallet_index: u32,
        chain_id: &ChainId,
    ) -> Result<EvmAddress, WalletError> {
        let manager = self.get_manager_for_index(wallet_index)?;
        manager.get_address(wallet_index, chain_id).await
    }

    async fn sign_transaction(
        &self,
        wallet_index: u32,
        transaction: &TypedTransaction,
        chain_id: &ChainId,
    ) -> Result<Signature, WalletError> {
        let manager = self.get_manager_for_index(wallet_index)?;
        manager.sign_transaction(wallet_index, transaction, chain_id).await
    }

    async fn sign_text(
        &self,
        wallet_index: u32,
        text: &str,
        chain_id: &ChainId,
    ) -> Result<Signature, WalletError> {
        let manager = self.get_manager_for_index(wallet_index)?;
        manager.sign_text(wallet_index, text, chain_id).await
    }

    async fn sign_typed_data(
        &self,
        wallet_index: u32,
        typed_data: &TypedData,
        chain_id: &ChainId,
    ) -> Result<Signature, WalletError> {
        let manager = self.get_manager_for_index(wallet_index)?;
        manager.sign_typed_data(wallet_index, typed_data, chain_id).await
    }

    fn supports_blobs(&self) -> bool {
        // Return true if either manager supports blobs
        let primary_supports = self.primary_manager.supports_blobs();
        let private_key_supports =
            self.private_key_manager.as_ref().is_some_and(|m| m.supports_blobs());
        primary_supports || private_key_supports
    }
}