aura_composition/adapters/
random.rs

1//! Random handler adapter
2
3use crate::adapters::collect_ops;
4use crate::adapters::utils::{deserialize_operation_params, serialize_operation_result};
5use crate::registry::{HandlerContext, HandlerError, RegistrableHandler};
6use async_trait::async_trait;
7use aura_core::effects::{RandomCoreEffects, RandomExtendedEffects};
8use aura_core::{EffectType, ExecutionMode};
9use aura_effects::random::RealRandomHandler;
10use std::sync::Arc;
11
12/// Adapter for RealRandomHandler
13pub struct RandomHandlerAdapter {
14    handler: Arc<dyn RandomCoreEffects>,
15}
16
17impl RandomHandlerAdapter {
18    pub fn new(handler: RealRandomHandler) -> Self {
19        Self {
20            handler: Arc::new(handler),
21        }
22    }
23
24    pub fn new_core(handler: Arc<dyn RandomCoreEffects>) -> Self {
25        Self { handler }
26    }
27}
28
29#[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
30#[cfg_attr(not(target_arch = "wasm32"), async_trait)]
31impl RegistrableHandler for RandomHandlerAdapter {
32    async fn execute_operation_bytes(
33        &self,
34        effect_type: EffectType,
35        operation: &str,
36        parameters: &[u8],
37        _ctx: &HandlerContext,
38    ) -> Result<Vec<u8>, HandlerError> {
39        if effect_type != EffectType::Random {
40            return Err(HandlerError::UnsupportedEffect { effect_type });
41        }
42
43        match operation {
44            "random_bytes" => {
45                let len: usize = deserialize_operation_params(effect_type, operation, parameters)?;
46                let result = self.handler.random_bytes(len).await;
47                serialize_operation_result(effect_type, operation, &result)
48            }
49            "random_bytes_32" => {
50                let result = self.handler.random_bytes_32().await;
51                serialize_operation_result(effect_type, operation, &result)
52            }
53            "random_u64" => {
54                let result = self.handler.random_u64().await;
55                serialize_operation_result(effect_type, operation, &result)
56            }
57            "random_range" => {
58                let (min, max): (u64, u64) =
59                    deserialize_operation_params(effect_type, operation, parameters)?;
60                let result = self.handler.random_range(min, max).await;
61                serialize_operation_result(effect_type, operation, &result)
62            }
63            "random_uuid" => {
64                let result = self.handler.random_uuid().await;
65                serialize_operation_result(effect_type, operation, &result)
66            }
67            _ => Err(HandlerError::UnknownOperation {
68                effect_type,
69                operation: operation.to_string(),
70            }),
71        }
72    }
73
74    fn supported_operations(&self, effect_type: EffectType) -> Vec<String> {
75        collect_ops(effect_type, true)
76    }
77
78    fn supports_effect(&self, effect_type: EffectType) -> bool {
79        effect_type == EffectType::Random
80    }
81
82    fn execution_mode(&self) -> ExecutionMode {
83        ExecutionMode::Production
84    }
85}
aura_composition/adapters/random.rs

aura_composition/adapters/
random.rs
