blueprint-pricing-engine 0.2.5

Tangle Cloud Pricing Engine for service offerings
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

use blueprint_core::error;
use tangle_subxt::{
    subxt::{Config, events::Events},
    tangle_testnet_runtime::api::services::events::{
        Registered, RpcAddressUpdated, ServiceInitiated, ServiceRequestApproved,
        ServiceRequestRejected, ServiceRequested, ServiceTerminated, Unregistered,
    },
};

/// Events from the blockchain that are relevant to the pricing engine
#[derive(Debug, Clone)]
pub enum BlockchainEvent {
    /// An operator has been registered for a service blueprint
    Registered(Registered),

    /// An operator has been unregistered
    Unregistered(Unregistered),

    /// An operator's RPC address has been updated
    RpcAddressUpdated(RpcAddressUpdated),

    /// A new service has been requested
    ServiceRequested(ServiceRequested),

    /// A service request has been approved
    ServiceRequestApproved(ServiceRequestApproved),

    /// A service request has been rejected
    ServiceRequestRejected(ServiceRequestRejected),

    /// A service has been initiated
    ServiceInitiated(ServiceInitiated),

    /// A service has been terminated
    ServiceTerminated(ServiceTerminated),

    /// Unknown event type (for testing and handling unexpected events)
    Unknown(String),
}

pub async fn handle_events<T: Config>(events: Events<T>) -> Vec<BlockchainEvent> {
    let mut blockchain_events = Vec::new();

    for event in events.find::<Registered>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::Registered(event)),
            Err(e) => error!("Error processing Registered event: {}", e),
        }
    }

    for event in events.find::<Unregistered>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::Unregistered(event)),
            Err(e) => error!("Error processing Unregistered event: {}", e),
        }
    }

    for event in events.find::<RpcAddressUpdated>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::RpcAddressUpdated(event)),
            Err(e) => error!("Error processing RpcAddressUpdated event: {}", e),
        }
    }

    for event in events.find::<ServiceRequested>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::ServiceRequested(event)),
            Err(e) => error!("Error processing ServiceRequested event: {}", e),
        }
    }

    for event in events.find::<ServiceRequestApproved>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::ServiceRequestApproved(event)),
            Err(e) => error!("Error processing ServiceRequestApproved event: {}", e),
        }
    }

    for event in events.find::<ServiceRequestRejected>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::ServiceRequestRejected(event)),
            Err(e) => error!("Error processing ServiceRequestRejected event: {}", e),
        }
    }

    for event in events.find::<ServiceInitiated>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::ServiceInitiated(event)),
            Err(e) => error!("Error processing ServiceInitiated event: {}", e),
        }
    }

    for event in events.find::<ServiceTerminated>() {
        match event {
            Ok(event) => blockchain_events.push(BlockchainEvent::ServiceTerminated(event)),
            Err(e) => error!("Error processing ServiceTerminated event: {}", e),
        }
    }

    blockchain_events
}