caxton 0.1.4

A secure WebAssembly runtime for multi-agent systems
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
111
112
113
114
115
116
117
118
119
120
121
122
123

use nutype::nutype;
use serde::{Deserialize, Serialize};
use std::time::Duration;

#[nutype(
    validate(greater_or_equal = 0),
    derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        PartialOrd,
        Ord,
        Serialize,
        Deserialize,
        Default
    ),
    default = 0
)]
pub struct FuelConsumed(u64);

impl FuelConsumed {
    pub fn zero() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn add(&self, other: &Self) -> Self {
        Self::try_new(self.into_inner() + other.into_inner()).unwrap_or_default()
    }
}

#[nutype(
    validate(predicate = |v: &Vec<u8>| v.len() <= 10_485_760),
    derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default),
    default = Vec::new()
)]
pub struct ExecutionOutput(Vec<u8>);

impl ExecutionOutput {
    pub fn empty() -> Self {
        Self::try_new(Vec::new()).unwrap_or_default()
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ExecutionStatus {
    Success,
    Failure { reason: FailureReason },
    Timeout { elapsed: ElapsedTime },
}

#[nutype(
    validate(len_char_min = 1, len_char_max = 1000),
    derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Display)
)]
pub struct FailureReason(String);

#[nutype(
    validate(greater_or_equal = 0),
    derive(
        Debug,
        Clone,
        Copy,
        PartialEq,
        Eq,
        PartialOrd,
        Ord,
        Serialize,
        Deserialize,
        Default
    ),
    default = 0
)]
pub struct ElapsedTime(u64);

impl ElapsedTime {
    pub fn from_duration(duration: Duration) -> Self {
        let millis = duration.as_millis();
        // Safe conversion: as_millis() returns u128, we need u64
        // If millis exceeds u64::MAX, we use the maximum representable value
        let millis_u64 = u64::try_from(millis).unwrap_or(u64::MAX);
        Self::try_new(millis_u64).unwrap_or_default()
    }

    pub fn meets_minimum(&self, minimum_ms: u64) -> bool {
        self.into_inner() >= minimum_ms
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExecutionResult {
    pub status: ExecutionStatus,
    pub fuel_consumed: FuelConsumed,
    pub output: Option<ExecutionOutput>,
}

impl ExecutionResult {
    pub fn success(fuel_consumed: FuelConsumed, output: Option<ExecutionOutput>) -> Self {
        Self {
            status: ExecutionStatus::Success,
            fuel_consumed,
            output,
        }
    }

    pub fn failure(reason: FailureReason, fuel_consumed: FuelConsumed) -> Self {
        Self {
            status: ExecutionStatus::Failure { reason },
            fuel_consumed,
            output: None,
        }
    }

    pub fn timeout(elapsed: ElapsedTime, fuel_consumed: FuelConsumed) -> Self {
        Self {
            status: ExecutionStatus::Timeout { elapsed },
            fuel_consumed,
            output: None,
        }
    }
}