oracle_omen_wasm 0.1.0

WASM sandbox with fuel limits for oracle.omen
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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Resource limits for WASM execution.

use serde::{Deserialize, Serialize};

/// Resource limits for WASM tools
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ResourceLimits {
    /// Maximum fuel (instructions)
    pub max_fuel: u64,

    /// Maximum memory pages (64KB each)
    pub max_memory_pages: u32,

    /// Maximum table elements
    pub max_table_elements: u32,

    /// Execution timeout in milliseconds
    pub timeout_ms: u64,

    /// Maximum output size in bytes
    pub max_output_bytes: usize,
}

impl ResourceLimits {
    /// Create new resource limits
    pub fn new(
        max_fuel: u64,
        max_memory_pages: u32,
        timeout_ms: u64,
    ) -> Self {
        Self {
            max_fuel,
            max_memory_pages,
            max_table_elements: 1024,
            timeout_ms,
            max_output_bytes: 1024 * 1024, // 1MB default
        }
    }

    /// Create minimal limits for testing
    pub fn minimal() -> Self {
        Self {
            max_fuel: 10_000,
            max_memory_pages: 1,
            max_table_elements: 10,
            timeout_ms: 100,
            max_output_bytes: 1024,
        }
    }

    /// Create generous limits
    pub fn generous() -> Self {
        Self {
            max_fuel: 10_000_000,
            max_memory_pages: 64, // 4MB
            max_table_elements: 4096,
            timeout_ms: 30_000,
            max_output_bytes: 10 * 1024 * 1024, // 10MB
        }
    }

    /// Get memory limit in bytes
    pub fn max_memory_bytes(&self) -> usize {
        (self.max_memory_pages as usize) * 65536
    }
}

impl Default for ResourceLimits {
    fn default() -> Self {
        Self::new(1_000_000, 16, 5000)
    }
}

/// Fuel cost for various operations
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct FuelCosts {
    pub base_opcost: u64,
    pub memory_opcost: u64,
    pub table_opcost: u64,
    pub host_call_cost: u64,
}

impl FuelCosts {
    /// Standard fuel costs (wasmi default)
    pub fn standard() -> Self {
        Self {
            base_opcost: 1,
            memory_opcost: 10,
            table_opcost: 10,
            host_call_cost: 100,
        }
    }

    /// Conservative fuel costs (for safety)
    pub fn conservative() -> Self {
        Self {
            base_opcost: 2,
            memory_opcost: 20,
            table_opcost: 20,
            host_call_cost: 200,
        }
    }
}

impl Default for FuelCosts {
    fn default() -> Self {
        Self::standard()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_resource_limits() {
        let limits = ResourceLimits::new(1000000, 16, 5000);
        assert_eq!(limits.max_fuel, 1000000);
        assert_eq!(limits.max_memory_pages, 16);
        assert_eq!(limits.max_memory_bytes(), 16 * 65536);
        assert_eq!(limits.timeout_ms, 5000);
    }

    #[test]
    fn test_minimal_limits() {
        let limits = ResourceLimits::minimal();
        assert_eq!(limits.max_fuel, 10_000);
        assert_eq!(limits.max_memory_pages, 1);
        assert_eq!(limits.max_output_bytes, 1024);
    }

    #[test]
    fn test_fuel_costs() {
        let costs = FuelCosts::standard();
        assert_eq!(costs.base_opcost, 1);
        assert_eq!(costs.host_call_cost, 100);
    }
}