repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/tree.rs | examples/tree.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct TreeParams {
pixel_offset: f32,
pixel_offset2: f32,
lights: f32,
exp: f32,
frame: f32,
col1: f32,
col2: f32,
decay: f32,
}
impl UniformProvider for TreeParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct TreeShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: TreeParams,
}
impl ShaderManager for TreeShader {
fn init(core: &Core) -> Self {
let initial_params = TreeParams {
pixel_offset: 1.35,
pixel_offset2: 1.0,
lights: 2.2,
exp: 4.0,
frame: 0.5,
col1: 205.0,
col2: 5.5,
decay: 0.96,
};
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// Create multipass system: buffer_a -> buffer_b -> buffer_c -> main_image
let passes = vec![
PassDescription::new("buffer_a", &[]), // no dependencies, generates fractal
PassDescription::new("buffer_b", &["buffer_a"]), // reads buffer_a
PassDescription::new("buffer_c", &["buffer_c", "buffer_b"]), // self-feedback + buffer_b
PassDescription::new("main_image", &["buffer_c"]),
];
let config = ComputeShader::builder()
.with_entry_point("buffer_a")
.with_multi_pass(&passes)
.with_custom_uniforms::<TreeParams>()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Tree Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/tree.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/tree.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Tree Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/tree.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for tree shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
// Update time uniform - this is crucial for accumulation!
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0; // Approximate delta time
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Tree Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Fractal Tree")
.collapsible(true)
.resizable(true)
.default_width(280.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Fractal Parameters")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.pixel_offset, -3.14..=3.14)
.text("Pixel Offset Y"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.pixel_offset2, -3.14..=3.14)
.text("Pixel Offset X"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.lights, 0.0..=12.2)
.text("Lights"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.exp, 1.0..=120.0).text("Exp"),
)
.changed();
});
egui::CollapsingHeader::new("Visual Settings")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.frame, 0.0..=2.2)
.text("Frame"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.col1, 0.0..=300.0)
.text("Iterations"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.col2, 0.0..=10.0)
.text("Color 2"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.decay, 0.0..=1.0)
.text("Feedback"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
ui.separator();
ui.label(format!("Frame: {}", self.compute_shader.current_frame));
ui.label("Multi-buffer fractal tree with particle tracing");
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
// Handle controls and clear buffers if requested
if controls_request.should_clear_buffers {
// Reset frame count to restart accumulation
self.compute_shader.current_frame = 0;
}
// Execute multi-pass compute shader: buffer_a -> buffer_b -> buffer_c -> main_image
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let compute_texture = self.compute_shader.get_output_texture();
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Tree Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
// Apply UI changes
self.base.apply_control_request(controls_request);
self.base.export_manager.apply_ui_request(export_request);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(std::iter::once(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = ShaderApp::new("Fractal Tree", 800, 600);
app.run(event_loop, TreeShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/particles.rs | examples/particles.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ParticleParams {
a: f32,
b: f32,
c: f32,
d: f32,
num_circles: f32,
num_points: f32,
particle_intensity: f32,
gamma: f32,
feedback_mix: f32,
feedback_decay: f32,
scale: f32,
rotation: f32,
bloom_scale: f32,
animation_speed: f32,
color_shift_speed: f32,
color_scale: f32,
}
impl UniformProvider for ParticleParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct ParticleShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: ParticleParams,
frame_count: u32,
}
impl ParticleShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
self.frame_count = 0;
}
}
impl ShaderManager for ParticleShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = ParticleParams {
a: -1.8,
b: -2.0,
c: -0.5,
d: -0.9,
num_circles: 6.0,
num_points: 7.0,
particle_intensity: 1.0,
gamma: 0.5,
feedback_mix: 0.5,
feedback_decay: 2.0,
scale: 3.0,
rotation: 0.0,
bloom_scale: 7.0,
animation_speed: 0.1,
color_shift_speed: 0.1,
color_scale: 1.2,
};
let config = ComputeShader::builder()
.with_entry_point("main_image")
.with_custom_uniforms::<ParticleParams>()
.with_storage_buffer(StorageBufferSpec::new(
"atomic_buffer",
(core.size.width * core.size.height * 3 * 4) as u64,
)) // 3 channels * u32 per pixel
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Particles Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/particles.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/particles.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Particles Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/particles.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for Particles shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
frame_count: 0,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Particle System")
.collapsible(true)
.resizable(true)
.default_width(280.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Attractor Parameters")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.a, -3.0..=3.0)
.text("Parameter A"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.b, -3.0..=3.0)
.text("Parameter B"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.c, -3.0..=3.0)
.text("Parameter C"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.d, -3.0..=3.0)
.text("Parameter D"),
)
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Visual Settings")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.num_circles, 1.0..=10.0)
.text("Number of Circles"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.num_points, 1.0..=10.0)
.text("Points per Circle"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(
&mut params.particle_intensity,
0.1..=5.0,
)
.text("Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=0.5)
.text("Gamma"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.bloom_scale, 1.0..=20.0)
.text("Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.scale, 0.1..=10.0)
.text("Attractor Scale"),
)
.changed();
});
egui::CollapsingHeader::new("Animation & Feedback")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.animation_speed, 0.0..=1.0)
.text("Animation Speed"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.feedback_decay, 0.0..=2.5)
.text("Feedback Decay"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.feedback_mix, 0.0..=1.0)
.text("Feedback Mix"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.color_shift_speed, 0.0..=1.0)
.text("Color Shift Speed"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.color_scale, 0.0..=3.24)
.text("Color Scale"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.compute_shader.time_uniform.data.frame = self.frame_count;
self.compute_shader.time_uniform.update(&core.queue);
// Single stage dispatch
self.compute_shader.dispatch(&mut encoder, core);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
self.frame_count = self.frame_count.wrapping_add(1);
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Particles", 800, 600);
app.run(event_loop, ParticleShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/cnn.rs | examples/cnn.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct CNNParams {
brush_size: f32,
input_resolution: f32,
clear_canvas: i32,
show_debug: i32,
feature_maps_1: f32,
feature_maps_2: f32,
num_classes: f32,
normalization_mean: f32,
normalization_std: f32,
show_frequencies: i32,
conv1_pool_size: f32,
conv2_pool_size: f32,
_padding1: f32,
_padding2: f32,
_padding3: f32,
_padding4: f32,
_padding5: f32,
_padding6: f32,
}
impl UniformProvider for CNNParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct CNNDigitRecognizer {
base: RenderKit,
compute_shader: ComputeShader,
current_params: CNNParams,
first_frame: bool,
}
impl CNNDigitRecognizer {}
impl ShaderManager for CNNDigitRecognizer {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// Configure multi-pass CNN with 5 stages: canvas_update -> conv_layer1 -> conv_layer2 -> fully_connected -> main_image
let passes = vec![
PassDescription::new("canvas_update", &[]).with_workgroup_size([28, 28, 1]),
PassDescription::new("conv_layer1", &["canvas_update"])
.with_workgroup_size([12, 12, 16]), // 16 Feature Maps
PassDescription::new("conv_layer2", &["conv_layer1"])
.with_workgroup_size([4, 4, 32]), // 32 Feature Maps
PassDescription::new("fully_connected", &["conv_layer2"])
.with_workgroup_size([47, 1, 1]), // 47 Classes
PassDescription::new("main_image", &["fully_connected"]),
];
let compute_shader = ComputeShaderBuilder::new()
.with_label("CNN Digit Recognizer")
.with_multi_pass(&passes)
.with_custom_uniforms::<CNNParams>()
.with_mouse()
.with_fonts()
.with_storage_buffer(StorageBufferSpec::new("canvas_data", (28 * 28 * 4) as u64))
.with_storage_buffer(StorageBufferSpec::new(
"conv1_data",
(12 * 12 * 16 * 4) as u64,
))
.with_storage_buffer(StorageBufferSpec::new(
"conv2_data",
(4 * 4 * 32 * 4) as u64
))
.with_storage_buffer(StorageBufferSpec::new(
"fc_data",
(47 * 4) as u64
))
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/cnn.wgsl"), compute_shader);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/cnn.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("CNN Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/cnn.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for cnn shader: {e}");
}
let current_params = CNNParams {
brush_size: 0.007,
input_resolution: 28.0,
clear_canvas: 0,
show_debug: 0,
feature_maps_1: 16.0,
feature_maps_2: 32.0,
num_classes: 47.0,
normalization_mean: 0.175,
normalization_std: 0.33,
show_frequencies: 0,
conv1_pool_size: 12.0,
conv2_pool_size: 4.0,
_padding1: 0.0,
_padding2: 0.0,
_padding3: 0.0,
_padding4: 0.0,
_padding5: 0.0,
_padding6: 0.0,
};
Self {
base,
compute_shader,
current_params,
first_frame: true,
}
}
fn update(&mut self, core: &Core) {
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
}
fn resize(&mut self, core: &Core) {
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("CNN Frame"),
});
let mut params = self.current_params;
let mut changed = self.first_frame; // Update params on first frame
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("CNN chr Recognizer")
.collapsible(true)
.resizable(true)
.default_width(280.0)
.show(ctx, |ui| {
ui.label("Draw a character in the canvas area and watch the CNN predict it!");
ui.separator();
ui.label("The CNN will predict the character using pre-trained weights");
ui.separator();
egui::CollapsingHeader::new("Brush")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brush_size, 0.001..=0.015)
.text("Brush Size"),
)
.changed();
if ui.button("Clear Canvas").clicked() {
params.clear_canvas = 1;
changed = true;
} else {
params.clear_canvas = 0;
}
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
// Update mouse uniform for drawing interaction
self.compute_shader
.update_mouse_uniform(&self.base.mouse_tracker.uniform, &core.queue);
// Execute CNN pipeline
// Note: our backend automatically uses custom workgroup sizes from PassDescription
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let compute_texture = self.compute_shader.get_output_texture();
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("CNN Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
// Apply UI changes
self.base.apply_control_request(controls_request.clone());
self.base.export_manager.apply_ui_request(export_request);
if should_start_export {
self.base.export_manager.start_export();
}
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
self.first_frame = false;
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(std::iter::once(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
// Handle mouse input for drawing on canvas
if self.base.handle_mouse_input(core, event, false) {
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
let (app, event_loop) = ShaderApp::new("EMNIST", 800, 600);
app.run(event_loop, CNNDigitRecognizer::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/fluid.rs | examples/fluid.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C, align(16))]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct FluidParams {
rotation_speed: f32,
motor_strength: f32,
distortion: f32,
feedback: f32,
particle_size: f32,
_padding: [f32; 7],
}
impl UniformProvider for FluidParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct FluidShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: FluidParams,
}
impl ShaderManager for FluidShader {
fn init(core: &Core) -> Self {
let initial_params = FluidParams {
rotation_speed: 2.0,
motor_strength: 0.01,
distortion: 10.0,
feedback: 0.95,
particle_size: 1.0,
_padding: [0.0; 7],
};
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// Create multipass system: buffer_a (simulation) -> main_image (display)
let passes = vec![
PassDescription::new("buffer_a", &[]),
PassDescription::new("main_image", &["buffer_a"]),
];
// Use input texture in Group 1 for external input
let config = ComputeShader::builder()
.with_entry_point("buffer_a")
.with_multi_pass(&passes)
.with_channels(1) // Enable channel0 in Group 2 - accessible from all passes!
.with_custom_uniforms::<FluidParams>()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Fluid Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/fluid.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/fluid.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Fluid Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/fluid.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for fluid shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Update current texture (video/webcam/static)
self.base.update_current_texture(core, &core.queue);
// Update channel0 with external texture (accessible from all passes!)
if let Some(texture_manager) = self.base.get_current_texture_manager() {
self.compute_shader.update_channel_texture(
0,
&texture_manager.view,
&texture_manager.sampler,
&core.device,
&core.queue,
);
}
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Fluid Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let using_video_texture = self.base.using_video_texture;
let using_hdri_texture = self.base.using_hdri_texture;
let using_webcam_texture = self.base.using_webcam_texture;
let video_info = self.base.get_video_info();
let hdri_info = self.base.get_hdri_info();
let webcam_info = self.base.get_webcam_info();
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Fluid Simulation")
.collapsible(true)
.resizable(true)
.default_width(300.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Fluid Parameters")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.rotation_speed, -5.0..=5.0)
.text("Rotation Speed"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.motor_strength, -0.2..=0.2)
.text("Motor Strength"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.distortion, 1.0..=20.0)
.text("Distortion"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.feedback, 0.0..=1.01)
.text("Feedback"),
)
.changed();
});
egui::CollapsingHeader::new("Quality")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.particle_size, 0.0..=1.5)
.text("Particle Size"),
)
.changed();
});
ui.separator();
ShaderControls::render_media_panel(
ui,
&mut controls_request,
using_video_texture,
video_info,
using_hdri_texture,
hdri_info,
using_webcam_texture,
webcam_info,
);
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
// Handle controls and clear buffers if requested
if controls_request.should_clear_buffers {
// Reset frame count to restart simulation
self.compute_shader.current_frame = 0;
}
// Execute multi-pass compute shader: buffer_a -> main_image
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let compute_texture = self.compute_shader.get_output_texture();
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Fluid Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base.apply_control_request(controls_request.clone());
self.base.handle_video_requests(core, &controls_request);
self.base.handle_webcam_requests(core, &controls_request);
self.base.handle_hdri_requests(core, &controls_request);
self.base.export_manager.apply_ui_request(export_request);
if should_start_export {
self.base.export_manager.start_export();
}
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(std::iter::once(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
cuneus::gst::init()?;
env_logger::init();
let (app, event_loop) = ShaderApp::new("Fluid Simulation", 800, 600);
app.run(event_loop, FluidShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/system.rs | examples/system.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct SystemParams {
a: f32,
b: f32,
c: f32,
dof_amount: f32,
dof_focal_dist: f32,
brightness: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
zoom: f32,
}
impl UniformProvider for SystemParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct SystemShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: SystemParams,
}
impl SystemShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for SystemShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let initial_params = SystemParams {
a: 0.0,
b: 0.0,
c: 0.4,
dof_amount: 0.0,
dof_focal_dist: 0.96,
brightness: 0.00004,
color1_r: 0.2,
color1_g: 0.8,
color1_b: 1.0,
color2_r: 1.0,
color2_g: 0.4,
color2_b: 0.1,
zoom: 1.0,
};
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let mut config = ComputeShader::builder()
.with_entry_point("Splat")
.with_custom_uniforms::<SystemParams>()
.with_atomic_buffer()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Electric Field System")
.build();
// Add second entry point manually
config.entry_points.push("main_image".to_string());
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/system.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/system.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("System Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/system.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for system shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export with custom dispatch pattern for system
self.compute_shader.handle_export_dispatch(
core,
&mut self.base,
|shader, encoder, core| {
shader.dispatch_stage_with_workgroups(encoder, 0, [2048, 1, 1]);
shader.dispatch_stage(encoder, core, 1);
},
);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Settings")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Field Parameters")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.a, 0.0..=2.0)
.text("Strength"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.b, 0.0..=1.0)
.text("Gradient"),
)
.changed();
changed |= ui
.add(egui::Slider::new(&mut params.c, 0.0..=2.0).text("Scale"))
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Visuals")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brightness, 0.00001..=0.0002)
.logarithmic(true)
.text("Brightness"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.zoom, 0.1..=5.0).text("Zoom"),
)
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Depth of Field")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.dof_amount, 0.0..=3.0)
.text("DOF"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dof_focal_dist, 0.0..=2.0)
.text("Focal Distance"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Color 1:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 2:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// No mouse integration needed anymore
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Stage 0: Splat field particles (workgroup size [256, 1, 1])
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 0, [2048, 1, 1]);
// Stage 1: Render to screen (workgroup size [16, 16, 1])
self.compute_shader.dispatch_stage(&mut encoder, core, 1);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Attractor Universe", 800, 600);
app.run(event_loop, SystemShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/galaxy.rs | examples/galaxy.rs | use cuneus::prelude::*;
use cuneus::{Core, RenderKit, ShaderApp, ShaderManager, UniformProvider};
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ShaderParams {
max_iterations: i32,
max_sub_iterations: i32,
point_intensity: f32,
center_scale: f32,
time_scale: f32,
dist_offset: f32,
_pad1: [f32; 2],
}
impl UniformProvider for ShaderParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct GalaxyShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: ShaderParams,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = ShaderApp::new("Galaxy", 800, 600);
app.run(event_loop, GalaxyShader::init)
}
impl ShaderManager for GalaxyShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let initial_params = ShaderParams {
max_iterations: 150,
max_sub_iterations: 11,
point_intensity: 0.000828,
center_scale: 1.0,
time_scale: 0.1,
dist_offset: 0.07,
_pad1: [0.0; 2],
};
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<ShaderParams>()
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/galaxy.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/galaxy.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Galaxy Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/galaxy.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for Galaxy shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.base.fps_tracker.update();
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Galaxy Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
});
egui::Window::new("Galaxy Settings").show(ctx, |ui| {
ui.collapsing("Parameters", |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.max_iterations, 50..=300)
.text("Max Iterations"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.max_sub_iterations, 5..=20)
.text("Max Sub Iterations"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.point_intensity, 0.0001..=0.01)
.logarithmic(true)
.text("Point Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.center_scale, 0.1..=5.0)
.text("Center Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.time_scale, 0.01..=1.0)
.text("Time Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dist_offset, 0.01..=0.5)
.text("Distance Offset"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Dispatch compute shader
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Main Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/synth.rs | examples/synth.rs | use cuneus::audio::{EnvelopeConfig, SynthesisManager};
use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct SynthParams {
tempo: f32,
waveform_type: u32,
octave: f32,
volume: f32,
beat_enabled: u32,
reverb_mix: f32,
delay_time: f32,
delay_feedback: f32,
filter_cutoff: f32,
filter_resonance: f32,
distortion_amount: f32,
chorus_rate: f32,
chorus_depth: f32,
attack_time: f32,
decay_time: f32,
sustain_level: f32,
release_time: f32,
_padding1: u32,
_padding2: u32,
_padding3: u32,
key_states: [[f32; 4]; 3],
key_decay: [[f32; 4]; 3],
}
impl UniformProvider for SynthParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct SynthManager {
base: RenderKit,
compute_shader: ComputeShader,
current_params: SynthParams,
gpu_synthesis: Option<SynthesisManager>,
// Track which keys are currently held down
keys_held: [bool; 9],
}
impl SynthManager {
fn set_key_state(&mut self, key_index: usize, state: f32) {
if key_index < 9 {
let vec_idx = key_index / 4;
let comp_idx = key_index % 4;
self.current_params.key_states[vec_idx][comp_idx] = state;
}
}
fn set_key_decay(&mut self, key_index: usize, decay: f32) {
if key_index < 9 {
let vec_idx = key_index / 4;
let comp_idx = key_index % 4;
self.current_params.key_decay[vec_idx][comp_idx] = decay;
}
}
fn get_note_frequency(&self, note_index: usize) -> f32 {
let notes = [
261.63, 293.66, 329.63, 349.23, 392.00, 440.00, 493.88, 523.25, 587.33,
];
let octave_multiplier = 2.0_f32.powf(self.current_params.octave - 4.0);
notes[note_index] * octave_multiplier
}
fn update_envelope_config(&mut self) {
if let Some(ref mut synth) = self.gpu_synthesis {
synth.set_adsr(
self.current_params.attack_time,
self.current_params.decay_time,
self.current_params.sustain_level,
self.current_params.release_time,
);
}
}
}
impl ShaderManager for SynthManager {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = SynthParams {
tempo: 120.0,
waveform_type: 1,
octave: 4.0,
volume: 0.7,
beat_enabled: 0,
reverb_mix: 0.15,
delay_time: 0.3,
delay_feedback: 0.3,
filter_cutoff: 0.9,
filter_resonance: 0.1,
distortion_amount: 0.0,
chorus_rate: 2.0,
chorus_depth: 0.1,
attack_time: 0.02,
decay_time: 0.15,
sustain_level: 0.7,
release_time: 0.4,
_padding1: 0,
_padding2: 0,
_padding3: 0,
key_states: [[0.0; 4]; 3],
key_decay: [[0.0; 4]; 3],
};
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<SynthParams>()
.with_audio(2048)
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Synth Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/synth.wgsl"), config);
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/synth.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Synth Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/synth.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for synth shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
// Initialize audio synthesis with envelope configuration
let gpu_synthesis = match SynthesisManager::new() {
Ok(mut synth) => {
// Set initial envelope config
synth.set_envelope(EnvelopeConfig {
attack_time: initial_params.attack_time,
decay_time: initial_params.decay_time,
sustain_level: initial_params.sustain_level,
release_time: initial_params.release_time,
});
if let Err(_e) = synth.start_gpu_synthesis() {
None
} else {
Some(synth)
}
}
Err(_e) => None,
};
Self {
base,
compute_shader,
current_params: initial_params,
gpu_synthesis,
keys_held: [false; 9],
}
}
fn update(&mut self, core: &Core) {
self.base.fps_tracker.update();
self.compute_shader.check_hot_reload(&core.device);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Update GPU shader params for visualization
// The audio backend handles the actual envelope - we just need to track key states for visuals
let mut needs_update = false;
for i in 0..9 {
if self.keys_held[i] {
// Key is held - show full visualization
self.set_key_state(i, 1.0);
self.set_key_decay(i, 1.0);
needs_update = true;
} else {
// Key released - get actual envelope level from audio backend for smooth visual
let current_decay = self.current_params.key_decay[i / 4][i % 4];
if current_decay > 0.01 {
// Smooth visual fade (the audio backend handles actual audio envelope)
let new_decay = current_decay * 0.92;
self.set_key_decay(i, new_decay);
if new_decay < 0.01 {
self.set_key_state(i, 0.0);
}
needs_update = true;
}
}
}
if needs_update {
self.compute_shader
.set_custom_params(self.current_params, &core.queue);
}
// Update audio synthesis
if let Some(ref mut synth) = self.gpu_synthesis {
// Update waveform
synth.update_waveform(self.current_params.waveform_type);
synth.set_master_volume(self.current_params.volume as f64);
// The audio manager handles envelopes internally
// We just need to call update() to process envelope states
synth.update();
}
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Synth Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Cuneus GPU Synth")
.collapsible(true)
.resizable(true)
.default_width(280.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("About")
.default_open(false)
.show(ui, |ui| {
ui.label("🎹 GPU-powered polyphonic synthesizer");
ui.label("• Press keys 1-9 for musical notes");
ui.label("• Smooth ADSR envelopes prevent clicks");
ui.label("• Real-time effects processing");
ui.label("• Visual feedback with spectrum bars");
});
egui::CollapsingHeader::new("Playback")
.default_open(true)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Keys:");
ui.label("1-9 for C D E F G A B C D");
});
let mut beat_enabled = params.beat_enabled > 0;
if ui.checkbox(&mut beat_enabled, "Background Beat").changed() {
params.beat_enabled = if beat_enabled { 1 } else { 0 };
changed = true;
}
changed |= ui
.add(
egui::Slider::new(&mut params.tempo, 60.0..=180.0)
.text("Tempo"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.octave, 2.0..=7.0)
.text("Octave"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.volume, 0.0..=1.0)
.text("Master Volume"),
)
.changed();
ui.horizontal(|ui| {
ui.label("Waveform:");
let waveform_names = ["Sin", "Saw", "Sqr", "Tri", "Nse"];
for (i, name) in waveform_names.iter().enumerate() {
let selected = params.waveform_type == i as u32;
if ui.selectable_label(selected, *name).clicked() {
params.waveform_type = i as u32;
changed = true;
}
}
});
});
egui::CollapsingHeader::new("Envelope (ADSR)")
.default_open(true)
.show(ui, |ui| {
ui.label("Controls click-free sound transitions");
ui.separator();
let attack_changed = ui
.add(
egui::Slider::new(&mut params.attack_time, 0.001..=0.5)
.logarithmic(true)
.text("Attack")
.suffix("s"),
)
.changed();
let decay_changed = ui
.add(
egui::Slider::new(&mut params.decay_time, 0.01..=1.0)
.logarithmic(true)
.text("Decay")
.suffix("s"),
)
.changed();
let sustain_changed = ui
.add(
egui::Slider::new(&mut params.sustain_level, 0.0..=1.0)
.text("Sustain"),
)
.changed();
let release_changed = ui
.add(
egui::Slider::new(&mut params.release_time, 0.01..=2.0)
.logarithmic(true)
.text("Release")
.suffix("s"),
)
.changed();
if attack_changed
|| decay_changed
|| sustain_changed
|| release_changed
{
changed = true;
}
ui.separator();
if ui.small_button("Piano Preset").clicked() {
params.attack_time = 0.01;
params.decay_time = 0.3;
params.sustain_level = 0.5;
params.release_time = 0.8;
changed = true;
}
ui.horizontal(|ui| {
if ui.small_button("Pad Preset").clicked() {
params.attack_time = 0.2;
params.decay_time = 0.5;
params.sustain_level = 0.8;
params.release_time = 1.5;
changed = true;
}
if ui.small_button("Pluck Preset").clicked() {
params.attack_time = 0.005;
params.decay_time = 0.1;
params.sustain_level = 0.3;
params.release_time = 0.2;
changed = true;
}
});
});
egui::CollapsingHeader::new("Filter")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.filter_cutoff, 0.0..=1.0)
.text("Cutoff"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.filter_resonance, 0.0..=0.9)
.text("Resonance"),
)
.changed();
});
egui::CollapsingHeader::new("Effects")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.reverb_mix, 0.0..=0.8)
.text("Reverb"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.delay_time, 0.01..=1.0)
.text("Delay Time"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.delay_feedback, 0.0..=0.8)
.text("Delay Feedback"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.distortion_amount, 0.0..=0.9)
.text("Distortion"),
)
.changed();
ui.separator();
changed |= ui
.add(
egui::Slider::new(&mut params.chorus_rate, 0.1..=10.0)
.text("Chorus Rate"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.chorus_depth, 0.0..=0.5)
.text("Chorus Depth"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
// Update envelope config in audio backend
self.update_envelope_config();
}
self.base.apply_control_request(controls_request);
self.compute_shader.dispatch(&mut encoder, core);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
if let winit::keyboard::Key::Character(ref s) = event.logical_key {
if let Some(key_index) = s.chars().next().and_then(|c| c.to_digit(10)) {
if (1..=9).contains(&key_index) {
let index = (key_index - 1) as usize;
let frequency = self.get_note_frequency(index);
if event.state == winit::event::ElementState::Pressed {
// Only trigger if not already held (prevent retriggering on key repeat)
if !self.keys_held[index] {
self.keys_held[index] = true;
// Update visual state
self.set_key_state(index, 1.0);
self.set_key_decay(index, 1.0);
self.compute_shader
.set_custom_params(self.current_params, &core.queue);
// Trigger note in audio backend (handles envelope automatically)
if let Some(ref mut synth) = self.gpu_synthesis {
let amplitude = self.current_params.volume * 0.4;
synth.set_voice(index, frequency, amplitude, true);
}
}
} else if event.state == winit::event::ElementState::Released {
self.keys_held[index] = false;
// Release note in audio backend (will fade out with envelope)
if let Some(ref mut synth) = self.gpu_synthesis {
synth.set_voice(index, frequency, 0.0, false);
}
// Visual state will fade in update()
}
return true;
}
}
}
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
cuneus::gst::init()?;
let (app, event_loop) = ShaderApp::new("Synth", 800, 600);
app.run(event_loop, SynthManager::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/plasma.rs | examples/plasma.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct NeuralParams {
detail: f32,
animation_speed: f32,
pattern: f32,
structure_smoothness: f32,
saturation: f32,
base_rotation: f32,
rot_variation: f32,
rotation_x: f32,
rotation_y: f32,
click_state: i32,
brightness_mult: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
dof_amount: f32,
dof_focal_dist: f32,
}
impl UniformProvider for NeuralParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct Neural2Shader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: NeuralParams,
mouse_look_enabled: bool,
}
impl Neural2Shader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for Neural2Shader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let initial_params = NeuralParams {
detail: 15.0,
animation_speed: 0.1,
pattern: 0.3,
structure_smoothness: 1.0,
saturation: 0.7,
base_rotation: 7.6,
rot_variation: 0.0070,
rotation_x: -0.6,
rotation_y: 0.15,
click_state: 0,
brightness_mult: 0.00004,
color1_r: 0.5,
color1_g: 0.1,
color1_b: 0.8,
color2_r: 0.0,
color2_g: 0.7,
color2_b: 1.0,
dof_amount: 0.95,
dof_focal_dist: 2.0,
};
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let mut config = ComputeShader::builder()
.with_entry_point("Splat")
.with_custom_uniforms::<NeuralParams>()
.with_atomic_buffer()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Neural Wave Unified")
.build();
// Add second entry point manually
config.entry_points.push("main_image".to_string());
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/plasma.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/plasma.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Plasma Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/plasma.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for Plasma shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
mouse_look_enabled: false,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Neural Wave")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Pattern")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.detail, 3.0..=45.0)
.text("Detail"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.animation_speed, 0.1..=6.0)
.text("v"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.pattern, 0.0..=1.0)
.text("pattern"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(
&mut params.structure_smoothness,
1.0..=3.5,
)
.text("Smoothness"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.saturation, 0.1..=1.0)
.text("Saturation"),
)
.changed();
ui.separator();
changed |= ui
.add(
egui::Slider::new(&mut params.base_rotation, 3.0..=12.0)
.text("rot"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.rot_variation, 0.0..=0.1)
.text("rot var"),
)
.changed();
});
egui::CollapsingHeader::new("Camera")
.default_open(true)
.show(ui, |ui| {
ui.checkbox(&mut self.mouse_look_enabled, "Enable Mouse Look");
ui.separator();
if !self.mouse_look_enabled {
changed |= ui
.add(
egui::Slider::new(&mut params.rotation_x, -1.0..=1.0)
.text("Rotation X"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.rotation_y, -1.0..=1.0)
.text("Rotation Y"),
)
.changed();
} else {
ui.label("Mouse Look Active - Move mouse to control camera");
}
});
egui::CollapsingHeader::new("Visual Settings")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(
&mut params.brightness_mult,
0.00001..=0.0001,
)
.logarithmic(true)
.text("Brightness"),
)
.changed();
});
egui::CollapsingHeader::new("Depth of Field")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.dof_amount, 0.0..=3.0)
.text("DOF Amount"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dof_focal_dist, 0.0..=3.0)
.text("Focal Distance"),
)
.changed();
params.click_state = 1;
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Base Color:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Highlight Color:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
ui.separator();
ui.separator();
ui.label("Controls:");
ui.horizontal(|ui| {
ui.label("• Mouse:");
if self.mouse_look_enabled {
ui.colored_label(egui::Color32::GREEN, "Active");
} else {
ui.colored_label(egui::Color32::RED, "Disabled");
}
});
ui.label("• Right click: Toggle mouse control");
ui.label("• H: Toggle UI");
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Mouse data integration
if self.mouse_look_enabled {
params.rotation_x = self.base.mouse_tracker.uniform.position[0];
params.rotation_y = self.base.mouse_tracker.uniform.position[1];
}
params.click_state = if self.base.mouse_tracker.uniform.buttons[0] & 1 > 0 {
1
} else {
0
};
changed = true;
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Stage 0: Generate and splat particles (workgroup size [256, 1, 1])
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 0, [2048, 1, 1]);
// Stage 1: Render to screen (workgroup size [16, 16, 1])
self.compute_shader.dispatch_stage(&mut encoder, core, 1);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::MouseInput { state, button, .. } = event {
if *button == winit::event::MouseButton::Right
&& *state == winit::event::ElementState::Released
{
self.mouse_look_enabled = !self.mouse_look_enabled;
return true;
}
}
if self.mouse_look_enabled && self.base.handle_mouse_input(core, event, false) {
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Neural Wave", 800, 600);
app.run(event_loop, Neural2Shader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/mandelbulb.rs | examples/mandelbulb.rs | use cuneus::compute::ComputeShader;
use cuneus::{
Core, ExportManager, RenderKit, ShaderControls, ShaderManager, UniformProvider,
};
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct MandelbulbParams {
power: f32,
max_bounces: u32,
samples_per_pixel: u32,
accumulate: u32,
animation_speed: f32,
hold_duration: f32,
transition_duration: f32,
exposure: f32,
focal_length: f32,
dof_strength: f32,
palette_a_r: f32,
palette_a_g: f32,
palette_a_b: f32,
palette_b_r: f32,
palette_b_g: f32,
palette_b_b: f32,
palette_c_r: f32,
palette_c_g: f32,
palette_c_b: f32,
palette_d_r: f32,
palette_d_g: f32,
palette_d_b: f32,
gamma: f32,
zoom: f32,
background_r: f32,
background_g: f32,
background_b: f32,
sun_color_r: f32,
sun_color_g: f32,
sun_color_b: f32,
fog_color_r: f32,
fog_color_g: f32,
fog_color_b: f32,
glow_color_r: f32,
glow_color_g: f32,
glow_color_b: f32,
rotation_x: f32,
rotation_y: f32,
rotation_z: f32,
_pad: f32,
}
impl UniformProvider for MandelbulbParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct MandelbulbShader {
base: RenderKit,
compute_shader: ComputeShader,
frame_count: u32,
should_reset_accumulation: bool,
current_params: MandelbulbParams,
// Mouse tracking for delta-based rotation
previous_mouse_pos: [f32; 2],
mouse_enabled: bool,
mouse_initialized: bool,
// Accumulated rotation (persists across frames)
accumulated_rotation: [f32; 3],
// Accumulated zoom from mouse wheel
accumulated_zoom: f32,
}
impl MandelbulbShader {
fn reset_accumulation(&mut self) {
self.compute_shader.current_frame = 0;
self.should_reset_accumulation = false;
self.frame_count = 0;
}
}
impl ShaderManager for MandelbulbShader {
fn init(core: &Core) -> Self {
let initial_params = MandelbulbParams {
power: 4.0,
max_bounces: 2,
samples_per_pixel: 1,
accumulate: 1,
animation_speed: 1.0,
hold_duration: 3.0,
transition_duration: 3.0,
exposure: 1.0,
focal_length: 2.5,
dof_strength: 0.04,
palette_a_r: 0.5,
palette_a_g: 0.7,
palette_a_b: 0.5,
palette_b_r: 0.9,
palette_b_g: 0.8,
palette_b_b: 0.1,
palette_c_r: 1.0,
palette_c_g: 1.0,
palette_c_b: 1.0,
palette_d_r: 1.0,
palette_d_g: 1.15,
palette_d_b: 0.20,
gamma: 1.1,
zoom: 1.0,
background_r: 0.05,
background_g: 0.1,
background_b: 0.15,
sun_color_r: 8.10,
sun_color_g: 6.00,
sun_color_b: 4.20,
fog_color_r: 0.05,
fog_color_g: 0.1,
fog_color_b: 0.15,
glow_color_r: 0.5,
glow_color_g: 0.7,
glow_color_b: 1.0,
rotation_x: 0.0,
rotation_y: 0.0,
rotation_z: 0.0,
_pad: 0.0,
};
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// multipass system: buffer_a (self-feedback) -> main_image (in shadertoy term)
// buffa: self-feedback for accumulation
// img: reads buffer_a for tonemapping
let passes = vec![
cuneus::compute::PassDescription::new("buffer_a", &["buffer_a"]),
cuneus::compute::PassDescription::new("main_image", &["buffer_a"]),
];
let config = ComputeShader::builder()
.with_entry_point("buffer_a")
.with_multi_pass(&passes)
.with_custom_uniforms::<MandelbulbParams>()
.with_mouse() // Enable mouse backend integration
.with_workgroup_size([16, 16, 1])
.with_texture_format(cuneus::compute::COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Mandelbulb Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/mandelbulb.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/mandelbulb.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Mandelbulb Hot Reload"),
source: wgpu::ShaderSource::Wgsl(
include_str!("shaders/mandelbulb.wgsl").into(),
),
}),
) {
eprintln!("Failed to enable hot reload for mandelbulb shader: {e}");
}
// Initialize custom uniform with initial parameters
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
frame_count: 0,
should_reset_accumulation: true,
current_params: initial_params,
previous_mouse_pos: [0.5, 0.5],
mouse_enabled: false,
mouse_initialized: false,
accumulated_rotation: [0.0, 0.0, 0.0],
accumulated_zoom: 1.0,
}
}
fn update(&mut self, core: &Core) {
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
println!("Resizing to {:?}", core.size);
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let current_mouse_pos = self.base.mouse_tracker.uniform.position;
let mouse_wheel = self.base.mouse_tracker.uniform.wheel;
if mouse_wheel[1].abs() > 0.001 {
let zoom_sensitivity = 0.1;
self.accumulated_zoom *= 1.0 - mouse_wheel[1] * zoom_sensitivity;
self.accumulated_zoom = self.accumulated_zoom.clamp(0.2, 5.0);
self.should_reset_accumulation = true;
}
if self.mouse_enabled {
if !self.mouse_initialized {
self.previous_mouse_pos = current_mouse_pos;
self.mouse_initialized = true;
} else {
let delta_x: f32 = current_mouse_pos[0] - self.previous_mouse_pos[0];
let delta_y = current_mouse_pos[1] - self.previous_mouse_pos[1];
if delta_x.abs() > 0.0001 || delta_y.abs() > 0.0001 {
let base_sensitivity = 5.0;
let aspect = core.size.width as f32 / core.size.height as f32;
self.accumulated_rotation[0] += delta_x * base_sensitivity;
self.accumulated_rotation[1] += delta_y * base_sensitivity * aspect;
self.should_reset_accumulation = true;
self.previous_mouse_pos = current_mouse_pos;
}
}
}
self.base.mouse_tracker.reset_wheel();
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let current_fps = self.base.fps_tracker.fps();
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Mandelbulb PathTracer")
.collapsible(true)
.resizable(true)
.default_width(350.0)
.show(ctx, |ui| {
ui.label("WASD: Rotate | QE: Roll | Scroll: Zoom");
ui.separator();
egui::CollapsingHeader::new("Camera&View")
.default_open(false)
.show(ui, |ui| {
if ui.add(egui::Slider::new(&mut self.accumulated_zoom, 0.2..=5.0).text("Zoom")).changed() {
self.should_reset_accumulation = true;
}
changed |= ui
.add(
egui::Slider::new(&mut params.focal_length, 2.0..=20.0)
.text("Focal Length"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dof_strength, 0.0..=1.0)
.text("DoF"),
)
.changed();
ui.separator();
let old_mouse_enabled = self.mouse_enabled;
ui.checkbox(&mut self.mouse_enabled, "Mouse Camera Control (M key)");
if self.mouse_enabled != old_mouse_enabled {
self.mouse_initialized = false;
}
if !self.mouse_enabled {
ui.colored_label(
egui::Color32::GRAY,
"Mouse disabled - camera locked",
);
} else {
ui.colored_label(egui::Color32::GREEN, "Mouse active");
}
ui.horizontal(|ui| {
if ui.button("Reset Rotation").clicked() {
self.accumulated_rotation = [0.0, 0.0, 0.0];
self.should_reset_accumulation = true;
}
if ui.button("Reset Zoom").clicked() {
self.accumulated_zoom = 1.0;
self.should_reset_accumulation = true;
}
});
});
egui::CollapsingHeader::new("Mandelbulb")
.default_open(false)
.show(ui, |ui| {
let old_power = params.power;
changed |= ui
.add(
egui::Slider::new(&mut params.power, 2.0..=12.0)
.text("Power"),
)
.changed();
if params.power != old_power {
self.should_reset_accumulation = true;
}
});
egui::CollapsingHeader::new("Render")
.default_open(false)
.show(ui, |ui| {
let old_samples = params.samples_per_pixel;
changed |= ui
.add(
egui::Slider::new(&mut params.samples_per_pixel, 1..=8)
.text("Samples/pixel"),
)
.changed();
if params.samples_per_pixel != old_samples {
self.should_reset_accumulation = true;
}
let old_bounces = params.max_bounces;
changed |= ui
.add(
egui::Slider::new(&mut params.max_bounces, 1..=12)
.text("Max Bounces"),
)
.changed();
if params.max_bounces != old_bounces {
self.should_reset_accumulation = true;
}
let old_accumulate = params.accumulate;
let mut accumulate_bool = params.accumulate > 0;
changed |= ui
.checkbox(&mut accumulate_bool, "Progressive Rendering")
.changed();
params.accumulate = if accumulate_bool { 1 } else { 0 };
if params.accumulate != old_accumulate {
self.should_reset_accumulation = true;
}
changed |= ui
.add(
egui::Slider::new(&mut params.exposure, 0.1..=5.0)
.text("Exposure"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=2.0)
.text("Gamma"),
)
.changed();
if ui.button("Reset Accumulation").clicked() {
self.should_reset_accumulation = true;
changed = true;
}
});
egui::CollapsingHeader::new("env")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("bg:");
let mut bg_color = [
params.background_r,
params.background_g,
params.background_b,
];
if ui.color_edit_button_rgb(&mut bg_color).changed() {
params.background_r = bg_color[0];
params.background_g = bg_color[1];
params.background_b = bg_color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Sun:");
let mut sun_color = [
params.sun_color_r,
params.sun_color_g,
params.sun_color_b,
];
if ui.color_edit_button_rgb(&mut sun_color).changed() {
params.sun_color_r = sun_color[0];
params.sun_color_g = sun_color[1];
params.sun_color_b = sun_color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Fog:");
let mut fog_color = [
params.fog_color_r,
params.fog_color_g,
params.fog_color_b,
];
if ui.color_edit_button_rgb(&mut fog_color).changed() {
params.fog_color_r = fog_color[0];
params.fog_color_g = fog_color[1];
params.fog_color_b = fog_color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Sky Glow:");
let mut glow_color = [
params.glow_color_r,
params.glow_color_g,
params.glow_color_b,
];
if ui.color_edit_button_rgb(&mut glow_color).changed() {
params.glow_color_r = glow_color[0];
params.glow_color_g = glow_color[1];
params.glow_color_b = glow_color[2];
changed = true;
}
});
if ui.button("Reset env cols").clicked() {
params.background_r = 0.1;
params.background_g = 0.1;
params.background_b = 0.15;
params.sun_color_r = 8.10;
params.sun_color_g = 6.00;
params.sun_color_b = 4.20;
params.fog_color_r = 0.1;
params.fog_color_g = 0.1;
params.fog_color_b = 0.15;
params.glow_color_r = 0.5;
params.glow_color_g = 0.7;
params.glow_color_b = 1.0;
changed = true;
}
});
egui::CollapsingHeader::new("Color Palette")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Base Color:");
let mut color_a = [
params.palette_a_r,
params.palette_a_g,
params.palette_a_b,
];
if ui.color_edit_button_rgb(&mut color_a).changed() {
params.palette_a_r = color_a[0];
params.palette_a_g = color_a[1];
params.palette_a_b = color_a[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Amplitude:");
let mut color_b = [
params.palette_b_r,
params.palette_b_g,
params.palette_b_b,
];
if ui.color_edit_button_rgb(&mut color_b).changed() {
params.palette_b_r = color_b[0];
params.palette_b_g = color_b[1];
params.palette_b_b = color_b[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Frequency:");
let mut color_c = [
params.palette_c_r,
params.palette_c_g,
params.palette_c_b,
];
if ui.color_edit_button_rgb(&mut color_c).changed() {
params.palette_c_r = color_c[0];
params.palette_c_g = color_c[1];
params.palette_c_b = color_c[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Phase:");
let mut color_d = [
params.palette_d_r,
params.palette_d_g,
params.palette_d_b,
];
if ui.color_edit_button_rgb(&mut color_d).changed() {
params.palette_d_r = color_d[0];
params.palette_d_g = color_d[1];
params.palette_d_b = color_d[2];
changed = true;
}
});
if ui.button("Reset to Default Palette").clicked() {
params.palette_a_r = 0.5;
params.palette_a_g = 0.5;
params.palette_a_b = 0.5;
params.palette_b_r = 0.5;
params.palette_b_g = 0.1;
params.palette_b_b = 0.1;
params.palette_c_r = 1.0;
params.palette_c_g = 1.0;
params.palette_c_b = 1.0;
params.palette_d_r = 0.0;
params.palette_d_g = 0.33;
params.palette_d_b = 0.67;
changed = true;
}
ui.separator();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
ui.separator();
ui.label(format!("Accumulated Samples: {}", self.frame_count));
ui.label(format!(
"Resolution: {}x{}",
core.size.width, core.size.height
));
ui.label(format!("FPS: {current_fps:.1}"));
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers || self.should_reset_accumulation {
self.reset_accumulation();
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
self.base.time_uniform.data.time = current_time;
self.base.time_uniform.data.frame = self.frame_count;
self.base.time_uniform.update(&core.queue);
// Update compute shader with the same time data
self.compute_shader
.set_time(current_time, 1.0 / 60.0, &core.queue);
self.compute_shader.time_uniform.data.frame = self.frame_count;
self.compute_shader.time_uniform.update(&core.queue);
if changed {
self.current_params = params;
self.should_reset_accumulation = true;
}
self.current_params.rotation_x = self.accumulated_rotation[0];
self.current_params.rotation_y = -self.accumulated_rotation[1];
self.current_params.rotation_z = self.accumulated_rotation[2];
self.current_params.zoom = self.accumulated_zoom;
self.compute_shader.set_custom_params(self.current_params, &core.queue);
if should_start_export {
self.base.export_manager.start_export();
}
self.compute_shader.dispatch(&mut encoder, core);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
if self.current_params.accumulate > 0 {
self.frame_count += 1;
}
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if self.base.handle_mouse_input(core, event, false) {
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
if let winit::keyboard::Key::Character(ch) = &event.logical_key {
match ch.as_str() {
" " => {
if event.state == winit::event::ElementState::Released {
self.current_params.accumulate = 1 - self.current_params.accumulate;
self.should_reset_accumulation = true;
self.compute_shader
.set_custom_params(self.current_params, &core.queue);
return true;
}
}
"m" | "M" => {
if event.state == winit::event::ElementState::Released {
self.mouse_enabled = !self.mouse_enabled;
self.mouse_initialized = false;
return true;
}
}
"w" | "W" => {
if event.state == winit::event::ElementState::Pressed {
self.accumulated_rotation[1] -= 0.1;
self.should_reset_accumulation = true;
return true;
}
}
"s" | "S" => {
if event.state == winit::event::ElementState::Pressed {
self.accumulated_rotation[1] += 0.1;
self.should_reset_accumulation = true;
return true;
}
}
"a" | "A" => {
if event.state == winit::event::ElementState::Pressed {
self.accumulated_rotation[0] -= 0.1;
self.should_reset_accumulation = true;
return true;
}
}
"d" | "D" => {
if event.state == winit::event::ElementState::Pressed {
self.accumulated_rotation[0] += 0.1;
self.should_reset_accumulation = true;
return true;
}
}
"q" | "Q" => {
if event.state == winit::event::ElementState::Pressed {
self.accumulated_rotation[2] -= 0.1;
self.should_reset_accumulation = true;
return true;
}
}
"e" | "E" => {
if event.state == winit::event::ElementState::Pressed {
self.accumulated_rotation[2] += 0.1;
self.should_reset_accumulation = true;
return true;
}
}
_ => {}
}
}
}
if let WindowEvent::KeyboardInput { event, .. } = event {
if self
.base
.key_handler
.handle_keyboard_input(core.window(), event)
{
return true;
}
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Mandelbulb Path Tracer", 600, 400);
app.run(event_loop, MandelbulbShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/lego.rs | examples/lego.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C, align(16))]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct LegoParams {
brick_scale: f32,
lightdir_x: f32,
lightdir_y: f32,
grain: f32,
gamma: f32,
shadow_str: f32,
shadow_dist: f32,
ao_str: f32,
spec_pow: f32,
spec_str: f32,
edge_enh: f32,
stud_h: f32,
base_h: f32,
rim_str: f32,
res_scale_mult: f32,
stud_h_mult: f32,
light_r: f32,
light_g: f32,
light_b: f32,
depth_scale: f32,
edge_blend: f32,
_pad: f32,
_pad2: f32,
_pad3: f32,
}
impl UniformProvider for LegoParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct LegoShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: LegoParams,
}
impl ShaderManager for LegoShader {
fn init(core: &Core) -> Self {
let initial_params = LegoParams {
brick_scale: 0.01,
lightdir_x: 0.8,
lightdir_y: 0.6,
grain: 0.04,
gamma: 0.4,
shadow_str: 0.5,
shadow_dist: 1.25,
ao_str: 0.85,
spec_pow: 12.0,
spec_str: 0.3,
edge_enh: 0.15,
stud_h: 0.045,
base_h: 0.2,
rim_str: 0.5,
res_scale_mult: 0.2,
stud_h_mult: 1.0,
light_r: 0.8,
light_g: 0.75,
light_b: 0.7,
depth_scale: 0.85,
edge_blend: 0.3,
_pad: 0.0,
_pad2: 0.0,
_pad3: 0.0,
};
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let config = ComputeShader::builder()
.with_entry_point("main_image")
.with_channels(1)
.with_custom_uniforms::<LegoParams>()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("LEGO Effect")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/lego.wgsl"), config);
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/lego.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("LEGO Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/lego.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
self.base.update_current_texture(core, &core.queue);
if let Some(texture_manager) = self.base.get_current_texture_manager() {
self.compute_shader.update_channel_texture(
0,
&texture_manager.view,
&texture_manager.sampler,
&core.device,
&core.queue,
);
}
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.base.fps_tracker.update();
self.compute_shader.check_hot_reload(&core.device);
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("LEGO Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
let using_video_texture = self.base.using_video_texture;
let using_hdri_texture = self.base.using_hdri_texture;
let using_webcam_texture = self.base.using_webcam_texture;
let video_info = self.base.get_video_info();
let hdri_info = self.base.get_hdri_info();
let webcam_info = self.base.get_webcam_info();
let current_fps = self.base.fps_tracker.fps();
controls_request.current_fps = Some(current_fps);
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("LEGO Effect")
.collapsible(true)
.resizable(true)
.default_width(320.0)
.show(ctx, |ui| {
ShaderControls::render_media_panel(
ui,
&mut controls_request,
using_video_texture,
video_info,
using_hdri_texture,
hdri_info,
using_webcam_texture,
webcam_info,
);
ui.separator();
egui::CollapsingHeader::new("Brick Geom")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brick_scale, 0.005..=0.05)
.text("Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.stud_h, 0.01..=0.1)
.text("Stud H"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.base_h, 0.05..=0.3)
.text("Base H"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.stud_h_mult, 1.0..=12.0)
.text("Stud Mult"),
)
.changed();
});
egui::CollapsingHeader::new("Lighting")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.lightdir_x, -1.0..=1.0)
.text("Dir X"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.lightdir_y, -1.0..=1.0)
.text("Dir Y"),
)
.changed();
ui.label("Light Color");
let mut color = [params.light_r, params.light_g, params.light_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.light_r = color[0];
params.light_g = color[1];
params.light_b = color[2];
changed = true;
}
changed |= ui
.add(
egui::Slider::new(&mut params.spec_pow, 2.0..=50.0)
.text("Spec Pow"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.spec_str, 0.0..=1.0)
.text("Spec Str"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.rim_str, 0.0..=1.0)
.text("Rim Str"),
)
.changed();
});
egui::CollapsingHeader::new("Shadows & AO")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.shadow_str, 0.0..=1.0)
.text("Shd Str"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.shadow_dist, 0.1..=3.0)
.text("Shd Dist"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.ao_str, 0.5..=1.5)
.text("AO Cntrst"),
)
.changed();
});
egui::CollapsingHeader::new("Post-FX")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.edge_enh, 0.0..=0.5)
.text("Edge Enh"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.edge_blend, 0.01..=0.3)
.text("Edge Blend"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.grain, 0.0..=0.1)
.text("Grain"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=1.4)
.text("Gamma"),
)
.changed();
});
egui::CollapsingHeader::new("Advanced")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.res_scale_mult, 0.01..=2.0)
.text("Res Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.depth_scale, 0.5..=1.0)
.text("Depth Scl"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
ui.separator();
ui.label(format!(
"Resolution: {}x{}",
core.size.width, core.size.height
));
ui.label(format!("FPS: {current_fps:.1}"));
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.apply_control_request(controls_request.clone());
self.base.handle_video_requests(core, &controls_request);
self.base.handle_webcam_requests(core, &controls_request);
self.base.handle_hdri_requests(core, &controls_request);
self.base.export_manager.apply_ui_request(export_request);
if should_start_export {
self.base.export_manager.start_export();
}
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
self.compute_shader.dispatch_stage(&mut encoder, core, 0);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
if let WindowEvent::DroppedFile(path) = event {
if let Err(e) = self.base.load_media(core, path) {
eprintln!("Failed to load dropped file: {e:?}");
}
return true;
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
cuneus::gst::init()?;
env_logger::init();
let (app, event_loop) = ShaderApp::new("LEGO Effect", 1280, 720);
app.run(event_loop, LegoShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/currents.rs | examples/currents.rs | // Photon tracing: currents
// Very complex example demonstrating multi-buffer ping-pong computation
// I hope this example is useful for those who came from the Shadertoy, I tried to use same terminology (bufferA, ichannels etc)
// I used the all buffers (buffera,b,c,d,mainimage) and complex ping-pong logic
use cuneus::compute::{ComputeShader, PassDescription, COMPUTE_TEXTURE_FORMAT_RGBA16};
use cuneus::{Core, RenderKit, ShaderApp, ShaderControls, ShaderManager};
use cuneus::{ExportManager, UniformProvider};
use winit::event::*;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct CurrentsParams {
sphere_radius: f32,
sphere_pos_x: f32,
sphere_pos_y: f32,
critic2_interval: f32,
critic2_pause: f32,
critic3_interval: f32,
metallic_reflection: f32,
line_intensity: f32,
pattern_scale: f32,
noise_strength: f32,
gradient_r: f32,
gradient_g: f32,
gradient_b: f32,
gradient_w: f32,
line_color_r: f32,
line_color_g: f32,
line_color_b: f32,
line_color_w: f32,
gradient_intensity: f32,
line_intensity_final: f32,
c2_min: f32,
c2_max: f32,
c3_min: f32,
c3_max: f32,
fbm_scale: f32,
fbm_offset: f32,
gamma: f32,
}
impl Default for CurrentsParams {
fn default() -> Self {
Self {
sphere_radius: 0.2,
sphere_pos_x: 0.0,
sphere_pos_y: -0.2,
critic2_interval: 10.0,
critic2_pause: 5.0,
critic3_interval: 10.0,
metallic_reflection: 1.8,
line_intensity: 0.8,
pattern_scale: 150.0,
noise_strength: 1.0,
gradient_r: 1.0,
gradient_g: 2.0,
gradient_b: 3.0,
gradient_w: 4.0,
line_color_r: 1.0,
line_color_g: 2.0,
line_color_b: 3.0,
line_color_w: 4.0,
gradient_intensity: 1.5,
line_intensity_final: 1.5,
c2_min: 333.0,
c2_max: 1.0,
c3_min: 1.0,
c3_max: 3.0,
fbm_scale: 4.0,
fbm_offset: 1.0,
gamma: 2.1,
}
}
}
impl UniformProvider for CurrentsParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct CurrentsShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: CurrentsParams,
}
impl CurrentsShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for CurrentsShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// Define the 5 passes
let passes = vec![
PassDescription::new("buffer_a", &["buffer_a"]), // self-feedback
PassDescription::new("buffer_b", &["buffer_b", "buffer_a"]), // reads BufferB + BufferA
PassDescription::new("buffer_c", &["buffer_c", "buffer_a"]), // reads BufferC + BufferA
PassDescription::new("buffer_d", &["buffer_d", "buffer_c", "buffer_b"]), // reads BufferD + BufferC + BufferB
PassDescription::new("main_image", &["buffer_d"]), // reads BufferD for final output
];
let config = ComputeShader::builder()
.with_entry_point("buffer_a") // Start with buffer_a
.with_multi_pass(&passes)
.with_custom_uniforms::<CurrentsParams>()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Currents Multi-Pass")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/currents.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/currents.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Currents Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/currents.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for currents shader: {e}");
}
let initial_params = CurrentsParams::default();
let shader = Self {
base,
compute_shader,
current_params: initial_params,
};
// Initialize custom uniform with default parameters
shader
.compute_shader
.set_custom_params(initial_params, &core.queue);
shader
}
fn update(&mut self, core: &Core) {
// Update time
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
// Handle UI and controls
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Multi-Buffer Ping-Pong Example")
.collapsible(true)
.resizable(true)
.default_width(280.0)
.show(ctx, |ui| {
// CURRENTS MODE UI
egui::CollapsingHeader::new("Sphere Settings")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.sphere_radius, 0.05..=0.5)
.text("Sphere Radius"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.sphere_pos_x, -1.0..=1.0)
.text("Sphere X"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.sphere_pos_y, -1.0..=1.0)
.text("Sphere Y"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(
&mut params.metallic_reflection,
0.5..=3.0,
)
.text("Metallic Reflection"),
)
.changed();
});
egui::CollapsingHeader::new("Pattern Control")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.pattern_scale, 50.0..=300.0)
.text("Pattern Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.critic2_interval, 5.0..=20.0)
.text("Flow Interval"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.critic2_pause, 1.0..=10.0)
.text("Flow Pause"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.critic3_interval, 5.0..=20.0)
.text("Scale Interval"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.noise_strength, 0.5..=5.0)
.text("Noise Strength"),
)
.changed();
});
egui::CollapsingHeader::new("Noise")
.default_open(false)
.show(ui, |ui| {
ui.label("Oscillator 2 (c2):");
changed |= ui
.add(
egui::Slider::new(&mut params.c2_min, 1.0..=500.0)
.text("C2 Min"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.c2_max, 0.1..=10.0)
.text("C2 Max"),
)
.changed();
ui.separator();
ui.label("Oscillator 3 (c3):");
changed |= ui
.add(
egui::Slider::new(&mut params.c3_min, 0.1..=10.0)
.text("C3 Min"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.c3_max, 0.5..=10.0)
.text("C3 Max"),
)
.changed();
ui.separator();
ui.label("FBM Noise:");
changed |= ui
.add(
egui::Slider::new(&mut params.fbm_scale, 1.0..=10.0)
.text("FBM Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.fbm_offset, 0.1..=5.0)
.text("FBM Offset"),
)
.changed();
});
egui::CollapsingHeader::new("Colors & Post-Processing")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Gradient:");
let mut color =
[params.gradient_r, params.gradient_g, params.gradient_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.gradient_r = color[0];
params.gradient_g = color[1];
params.gradient_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Lines:");
let mut color = [
params.line_color_r,
params.line_color_g,
params.line_color_b,
];
if ui.color_edit_button_rgb(&mut color).changed() {
params.line_color_r = color[0];
params.line_color_g = color[1];
params.line_color_b = color[2];
changed = true;
}
});
ui.separator();
changed |= ui
.add(
egui::Slider::new(
&mut params.gradient_intensity,
0.1..=2.0,
)
.text("Gradient Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(
&mut params.line_intensity_final,
0.1..=2.0,
)
.text("Line Final Intensity"),
)
.changed();
ui.separator();
changed |= ui
.add(
egui::Slider::new(&mut params.line_intensity, 0.1..=3.0)
.text("Line Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=4.0)
.text("Gamma Correction"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
ui.separator();
ui.label(format!("Frame: {}", self.compute_shader.current_frame));
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
// Reset frame counter for proper photon accumulation restart
self.compute_shader.current_frame = 0;
}
if should_start_export {
self.base.export_manager.start_export();
}
// Create command encoder
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Currents Render Encoder"),
});
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Currents Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
// Flip ping-pong buffers for next frame
self.compute_shader.flip_buffers();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = ShaderApp::new("Photon Tracing", 800, 600);
app.run(event_loop, CurrentsShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/debugscreen.rs | examples/debugscreen.rs | use cuneus::audio::SynthesisManager;
use cuneus::compute::{ComputeShader, COMPUTE_TEXTURE_FORMAT_RGBA16};
use cuneus::{Core, RenderKit, ShaderApp, ShaderControls, ShaderManager};
use winit::event::*;
struct DebugScreen {
base: RenderKit,
compute_shader: ComputeShader,
audio_synthesis: Option<SynthesisManager>,
generate_note: bool,
}
impl ShaderManager for DebugScreen {
fn init(core: &Core) -> Self {
// Create texture display layout - needed to show compute shader output on screen
// This layout defines how to bind the texture (binding 0) and sampler (binding 1) for rendering
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// Entry point configuration
let config = ComputeShader::builder()
.with_entry_point("main")
.with_mouse() // Automatically goes to @group(2)
.with_fonts() // Automatically goes to @group(2)
.with_audio(1024) // Automatically goes to @group(2)
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Debug Screen")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/debugscreen.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/debugscreen.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Debug Screen Hot Reload"),
source: wgpu::ShaderSource::Wgsl(
include_str!("shaders/debugscreen.wgsl").into(),
),
}),
) {
eprintln!("Failed to enable hot reload for debugscreen shader: {e}");
}
// init audio synthesis system
let audio_synthesis = match SynthesisManager::new() {
Ok(mut synth) => {
if let Err(_e) = synth.start_gpu_synthesis() {
None
} else {
Some(synth)
}
}
Err(_e) => None,
};
Self {
base,
compute_shader,
audio_synthesis,
generate_note: false,
}
}
fn update(&mut self, core: &Core) {
// Update time
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Update mouse data
if let Some(mouse_uniform) = &mut self.compute_shader.mouse_uniform {
mouse_uniform.data = self.base.mouse_tracker.uniform;
mouse_uniform.update(&core.queue);
}
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle audio generation
if self.generate_note {
if self.base.time_uniform.data.frame % 60 == 0 {
if let Some(ref mut synth) = self.audio_synthesis {
let frequency = 220.0 + self.base.mouse_tracker.uniform.position[1] * 440.0;
let active = self.base.mouse_tracker.uniform.buttons[0] & 1 != 0;
let amp = if active { 0.1 } else { 0.0 };
synth.set_voice(0, frequency, amp, active);
}
}
} else if let Some(ref mut synth) = self.audio_synthesis {
synth.set_voice(0, 440.0, 0.0, false);
}
if let Some(ref mut synth) = self.audio_synthesis {
synth.update();
}
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let mouse_pos = self.base.mouse_tracker.uniform.position;
let raw_pos = self.base.mouse_tracker.raw_position;
let mouse_buttons = self.base.mouse_tracker.uniform.buttons[0];
let mouse_wheel = self.base.mouse_tracker.uniform.wheel;
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
});
egui::Window::new("Debug Screen").show(ctx, |ui| {
ui.heading("Controls");
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
ui.heading("Mouse Debug");
ui.label(format!(
"Position (normalized): {:.3}, {:.3}",
mouse_pos[0], mouse_pos[1]
));
ui.label(format!(
"Position (pixels): {:.1}, {:.1}",
raw_pos[0], raw_pos[1]
));
ui.label(format!("Buttons: {mouse_buttons:#b}"));
ui.label(format!(
"Wheel: {:.2}, {:.2}",
mouse_wheel[0], mouse_wheel[1]
));
ui.separator();
ui.heading("Audio Test");
if ui.button("Press 5 to generate a simple note").clicked() {
self.generate_note = !self.generate_note;
}
if ui.input(|i| i.key_pressed(egui::Key::Num5)) {
self.generate_note = !self.generate_note;
}
let audio_status = if self.generate_note {
"🔊 Note playing"
} else {
"🔇 No audio"
};
ui.label(audio_status);
if let Some(ref synth) = self.audio_synthesis {
if synth.is_gpu_synthesis_enabled() {
ui.label("✓ Audio synthesis ready");
} else {
ui.label("⚠ Audio synthesis not active");
}
} else {
ui.label("❌ Audio synthesis unavailable");
}
ui.separator();
ui.label("Controls:");
ui.label("• Scroll wheel");
ui.label("• Press 'H' to toggle this UI");
ui.label("• Press 'F' to toggle fullscreen");
ui.label("• Press '5' to generate audio note");
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.apply_control_request(controls_request);
// Create command encoder
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Main Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if self.base.handle_mouse_input(core, event, false) {
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
cuneus::gst::init()?;
let (app, event_loop) = ShaderApp::new("Debug Screen", 800, 600);
app.run(event_loop, DebugScreen::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/vortex.rs | examples/vortex.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct VortexParams {
a: f32,
b: f32,
c: f32,
dof_amount: f32,
dof_focal_dist: f32,
brightness: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
zoom: f32,
camera_rotation_x: f32,
camera_rotation_y: f32,
camera_auto_rotate: f32,
_padding: f32,
}
impl UniformProvider for VortexParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct VortexShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: VortexParams,
}
impl VortexShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for VortexShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let initial_params = VortexParams {
a: 1.0, // Tunnel speed
b: 1.1, // Rotation speed
c: 0.3, // Noise strength
dof_amount: 0.0,
dof_focal_dist: 0.96,
brightness: 0.02,
color1_r: 0.1, // Blue base
color1_g: 0.3,
color1_b: 0.7,
color2_r: 0.8, // Orange/red energy
color2_g: 0.4,
color2_b: 0.2,
zoom: 1.0,
camera_rotation_x: 0.0, // Manual camera X rotation
camera_rotation_y: 0.5, // Manual camera Y rotation
camera_auto_rotate: 0.0, // Disable auto rotation by default
_padding: 0.0,
};
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let mut config = ComputeShader::builder()
.with_entry_point("Splat")
.with_custom_uniforms::<VortexParams>()
.with_atomic_buffer()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Plasma Tunnel Vortex")
.build();
// Add second entry point manually
config.entry_points.push("main_image".to_string());
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/vortex.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/vortex.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Vortex Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/vortex.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for vortex shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export with custom dispatch pattern for vortex
self.compute_shader.handle_export_dispatch(
core,
&mut self.base,
|shader, encoder, core| {
shader.dispatch_stage_with_workgroups(encoder, 0, [4096, 1, 1]);
shader.dispatch_stage(encoder, core, 1);
},
);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Vortex")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Tunnel Parameters")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.a, 0.0..=3.0)
.text("Tunnel Speed"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.b, 0.0..=3.0)
.text("Rotation Speed"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.c, 0.0..=1.0)
.text("Noise Strength"),
)
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Visuals")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brightness, 0.001..=0.1)
.logarithmic(true)
.text("Brightness"),
)
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Camera")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(
&mut params.camera_rotation_x,
-2.0..=2.0,
)
.text("Camera X Rotation"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(
&mut params.camera_rotation_y,
-2.0..=2.0,
)
.text("Camera Y Rotation"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.zoom, 0.1..=5.0).text("Zoom"),
)
.changed();
ui.horizontal(|ui| {
ui.label("Auto Rotate:");
let mut auto_rotate = params.camera_auto_rotate > 0.5;
if ui.checkbox(&mut auto_rotate, "").changed() {
params.camera_auto_rotate =
if auto_rotate { 1.0 } else { 0.0 };
changed = true;
}
});
if ui.button("Reset Camera").clicked() {
params.camera_rotation_x = 0.0;
params.camera_rotation_y = 0.5;
params.camera_auto_rotate = 0.0;
changed = true;
}
});
egui::CollapsingHeader::new("Depth of Field")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.dof_amount, 0.0..=3.0)
.text("DOF"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dof_focal_dist, 0.0..=2.0)
.text("Focal Distance"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Tunnel Color:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Energy Color:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Stage 0: Splat tunnel particles (workgroup size [256, 1, 1])
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 0, [4096, 1, 1]);
// Stage 1: Render to screen (workgroup size [16, 16, 1])
self.compute_shader.dispatch_stage(&mut encoder, core, 1);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Plasma Vortex", 800, 600);
app.run(event_loop, VortexShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/circuits.rs | examples/circuits.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct CircuitParams {
rotation_speed: f32,
distance_offset: f32,
gamma: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
intensity: f32,
_padding1: f32,
_padding2: f32,
_padding3: f32,
_padding4: f32,
_padding5: f32,
_padding6: f32,
}
impl UniformProvider for CircuitParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct CircuitShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: CircuitParams,
}
impl CircuitShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for CircuitShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = CircuitParams {
rotation_speed: 0.3,
distance_offset: 0.01,
gamma: 0.4,
color1_r: 0.1,
color1_g: 0.5,
color1_b: 0.9,
color2_r: 0.9,
color2_g: 0.4,
color2_b: 0.1,
intensity: 0.00003,
_padding1: 0.0,
_padding2: 0.0,
_padding3: 0.0,
_padding4: 0.0,
_padding5: 0.0,
_padding6: 0.0,
};
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<CircuitParams>()
.with_workgroup_size([8, 8, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Circuits Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/circuits.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/circuits.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Circuits Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/circuits.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for circuits shader: {e}");
}
//Set initial parameters on startup
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Circuits")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Effect Settings")
.default_open(true)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.rotation_speed, 0.0..=3.2)
.text("R"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.distance_offset, 0.001..=0.1)
.logarithmic(true)
.text("Distance"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.intensity, 0.00001..=0.001)
.logarithmic(true)
.text("Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=4.0)
.text("Gamma"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(true)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Color 1:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 2:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
self.compute_shader.dispatch(&mut encoder, core);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Circuits", 800, 600);
app.run(event_loop, CircuitShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/sdvert.rs | examples/sdvert.rs | use cuneus::prelude::ComputeShader;
use cuneus::{Core, RenderKit, ShaderApp, ShaderManager, UniformProvider};
use winit::event::*;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ShaderParams {
lambda: f32,
theta: f32,
alpha: f32,
sigma: f32,
gamma: f32,
blue: f32,
a: f32,
b: f32,
base_color_r: f32,
base_color_g: f32,
base_color_b: f32,
accent_color_r: f32,
accent_color_g: f32,
accent_color_b: f32,
background_r: f32,
background_g: f32,
background_b: f32,
gamma_correction: f32,
aces_tonemapping: f32,
_padding: f32,
}
impl UniformProvider for ShaderParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct Shader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: ShaderParams,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = ShaderApp::new("sdvert", 800, 600);
app.run(event_loop, Shader::init)
}
impl ShaderManager for Shader {
fn init(core: &Core) -> Self {
// Create texture display layout
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = ShaderParams {
sigma: 0.07,
gamma: 1.5,
blue: 1.0,
a: 2.0,
b: 0.5,
lambda: 3.0,
theta: 2.0,
alpha: 0.3,
base_color_r: 1.0,
base_color_g: 1.0,
base_color_b: 1.0,
accent_color_r: 1.0,
accent_color_g: 1.0,
accent_color_b: 1.0,
background_r: 0.6,
background_g: 0.9,
background_b: 0.9,
gamma_correction: 0.41,
aces_tonemapping: 0.4,
_padding: 0.0,
};
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<ShaderParams>()
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/sdvert.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/sdvert.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("SDVert Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/sdvert.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for sdvert shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Update time
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.base.fps_tracker.update();
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.compute_shader.check_hot_reload(&core.device);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("SDVert Controls")
.collapsible(true)
.resizable(true)
.default_width(300.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Geometry")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.lambda, 1.0..=20.0)
.text("Vertices"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.theta, 0.0..=10.0)
.text("Angle Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=3.0)
.text("Layer Size"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.alpha, 0.001..=0.5)
.text("Layer Min"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.sigma, 0.01..=0.5)
.text("Layer Max"),
)
.changed();
});
egui::CollapsingHeader::new("Shape Parameters")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.a, 0.0..=5.0)
.text("Depth Factor"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.b, 0.0..=5.0)
.text("Fold Pattern"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.blue, 0.0..=5.0)
.text("Hue Shift"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Base:");
let mut base_color = [
params.base_color_r,
params.base_color_g,
params.base_color_b,
];
if ui.color_edit_button_rgb(&mut base_color).changed() {
params.base_color_r = base_color[0];
params.base_color_g = base_color[1];
params.base_color_b = base_color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Accent:");
let mut accent_color = [
params.accent_color_r,
params.accent_color_g,
params.accent_color_b,
];
if ui.color_edit_button_rgb(&mut accent_color).changed() {
params.accent_color_r = accent_color[0];
params.accent_color_g = accent_color[1];
params.accent_color_b = accent_color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Background:");
let mut bg_color = [
params.background_r,
params.background_g,
params.background_b,
];
if ui.color_edit_button_rgb(&mut bg_color).changed() {
params.background_r = bg_color[0];
params.background_g = bg_color[1];
params.background_b = bg_color[2];
changed = true;
}
});
});
egui::CollapsingHeader::new("Post-Processing")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.gamma_correction, 0.1..=3.0)
.text("Gamma Correction"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.aces_tonemapping, 0.0..=2.0)
.text("ACES Tonemapping"),
)
.changed();
});
ui.separator();
cuneus::ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
cuneus::ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
self.base.apply_control_request(controls_request);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Create command encoder
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
// Update time uniform
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta_time = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta_time, &core.queue);
// Dispatch compute shader
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Main Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/buddhabrot.rs | examples/buddhabrot.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct BuddhabrotParams {
max_iterations: u32,
escape_radius: f32,
zoom: f32,
offset_x: f32,
offset_y: f32,
rotation: f32,
exposure: f32,
low_iterations: u32,
high_iterations: u32,
motion_speed: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
sample_density: f32,
dithering: f32,
}
impl UniformProvider for BuddhabrotParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct BuddhabrotShader {
base: RenderKit,
compute_shader: ComputeShader,
frame_count: u32,
accumulated_rendering: bool,
current_params: BuddhabrotParams,
}
impl BuddhabrotShader {
fn clear_buffers(&mut self, core: &Core) {
// Clear atomic buffer (by recreating it)
self.compute_shader.clear_atomic_buffer(core);
self.compute_shader.current_frame = 0;
self.frame_count = 0;
self.accumulated_rendering = false;
}
}
impl ShaderManager for BuddhabrotShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = BuddhabrotParams {
max_iterations: 500,
escape_radius: 4.0,
zoom: 0.5,
offset_x: -0.5,
offset_y: 0.0,
rotation: 1.5,
exposure: 0.0005,
low_iterations: 20,
high_iterations: 100,
motion_speed: 0.0,
color1_r: 1.0,
color1_g: 0.5,
color1_b: 0.2,
color2_r: 0.2,
color2_g: 0.5,
color2_b: 1.0,
sample_density: 0.5,
dithering: 0.2,
};
let mut config = ComputeShader::builder()
.with_entry_point("Splat")
.with_custom_uniforms::<BuddhabrotParams>()
.with_atomic_buffer()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Buddhabrot Unified")
.build();
// Add second entry point
config.entry_points.push("main_image".to_string());
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/buddhabrot.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/buddhabrot.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Buddhabrot Hot Reload"),
source: wgpu::ShaderSource::Wgsl(
include_str!("shaders/buddhabrot.wgsl").into(),
),
}),
) {
eprintln!("Failed to enable hot reload for buddhabrot shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
frame_count: 0,
accumulated_rendering: false,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export_dispatch(
core,
&mut self.base,
|shader, encoder, core| {
shader.dispatch_stage_with_workgroups(encoder, 0, [2048, 1, 1]);
shader.dispatch_stage(encoder, core, 1);
},
);
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Buddhabrot Explorer")
.collapsible(true)
.resizable(true)
.default_width(300.0)
.min_width(250.0)
.max_width(500.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Fractal Parameters")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.max_iterations, 100..=500)
.text("Max Iterations"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.escape_radius, 2.0..=10.0)
.text("Escape Radius"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.low_iterations, 5..=50)
.text("Low Iterations"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.high_iterations, 50..=500)
.text("High Iterations"),
)
.changed();
});
egui::CollapsingHeader::new("View Controls")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.zoom, 0.1..=5.0)
.logarithmic(true)
.text("Zoom"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.offset_x, -2.0..=1.0)
.text("Offset X"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.offset_y, -1.5..=1.5)
.text("Offset Y"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.rotation, -3.14159..=3.14159)
.text("Rotation"),
)
.changed();
ui.add_space(10.0);
ui.separator();
changed |= ui
.add(
egui::Slider::new(&mut params.exposure, 0.00005..=0.001)
.logarithmic(true)
.text("Exposure"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.sample_density, 0.1..=2.0)
.text("Sample Density"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dithering, 0.0..=1.0)
.text("Dithering"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Color 1:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 2:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
egui::CollapsingHeader::new("Rendering Options")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Accumulated?:");
ui.checkbox(&mut self.accumulated_rendering, "");
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
// Clear buffers when parameters change (unless in accumulated mode)
if !self.accumulated_rendering {
self.clear_buffers(core);
}
}
if should_start_export {
self.base.export_manager.start_export();
}
// Only generate new samples if we're not in accumulated mode
// or if we're still accumulating (frame count < 500) - use frame counter
let should_generate_samples =
!self.accumulated_rendering || self.compute_shader.current_frame < 500;
if should_generate_samples {
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 0, [2048, 1, 1]);
}
// Always dispatch stage 1 (main_image) for rendering with screen-based workgroups
// Note: in cuneus, individual stage dispatch methods need manual frame management (if you need of course!)
self.compute_shader.dispatch_stage(&mut encoder, core, 1);
//Manual frame increment since dispatch_stage() doesn't auto-increment
self.compute_shader.current_frame += 1;
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
self.frame_count = self.frame_count.wrapping_add(1);
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Buddhabrot", 800, 600);
app.run(event_loop, BuddhabrotShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/cuneus.rs | examples/cuneus.rs | use cuneus::compute::{ComputeShader, COMPUTE_TEXTURE_FORMAT_RGBA16};
use cuneus::{Core, RenderKit, ShaderApp, ShaderControls, ShaderManager};
use cuneus::{ExportManager, UniformProvider};
use winit::event::*;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ShaderParams {
background_color: f32,
_pad0: f32,
_pad00: f32,
_pad000: f32,
hue_color: [f32; 3],
_pad1: f32,
light_intensity: f32,
rim_power: f32,
ao_strength: f32,
env_light_strength: f32,
iridescence_power: f32,
falloff_distance: f32,
global_light: f32,
alpha_threshold: f32,
mix_factor_scale: f32,
_pad2: f32,
_pad3: f32,
_pad4: f32,
_pad5: f32,
_pad6: f32,
_pad7: f32,
_pad8: f32,
_pad9: f32,
_pad10: f32,
}
impl UniformProvider for ShaderParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct Shader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: ShaderParams,
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = ShaderApp::new("cuneus", 800, 600);
app.run(event_loop, Shader::init)
}
impl Shader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for Shader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = ShaderParams {
background_color: 0.4,
_pad0: 0.0,
_pad00: 0.0,
_pad000: 0.0,
hue_color: [1.0, 2.0, 3.0],
_pad1: 0.0,
light_intensity: 1.8,
rim_power: 3.0,
ao_strength: 0.1,
env_light_strength: 0.5,
iridescence_power: 0.2,
falloff_distance: 1.0,
global_light: 1.0,
alpha_threshold: 1.0,
mix_factor_scale: 0.3,
_pad2: 0.0,
_pad3: 0.0,
_pad4: 0.0,
_pad5: 0.0,
_pad6: 0.0,
_pad7: 0.0,
_pad8: 0.0,
_pad9: 0.0,
_pad10: 0.0,
};
// Entry point configuration
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<ShaderParams>()
.with_audio(1024) // Automatically goes to @group(2)
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Cuneus Compute")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/cuneus.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/cuneus.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Cuneus Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/cuneus.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for cuneus shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Cuneus")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.background_color, 0.0..=1.0)
.text("Background"),
)
.changed();
changed |=
ui.color_edit_button_rgb(&mut params.hue_color).changed();
ui.label("Base Color");
});
egui::CollapsingHeader::new("Lighting")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.light_intensity, 0.0..=3.2)
.text("Light Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.ao_strength, 0.0..=10.0)
.text("AO Strength"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.global_light, 0.1..=2.0)
.text("Global Light"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.rim_power, 0.1..=10.0)
.text("Rim Power"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(
&mut params.env_light_strength,
0.0..=1.0,
)
.text("Environment Light"),
)
.changed();
});
egui::CollapsingHeader::new("Effects")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.alpha_threshold, 0.0..=3.0)
.text("Alpha Threshold"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.mix_factor_scale, 0.0..=1.5)
.text("Mix Factor Scale"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.iridescence_power, 0.0..=1.0)
.text("Iridescence"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.falloff_distance, 0.5..=5.0)
.text("Light Falloff"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
self.compute_shader.dispatch(&mut encoder, core);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/matrix.rs | examples/matrix.rs | use cuneus::prelude::ComputeShader;
use cuneus::{
Core, ExportManager, RenderKit, ShaderApp, ShaderControls, ShaderManager, UniformProvider,
};
use winit::event::*;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct ShaderParams {
red_power: f32,
green_power: f32,
blue_power: f32,
green_boost: f32,
contrast: f32,
gamma: f32,
glow: f32,
}
impl UniformProvider for ShaderParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
cuneus::gst::init()?;
env_logger::init();
let (app, event_loop) = ShaderApp::new("matrix", 800, 600);
app.run(event_loop, MatrixShader::init)
}
struct MatrixShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: ShaderParams,
}
impl ShaderManager for MatrixShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = ShaderParams {
red_power: 0.98,
green_power: 0.85,
blue_power: 0.90,
green_boost: 1.62,
contrast: 1.0,
gamma: 1.0,
glow: 0.05,
};
let config = ComputeShader::builder()
.with_entry_point("main")
.with_input_texture()
.with_custom_uniforms::<ShaderParams>()
.build();
let compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/matrix.wgsl"), config);
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Update time
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Update input textures for media processing
self.base.update_current_texture(core, &core.queue);
if let Some(texture_manager) = self.base.get_current_texture_manager() {
self.compute_shader.update_input_texture(
&texture_manager.view,
&texture_manager.sampler,
&core.device,
);
}
self.base.fps_tracker.update();
self.compute_shader.check_hot_reload(&core.device);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
let using_video_texture = self.base.using_video_texture;
let using_hdri_texture = self.base.using_hdri_texture;
let using_webcam_texture = self.base.using_webcam_texture;
let video_info = self.base.get_video_info();
let hdri_info = self.base.get_hdri_info();
let webcam_info = self.base.get_webcam_info();
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Matrix Effect")
.collapsible(true)
.resizable(true)
.default_size([300.0, 100.0])
.show(ctx, |ui| {
ui.collapsing("Media", |ui: &mut egui::Ui| {
ShaderControls::render_media_panel(
ui,
&mut controls_request,
using_video_texture,
video_info,
using_hdri_texture,
hdri_info,
using_webcam_texture,
webcam_info,
);
});
ui.separator();
ui.collapsing("Matrix Color Settings", |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.red_power, 0.5..=3.0)
.text("Red Power"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.green_power, 0.5..=3.0)
.text("Green Power"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.blue_power, 0.5..=3.0)
.text("Blue Power"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.green_boost, 0.5..=2.0)
.text("Green Boost"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.contrast, 0.5..=2.0)
.text("Contrast"),
)
.changed();
changed |= ui
.add(egui::Slider::new(&mut params.gamma, 0.2..=2.0).text("Gamma"))
.changed();
changed |= ui
.add(egui::Slider::new(&mut params.glow, -1.0..=1.0).text("Glow"))
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
self.base.apply_control_request(controls_request.clone());
self.base.handle_video_requests(core, &controls_request);
self.base.handle_webcam_requests(core, &controls_request);
self.base.handle_hdri_requests(core, &controls_request);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
// Run compute shader
self.compute_shader.dispatch(&mut encoder, core);
// Render result to screen
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Main Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/spiralchaos.rs | examples/spiralchaos.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct SpiralParams {
a: f32,
b: f32,
c: f32,
dof_amount: f32,
dof_focal_dist: f32,
rotation_x: f32,
rotation_y: f32,
click_state: i32,
brightness: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
_padding: u32,
}
impl UniformProvider for SpiralParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct SpiralShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: SpiralParams,
}
impl SpiralShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for SpiralShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let initial_params = SpiralParams {
a: 1.0,
b: 1.0,
c: 1.0,
dof_amount: 1.0,
dof_focal_dist: 1.0,
rotation_x: 0.0,
rotation_y: 0.0,
click_state: 0,
brightness: 0.00004,
color1_r: 0.0,
color1_g: 0.7,
color1_b: 1.0,
color2_r: 1.0,
color2_g: 0.3,
color2_b: 0.5,
_padding: 0,
};
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let mut config = ComputeShader::builder()
.with_entry_point("Splat")
.with_custom_uniforms::<SpiralParams>()
.with_atomic_buffer()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Spiralchaos Unified")
.build();
// Add second entry point manually
config.entry_points.push("main_image".to_string());
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/spiralchaos.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/spiralchaos.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Spiralchaos Hot Reload"),
source: wgpu::ShaderSource::Wgsl(
include_str!("shaders/spiralchaos.wgsl").into(),
),
}),
) {
eprintln!("Failed to enable hot reload for Spiralchaos shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export with custom dispatch pattern
self.compute_shader.handle_export_dispatch(
core,
&mut self.base,
|shader, encoder, core| {
shader.dispatch_stage_with_workgroups(encoder, 0, [4096, 1, 1]);
shader.dispatch_stage(encoder, core, 1);
},
);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Chaos Spiral")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Spiral Parameters")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.a, 0.0..=3.0)
.text("Tightness"),
)
.changed();
changed |= ui
.add(egui::Slider::new(&mut params.b, 0.0..=3.0).text("Speed"))
.changed();
changed |= ui
.add(egui::Slider::new(&mut params.c, 0.0..=3.0).text("N Arms"))
.changed();
});
egui::CollapsingHeader::new("DOF")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.dof_amount, 0.0..=3.0)
.text("Amount"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dof_focal_dist, 0.0..=3.0)
.text("Focal Distance"),
)
.changed();
});
egui::CollapsingHeader::new("Rotation")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.rotation_x, -1.0..=1.0)
.text("X"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.rotation_y, -1.0..=1.0)
.text("Y"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brightness, 0.00001..=0.0001)
.logarithmic(true)
.text("Brightness"),
)
.changed();
ui.horizontal(|ui| {
ui.label("Color 1:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 2:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Mouse data integration
params.rotation_x = self.base.mouse_tracker.uniform.position[0];
params.rotation_y = self.base.mouse_tracker.uniform.position[1];
params.click_state = if self.base.mouse_tracker.uniform.buttons[0] & 1 > 0 {
1
} else {
0
};
changed = true;
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Note: in cuneus, individual stage dispatch methods need manual frame management (if you need of course!)
// Stage 0: Splat particles (workgroup size [256, 1, 1])
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 0, [4096, 1, 1]);
// Stage 1: Render to screen (workgroup size [16, 16, 1])
self.compute_shader.dispatch_stage(&mut encoder, core, 1);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Chaos Spiral", 800, 600);
app.run(event_loop, SpiralShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/audiovis.rs | examples/audiovis.rs | use cuneus::compute::{ComputeShader, COMPUTE_TEXTURE_FORMAT_RGBA16};
use cuneus::{
Core, ExportManager, RenderKit, ShaderApp, ShaderControls, ShaderManager, UniformProvider,
};
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct AudioVisParams {
red_power: f32,
green_power: f32,
blue_power: f32,
green_boost: f32,
contrast: f32,
gamma: f32,
glow: f32,
_padding: f32,
}
impl Default for AudioVisParams {
fn default() -> Self {
Self {
red_power: 0.98,
green_power: 0.85,
blue_power: 0.90,
green_boost: 1.62,
contrast: 1.0,
gamma: 1.0,
glow: 0.05,
_padding: 0.0,
}
}
}
impl UniformProvider for AudioVisParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct AudioVisCompute {
base: RenderKit,
compute_shader: ComputeShader,
current_params: AudioVisParams,
}
impl ShaderManager for AudioVisCompute {
fn init(core: &Core) -> Self {
let initial_params = AudioVisParams::default();
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<AudioVisParams>()
.with_audio_spectrum(69) // 64 spectrum + BPM + 4 energy values
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Audio Visualizer Compute")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/audiovis.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/audiovis.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("AudioVis Compute Shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/audiovis.wgsl").into()),
}),
) {
eprintln!("Failed to enable audio visualizer compute shader hot reload: {e}");
}
// Initialize custom uniform with initial parameters
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Update time
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Update audio spectrum - energy values are computed in spectrum.rs
// and included in the buffer at indices 65-68
self.base.update_audio_spectrum(&core.queue);
self.compute_shader
.update_audio_spectrum(&self.base.resolution_uniform.data, &core.queue);
self.base.fps_tracker.update();
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
// Update video texture (this triggers spectrum data polling!)
let _video_updated = if self.base.using_video_texture {
self.base.update_video_texture(core, &core.queue)
} else {
false
};
let _webcam_updated = if self.base.using_webcam_texture {
self.base.update_webcam_texture(core, &core.queue)
} else {
false
};
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
let using_video_texture = self.base.using_video_texture;
let using_hdri_texture = self.base.using_hdri_texture;
let using_webcam_texture = self.base.using_webcam_texture;
let video_info = self.base.get_video_info();
let hdri_info = self.base.get_hdri_info();
let webcam_info = self.base.get_webcam_info();
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Audio Visualizer")
.collapsible(true)
.resizable(true)
.default_width(300.0)
.show(ctx, |ui| {
// Media controls
ShaderControls::render_media_panel(
ui,
&mut controls_request,
using_video_texture,
video_info,
using_hdri_texture,
hdri_info,
using_webcam_texture,
webcam_info,
);
ui.separator();
egui::CollapsingHeader::new("Visual Parameters")
.default_open(true)
.show(ui, |ui| {
ui.label("Color Power:");
changed |= ui
.add(
egui::Slider::new(&mut params.red_power, 0.1..=2.0)
.text("Red Power"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.green_power, 0.1..=2.0)
.text("Green Power"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.blue_power, 0.1..=2.0)
.text("Blue Power"),
)
.changed();
ui.separator();
changed |= ui
.add(
egui::Slider::new(&mut params.green_boost, 0.0..=3.0)
.text("Green Boost"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.contrast, 0.1..=3.0)
.text("Contrast"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=3.0)
.text("Gamma"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.glow, 0.0..=1.0).text("Glow"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
ui.separator();
ui.label(format!("Frame: {}", self.compute_shader.current_frame));
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
// Apply controls
self.base.export_manager.apply_ui_request(export_request);
self.base.apply_control_request(controls_request.clone());
self.base.handle_video_requests(core, &controls_request);
self.base.handle_webcam_requests(core, &controls_request);
self.base.handle_hdri_requests(core, &controls_request);
// Apply parameter changes
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
// Create command encoder
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("AudioVis Compute Render Encoder"),
});
// Dispatch compute shader
self.compute_shader.dispatch(&mut encoder, core);
// Render compute output to screen
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("AudioVis Compute Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
if let WindowEvent::DroppedFile(path) = event {
if let Err(e) = self.base.load_media(core, path) {
eprintln!("Failed to load dropped file: {e:?}");
}
return true;
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
cuneus::gst::init()?;
let (app, event_loop) = ShaderApp::new("Audio Visualizer", 800, 600);
app.run(event_loop, AudioVisCompute::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/volumepassage.rs | examples/volumepassage.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct VolumeParams {
speed: f32,
intensity: f32,
color1_r: f32,
color1_g: f32,
color1_b: f32,
color2_r: f32,
color2_g: f32,
color2_b: f32,
color3_r: f32,
color3_g: f32,
color3_b: f32,
gamma: f32,
zoom: f32,
_padding1: f32,
_padding2: f32,
_padding3: f32,
}
impl UniformProvider for VolumeParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct VolumeShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: VolumeParams,
}
impl VolumeShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
}
}
impl ShaderManager for VolumeShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let initial_params = VolumeParams {
speed: 1.0,
intensity: 0.001,
color1_r: 0.1,
color1_g: 0.3,
color1_b: 0.7,
color2_r: 0.8,
color2_g: 0.4,
color2_b: 0.2,
color3_r: 1.0,
color3_g: 1.0,
color3_b: 1.0,
gamma: 0.8,
zoom: 1.0,
_padding1: 0.0,
_padding2: 0.0,
_padding3: 0.0,
};
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let config = ComputeShader::builder()
.with_entry_point("main")
.with_custom_uniforms::<VolumeParams>()
.with_workgroup_size([8, 8, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Volume Passage Unified")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/volumepassage.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/volumepassage.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Volumepassage Hot Reload"),
source: wgpu::ShaderSource::Wgsl(
include_str!("shaders/volumepassage.wgsl").into(),
),
}),
) {
eprintln!("Failed to enable hot reload for volumepassage shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("Volume Passage")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Animation Settings")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.speed, 0.1..=3.0)
.text("Speed"),
)
.changed();
});
egui::CollapsingHeader::new("Visual Settings")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.intensity, 0.0001..=0.01)
.logarithmic(true)
.text("Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=3.0)
.text("Gamma"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.zoom, 0.1..=6.0).text("Zoom"),
)
.changed();
});
egui::CollapsingHeader::new("Colors")
.default_open(false)
.show(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Color 1:");
let mut color =
[params.color1_r, params.color1_g, params.color1_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color1_r = color[0];
params.color1_g = color[1];
params.color1_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 2:");
let mut color =
[params.color2_r, params.color2_g, params.color2_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color2_r = color[0];
params.color2_g = color[1];
params.color2_b = color[2];
changed = true;
}
});
ui.horizontal(|ui| {
ui.label("Color 3:");
let mut color =
[params.color3_r, params.color3_g, params.color3_b];
if ui.color_edit_button_rgb(&mut color).changed() {
params.color3_r = color[0];
params.color3_g = color[1];
params.color3_b = color[2];
changed = true;
}
});
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
self.compute_shader.dispatch(&mut encoder, core);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("Volume Passage", 600, 300);
app.run(event_loop, VolumeShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/fft.rs | examples/fft.rs | use cuneus::compute::{
ComputeShader, PassDescription, StorageBufferSpec, COMPUTE_TEXTURE_FORMAT_RGBA16,
};
use cuneus::{Core, ExportManager, RenderKit, ShaderControls, ShaderManager, UniformProvider};
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct FFTParams {
filter_type: i32,
filter_strength: f32,
filter_direction: f32,
filter_radius: f32,
show_freqs: i32,
resolution: u32,
_padding1: u32,
_padding2: u32,
}
impl UniformProvider for FFTParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct FFTShader {
base: RenderKit,
compute_shader: ComputeShader,
should_initialize: bool,
current_params: FFTParams, // Store current parameters
}
impl ShaderManager for FFTShader {
fn init(core: &Core) -> Self {
let initial_params = FFTParams {
filter_type: 1,
filter_strength: 0.3,
filter_direction: 0.0,
filter_radius: 3.0,
show_freqs: 0,
resolution: 1024,
_padding1: 0,
_padding2: 0,
};
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
// Define the FFT multi-pass pipeline
let passes = vec![
PassDescription::new("initialize_data", &[]), // Stage 0: Initialize from input texture
PassDescription::new("fft_horizontal", &["initialize_data"]), // Stage 1: FFT horizontal pass
PassDescription::new("fft_vertical", &["fft_horizontal"]), // Stage 2: FFT vertical pass
PassDescription::new("modify_frequencies", &["fft_vertical"]), // Stage 3: Apply frequency domain filters
PassDescription::new("ifft_horizontal", &["modify_frequencies"]), // Stage 4: Inverse FFT horizontal
PassDescription::new("ifft_vertical", &["ifft_horizontal"]), // Stage 5: Inverse FFT vertical
PassDescription::new("main_image", &["ifft_vertical"]), // Stage 6: Final display
];
let config = ComputeShader::builder()
.with_entry_point("initialize_data") // Start with data initialization
.with_multi_pass(&passes)
.with_input_texture() // Re-enable input texture support
.with_custom_uniforms::<FFTParams>()
.with_storage_buffer(StorageBufferSpec::new("image_data", 1024 * 1024 * 3 * 8)) // FFT working memory: 3 channels × 8 bytes per complex number (vec2f)
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("FFT Multi-Pass")
.build();
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/fft.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/fft.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("FFT Compute Shader"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/fft.wgsl").into()),
}),
) {
eprintln!("Failed to enable FFT compute shader hot reload: {e}");
}
// Initialize custom uniform with initial parameters
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
should_initialize: true,
current_params: initial_params,
}
}
fn update(&mut self, core: &Core) {
// Update time
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
// Update input textures for image proc.
self.base.update_current_texture(core, &core.queue);
if let Some(texture_manager) = self.base.get_current_texture_manager() {
// Update input texture in unified ComputeShader
self.compute_shader.update_input_texture(
&texture_manager.view,
&texture_manager.sampler,
&core.device,
);
}
self.base.fps_tracker.update();
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
}
fn resize(&mut self, core: &Core) {
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("FFT Render Encoder"),
});
// Handle UI and controls - using original transparent UI design
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
let using_video_texture = self.base.using_video_texture;
let using_hdri_texture = self.base.using_hdri_texture;
let using_webcam_texture = self.base.using_webcam_texture;
let video_info = self.base.get_video_info();
let hdri_info = self.base.get_hdri_info();
let webcam_info = self.base.get_webcam_info();
controls_request.current_fps = Some(self.base.fps_tracker.fps());
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("fourier workflow")
.collapsible(true)
.resizable(true)
.default_width(250.0)
.show(ctx, |ui| {
// Media controls
ShaderControls::render_media_panel(
ui,
&mut controls_request,
using_video_texture,
video_info,
using_hdri_texture,
hdri_info,
using_webcam_texture,
webcam_info,
);
ui.separator();
egui::CollapsingHeader::new("FFT Settings")
.default_open(false)
.show(ui, |ui| {
ui.label("Resolution:");
ui.horizontal(|ui| {
changed |= ui
.radio_value(&mut params.resolution, 256, "256")
.changed();
changed |= ui
.radio_value(&mut params.resolution, 512, "512")
.changed();
changed |= ui
.radio_value(&mut params.resolution, 1024, "1024")
.changed();
changed |= ui
.radio_value(&mut params.resolution, 2048, "2048")
.changed();
});
if changed {
self.should_initialize = true;
}
ui.separator();
ui.label("View Mode:");
changed |= ui
.radio_value(&mut params.show_freqs, 0, "Filtered")
.changed();
changed |= ui
.radio_value(&mut params.show_freqs, 1, "Frequency Domain")
.changed();
ui.separator();
});
egui::CollapsingHeader::new("Filter Settings")
.default_open(false)
.show(ui, |ui| {
ui.label("Filter Type:");
// Keep the improved ComboBox as requested
changed |= egui::ComboBox::from_label("")
.selected_text(match params.filter_type {
0 => "LP",
1 => "HP",
2 => "BP",
3 => "Directional",
_ => "None",
})
.show_ui(ui, |ui| {
ui.selectable_value(&mut params.filter_type, 0, "LP")
.changed()
|| ui
.selectable_value(&mut params.filter_type, 1, "HP")
.changed()
|| ui
.selectable_value(&mut params.filter_type, 2, "BP")
.changed()
|| ui
.selectable_value(
&mut params.filter_type,
3,
"Directional",
)
.changed()
})
.inner
.unwrap_or(false);
ui.separator();
changed |= ui
.add(
egui::Slider::new(&mut params.filter_strength, 0.0..=1.0)
.text("Filter Strength"),
)
.changed();
if params.filter_type == 2 {
changed |= ui
.add(
egui::Slider::new(
&mut params.filter_radius,
0.0..=6.28,
)
.text("Band Radius"),
)
.changed();
}
if params.filter_type == 3 {
changed |= ui
.add(
egui::Slider::new(
&mut params.filter_direction,
0.0..=6.28,
)
.text("Direction"),
)
.changed();
}
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
// Keep current parameters - don't reset to defaults
// The UI will modify 'params' directly, and we'll apply changes at the end
// Apply controls
self.base.apply_control_request(controls_request.clone());
self.base.handle_video_requests(core, &controls_request);
self.base.handle_webcam_requests(core, &controls_request);
// Handle export requests
self.base.export_manager.apply_ui_request(export_request);
if should_start_export {
self.base.export_manager.start_export();
}
if controls_request.load_media_path.is_some() {
self.should_initialize = true;
}
if controls_request.start_webcam {
self.should_initialize = true;
}
// Apply parameter changes
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
self.should_initialize = true; // Trigger FFT reprocessing
}
// FFT dispatch - only run full pipeline when needed, otherwise just display
let mut should_run_full_fft = self.should_initialize
|| self.base.using_video_texture
|| self.base.using_webcam_texture
|| changed; // Also run when parameters change
// FORCE run FFT if there's any texture to debug the issue
let has_any_texture = self.base.get_current_texture_manager().is_some();
if has_any_texture && !should_run_full_fft {
should_run_full_fft = true;
}
// Get FFT resolution for proper workgroup calculation
let n = params.resolution;
if should_run_full_fft {
// Stage 0: Initialize data from input texture (16x16 workgroups)
self.compute_shader.dispatch_stage_with_workgroups(
&mut encoder,
0,
[n.div_ceil(16), n.div_ceil(16), 1],
);
// Stage 1: FFT horizontal (Nx1 workgroups)
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 1, [n, 1, 1]);
// Stage 2: FFT vertical (Nx1 workgroups)
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 2, [n, 1, 1]);
// Stage 3: Modify frequencies - apply filter (16x16 workgroups)
self.compute_shader.dispatch_stage_with_workgroups(
&mut encoder,
3,
[n.div_ceil(16), n.div_ceil(16), 1],
);
// Stage 4: Inverse FFT horizontal (Nx1 workgroups)
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 4, [n, 1, 1]);
// Stage 5: Inverse FFT vertical (Nx1 workgroups)
self.compute_shader
.dispatch_stage_with_workgroups(&mut encoder, 5, [n, 1, 1]);
self.should_initialize = false;
log::info!("Completed full FFT pipeline");
} else {
log::debug!("Skipping full FFT pipeline - using cached result");
}
// Stage 6: Main rendering - always run for display (uses screen size)
self.compute_shader.dispatch_stage(&mut encoder, core, 6);
// Display result using unified ComputeShader
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("FFT Render Pass"),
);
let compute_texture = self.compute_shader.get_output_texture();
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &compute_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
if let WindowEvent::DroppedFile(path) = event {
if let Err(e) = self.base.load_media(core, path) {
eprintln!("Failed to load dropped file: {e:?}");
} else {
self.should_initialize = true;
}
return true;
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
cuneus::gst::init()?;
env_logger::init();
let (app, event_loop) = cuneus::ShaderApp::new("FFT", 800, 600);
app.run(event_loop, FFTShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
altunenes/cuneus | https://github.com/altunenes/cuneus/blob/4ab4a90169f70265c17a065d0db53bc168aeecc2/examples/nebula.rs | examples/nebula.rs | use cuneus::compute::*;
use cuneus::prelude::*;
use winit::event::WindowEvent;
#[repr(C)]
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
struct NebulaParams {
iterations: i32,
formuparam: f32,
volsteps: i32,
stepsize: f32,
zoom: f32,
tile: f32,
speed: f32,
brightness: f32,
dust_intensity: f32,
distfading: f32,
color_variation: f32,
n_boxes: f32,
rotation: i32,
depth: f32,
color_mode: i32,
_padding1: f32,
rotation_x: f32,
rotation_y: f32,
click_state: i32,
scale: f32,
exposure: f32,
gamma: f32,
_padding4: f32,
_padding5: f32,
_padding6: f32,
_padding7: f32,
_padding8: f32,
_padding9: f32,
_padding10: f32,
time_scale: f32,
visual_mode: i32,
_padding2: f32,
_padding3: f32,
}
impl UniformProvider for NebulaParams {
fn as_bytes(&self) -> &[u8] {
bytemuck::bytes_of(self)
}
}
struct NebulaShader {
base: RenderKit,
compute_shader: ComputeShader,
current_params: NebulaParams,
frame_count: u32,
}
impl NebulaShader {
fn clear_buffers(&mut self, core: &Core) {
self.compute_shader.clear_all_buffers(core);
self.frame_count = 0;
}
}
impl ShaderManager for NebulaShader {
fn init(core: &Core) -> Self {
let texture_bind_group_layout = RenderKit::create_standard_texture_layout(&core.device);
let base = RenderKit::new(core, &texture_bind_group_layout, None);
let initial_params = NebulaParams {
iterations: 17,
formuparam: 0.52,
volsteps: 6,
stepsize: 0.31,
zoom: 5.0,
tile: 0.35,
speed: 0.020,
brightness: 0.00062,
dust_intensity: 1.0,
distfading: 0.95,
color_variation: 0.51,
n_boxes: 10.0,
rotation: 1,
depth: 5.0,
color_mode: 1,
_padding1: 0.0,
rotation_x: 0.0,
rotation_y: 0.0,
click_state: 0,
scale: 1.0,
exposure: 1.6,
gamma: 0.400,
_padding4: 0.0,
_padding5: 0.0,
_padding6: 0.0,
_padding7: 0.0,
_padding8: 0.0,
_padding9: 0.0,
_padding10: 0.0,
time_scale: 1.0,
visual_mode: 0,
_padding2: 0.0,
_padding3: 0.0,
};
let mut config = ComputeShader::builder()
.with_entry_point("volumetric_render")
.with_custom_uniforms::<NebulaParams>()
.with_atomic_buffer()
.with_workgroup_size([16, 16, 1])
.with_texture_format(COMPUTE_TEXTURE_FORMAT_RGBA16)
.with_label("Nebula Unified")
.build();
// Add second entry point manually
config.entry_points.push("main_image".to_string());
let mut compute_shader =
ComputeShader::from_builder(core, include_str!("shaders/nebula.wgsl"), config);
// Enable hot reload
if let Err(e) = compute_shader.enable_hot_reload(
core.device.clone(),
std::path::PathBuf::from("examples/shaders/nebula.wgsl"),
core.device
.create_shader_module(wgpu::ShaderModuleDescriptor {
label: Some("Nebula Hot Reload"),
source: wgpu::ShaderSource::Wgsl(include_str!("shaders/nebula.wgsl").into()),
}),
) {
eprintln!("Failed to enable hot reload for Nebula shader: {e}");
}
compute_shader.set_custom_params(initial_params, &core.queue);
Self {
base,
compute_shader,
current_params: initial_params,
frame_count: 0,
}
}
fn update(&mut self, core: &Core) {
// Check for hot reload updates
self.compute_shader.check_hot_reload(&core.device);
// Handle export
self.compute_shader.handle_export(core, &mut self.base);
self.base.fps_tracker.update();
}
fn resize(&mut self, core: &Core) {
self.base.update_resolution(&core.queue, core.size);
self.compute_shader
.resize(core, core.size.width, core.size.height);
}
fn render(&mut self, core: &Core) -> Result<(), wgpu::SurfaceError> {
let output = core.surface.get_current_texture()?;
let view = output
.texture
.create_view(&wgpu::TextureViewDescriptor::default());
let mut encoder = core
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
label: Some("Render Encoder"),
});
let mut params = self.current_params;
let mut changed = false;
let mut should_start_export = false;
let mut export_request = self.base.export_manager.get_ui_request();
let mut controls_request = self
.base
.controls
.get_ui_request(&self.base.start_time, &core.size);
controls_request.current_fps = Some(self.base.fps_tracker.fps());
// Mouse interaction
if self.base.mouse_tracker.uniform.buttons[0] & 1 != 0 {
params.rotation_x = self.base.mouse_tracker.uniform.position[0];
params.rotation_y = self.base.mouse_tracker.uniform.position[1];
params.click_state = 1;
changed = true;
} else {
params.click_state = 0;
}
let full_output = if self.base.key_handler.show_ui {
self.base.render_ui(core, |ctx| {
ctx.style_mut(|style| {
style.visuals.window_fill =
egui::Color32::from_rgba_premultiplied(0, 0, 0, 180);
style
.text_styles
.get_mut(&egui::TextStyle::Body)
.unwrap()
.size = 11.0;
style
.text_styles
.get_mut(&egui::TextStyle::Button)
.unwrap()
.size = 10.0;
});
egui::Window::new("universe")
.collapsible(true)
.resizable(true)
.default_width(320.0)
.show(ctx, |ui| {
egui::CollapsingHeader::new("Volumetric Parameters")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.iterations, 5..=30)
.text("Iterations"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.formuparam, 0.1..=1.0)
.text("Form Parameter"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.volsteps, 1..=20)
.text("Volume Steps"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.stepsize, 0.05..=0.5)
.text("Step Size"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.zoom, 0.1..=112.0)
.text("Zoom"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.tile, 0.1..=3.0).text("Tile"),
)
.changed();
});
egui::CollapsingHeader::new("Appearance")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.brightness, 0.0001..=0.015)
.logarithmic(true)
.text("Brightness"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.dust_intensity, 0.0..=2.0)
.text("Dust Intensity"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.distfading, 0.1..=3.0)
.text("Distance Fading"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.color_variation, 0.2..=5.0)
.text("Color Variation"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.exposure, 0.2..=3.0)
.text("Exposure"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.gamma, 0.1..=1.2)
.text("Gamma"),
)
.changed();
});
egui::CollapsingHeader::new("Animation")
.default_open(false)
.show(ui, |ui| {
changed |= ui
.add(
egui::Slider::new(&mut params.speed, -0.1..=0.1)
.text("Galaxy Speed"),
)
.changed();
changed |= ui
.add(
egui::Slider::new(&mut params.time_scale, 0.1..=2.0)
.text("Animation Speed"),
)
.changed();
});
ui.separator();
ShaderControls::render_controls_widget(ui, &mut controls_request);
ui.separator();
should_start_export =
ExportManager::render_export_ui_widget(ui, &mut export_request);
});
})
} else {
self.base.render_ui(core, |_ctx| {})
};
self.base.export_manager.apply_ui_request(export_request);
if controls_request.should_clear_buffers {
self.clear_buffers(core);
}
self.base.apply_control_request(controls_request);
if changed {
self.current_params = params;
self.compute_shader.set_custom_params(params, &core.queue);
}
if should_start_export {
self.base.export_manager.start_export();
}
let current_time = self.base.controls.get_time(&self.base.start_time);
let delta = 1.0 / 60.0;
self.compute_shader
.set_time(current_time, delta, &core.queue);
self.compute_shader.time_uniform.data.frame = self.frame_count;
self.compute_shader.time_uniform.update(&core.queue);
// Stage 0: Volumetric render (not doing anything in this case, just placeholder)
self.compute_shader.dispatch_stage(&mut encoder, core, 0);
// Stage 1: Main image render
self.compute_shader.dispatch_stage(&mut encoder, core, 1);
{
let mut render_pass = cuneus::Renderer::begin_render_pass(
&mut encoder,
&view,
wgpu::LoadOp::Clear(wgpu::Color::BLACK),
Some("Display Pass"),
);
render_pass.set_pipeline(&self.base.renderer.render_pipeline);
render_pass.set_vertex_buffer(0, self.base.renderer.vertex_buffer.slice(..));
render_pass.set_bind_group(0, &self.compute_shader.output_texture.bind_group, &[]);
render_pass.draw(0..4, 0..1);
}
self.frame_count = self.frame_count.wrapping_add(1);
self.base
.handle_render_output(core, &view, full_output, &mut encoder);
core.queue.submit(Some(encoder.finish()));
output.present();
Ok(())
}
fn handle_input(&mut self, core: &Core, event: &WindowEvent) -> bool {
if self
.base
.egui_state
.on_window_event(core.window(), event)
.consumed
{
return true;
}
if self.base.handle_mouse_input(core, event, false) {
return true;
}
if let WindowEvent::KeyboardInput { event, .. } = event {
return self
.base
.key_handler
.handle_keyboard_input(core.window(), event);
}
false
}
}
fn main() -> Result<(), Box<dyn std::error::Error>> {
env_logger::init();
let (app, event_loop) = ShaderApp::new("universe", 800, 600);
app.run(event_loop, NebulaShader::init)
}
| rust | MIT | 4ab4a90169f70265c17a065d0db53bc168aeecc2 | 2026-01-04T20:21:00.414612Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/ipc_windows.rs | src/ipc_windows.rs | use crate::{discord_ipc::DiscordIpc, error::Error};
use serde_json::json;
use std::{
fs::{File, OpenOptions},
io::{Read, Write},
os::windows::fs::OpenOptionsExt,
path::PathBuf,
};
type Result<T> = std::result::Result<T, Error>;
#[allow(dead_code)]
#[derive(Debug)]
/// A wrapper struct for the functionality contained in the
/// underlying [`DiscordIpc`](trait@DiscordIpc) trait.
pub struct DiscordIpcClient {
/// Client ID of the IPC client.
pub client_id: String,
socket: Option<File>,
}
impl DiscordIpcClient {
/// Creates a new `DiscordIpcClient`.
///
/// # Examples
/// ```
/// let ipc_client = DiscordIpcClient::new("<some client id>");
/// ```
pub fn new<T: AsRef<str>>(client_id: T) -> Self {
Self {
client_id: client_id.as_ref().to_string(),
socket: None,
}
}
}
impl DiscordIpc for DiscordIpcClient {
fn connect_ipc(&mut self) -> Result<()> {
for i in 0..10 {
let path = PathBuf::from(format!(r"\\?\pipe\discord-ipc-{}", i));
match OpenOptions::new().access_mode(0x3).open(&path) {
Ok(handle) => {
self.socket = Some(handle);
return Ok(());
}
Err(_) => continue,
}
}
Err(Error::IPCConnectionFailed)
}
fn write(&mut self, data: &[u8]) -> Result<()> {
let socket = self.socket.as_mut().ok_or(Error::NotConnected)?;
socket.write_all(data).map_err(Error::WriteError)?;
Ok(())
}
fn read(&mut self, buffer: &mut [u8]) -> Result<()> {
let socket = self.socket.as_mut().ok_or(Error::NotConnected)?;
socket.read_exact(buffer).map_err(Error::ReadError)?;
Ok(())
}
fn close(&mut self) -> Result<()> {
let data = json!({});
if self.send(data, 2).is_ok() {}
let socket = self.socket.as_mut().ok_or(Error::NotConnected)?;
socket.flush().map_err(Error::FlushError)?;
Ok(())
}
fn get_client_id(&self) -> &str {
&self.client_id
}
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/ipc_unix.rs | src/ipc_unix.rs | use crate::{discord_ipc::DiscordIpc, error::Error};
use serde_json::json;
use std::{
env::var,
io::{Read, Write},
net::Shutdown,
os::unix::net::UnixStream,
path::PathBuf,
};
// Environment keys to search for the Discord pipe
const ENV_KEYS: [&str; 4] = ["XDG_RUNTIME_DIR", "TMPDIR", "TMP", "TEMP"];
const APP_SUBPATHS: [&str; 7] = [
"",
"app/com.discordapp.Discord/",
"app/dev.vencord.Vesktop/",
".flatpak/com.discordapp.Discord/xdg-run/",
".flatpak/dev.vencord.Vesktop/xdg-run/",
"snap.discord-canary/",
"snap.discord/",
];
type Result<T> = std::result::Result<T, Error>;
#[allow(dead_code)]
#[derive(Debug)]
/// A wrapper struct for the functionality contained in the
/// underlying [`DiscordIpc`](trait@DiscordIpc) trait.
pub struct DiscordIpcClient {
/// Client ID of the IPC client.
pub client_id: String,
socket: Option<UnixStream>,
}
impl DiscordIpcClient {
/// Creates a new `DiscordIpcClient`.
///
/// # Examples
/// ```
/// let ipc_client = DiscordIpcClient::new("<some client id>");
/// ```
pub fn new<T: AsRef<str>>(client_id: T) -> Self {
Self {
client_id: client_id.as_ref().to_string(),
socket: None,
}
}
fn get_pipe_pattern() -> PathBuf {
log::debug!("get_pipe_pattern: {}", var("SNAP").is_ok());
let mut path = String::new();
for key in &ENV_KEYS {
match var(key) {
Ok(val) => {
if var("SNAP").is_ok() {
if key == &ENV_KEYS[0] {
path = val
.rsplit_once('/')
.map(|(parent, _)| parent)
.unwrap_or("")
.to_string();
}
} else {
path = val;
}
break;
}
Err(_e) => continue,
}
}
PathBuf::from(path)
}
}
impl DiscordIpc for DiscordIpcClient {
fn connect_ipc(&mut self) -> Result<()> {
for i in 0..10 {
for subpath in APP_SUBPATHS {
let path = DiscordIpcClient::get_pipe_pattern()
.join(subpath)
.join(format!("discord-ipc-{}", i));
log::debug!("connect_ipc: {}", path.display());
match UnixStream::connect(&path) {
Ok(socket) => {
self.socket = Some(socket);
return Ok(());
}
Err(err) => {
log::debug!("connect_ipc: {}", err);
continue;
}
}
}
}
Err(Error::IPCConnectionFailed)
}
fn write(&mut self, data: &[u8]) -> Result<()> {
let socket = self.socket.as_mut().ok_or(Error::NotConnected)?;
socket.write_all(data).map_err(Error::WriteError)?;
Ok(())
}
fn read(&mut self, buffer: &mut [u8]) -> Result<()> {
let socket = self.socket.as_mut().ok_or(Error::NotConnected)?;
socket.read_exact(buffer).map_err(Error::ReadError)?;
Ok(())
}
fn close(&mut self) -> Result<()> {
let data = json!({});
let _ = self.send(data, 2);
let socket = self.socket.as_mut().ok_or(Error::NotConnected)?;
socket.flush().map_err(Error::FlushError)?;
match socket.shutdown(Shutdown::Both) {
Ok(()) => (),
Err(_err) => (),
}
Ok(())
}
fn get_client_id(&self) -> &str {
&self.client_id
}
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/lib.rs | src/lib.rs | //! This library provides easy access to the Discord IPC.
//!
//! It provides implementations for both Unix and Windows
//! operating systems, with both implementations using the
//! same API. Thus, this crate can be used in a platform-agnostic
//! manner.
//!
//! # Hello world
//! ```
//! use discord_rich_presence::{activity, DiscordIpc, DiscordIpcClient};
//!
//! fn main() -> Result<(), Box<dyn std::error::Error>> {
//! let mut client = DiscordIpcClient::new("<some client id>")?;
//! client.connect()?;
//!
//! let payload = activity::Activity::new().state("Hello world!");
//! client.set_activity(payload)?;
//! }
//! ```
#![deny(missing_docs)]
mod discord_ipc;
mod pack_unpack;
pub use discord_ipc::*;
pub mod activity;
pub mod error;
#[cfg(unix)]
mod ipc_unix;
#[cfg(unix)]
use ipc_unix as ipc;
#[cfg(windows)]
mod ipc_windows;
#[cfg(windows)]
use ipc_windows as ipc;
pub use ipc::DiscordIpcClient;
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/pack_unpack.rs | src/pack_unpack.rs | use std::convert::TryInto;
use crate::error::Error;
// Re-implement some packing methods in Rust
pub fn pack(opcode: u32, data_len: u32) -> Vec<u8> {
let mut bytes = Vec::new();
for byte_array in &[opcode.to_le_bytes(), data_len.to_le_bytes()] {
bytes.extend_from_slice(byte_array);
}
bytes
}
pub fn unpack(data: &[u8]) -> Result<(u32, u32), Error> {
let (opcode, header) = data.split_at(std::mem::size_of::<u32>());
let opcode = u32::from_le_bytes(opcode.try_into().map_err(|_| Error::DecodeOpcode)?);
let header = u32::from_le_bytes(header.try_into().map_err(|_| Error::DecodeHeader)?);
Ok((opcode, header))
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/discord_ipc.rs | src/discord_ipc.rs | use crate::{
activity::Activity,
error::Error,
pack_unpack::{pack, unpack},
};
use serde_json::{json, Value};
use uuid::Uuid;
type Result<T> = std::result::Result<T, Error>;
/// A client that connects to and communicates with the Discord IPC.
///
/// Implemented via the [`DiscordIpcClient`](struct@crate::DiscordIpcClient) struct.
pub trait DiscordIpc {
/// Connects the client to the Discord IPC.
///
/// This method attempts to first establish a connection,
/// and then sends a handshake.
///
/// # Errors
///
/// Returns an `Err` variant if the client
/// fails to connect to the socket, or if it fails to
/// send a handshake.
///
/// # Examples
/// ```
/// let mut client = discord_rich_presence::new_client("<some client id>")?;
/// client.connect()?;
/// ```
fn connect(&mut self) -> Result<()> {
self.connect_ipc()?;
self.send_handshake()?;
Ok(())
}
/// Reconnects to the Discord IPC.
///
/// This method closes the client's active connection,
/// then re-connects it and re-sends a handshake.
///
/// # Errors
///
/// Returns an `Err` variant if the client
/// failed to connect to the socket, or if it failed to
/// send a handshake.
///
/// # Examples
/// ```
/// let mut client = discord_rich_presence::new_client("<some client id>")?;
/// client.connect()?;
///
/// client.close()?;
/// client.reconnect()?;
/// ```
fn reconnect(&mut self) -> Result<()> {
self.close()?;
self.connect_ipc()?;
self.send_handshake()?;
Ok(())
}
#[doc(hidden)]
fn get_client_id(&self) -> &str;
#[doc(hidden)]
fn connect_ipc(&mut self) -> Result<()>;
/// Handshakes the Discord IPC.
///
/// This method sends the handshake signal to the IPC.
/// It is usually not called manually, as it is automatically
/// called by [`connect`] and/or [`reconnect`].
///
/// [`connect`]: #method.connect
/// [`reconnect`]: #method.reconnect
///
/// # Errors
///
/// Returns an `Err` variant if sending the handshake failed.
fn send_handshake(&mut self) -> Result<()> {
self.send(
json!({
"v": 1,
"client_id": self.get_client_id()
}),
0,
)?;
// TODO: Return an Err if the handshake is rejected
self.recv()?;
Ok(())
}
/// Sends JSON data to the Discord IPC.
///
/// This method takes data (`serde_json::Value`) and
/// an opcode as its parameters.
///
/// # Errors
/// Returns an `Err` variant if writing to the socket failed
///
/// # Examples
/// ```
/// let payload = serde_json::json!({ "field": "value" });
/// client.send(payload, 0)?;
/// ```
fn send(&mut self, data: Value, opcode: u8) -> Result<()> {
let data_string = data.to_string();
let header = pack(opcode.into(), data_string.len() as u32);
self.write(&header)?;
self.write(data_string.as_bytes())?;
Ok(())
}
#[doc(hidden)]
fn write(&mut self, data: &[u8]) -> Result<()>;
/// Receives an opcode and JSON data from the Discord IPC.
///
/// This method returns any data received from the IPC.
/// It returns a tuple containing the opcode, and the JSON data.
///
/// # Errors
/// Returns an `Err` variant if reading the socket was
/// unsuccessful.
///
/// # Examples
/// ```
/// client.connect_ipc()?;
/// client.send_handshake()?;
///
/// println!("{:?}", client.recv()?);
/// ```
fn recv(&mut self) -> Result<(u32, Value)> {
let mut header = [0; 8];
self.read(&mut header)?;
let (op, length) = unpack(&header)?;
let mut data = vec![0u8; length as usize];
self.read(&mut data)?;
let response = str::from_utf8(&data).map_err(|_| Error::RecvUtf8Response)?;
let json_data =
serde_json::from_str::<Value>(response).map_err(|_| Error::JsonParseResponse)?;
Ok((op, json_data))
}
#[doc(hidden)]
fn read(&mut self, buffer: &mut [u8]) -> Result<()>;
/// Sets a Discord activity.
///
/// This method is an abstraction of [`send`],
/// wrapping it such that only an activity payload
/// is required.
///
/// [`send`]: #method.send
///
/// # Errors
/// Returns an `Err` variant if sending the payload failed.
fn set_activity(&mut self, activity_payload: Activity) -> Result<()> {
let data = json!({
"cmd": "SET_ACTIVITY",
"args": {
"pid": std::process::id(),
"activity": activity_payload
},
"nonce": Uuid::new_v4().to_string()
});
self.send(data, 1)?;
Ok(())
}
/// Works the same as as [`set_activity`] but clears activity instead.
///
/// [`set_activity`]: #method.set_activity
///
/// # Errors
/// Returns an `Err` variant if sending the payload failed.
fn clear_activity(&mut self) -> Result<()> {
let data = json!({
"cmd": "SET_ACTIVITY",
"args": {
"pid": std::process::id(),
"activity": None::<()>
},
"nonce": Uuid::new_v4().to_string()
});
self.send(data, 1)?;
Ok(())
}
/// Closes the Discord IPC connection. Implementation is dependent on platform.
fn close(&mut self) -> Result<()>;
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/error.rs | src/error.rs | //! Error types for this crate.
use thiserror::Error;
/// Error type for this crate.
#[derive(Error, Debug)]
pub enum Error {
/// Failed to decode opcode.
#[error("failed to decode opcode")]
DecodeOpcode,
/// Failed to decode header.
#[error("failed to decode header")]
DecodeHeader,
/// Failed to recieve UTF-8 response.
#[error("failed to recieve valid UTF-8 response")]
RecvUtf8Response,
/// Failed to parse response json.
#[error("failed to parse response json")]
JsonParseResponse,
/// Failed to connect to IPC socket.
#[error("failed to connect to IPC socket")]
IPCConnectionFailed,
/// Not connected to IPC socket.
#[error("not connected to IPC socket")]
NotConnected,
/// Failed to read from IPC socket.
#[error("failed to read to IPC socket")]
ReadError(std::io::Error),
/// Failed to write to IPC socket.
#[error("failed to write to IPC socket")]
WriteError(std::io::Error),
/// Failed to flush IPC socket.
#[error("failed to flush IPC socket")]
FlushError(std::io::Error),
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/src/activity.rs | src/activity.rs | //! Provides an interface for building activities to send
//! to Discord via [`DiscordIpc::set_activity`](crate::DiscordIpc::set_activity).
use serde_derive::Serialize;
use serde_repr::Serialize_repr;
use std::borrow::Cow;
/// A struct representing a Discord rich presence activity
///
/// Note that all methods return `Self`, and can be chained
/// for fluency
#[derive(Serialize, Clone)]
pub struct Activity<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
name: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
state: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
state_url: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
details: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
details_url: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
timestamps: Option<Timestamps>,
#[serde(skip_serializing_if = "Option::is_none")]
party: Option<Party<'a>>,
#[serde(skip_serializing_if = "Option::is_none")]
assets: Option<Assets<'a>>,
#[serde(skip_serializing_if = "Option::is_none")]
secrets: Option<Secrets<'a>>,
#[serde(skip_serializing_if = "Option::is_none")]
buttons: Option<Vec<Button<'a>>>,
#[serde(skip_serializing_if = "Option::is_none", rename = "type")]
activity_type: Option<ActivityType>,
#[serde(skip_serializing_if = "Option::is_none")]
status_display_type: Option<StatusDisplayType>,
}
/// A struct representing an `Activity`'s timestamps
///
/// For `ActivityType::Listening` and `ActivityType::Watching`,
/// including both `start` and `end` timestamps will display
/// a time bar
///
/// Note that all methods return `Self`, and can be chained
/// for fluency
#[derive(Serialize, Clone)]
pub struct Timestamps {
/// Unix time (in milliseconds) of when the activity started
#[serde(skip_serializing_if = "Option::is_none")]
start: Option<i64>,
/// Unix time (in milliseconds) of when the activity ends
#[serde(skip_serializing_if = "Option::is_none")]
end: Option<i64>,
}
/// A struct representing an `Activity`'s game party
///
/// Note that all methods return `Self`, and can be chained
/// for fluency
#[derive(Serialize, Clone)]
pub struct Party<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
id: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
size: Option<[i32; 2]>,
}
/// A struct representing the art assets and hover text
/// used by an `Activity`
///
/// Note that all methods return `Self`, and can be chained
/// for fluency
#[derive(Serialize, Clone)]
pub struct Assets<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
large_image: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
large_text: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
large_url: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
small_image: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
small_text: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
small_url: Option<Cow<'a, str>>,
}
/// A struct representing the secrets used by an
/// `Activity`
///
/// Note that all methods return `Self`, and can be chained
/// for fluency
#[derive(Serialize, Clone)]
pub struct Secrets<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
join: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
spectate: Option<Cow<'a, str>>,
#[serde(skip_serializing_if = "Option::is_none")]
r#match: Option<Cow<'a, str>>,
}
/// A struct representing the buttons that are
/// attached to an `Activity`
///
/// An activity may have a maximum of 2 buttons
#[derive(Serialize, Clone)]
pub struct Button<'a> {
label: Cow<'a, str>,
url: Cow<'a, str>,
}
/// A struct to set the Activity Type of the `Activity`
#[derive(Serialize_repr, Clone)]
#[repr(u8)]
pub enum ActivityType {
/// Activity type "Playing X"
Playing = 0,
/// Activity type "Listening to X"
Listening = 2,
/// Activity type "Watching X"
Watching = 3,
/// Activity type "Competing in X"
Competing = 5,
}
/// A struct to set the Status Display Type of the `Activity`
/// Controls which field is displayed in the user's status text in the member list
#[derive(Serialize_repr, Clone)]
#[repr(u8)]
pub enum StatusDisplayType {
/// "Listening to Spotify"
Name = 0,
/// "Listening to Rick Astley"
State = 1,
/// "Listening to Never Gonna Give You Up"
Details = 2,
}
impl<'a> Activity<'a> {
/// Creates a new `Activity`
#[must_use]
pub const fn new() -> Self {
Activity {
name: None,
state: None,
state_url: None,
details: None,
details_url: None,
assets: None,
buttons: None,
party: None,
secrets: None,
timestamps: None,
activity_type: None,
status_display_type: None,
}
}
/// Sets the name of the activity (overrides default App name)
#[must_use]
pub fn name<S: Into<Cow<'a, str>>>(mut self, name: S) -> Self {
self.name = Some(name.into());
self
}
/// Sets the state of the activity
#[must_use]
pub fn state<S: Into<Cow<'a, str>>>(mut self, state: S) -> Self {
self.state = Some(state.into());
self
}
/// Sets the state URL of the activity
#[must_use]
pub fn state_url<S: Into<Cow<'a, str>>>(mut self, state_url: S) -> Self {
self.state_url = Some(state_url.into());
self
}
/// Sets the details of the activity
#[must_use]
pub fn details<S: Into<Cow<'a, str>>>(mut self, details: S) -> Self {
self.details = Some(details.into());
self
}
/// Sets the details URL of the activity
#[must_use]
pub fn details_url<S: Into<Cow<'a, str>>>(mut self, details_url: S) -> Self {
self.details_url = Some(details_url.into());
self
}
/// Add a `Timestamps` to this activity
#[must_use]
pub const fn timestamps(mut self, timestamps: Timestamps) -> Self {
self.timestamps = Some(timestamps);
self
}
/// Add a `Party` to this activity
#[must_use]
pub fn party(mut self, party: Party<'a>) -> Self {
self.party = Some(party);
self
}
/// Add an `Assets` to this activity
#[must_use]
pub fn assets(mut self, assets: Assets<'a>) -> Self {
self.assets = Some(assets);
self
}
/// Add a `Secrets` to this activity
#[must_use]
pub fn secrets(mut self, secrets: Secrets<'a>) -> Self {
self.secrets = Some(secrets);
self
}
/// Add a `Vec` of `Button`s to this activity
///
/// An activity may contain no more than 2 buttons
#[must_use]
pub fn buttons(mut self, buttons: Vec<Button<'a>>) -> Self {
// API call fails if the array is empty, so we skip serialization
// entirely if this is the case
if buttons.is_empty() {
return self;
}
self.buttons = Some(buttons);
self
}
/// Add an `ActivityType` to this activity
#[must_use]
pub const fn activity_type(mut self, activity_type: ActivityType) -> Self {
self.activity_type = Some(activity_type);
self
}
/// Add a `StatusDisplayType` to this activity
#[must_use]
pub const fn status_display_type(mut self, status_display_type: StatusDisplayType) -> Self {
self.status_display_type = Some(status_display_type);
self
}
}
impl Default for Activity<'_> {
fn default() -> Self {
Self::new()
}
}
impl Timestamps {
/// Creates a new `Timestamps`
#[must_use]
pub const fn new() -> Self {
Self {
start: None,
end: None,
}
}
/// Sets the start time
#[must_use]
pub const fn start(mut self, start: i64) -> Self {
self.start = Some(start);
self
}
/// Sets the end time
#[must_use]
pub const fn end(mut self, end: i64) -> Self {
self.end = Some(end);
self
}
}
impl Default for Timestamps {
fn default() -> Self {
Self::new()
}
}
impl<'a> Party<'a> {
/// Creates a new `Party`
#[must_use]
pub const fn new() -> Self {
Self {
id: None,
size: None,
}
}
/// Sets the ID of the party
#[must_use]
pub fn id<S: Into<Cow<'a, str>>>(mut self, id: S) -> Self {
self.id = Some(id.into());
self
}
/// Sets the size of the party (current and maximum)
///
/// # Example
/// ```
/// // Creates a party with a current size
/// // of 1, and a max size of 3
/// let party = Party::new().size([1, 3])
/// ```
#[must_use]
pub const fn size(mut self, size: [i32; 2]) -> Self {
self.size = Some(size);
self
}
}
impl Default for Party<'_> {
fn default() -> Self {
Self::new()
}
}
impl<'a> Assets<'a> {
/// Creates a new `Assets`
#[must_use]
pub const fn new() -> Self {
Self {
large_image: None,
large_text: None,
large_url: None,
small_image: None,
small_text: None,
small_url: None,
}
}
/// Sets the asset name or URL to be used as the large image
#[must_use]
pub fn large_image<S: Into<Cow<'a, str>>>(mut self, large_image: S) -> Self {
self.large_image = Some(large_image.into());
self
}
/// Sets the text to be shown when hovering over the large
/// image
#[must_use]
pub fn large_text<S: Into<Cow<'a, str>>>(mut self, large_text: S) -> Self {
self.large_text = Some(large_text.into());
self
}
/// Sets the url to be shown when clicking the large image
#[must_use]
pub fn large_url<S: Into<Cow<'a, str>>>(mut self, large_url: S) -> Self {
self.large_url = Some(large_url.into());
self
}
/// Sets the asset name or URL to be used as the small image
#[must_use]
pub fn small_image<S: Into<Cow<'a, str>>>(mut self, small_image: S) -> Self {
self.small_image = Some(small_image.into());
self
}
/// Sets the text that is shown when hovering over the small
/// image
#[must_use]
pub fn small_text<S: Into<Cow<'a, str>>>(mut self, small_text: S) -> Self {
self.small_text = Some(small_text.into());
self
}
/// Sets the url to be shown when clicking the small image
#[must_use]
pub fn small_url<S: Into<Cow<'a, str>>>(mut self, small_url: S) -> Self {
self.small_url = Some(small_url.into());
self
}
}
impl Default for Assets<'_> {
fn default() -> Self {
Self::new()
}
}
impl<'a> Secrets<'a> {
/// Creates a new `Secrets`
#[must_use]
pub const fn new() -> Self {
Self {
join: None,
spectate: None,
r#match: None,
}
}
/// Sets the secret for joining a game party
#[must_use]
pub fn join<S: Into<Cow<'a, str>>>(mut self, join: S) -> Self {
self.join = Some(join.into());
self
}
/// Sets the secret for spectating a match
#[must_use]
pub fn spectate<S: Into<Cow<'a, str>>>(mut self, spectate: S) -> Self {
self.spectate = Some(spectate.into());
self
}
/// Sets the secret for a specific, instanced match
#[must_use]
pub fn r#match<S: Into<Cow<'a, str>>>(mut self, r#match: S) -> Self {
self.r#match = Some(r#match.into());
self
}
}
impl Default for Secrets<'_> {
fn default() -> Self {
Self::new()
}
}
impl<'a> Button<'a> {
/// Creates a new `Button` with the given label and
/// URL
///
/// The label must be 1-32 characters long
///
/// The URL must be 1-512 characters long
pub fn new<L: Into<Cow<'a, str>>, U: Into<Cow<'a, str>>>(label: L, url: U) -> Self {
Self {
label: label.into(),
url: url.into(),
}
}
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/tests/models_test.rs | tests/models_test.rs | use discord_rich_presence::{activity, DiscordIpc, DiscordIpcClient};
use std::error::Error;
#[test]
fn test_models() -> Result<(), Box<dyn Error>> {
let mut client = DiscordIpcClient::new("771124766517755954");
client.connect()?;
let activity = activity::Activity::new()
.state("A test")
.details("A placeholder")
.assets(
activity::Assets::new()
.large_image("large-image")
.large_text("Large text")
.large_url("https://example.com")
.small_image("https://picsum.photos/id/128/200")
.small_text("Small image")
.small_url("https://picsum.photos/id/128/200")
)
.buttons(vec![activity::Button::new(
"A button",
"https://github.com",
)]);
client.set_activity(activity)?;
std::thread::sleep(std::time::Duration::from_secs(10));
client.close()?;
Ok(())
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/tests/update_test.rs | tests/update_test.rs | use discord_rich_presence::{activity, DiscordIpc, DiscordIpcClient};
use std::error::Error;
#[test]
fn test_updating() -> Result<(), Box<dyn Error>> {
let mut client = DiscordIpcClient::new("771124766517755954");
client.connect()?;
client.set_activity(
activity::Activity::new()
.state("part 1 (test)")
.details("a placeholder")
.assets(
activity::Assets::new()
.large_image("large-image")
.large_text("a thing"),
),
)?;
std::thread::sleep(std::time::Duration::from_secs(2));
client.set_activity(
activity::Activity::new()
.state("part 2 (test)")
.details("a placeholder")
.assets(
activity::Assets::new()
.large_image("small-image")
.large_text("a thing"),
),
)?;
std::thread::sleep(std::time::Duration::from_secs(2));
client.close()?;
Ok(())
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/tests/reconnect_test.rs | tests/reconnect_test.rs | use discord_rich_presence::{activity, DiscordIpc, DiscordIpcClient};
use std::error::Error;
#[test]
fn test_reconnect() -> Result<(), Box<dyn Error>> {
let mut client = DiscordIpcClient::new("771124766517755954");
loop {
if client.connect().is_ok() {
break;
}
}
loop {
let payload = activity::Activity::new()
.state("part 1 (test)")
.details("a placeholder")
.assets(
activity::Assets::new()
.large_image("large-image")
.large_text("a thing"),
);
if client.set_activity(payload).is_err() && client.reconnect().is_ok() {
continue;
}
std::thread::sleep(std::time::Duration::from_secs(2));
}
#[allow(unreachable_code)]
Ok(())
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
vionya/discord-rich-presence | https://github.com/vionya/discord-rich-presence/blob/d83d26062bf8ea072b5774bdca584d9ae423915f/examples/presence.rs | examples/presence.rs | use discord_rich_presence::{activity, DiscordIpc, DiscordIpcClient};
fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut client = DiscordIpcClient::new(&std::env::args().collect::<Vec<String>>()[1]);
client.connect()?;
client.set_activity(activity::Activity::new().state("foo").details("bar"))?;
println!("Activity set! Press enter to exit...");
let mut dummy = String::new();
match std::io::stdin().read_line(&mut dummy) {
_ => (),
}
client.close()?;
Ok(())
}
| rust | MIT | d83d26062bf8ea072b5774bdca584d9ae423915f | 2026-01-04T20:21:07.642725Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/build.rs | build.rs | use std::io::Result;
fn main() -> Result<()> {
println!("cargo:rerun-if-changed=proto/");
// Generate proto files for Kaonic
tonic_build::configure()
.type_attribute(
"ConfigurationRequest",
"#[derive(serde::Deserialize, serde::Serialize)]",
)
.type_attribute(
"RadioPhyConfigFSK",
"#[derive(serde::Deserialize, serde::Serialize)]",
)
.type_attribute(
"RadioPhyConfigOFDM",
"#[derive(serde::Deserialize, serde::Serialize)]",
)
.type_attribute(
"RadioPhyConfigQPSK",
"#[derive(serde::Deserialize, serde::Serialize)]",
)
.type_attribute(
"kaonic.ConfigurationRequest.phy_config",
"#[derive(serde::Deserialize, serde::Serialize)]",
)
.type_attribute(
"kaonic.ConfigurationRequest.phy_config",
"#[serde(tag = \"type\", content = \"data\")]",
)
.compile_protos(
&["proto/kaonic/kaonic.proto"],
&["proto/kaonic"], // The directory containing your proto files
)?;
Ok(())
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/serde.rs | src/serde.rs | use crate::{
buffer::{InputBuffer, OutputBuffer, StaticBuffer},
error::RnsError,
hash::AddressHash,
packet::{Header, HeaderType, Packet, PacketContext},
};
pub trait Serialize {
fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError>;
}
impl Serialize for AddressHash {
fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
buffer.write(self.as_slice())
}
}
impl Serialize for Header {
fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
buffer.write(&[self.to_meta(), self.hops])
}
}
impl Serialize for PacketContext {
fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
buffer.write(&[*self as u8])
}
}
impl Serialize for Packet {
fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
self.header.serialize(buffer)?;
if self.header.header_type == HeaderType::Type2 {
if let Some(transport) = &self.transport {
transport.serialize(buffer)?;
}
}
self.destination.serialize(buffer)?;
self.context.serialize(buffer)?;
buffer.write(self.data.as_slice())
}
}
impl Header {
pub fn deserialize(buffer: &mut InputBuffer) -> Result<Header, RnsError> {
let mut header = Header::from_meta(buffer.read_byte()?);
header.hops = buffer.read_byte()?;
Ok(header)
}
}
impl AddressHash {
pub fn deserialize(buffer: &mut InputBuffer) -> Result<AddressHash, RnsError> {
let mut address = AddressHash::new_empty();
buffer.read(&mut address.as_mut_slice())?;
Ok(address)
}
}
impl PacketContext {
pub fn deserialize(buffer: &mut InputBuffer) -> Result<PacketContext, RnsError> {
Ok(PacketContext::from(buffer.read_byte()?))
}
}
impl Packet {
pub fn deserialize(buffer: &mut InputBuffer) -> Result<Packet, RnsError> {
let header = Header::deserialize(buffer)?;
let transport = if header.header_type == HeaderType::Type2 {
Some(AddressHash::deserialize(buffer)?)
} else {
None
};
let destination = AddressHash::deserialize(buffer)?;
let context = PacketContext::deserialize(buffer)?;
let mut packet = Packet {
header,
ifac: None,
destination,
transport,
context,
data: StaticBuffer::new(),
};
buffer.read(&mut packet.data.accuire_buf(buffer.bytes_left()))?;
Ok(packet)
}
}
#[cfg(test)]
mod tests {
use rand_core::OsRng;
use crate::{
buffer::{InputBuffer, OutputBuffer, StaticBuffer},
hash::AddressHash,
packet::{
DestinationType, Header, HeaderType, IfacFlag, Packet, PacketContext, PacketType,
PropagationType,
},
};
use super::Serialize;
#[test]
fn serialize_packet() {
let mut output_data = [0u8; 4096];
let mut buffer = OutputBuffer::new(&mut output_data);
let packet = Packet {
header: Header {
ifac_flag: IfacFlag::Open,
header_type: HeaderType::Type1,
propagation_type: PropagationType::Broadcast,
destination_type: DestinationType::Single,
packet_type: PacketType::Announce,
hops: 0,
},
ifac: None,
destination: AddressHash::new_from_rand(OsRng),
transport: None,
context: PacketContext::None,
data: StaticBuffer::new(),
};
packet.serialize(&mut buffer).expect("serialized packet");
println!("{}", buffer);
}
#[test]
fn deserialize_packet() {
let mut output_data = [0u8; 4096];
let mut buffer = OutputBuffer::new(&mut output_data);
let mut packet = Packet {
header: Header {
ifac_flag: IfacFlag::Open,
header_type: HeaderType::Type1,
propagation_type: PropagationType::Broadcast,
destination_type: DestinationType::Single,
packet_type: PacketType::Announce,
hops: 0,
},
ifac: None,
destination: AddressHash::new_from_rand(OsRng),
transport: None,
context: PacketContext::None,
data: StaticBuffer::new(),
};
packet.data.safe_write(b"Hello, world!");
packet.serialize(&mut buffer).expect("serialized packet");
let mut input_buffer = InputBuffer::new(buffer.as_slice());
let new_packet = Packet::deserialize(&mut input_buffer).expect("deserialized packet");
assert_eq!(packet.header, new_packet.header);
assert_eq!(packet.destination, new_packet.destination);
assert_eq!(packet.transport, new_packet.transport);
assert_eq!(packet.context, new_packet.context);
assert_eq!(packet.data.as_slice(), new_packet.data.as_slice());
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/packet.rs | src/packet.rs | use core::fmt;
use sha2::Digest;
use crate::buffer::StaticBuffer;
use crate::hash::AddressHash;
use crate::hash::Hash;
pub const PACKET_MDU: usize = 2048usize;
pub const PACKET_IFAC_MAX_LENGTH: usize = 64usize;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum IfacFlag {
Open = 0b0,
Authenticated = 0b1,
}
impl From<u8> for IfacFlag {
fn from(value: u8) -> Self {
match value {
0 => IfacFlag::Open,
1 => IfacFlag::Authenticated,
_ => IfacFlag::Open,
}
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum HeaderType {
Type1 = 0b0,
Type2 = 0b1,
}
impl From<u8> for HeaderType {
fn from(value: u8) -> Self {
match value & 0b1 {
0 => HeaderType::Type1,
1 => HeaderType::Type2,
_ => HeaderType::Type1,
}
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum PropagationType {
Broadcast = 0b00,
Transport = 0b01,
Reserved1 = 0b10,
Reserved2 = 0b11,
}
impl From<u8> for PropagationType {
fn from(value: u8) -> Self {
match value & 0b11 {
0b00 => PropagationType::Broadcast,
0b01 => PropagationType::Transport,
0b10 => PropagationType::Reserved1,
0b11 => PropagationType::Reserved2,
_ => PropagationType::Broadcast,
}
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum DestinationType {
Single = 0b00,
Group = 0b01,
Plain = 0b10,
Link = 0b11,
}
impl From<u8> for DestinationType {
fn from(value: u8) -> Self {
match value & 0b11 {
0b00 => DestinationType::Single,
0b01 => DestinationType::Group,
0b10 => DestinationType::Plain,
0b11 => DestinationType::Link,
_ => DestinationType::Single,
}
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum PacketType {
Data = 0b00,
Announce = 0b01,
LinkRequest = 0b10,
Proof = 0b11,
}
impl From<u8> for PacketType {
fn from(value: u8) -> Self {
match value & 0b11 {
0b00 => PacketType::Data,
0b01 => PacketType::Announce,
0b10 => PacketType::LinkRequest,
0b11 => PacketType::Proof,
_ => PacketType::Data,
}
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum PacketContext {
None = 0x00, // Generic data packet
Resource = 0x01, // Packet is part of a resource
ResourceAdvrtisement = 0x02, // Packet is a resource advertisement
ResourceRequest = 0x03, // Packet is a resource part request
ResourceHashUpdate = 0x04, // Packet is a resource hashmap update
ResourceProof = 0x05, // Packet is a resource proof
ResourceInitiatorCancel = 0x06, // Packet is a resource initiator cancel message
ResourceReceiverCancel = 0x07, // Packet is a resource receiver cancel message
CacheRequest = 0x08, // Packet is a cache request
Request = 0x09, // Packet is a request
Response = 0x0A, // Packet is a response to a request
PathResponse = 0x0B, // Packet is a response to a path request
Command = 0x0C, // Packet is a command
CommandStatus = 0x0D, // Packet is a status of an executed command
Channel = 0x0E, // Packet contains link channel data
KeepAlive = 0xFA, // Packet is a keepalive packet
LinkIdentify = 0xFB, // Packet is a link peer identification proof
LinkClose = 0xFC, // Packet is a link close message
LinkProof = 0xFD, // Packet is a link packet proof
LinkRTT = 0xFE, // Packet is a link request round-trip time measurement
LinkRequestProof = 0xFF, // Packet is a link request proof
}
impl From<u8> for PacketContext {
fn from(value: u8) -> Self {
match value {
0x01 => PacketContext::Resource,
0x02 => PacketContext::ResourceAdvrtisement,
0x03 => PacketContext::ResourceRequest,
0x04 => PacketContext::ResourceHashUpdate,
0x05 => PacketContext::ResourceProof,
0x06 => PacketContext::ResourceInitiatorCancel,
0x07 => PacketContext::ResourceReceiverCancel,
0x08 => PacketContext::CacheRequest,
0x09 => PacketContext::Request,
0x0A => PacketContext::Response,
0x0B => PacketContext::PathResponse,
0x0C => PacketContext::Command,
0x0D => PacketContext::CommandStatus,
0x0E => PacketContext::Channel,
0xFA => PacketContext::KeepAlive,
0xFB => PacketContext::LinkIdentify,
0xFC => PacketContext::LinkClose,
0xFD => PacketContext::LinkProof,
0xFE => PacketContext::LinkRTT,
0xFF => PacketContext::LinkRequestProof,
_ => PacketContext::None,
}
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct Header {
pub ifac_flag: IfacFlag,
pub header_type: HeaderType,
pub propagation_type: PropagationType,
pub destination_type: DestinationType,
pub packet_type: PacketType,
pub hops: u8,
}
impl Default for Header {
fn default() -> Self {
Self {
ifac_flag: IfacFlag::Open,
header_type: HeaderType::Type1,
propagation_type: PropagationType::Broadcast,
destination_type: DestinationType::Single,
packet_type: PacketType::Data,
hops: 0,
}
}
}
impl Header {
pub fn to_meta(&self) -> u8 {
let meta = (self.ifac_flag as u8) << 7
| (self.header_type as u8) << 6
| (self.propagation_type as u8) << 4
| (self.destination_type as u8) << 2
| (self.packet_type as u8) << 0;
meta
}
pub fn from_meta(meta: u8) -> Self {
Self {
ifac_flag: IfacFlag::from(meta >> 7),
header_type: HeaderType::from(meta >> 6),
propagation_type: PropagationType::from(meta >> 4),
destination_type: DestinationType::from(meta >> 2),
packet_type: PacketType::from(meta >> 0),
hops: 0,
}
}
}
impl fmt::Display for Header {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{:b}{:b}{:0>2b}{:0>2b}{:0>2b}.{}",
self.ifac_flag as u8,
self.header_type as u8,
self.propagation_type as u8,
self.destination_type as u8,
self.packet_type as u8,
self.hops,
)
}
}
pub type PacketDataBuffer = StaticBuffer<PACKET_MDU>;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct PacketIfac {
pub access_code: [u8; PACKET_IFAC_MAX_LENGTH],
pub length: usize,
}
impl PacketIfac {
pub fn new_from_slice(slice: &[u8]) -> Self {
let mut access_code = [0u8; PACKET_IFAC_MAX_LENGTH];
access_code[..slice.len()].copy_from_slice(slice);
Self {
access_code,
length: slice.len(),
}
}
pub fn as_slice(&self) -> &[u8] {
&self.access_code[..self.length]
}
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct Packet {
pub header: Header,
pub ifac: Option<PacketIfac>,
pub destination: AddressHash,
pub transport: Option<AddressHash>,
pub context: PacketContext,
pub data: PacketDataBuffer,
}
impl Packet {
pub fn hash(&self) -> Hash {
Hash::new(
Hash::generator()
.chain_update(&[self.header.to_meta() & 0b00001111])
.chain_update(self.destination.as_slice())
.chain_update(&[self.context as u8])
.chain_update(self.data.as_slice())
.finalize()
.into(),
)
}
}
impl Default for Packet {
fn default() -> Self {
Self {
header: Default::default(),
destination: AddressHash::new_empty(),
data: Default::default(),
ifac: None,
transport: None,
context: crate::packet::PacketContext::None,
}
}
}
impl fmt::Display for Packet {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[{}", self.header)?;
if let Some(transport) = self.transport {
write!(f, " {}", transport)?;
}
write!(f, " {}", self.destination)?;
write!(f, " 0x[{}]]", self.data.len())?;
Ok(())
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/lib.rs | src/lib.rs | #[cfg(feature = "alloc")]
extern crate alloc;
pub mod buffer;
pub mod crypt;
pub mod destination;
pub mod error;
pub mod hash;
pub mod identity;
pub mod iface;
pub mod packet;
pub mod transport;
mod utils;
mod serde;
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/crypt.rs | src/crypt.rs | pub mod fernet;
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/destination.rs | src/destination.rs | pub mod link;
pub mod link_map;
use ed25519_dalek::{Signature, SigningKey, VerifyingKey, SIGNATURE_LENGTH};
use rand_core::CryptoRngCore;
use x25519_dalek::PublicKey;
use core::{fmt, marker::PhantomData};
use crate::{
error::RnsError,
hash::{AddressHash, Hash},
identity::{EmptyIdentity, HashIdentity, Identity, PrivateIdentity, PUBLIC_KEY_LENGTH},
packet::{
self, DestinationType, Header, HeaderType, IfacFlag, Packet, PacketContext,
PacketDataBuffer, PacketType, PropagationType,
},
};
use sha2::Digest;
//***************************************************************************//
pub trait Direction {}
pub struct Input;
pub struct Output;
impl Direction for Input {}
impl Direction for Output {}
//***************************************************************************//
pub trait Type {
fn destination_type() -> DestinationType;
}
pub struct Single;
pub struct Plain;
pub struct Group;
impl Type for Single {
fn destination_type() -> DestinationType {
DestinationType::Single
}
}
impl Type for Plain {
fn destination_type() -> DestinationType {
DestinationType::Plain
}
}
impl Type for Group {
fn destination_type() -> DestinationType {
DestinationType::Group
}
}
pub const NAME_HASH_LENGTH: usize = 10;
pub const RAND_HASH_LENGTH: usize = 10;
pub const MIN_ANNOUNCE_DATA_LENGTH: usize =
PUBLIC_KEY_LENGTH * 2 + NAME_HASH_LENGTH + RAND_HASH_LENGTH + SIGNATURE_LENGTH;
#[derive(Copy, Clone)]
pub struct DestinationName {
pub hash: Hash,
}
impl DestinationName {
pub fn new(app_name: &str, aspects: &str) -> Self {
let hash = Hash::new(
Hash::generator()
.chain_update(app_name.as_bytes())
.chain_update(".".as_bytes())
.chain_update(aspects.as_bytes())
.finalize()
.into(),
);
Self { hash }
}
pub fn new_from_hash_slice(hash_slice: &[u8]) -> Self {
let mut hash = [0u8; 32];
hash[..hash_slice.len()].copy_from_slice(hash_slice);
Self {
hash: Hash::new(hash),
}
}
pub fn as_name_hash_slice(&self) -> &[u8] {
&self.hash.as_slice()[..NAME_HASH_LENGTH]
}
}
#[derive(Copy, Clone)]
pub struct DestinationDesc {
pub identity: Identity,
pub address_hash: AddressHash,
pub name: DestinationName,
}
impl fmt::Display for DestinationDesc {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.address_hash)?;
Ok(())
}
}
pub type DestinationAnnounce = Packet;
impl DestinationAnnounce {
pub fn validate(packet: &Packet) -> Result<(SingleOutputDestination, &[u8]), RnsError> {
if packet.header.packet_type != PacketType::Announce {
return Err(RnsError::PacketError);
}
let announce_data = packet.data.as_slice();
if announce_data.len() < MIN_ANNOUNCE_DATA_LENGTH {
return Err(RnsError::OutOfMemory);
}
let mut offset = 0usize;
let public_key = {
let mut key_data = [0u8; PUBLIC_KEY_LENGTH];
key_data.copy_from_slice(&announce_data[offset..(offset + PUBLIC_KEY_LENGTH)]);
offset += PUBLIC_KEY_LENGTH;
PublicKey::from(key_data)
};
let verifying_key = {
let mut key_data = [0u8; PUBLIC_KEY_LENGTH];
key_data.copy_from_slice(&announce_data[offset..(offset + PUBLIC_KEY_LENGTH)]);
offset += PUBLIC_KEY_LENGTH;
VerifyingKey::from_bytes(&key_data).map_err(|_| RnsError::CryptoError)?
};
let identity = Identity::new(public_key, verifying_key);
let name_hash = &announce_data[offset..(offset + NAME_HASH_LENGTH)];
offset += NAME_HASH_LENGTH;
let rand_hash = &announce_data[offset..(offset + RAND_HASH_LENGTH)];
offset += RAND_HASH_LENGTH;
let signature = &announce_data[offset..(offset + SIGNATURE_LENGTH)];
offset += SIGNATURE_LENGTH;
let app_data = &announce_data[offset..];
let destination = &packet.destination;
// Keeping signed data on stack is only option for now.
// Verification function doesn't support prehashed message.
let signed_data = PacketDataBuffer::new()
.chain_write(destination.as_slice())?
.chain_write(public_key.as_bytes())?
.chain_write(verifying_key.as_bytes())?
.chain_write(name_hash)?
.chain_write(rand_hash)?
.chain_write(app_data)?
.finalize();
let signature = Signature::from_slice(signature).map_err(|_| RnsError::CryptoError)?;
identity.verify(signed_data.as_slice(), &signature)?;
Ok((
SingleOutputDestination::new(identity, DestinationName::new_from_hash_slice(name_hash)),
app_data,
))
}
}
pub struct Destination<I: HashIdentity, D: Direction, T: Type> {
pub direction: PhantomData<D>,
pub r#type: PhantomData<T>,
pub identity: I,
pub desc: DestinationDesc,
}
impl<I: HashIdentity, D: Direction, T: Type> Destination<I, D, T> {
pub fn destination_type(&self) -> packet::DestinationType {
<T as Type>::destination_type()
}
}
// impl<I: DecryptIdentity + HashIdentity, T: Type> Destination<I, Input, T> {
// pub fn decrypt<'b, R: CryptoRngCore + Copy>(
// &self,
// rng: R,
// data: &[u8],
// out_buf: &'b mut [u8],
// ) -> Result<&'b [u8], RnsError> {
// self.identity.decrypt(rng, data, out_buf)
// }
// }
// impl<I: EncryptIdentity + HashIdentity, D: Direction, T: Type> Destination<I, D, T> {
// pub fn encrypt<'b, R: CryptoRngCore + Copy>(
// &self,
// rng: R,
// text: &[u8],
// out_buf: &'b mut [u8],
// ) -> Result<&'b [u8], RnsError> {
// // self.identity.encrypt(
// // rng,
// // text,
// // Some(self.identity.as_address_hash_slice()),
// // out_buf,
// // )
// }
// }
pub enum DestinationHandleStatus {
None,
LinkProof,
}
impl Destination<PrivateIdentity, Input, Single> {
pub fn new(identity: PrivateIdentity, name: DestinationName) -> Self {
let address_hash = create_address_hash(&identity, &name);
let pub_identity = identity.as_identity().clone();
Self {
direction: PhantomData,
r#type: PhantomData,
identity,
desc: DestinationDesc {
identity: pub_identity,
name,
address_hash,
},
}
}
pub fn announce<R: CryptoRngCore + Copy>(
&self,
rng: R,
app_data: Option<&[u8]>,
) -> Result<Packet, RnsError> {
let mut packet_data = PacketDataBuffer::new();
let rand_hash = Hash::new_from_rand(rng);
let rand_hash = &rand_hash.as_slice()[..RAND_HASH_LENGTH];
let pub_key = self.identity.as_identity().public_key_bytes();
let verifying_key = self.identity.as_identity().verifying_key_bytes();
packet_data
.chain_safe_write(self.desc.address_hash.as_slice())
.chain_safe_write(pub_key)
.chain_safe_write(verifying_key)
.chain_safe_write(self.desc.name.as_name_hash_slice())
.chain_safe_write(rand_hash);
if let Some(data) = app_data {
packet_data.write(data)?;
}
let signature = self.identity.sign(packet_data.as_slice());
packet_data.reset();
packet_data
.chain_safe_write(pub_key)
.chain_safe_write(verifying_key)
.chain_safe_write(self.desc.name.as_name_hash_slice())
.chain_safe_write(rand_hash)
.chain_safe_write(&signature.to_bytes());
if let Some(data) = app_data {
packet_data.write(data)?;
}
Ok(Packet {
header: Header {
ifac_flag: IfacFlag::Open,
header_type: HeaderType::Type1,
propagation_type: PropagationType::Broadcast,
destination_type: DestinationType::Single,
packet_type: PacketType::Announce,
hops: 0,
},
ifac: None,
destination: self.desc.address_hash,
transport: None,
context: PacketContext::None,
data: packet_data,
})
}
pub fn handle_packet(&mut self, packet: &Packet) -> DestinationHandleStatus {
if self.desc.address_hash != packet.destination {
return DestinationHandleStatus::None;
}
match packet.header.packet_type {
PacketType::LinkRequest => {
// TODO: check prove strategy
return DestinationHandleStatus::LinkProof;
}
_ => {}
}
DestinationHandleStatus::None
}
pub fn sign_key(&self) -> &SigningKey {
self.identity.sign_key()
}
}
impl Destination<Identity, Output, Single> {
pub fn new(identity: Identity, name: DestinationName) -> Self {
let address_hash = create_address_hash(&identity, &name);
Self {
direction: PhantomData,
r#type: PhantomData,
identity,
desc: DestinationDesc {
identity,
name,
address_hash,
},
}
}
}
impl<D: Direction> Destination<EmptyIdentity, D, Plain> {
pub fn new(identity: EmptyIdentity, name: DestinationName) -> Self {
let address_hash = create_address_hash(&identity, &name);
Self {
direction: PhantomData,
r#type: PhantomData,
identity,
desc: DestinationDesc {
identity: Default::default(),
name,
address_hash,
},
}
}
}
fn create_address_hash<I: HashIdentity>(identity: &I, name: &DestinationName) -> AddressHash {
AddressHash::new_from_hash(&Hash::new(
Hash::generator()
.chain_update(name.as_name_hash_slice())
.chain_update(identity.as_address_hash_slice())
.finalize()
.into(),
))
}
pub type SingleInputDestination = Destination<PrivateIdentity, Input, Single>;
pub type SingleOutputDestination = Destination<Identity, Output, Single>;
pub type PlainInputDestination = Destination<EmptyIdentity, Input, Plain>;
pub type PlainOutputDestination = Destination<EmptyIdentity, Output, Plain>;
#[cfg(test)]
mod tests {
use rand_core::OsRng;
use crate::buffer::OutputBuffer;
use crate::hash::Hash;
use crate::identity::PrivateIdentity;
use crate::serde::Serialize;
use super::DestinationAnnounce;
use super::DestinationName;
use super::SingleInputDestination;
#[test]
fn create_announce() {
let identity = PrivateIdentity::new_from_rand(OsRng);
let single_in_destination =
SingleInputDestination::new(identity, DestinationName::new("test", "in"));
let announce_packet = single_in_destination
.announce(OsRng, None)
.expect("valid announce packet");
println!("Announce packet {}", announce_packet);
}
#[test]
fn create_path_request_hash() {
let name = DestinationName::new("rnstransport", "path.request");
println!("PathRequest Name Hash {}", name.hash);
println!(
"PathRequest Destination Hash {}",
Hash::new_from_slice(name.as_name_hash_slice())
);
}
#[test]
fn compare_announce() {
let priv_key: [u8; 32] = [
0xf0, 0xec, 0xbb, 0xa4, 0x9e, 0x78, 0x3d, 0xee, 0x14, 0xff, 0xc6, 0xc9, 0xf1, 0xe1,
0x25, 0x1e, 0xfa, 0x7d, 0x76, 0x29, 0xe0, 0xfa, 0x32, 0x41, 0x3c, 0x5c, 0x59, 0xec,
0x2e, 0x0f, 0x6d, 0x6c,
];
let sign_priv_key: [u8; 32] = [
0xf0, 0xec, 0xbb, 0xa4, 0x9e, 0x78, 0x3d, 0xee, 0x14, 0xff, 0xc6, 0xc9, 0xf1, 0xe1,
0x25, 0x1e, 0xfa, 0x7d, 0x76, 0x29, 0xe0, 0xfa, 0x32, 0x41, 0x3c, 0x5c, 0x59, 0xec,
0x2e, 0x0f, 0x6d, 0x6c,
];
let priv_identity = PrivateIdentity::new(priv_key.into(), sign_priv_key.into());
println!("identity hash {}", priv_identity.as_identity().address_hash);
let destination = SingleInputDestination::new(
priv_identity,
DestinationName::new("example_utilities", "announcesample.fruits"),
);
println!("destination name hash {}", destination.desc.name.hash);
println!("destination hash {}", destination.desc.address_hash);
let announce = destination
.announce(OsRng, None)
.expect("valid announce packet");
let mut output_data = [0u8; 4096];
let mut buffer = OutputBuffer::new(&mut output_data);
let _ = announce.serialize(&mut buffer).expect("correct data");
println!("ANNOUNCE {}", buffer);
}
#[test]
fn check_announce() {
let priv_identity = PrivateIdentity::new_from_rand(OsRng);
let destination = SingleInputDestination::new(
priv_identity,
DestinationName::new("example_utilities", "announcesample.fruits"),
);
let announce = destination
.announce(OsRng, None)
.expect("valid announce packet");
DestinationAnnounce::validate(&announce).expect("valid announce");
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/error.rs | src/error.rs | #[derive(Debug)]
pub enum RnsError {
OutOfMemory,
InvalidArgument,
IncorrectSignature,
IncorrectHash,
CryptoError,
PacketError,
ConnectionError,
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface.rs | src/iface.rs | pub mod hdlc;
pub mod kaonic;
pub mod tcp_client;
pub mod tcp_server;
pub mod udp;
use std::sync::Arc;
use std::sync::Mutex;
use tokio::sync::mpsc;
use tokio::task;
use tokio_util::sync::CancellationToken;
use crate::hash::AddressHash;
use crate::hash::Hash;
use crate::packet::Packet;
pub type InterfaceTxSender = mpsc::Sender<TxMessage>;
pub type InterfaceTxReceiver = mpsc::Receiver<TxMessage>;
pub type InterfaceRxSender = mpsc::Sender<RxMessage>;
pub type InterfaceRxReceiver = mpsc::Receiver<RxMessage>;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum TxMessageType {
Broadcast(Option<AddressHash>),
Direct(AddressHash),
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct TxMessage {
pub tx_type: TxMessageType,
pub packet: Packet,
}
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct RxMessage {
pub address: AddressHash, // Address of source interface
pub packet: Packet, // Received packet
}
pub struct InterfaceChannel {
pub address: AddressHash,
pub rx_channel: InterfaceRxSender,
pub tx_channel: InterfaceTxReceiver,
pub stop: CancellationToken,
}
impl InterfaceChannel {
pub fn make_rx_channel(cap: usize) -> (InterfaceRxSender, InterfaceRxReceiver) {
mpsc::channel(cap)
}
pub fn make_tx_channel(cap: usize) -> (InterfaceTxSender, InterfaceTxReceiver) {
mpsc::channel(cap)
}
pub fn new(
rx_channel: InterfaceRxSender,
tx_channel: InterfaceTxReceiver,
address: AddressHash,
stop: CancellationToken,
) -> Self {
Self {
address,
rx_channel,
tx_channel,
stop,
}
}
pub fn address(&self) -> &AddressHash {
&self.address
}
pub fn split(self) -> (InterfaceRxSender, InterfaceTxReceiver) {
(self.rx_channel, self.tx_channel)
}
}
pub trait Interface {
fn mtu() -> usize;
}
struct LocalInterface {
address: AddressHash,
tx_send: InterfaceTxSender,
stop: CancellationToken,
}
pub struct InterfaceContext<T: Interface> {
pub inner: Arc<Mutex<T>>,
pub channel: InterfaceChannel,
pub cancel: CancellationToken,
}
pub struct InterfaceManager {
counter: usize,
rx_recv: Arc<tokio::sync::Mutex<InterfaceRxReceiver>>,
rx_send: InterfaceRxSender,
cancel: CancellationToken,
ifaces: Vec<LocalInterface>,
}
impl InterfaceManager {
pub fn new(rx_cap: usize) -> Self {
let (rx_send, rx_recv) = InterfaceChannel::make_rx_channel(rx_cap);
let rx_recv = Arc::new(tokio::sync::Mutex::new(rx_recv));
Self {
counter: 0,
rx_recv,
rx_send,
cancel: CancellationToken::new(),
ifaces: Vec::new(),
}
}
pub fn new_channel(&mut self, tx_cap: usize) -> InterfaceChannel {
self.counter += 1;
let counter_bytes = self.counter.to_le_bytes();
let address = AddressHash::new_from_hash(&Hash::new_from_slice(&counter_bytes[..]));
let (tx_send, tx_recv) = InterfaceChannel::make_tx_channel(tx_cap);
log::debug!("iface: create channel {}", address);
let stop = CancellationToken::new();
self.ifaces.push(LocalInterface {
address,
tx_send,
stop: stop.clone(),
});
InterfaceChannel {
rx_channel: self.rx_send.clone(),
tx_channel: tx_recv,
address,
stop,
}
}
pub fn new_context<T: Interface>(&mut self, inner: T) -> InterfaceContext<T> {
let channel = self.new_channel(1);
let inner = Arc::new(Mutex::new(inner));
let context = InterfaceContext::<T> {
inner: inner.clone(),
channel,
cancel: self.cancel.clone(),
};
context
}
pub fn spawn<T: Interface, F, R>(&mut self, inner: T, worker: F) -> AddressHash
where
F: FnOnce(InterfaceContext<T>) -> R,
R: std::future::Future<Output = ()> + Send + 'static,
R::Output: Send + 'static,
{
let context = self.new_context(inner);
let address = context.channel.address().clone();
task::spawn(worker(context));
address
}
pub fn receiver(&self) -> Arc<tokio::sync::Mutex<InterfaceRxReceiver>> {
self.rx_recv.clone()
}
pub fn cleanup(&mut self) {
self.ifaces.retain(|iface| !iface.stop.is_cancelled());
}
pub async fn send(&self, message: TxMessage) {
for iface in &self.ifaces {
let should_send = match message.tx_type {
TxMessageType::Broadcast(address) => {
let mut should_send = true;
if let Some(address) = address {
should_send = address != iface.address;
}
should_send
},
TxMessageType::Direct(address) => address == iface.address,
};
if should_send && !iface.stop.is_cancelled() {
let _ = iface.tx_send.send(message.clone()).await;
}
}
}
}
impl Drop for InterfaceManager {
fn drop(&mut self) {
self.cancel.cancel();
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/utils.rs | src/utils.rs |
pub mod cache_set;
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/hash.rs | src/hash.rs | use alloc::fmt::Write;
use core::cmp;
use core::fmt;
use crypto_common::typenum::Unsigned;
use crypto_common::OutputSizeUser;
use rand_core::CryptoRngCore;
use sha2::{Digest, Sha256};
use crate::error::RnsError;
pub const HASH_SIZE: usize = <<Sha256 as OutputSizeUser>::OutputSize as Unsigned>::USIZE;
pub const ADDRESS_HASH_SIZE: usize = 16;
pub fn create_hash(data: &[u8], out: &mut [u8]) {
out.copy_from_slice(
&Sha256::new().chain_update(data).finalize().as_slice()[..cmp::min(out.len(), HASH_SIZE)],
);
}
#[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
pub struct Hash([u8; HASH_SIZE]);
#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Copy, Clone, Hash)]
pub struct AddressHash([u8; ADDRESS_HASH_SIZE]);
impl Hash {
pub fn generator() -> Sha256 {
Sha256::new()
}
pub const fn new(hash: [u8; HASH_SIZE]) -> Self {
Self { 0: hash }
}
pub const fn new_empty() -> Self {
Self {
0: [0u8; HASH_SIZE],
}
}
pub fn new_from_slice(data: &[u8]) -> Self {
let mut hash = [0u8; HASH_SIZE];
create_hash(data, &mut hash);
Self { 0: hash }
}
pub fn new_from_rand<R: CryptoRngCore>(mut rng: R) -> Self {
let mut hash = [0u8; HASH_SIZE];
let mut data = [0u8; HASH_SIZE];
rng.fill_bytes(&mut data[..]);
create_hash(&data, &mut hash);
Self { 0: hash }
}
pub fn as_slice(&self) -> &[u8] {
&self.0
}
pub fn as_bytes(&self) -> &[u8; HASH_SIZE] {
&self.0
}
pub fn to_bytes(&self) -> [u8; HASH_SIZE] {
self.0
}
pub fn as_slice_mut(&mut self) -> &mut [u8] {
&mut self.0
}
}
impl AddressHash {
pub const fn new(hash: [u8; ADDRESS_HASH_SIZE]) -> Self {
Self { 0: hash }
}
pub fn new_from_slice(data: &[u8]) -> Self {
let mut hash = [0u8; ADDRESS_HASH_SIZE];
create_hash(data, &mut hash);
Self { 0: hash }
}
pub fn new_from_hash(hash: &Hash) -> Self {
let mut address_hash = [0u8; ADDRESS_HASH_SIZE];
address_hash.copy_from_slice(&hash.0[0..ADDRESS_HASH_SIZE]);
Self { 0: address_hash }
}
pub fn new_from_rand<R: CryptoRngCore>(rng: R) -> Self {
Self::new_from_hash(&Hash::new_from_rand(rng))
}
pub fn new_from_hex_string(hex_string: &str) -> Result<Self, RnsError> {
if hex_string.len() < ADDRESS_HASH_SIZE * 2 {
return Err(RnsError::IncorrectHash);
}
let mut bytes = [0u8; ADDRESS_HASH_SIZE];
for i in 0..ADDRESS_HASH_SIZE {
bytes[i] = u8::from_str_radix(&hex_string[i * 2..(i * 2) + 2], 16).unwrap();
}
Ok(Self { 0: bytes })
}
pub const fn new_empty() -> Self {
Self {
0: [0u8; ADDRESS_HASH_SIZE],
}
}
pub fn as_slice(&self) -> &[u8] {
&self.0[..]
}
pub fn as_mut_slice(&mut self) -> &mut [u8] {
&mut self.0[..]
}
pub const fn len(&self) -> usize {
self.0.len()
}
pub fn to_hex_string(&self) -> String {
let mut hex_string = String::with_capacity(ADDRESS_HASH_SIZE * 2);
for byte in self.0 {
write!(&mut hex_string, "{:02x}", byte).unwrap();
}
hex_string
}
}
impl From<Hash> for AddressHash {
fn from(hash: Hash) -> Self {
Self::new_from_hash(&hash)
}
}
impl fmt::Display for AddressHash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "/")?;
for data in self.0.iter() {
write!(f, "{:0>2x}", data)?;
}
write!(f, "/")?;
Ok(())
}
}
impl fmt::Display for Hash {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
for data in self.0.iter() {
write!(f, "{:0>2x}", data)?;
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use rand_core::OsRng;
use crate::hash::AddressHash;
#[test]
fn address_hex_string() {
let original_address_hash = AddressHash::new_from_rand(OsRng);
let address_hash_hex = original_address_hash.to_hex_string();
let actual_address_hash =
AddressHash::new_from_hex_string(&address_hash_hex).expect("valid hash");
assert_eq!(
actual_address_hash.as_slice(),
original_address_hash.as_slice()
);
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/transport.rs | src/transport.rs | use alloc::sync::Arc;
use announce_limits::AnnounceLimits;
use announce_table::AnnounceTable;
use link_table::LinkTable;
use packet_cache::PacketCache;
use path_table::PathTable;
use rand_core::OsRng;
use std::collections::HashMap;
use std::time::Duration;
use tokio::time;
use tokio_util::sync::CancellationToken;
use tokio::sync::broadcast;
use tokio::sync::Mutex;
use tokio::sync::MutexGuard;
use crate::destination::link::Link;
use crate::destination::link::LinkEventData;
use crate::destination::link::LinkHandleResult;
use crate::destination::link::LinkId;
use crate::destination::link::LinkStatus;
use crate::destination::DestinationAnnounce;
use crate::destination::DestinationDesc;
use crate::destination::DestinationHandleStatus;
use crate::destination::DestinationName;
use crate::destination::SingleInputDestination;
use crate::destination::SingleOutputDestination;
use crate::hash::AddressHash;
use crate::identity::PrivateIdentity;
use crate::iface::InterfaceManager;
use crate::iface::InterfaceRxReceiver;
use crate::iface::RxMessage;
use crate::iface::TxMessage;
use crate::iface::TxMessageType;
use crate::packet::DestinationType;
use crate::packet::Header;
use crate::packet::Packet;
use crate::packet::PacketContext;
use crate::packet::PacketDataBuffer;
use crate::packet::PacketType;
mod announce_limits;
mod announce_table;
mod link_table;
mod packet_cache;
mod path_table;
// TODO: Configure via features
const PACKET_TRACE: bool = false;
pub const PATHFINDER_M: usize = 128; // Max hops
const INTERVAL_LINKS_CHECK: Duration = Duration::from_secs(1);
const INTERVAL_INPUT_LINK_CLEANUP: Duration = Duration::from_secs(20);
const INTERVAL_OUTPUT_LINK_RESTART: Duration = Duration::from_secs(60);
const INTERVAL_OUTPUT_LINK_REPEAT: Duration = Duration::from_secs(6);
const INTERVAL_OUTPUT_LINK_KEEP: Duration = Duration::from_secs(5);
const INTERVAL_IFACE_CLEANUP: Duration = Duration::from_secs(10);
const INTERVAL_ANNOUNCES_RETRANSMIT: Duration = Duration::from_secs(1);
const INTERVAL_KEEP_PACKET_CACHED: Duration = Duration::from_secs(180);
const INTERVAL_PACKET_CACHE_CLEANUP: Duration = Duration::from_secs(90);
// Other constants
const KEEP_ALIVE_REQUEST: u8 = 0xFF;
const KEEP_ALIVE_RESPONSE: u8 = 0xFE;
#[derive(Clone)]
pub struct ReceivedData {
pub destination: AddressHash,
pub data: PacketDataBuffer,
}
pub struct TransportConfig {
name: String,
identity: PrivateIdentity,
broadcast: bool,
retransmit: bool,
}
#[derive(Clone)]
pub struct AnnounceEvent {
pub destination: Arc<Mutex<SingleOutputDestination>>,
pub app_data: PacketDataBuffer,
}
struct TransportHandler {
config: TransportConfig,
iface_manager: Arc<Mutex<InterfaceManager>>,
announce_tx: broadcast::Sender<AnnounceEvent>,
path_table: PathTable,
announce_table: AnnounceTable,
link_table: LinkTable,
single_in_destinations: HashMap<AddressHash, Arc<Mutex<SingleInputDestination>>>,
single_out_destinations: HashMap<AddressHash, Arc<Mutex<SingleOutputDestination>>>,
announce_limits: AnnounceLimits,
out_links: HashMap<AddressHash, Arc<Mutex<Link>>>,
in_links: HashMap<AddressHash, Arc<Mutex<Link>>>,
packet_cache: Mutex<PacketCache>,
link_in_event_tx: broadcast::Sender<LinkEventData>,
received_data_tx: broadcast::Sender<ReceivedData>,
cancel: CancellationToken,
}
pub struct Transport {
name: String,
link_in_event_tx: broadcast::Sender<LinkEventData>,
link_out_event_tx: broadcast::Sender<LinkEventData>,
received_data_tx: broadcast::Sender<ReceivedData>,
iface_messages_tx: broadcast::Sender<RxMessage>,
handler: Arc<Mutex<TransportHandler>>,
iface_manager: Arc<Mutex<InterfaceManager>>,
cancel: CancellationToken,
}
impl TransportConfig {
pub fn new<T: Into<String>>(name: T, identity: &PrivateIdentity, broadcast: bool) -> Self {
Self {
name: name.into(),
identity: identity.clone(),
broadcast,
retransmit: false,
}
}
pub fn set_retransmit(&mut self, retransmit: bool) {
self.retransmit = retransmit;
}
pub fn set_broadcast(&mut self, broadcast: bool) {
self.broadcast = broadcast;
}
}
impl Default for TransportConfig {
fn default() -> Self {
Self {
name: "tp".into(),
identity: PrivateIdentity::new_from_rand(OsRng),
broadcast: false,
retransmit: false,
}
}
}
impl Transport {
pub fn new(config: TransportConfig) -> Self {
let (announce_tx, _) = tokio::sync::broadcast::channel(16);
let (link_in_event_tx, _) = tokio::sync::broadcast::channel(16);
let (link_out_event_tx, _) = tokio::sync::broadcast::channel(16);
let (received_data_tx, _) = tokio::sync::broadcast::channel(16);
let (iface_messages_tx, _) = tokio::sync::broadcast::channel(16);
let iface_manager = InterfaceManager::new(16);
let rx_receiver = iface_manager.receiver();
let iface_manager = Arc::new(Mutex::new(iface_manager));
let cancel = CancellationToken::new();
let name = config.name.clone();
let handler = Arc::new(Mutex::new(TransportHandler {
config,
iface_manager: iface_manager.clone(),
announce_table: AnnounceTable::new(),
link_table: LinkTable::new(),
path_table: PathTable::new(),
single_in_destinations: HashMap::new(),
single_out_destinations: HashMap::new(),
announce_limits: AnnounceLimits::new(),
out_links: HashMap::new(),
in_links: HashMap::new(),
packet_cache: Mutex::new(PacketCache::new()),
announce_tx,
link_in_event_tx: link_in_event_tx.clone(),
received_data_tx: received_data_tx.clone(),
cancel: cancel.clone(),
}));
{
let handler = handler.clone();
tokio::spawn(manage_transport(
handler,
rx_receiver,
iface_messages_tx.clone(),
))
};
Self {
name,
iface_manager,
link_in_event_tx,
link_out_event_tx,
received_data_tx,
iface_messages_tx,
handler,
cancel,
}
}
pub async fn outbound(&self, packet: &Packet) {
let (packet, maybe_iface) = self
.handler
.lock()
.await
.path_table
.handle_packet(packet);
if let Some(iface) = maybe_iface {
self.send_direct(iface, packet.clone()).await;
log::trace!("Sent outbound packet to {}", iface);
}
// TODO handle other cases
}
pub fn iface_manager(&self) -> Arc<Mutex<InterfaceManager>> {
self.iface_manager.clone()
}
pub fn iface_rx(&self) -> broadcast::Receiver<RxMessage> {
self.iface_messages_tx.subscribe()
}
pub async fn recv_announces(&self) -> broadcast::Receiver<AnnounceEvent> {
self.handler.lock().await.announce_tx.subscribe()
}
pub async fn send_packet(&self, packet: Packet) {
self.handler.lock().await.send_packet(packet).await;
}
pub async fn send_announce(
&self,
destination: &Arc<Mutex<SingleInputDestination>>,
app_data: Option<&[u8]>,
) {
self.handler
.lock()
.await
.send_packet(
destination
.lock()
.await
.announce(OsRng, app_data)
.expect("valid announce packet"),
)
.await;
}
pub async fn send_broadcast(&self, packet: Packet, from_iface: Option<AddressHash>) {
self.handler
.lock()
.await
.send(TxMessage {
tx_type: TxMessageType::Broadcast(from_iface),
packet,
})
.await;
}
pub async fn send_direct(&self, addr: AddressHash, packet: Packet) {
self.handler
.lock()
.await
.send(TxMessage {
tx_type: TxMessageType::Direct(addr),
packet,
})
.await;
}
pub async fn send_to_all_out_links(&self, payload: &[u8]) {
let handler = self.handler.lock().await;
for link in handler.out_links.values() {
let link = link.lock().await;
if link.status() == LinkStatus::Active {
let packet = link.data_packet(payload);
if let Ok(packet) = packet {
handler.send_packet(packet).await;
}
}
}
}
pub async fn send_to_out_links(&self, destination: &AddressHash, payload: &[u8]) {
let mut count = 0usize;
let handler = self.handler.lock().await;
for link in handler.out_links.values() {
let link = link.lock().await;
if link.destination().address_hash == *destination
&& link.status() == LinkStatus::Active
{
let packet = link.data_packet(payload);
if let Ok(packet) = packet {
handler.send_packet(packet).await;
count += 1;
}
}
}
if count == 0 {
log::trace!(
"tp({}): no output links for {} destination",
self.name,
destination
);
}
}
pub async fn send_to_in_links(&self, destination: &AddressHash, payload: &[u8]) {
let handler = self.handler.lock().await;
let mut count = 0usize;
for link in handler.in_links.values() {
let link = link.lock().await;
if link.destination().address_hash == *destination
&& link.status() == LinkStatus::Active
{
let packet = link.data_packet(payload);
if let Ok(packet) = packet {
handler.send_packet(packet).await;
count += 1;
}
}
}
if count == 0 {
log::trace!(
"tp({}): no input links for {} destination",
self.name,
destination
);
}
}
pub async fn find_out_link(&self, link_id: &AddressHash) -> Option<Arc<Mutex<Link>>> {
self.handler.lock().await.out_links.get(link_id).cloned()
}
pub async fn find_in_link(&self, link_id: &AddressHash) -> Option<Arc<Mutex<Link>>> {
self.handler.lock().await.in_links.get(link_id).cloned()
}
pub async fn link(&self, destination: DestinationDesc) -> Arc<Mutex<Link>> {
let link = self
.handler
.lock()
.await
.out_links
.get(&destination.address_hash)
.cloned();
if let Some(link) = link {
if link.lock().await.status() != LinkStatus::Closed {
return link;
} else {
log::warn!("tp({}): link was closed", self.name);
}
}
let mut link = Link::new(destination, self.link_out_event_tx.clone());
let packet = link.request();
log::debug!(
"tp({}): create new link {} for destination {}",
self.name,
link.id(),
destination
);
let link = Arc::new(Mutex::new(link));
self.send_packet(packet).await;
self.handler
.lock()
.await
.out_links
.insert(destination.address_hash, link.clone());
link
}
pub fn out_link_events(&self) -> broadcast::Receiver<LinkEventData> {
self.link_out_event_tx.subscribe()
}
pub fn in_link_events(&self) -> broadcast::Receiver<LinkEventData> {
self.link_in_event_tx.subscribe()
}
pub fn received_data_events(&self) -> broadcast::Receiver<ReceivedData> {
self.received_data_tx.subscribe()
}
pub async fn add_destination(
&mut self,
identity: PrivateIdentity,
name: DestinationName,
) -> Arc<Mutex<SingleInputDestination>> {
let destination = SingleInputDestination::new(identity, name);
let address_hash = destination.desc.address_hash;
log::debug!("tp({}): add destination {}", self.name, address_hash);
let destination = Arc::new(Mutex::new(destination));
self.handler
.lock()
.await
.single_in_destinations
.insert(address_hash, destination.clone());
destination
}
pub async fn has_destination(&self, address: &AddressHash) -> bool {
self.handler.lock().await.has_destination(address)
}
pub fn get_handler(&self) -> Arc<Mutex<TransportHandler>> {
// direct access to handler for testing purposes
self.handler.clone()
}
}
impl Drop for Transport {
fn drop(&mut self) {
self.cancel.cancel();
}
}
impl TransportHandler {
async fn send_packet(&self, packet: Packet) {
let message = TxMessage {
tx_type: TxMessageType::Broadcast(None),
packet,
};
self.send(message).await;
}
async fn send(&self, message: TxMessage) {
self.packet_cache.lock().await.update(&message.packet);
self.iface_manager.lock().await.send(message).await;
}
fn has_destination(&self, address: &AddressHash) -> bool {
self.single_in_destinations.contains_key(address)
}
async fn filter_duplicate_packets(&self, packet: &Packet) -> bool {
let mut allow_duplicate = false;
match packet.header.packet_type {
PacketType::Announce => {
return true;
},
PacketType::Proof => {
if packet.context == PacketContext::LinkRequestProof {
if let Some(link) = self.in_links.get(&packet.destination) {
if link.lock().await.status().not_yet_active() {
allow_duplicate = true;
}
}
}
},
_ => {}
}
let is_new = self.packet_cache.lock().await.update(packet);
is_new || allow_duplicate
}
}
async fn handle_proof<'a>(packet: &Packet, mut handler: MutexGuard<'a, TransportHandler>) {
log::trace!(
"tp({}): handle proof for {}",
handler.config.name,
packet.destination
);
for link in handler.out_links.values() {
let mut link = link.lock().await;
match link.handle_packet(packet) {
LinkHandleResult::Activated => {
let rtt_packet = link.create_rtt();
handler.send_packet(rtt_packet).await;
}
_ => {}
}
}
let maybe_packet = handler.link_table.handle_proof(packet);
if let Some((packet, iface)) = maybe_packet {
handler.send(TxMessage {
tx_type: TxMessageType::Direct(iface),
packet
})
.await;
}
}
async fn send_to_next_hop<'a>(
packet: &Packet,
handler: &MutexGuard<'a, TransportHandler>,
lookup: Option<AddressHash>
) -> bool {
let (packet, maybe_iface) = handler.path_table.handle_inbound_packet(
packet,
lookup
);
if let Some(iface) = maybe_iface {
handler.send(TxMessage {
tx_type: TxMessageType::Direct(iface),
packet,
})
.await;
}
maybe_iface.is_some()
}
async fn handle_keepalive_response<'a>(
packet: &Packet,
handler: &MutexGuard<'a, TransportHandler>
) -> bool {
if packet.context == PacketContext::KeepAlive {
if packet.data.as_slice()[0] == KEEP_ALIVE_RESPONSE {
let lookup = handler.link_table.handle_keepalive(packet);
if let Some((propagated, iface)) = lookup {
handler.send(TxMessage {
tx_type: TxMessageType::Direct(iface),
packet: propagated,
})
.await;
}
return true;
}
}
false
}
async fn handle_data<'a>(packet: &Packet, handler: MutexGuard<'a, TransportHandler>) {
let mut data_handled = false;
if packet.header.destination_type == DestinationType::Link {
if let Some(link) = handler.in_links.get(&packet.destination).cloned() {
let mut link = link.lock().await;
let result = link.handle_packet(packet);
match result {
LinkHandleResult::KeepAlive => {
let packet = link.keep_alive_packet(KEEP_ALIVE_RESPONSE);
handler.send_packet(packet).await;
}
_ => {}
}
}
for link in handler.out_links.values() {
let mut link = link.lock().await;
let _ = link.handle_packet(packet);
data_handled = true;
}
if handle_keepalive_response(packet, &handler).await {
return;
}
let lookup = handler.link_table.original_destination(&packet.destination);
if lookup.is_some() {
let sent = send_to_next_hop(packet, &handler, lookup).await;
log::trace!(
"tp({}): {} packet to remote link {}",
handler.config.name,
if sent { "forwarded" } else { "could not forward" },
packet.destination
);
}
}
if packet.header.destination_type == DestinationType::Single {
if let Some(_destination) = handler
.single_in_destinations
.get(&packet.destination)
.cloned()
{
data_handled = true;
handler.received_data_tx.send(ReceivedData {
destination: packet.destination.clone(),
data: packet.data.clone(),
}).ok();
} else {
data_handled = send_to_next_hop(packet, &handler, None).await;
}
}
if data_handled {
log::trace!(
"tp({}): handle data request for {} dst={:2x} ctx={:2x}",
handler.config.name,
packet.destination,
packet.header.destination_type as u8,
packet.context as u8,
);
}
}
async fn handle_announce<'a>(
packet: &Packet,
mut handler: MutexGuard<'a, TransportHandler>,
iface: AddressHash
) {
if let Some(blocked_until) = handler.announce_limits.check(&packet.destination) {
log::info!(
"tp({}): too many announces from {}, blocked for {} seconds",
handler.config.name,
&packet.destination,
blocked_until.as_secs(),
);
return;
}
let destination_known = handler.has_destination(&packet.destination);
if let Ok(result) = DestinationAnnounce::validate(packet) {
let destination = result.0;
let app_data = result.1;
let dest_hash = destination.identity.address_hash;
let destination = Arc::new(Mutex::new(destination));
if !destination_known {
if !handler
.single_out_destinations
.contains_key(&packet.destination)
{
log::trace!(
"tp({}): new announce for {}",
handler.config.name,
packet.destination
);
handler
.single_out_destinations
.insert(packet.destination, destination.clone());
}
handler.announce_table.add(
packet,
dest_hash,
iface,
);
handler.path_table.handle_announce(
packet,
packet.transport,
iface,
);
}
let retransmit = handler.config.retransmit;
if retransmit {
let transport_id = handler.config.identity.address_hash().clone();
if let Some((recv_from, packet)) = handler.announce_table.new_packet(
&dest_hash,
&transport_id,
) {
handler.send(TxMessage {
tx_type: TxMessageType::Broadcast(Some(recv_from)),
packet
}).await;
}
}
let _ = handler.announce_tx.send(AnnounceEvent {
destination,
app_data: PacketDataBuffer::new_from_slice(&app_data),
});
}
}
async fn handle_link_request_as_destination<'a>(
destination: Arc<Mutex<SingleInputDestination>>,
packet: &Packet,
mut handler: MutexGuard<'a, TransportHandler>
) {
let mut destination = destination.lock().await;
match destination.handle_packet(packet) {
DestinationHandleStatus::LinkProof => {
let link_id = LinkId::from(packet);
if !handler.in_links.contains_key(&link_id) {
log::trace!(
"tp({}): send proof to {}",
handler.config.name,
packet.destination
);
let link = Link::new_from_request(
packet,
destination.sign_key().clone(),
destination.desc,
handler.link_in_event_tx.clone(),
);
if let Ok(mut link) = link {
handler.send_packet(link.prove()).await;
log::debug!(
"tp({}): save input link {} for destination {}",
handler.config.name,
link.id(),
link.destination().address_hash
);
handler
.in_links
.insert(*link.id(), Arc::new(Mutex::new(link)));
}
}
}
DestinationHandleStatus::None => {}
}
}
async fn handle_link_request_as_intermediate<'a>(
received_from: AddressHash,
next_hop: AddressHash,
next_hop_iface: AddressHash,
packet: &Packet,
mut handler: MutexGuard<'a, TransportHandler>
) {
handler.link_table.add(
packet,
packet.destination,
received_from,
next_hop,
next_hop_iface
);
send_to_next_hop(packet, &handler, None).await;
}
async fn handle_link_request<'a>(
packet: &Packet,
iface: AddressHash,
mut handler: MutexGuard<'a, TransportHandler>
) {
if let Some(destination) = handler
.single_in_destinations
.get(&packet.destination)
.cloned()
{
log::trace!(
"tp({}): handle link request for {}",
handler.config.name,
packet.destination
);
handle_link_request_as_destination(destination, packet, handler).await;
} else if let Some(entry) = handler.path_table.next_hop_full(&packet.destination) {
log::trace!(
"tp({}): handle link request for remote destination {}",
handler.config.name,
packet.destination
);
let (next_hop, next_iface) = entry;
handle_link_request_as_intermediate(
iface,
next_hop,
next_iface,
packet,
handler
).await;
} else {
log::trace!(
"tp({}): dropping link request to unknown destination {}",
handler.config.name,
packet.destination
);
}
}
async fn handle_check_links<'a>(mut handler: MutexGuard<'a, TransportHandler>) {
let mut links_to_remove: Vec<AddressHash> = Vec::new();
// Clean up input links
for link_entry in &handler.in_links {
let mut link = link_entry.1.lock().await;
if link.elapsed() > INTERVAL_INPUT_LINK_CLEANUP {
link.close();
links_to_remove.push(*link_entry.0);
}
}
for addr in &links_to_remove {
handler.in_links.remove(&addr);
}
links_to_remove.clear();
for link_entry in &handler.out_links {
let mut link = link_entry.1.lock().await;
if link.status() == LinkStatus::Closed {
link.close();
links_to_remove.push(*link_entry.0);
}
}
for addr in &links_to_remove {
handler.out_links.remove(&addr);
}
for link_entry in &handler.out_links {
let mut link = link_entry.1.lock().await;
if link.status() == LinkStatus::Active && link.elapsed() > INTERVAL_OUTPUT_LINK_RESTART {
link.restart();
}
if link.status() == LinkStatus::Pending {
if link.elapsed() > INTERVAL_OUTPUT_LINK_REPEAT {
log::warn!(
"tp({}): repeat link request {}",
handler.config.name,
link.id()
);
handler.send_packet(link.request()).await;
}
}
}
}
async fn handle_keep_links<'a>(handler: MutexGuard<'a, TransportHandler>) {
for link in handler.out_links.values() {
let link = link.lock().await;
if link.status() == LinkStatus::Active {
handler.send_packet(link.keep_alive_packet(KEEP_ALIVE_REQUEST)).await;
}
}
}
async fn handle_cleanup<'a>(handler: MutexGuard<'a, TransportHandler>) {
handler.iface_manager.lock().await.cleanup();
}
async fn retransmit_announces<'a>(mut handler: MutexGuard<'a, TransportHandler>) {
let transport_id = handler.config.identity.address_hash().clone();
let announces = handler.announce_table.to_retransmit(&transport_id);
if announces.is_empty() {
return;
}
for (received_from, announce) in announces {
let message = TxMessage {
tx_type: TxMessageType::Broadcast(Some(received_from)),
packet: announce,
};
handler.send(message).await;
}
}
fn create_retransmit_packet(packet: &Packet) -> Packet {
Packet {
header: Header {
ifac_flag: packet.header.ifac_flag,
header_type: packet.header.header_type,
propagation_type: packet.header.propagation_type,
destination_type: packet.header.destination_type,
packet_type: packet.header.packet_type,
hops: packet.header.hops + 1,
},
ifac: packet.ifac,
destination: packet.destination,
transport: packet.transport,
context: packet.context,
data: packet.data,
}
}
async fn manage_transport(
handler: Arc<Mutex<TransportHandler>>,
rx_receiver: Arc<Mutex<InterfaceRxReceiver>>,
iface_messages_tx: broadcast::Sender<RxMessage>,
) {
let cancel = handler.lock().await.cancel.clone();
let retransmit = handler.lock().await.config.retransmit;
let _packet_task = {
let handler = handler.clone();
let cancel = cancel.clone();
log::trace!(
"tp({}): start packet task",
handler.lock().await.config.name
);
tokio::spawn(async move {
loop {
let mut rx_receiver = rx_receiver.lock().await;
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
},
Some(message) = rx_receiver.recv() => {
let _ = iface_messages_tx.send(message);
let packet = message.packet;
let handler = handler.lock().await;
if PACKET_TRACE {
log::trace!("tp: << rx({}) = {} {}", message.address, packet, packet.hash());
}
if !handler.filter_duplicate_packets(&packet).await {
break;
}
if handler.config.broadcast && packet.header.packet_type != PacketType::Announce {
// TODO: remove seperate handling for announces in handle_announce.
// Send broadcast message expect current iface address
handler.send(TxMessage { tx_type: TxMessageType::Broadcast(Some(message.address)), packet }).await;
}
match packet.header.packet_type {
PacketType::Announce => handle_announce(
&packet,
handler,
message.address
).await,
PacketType::LinkRequest => handle_link_request(
&packet,
message.address,
handler
).await,
PacketType::Proof => handle_proof(&packet, handler).await,
PacketType::Data => handle_data(&packet, handler).await,
}
}
};
}
})
};
{
let handler = handler.clone();
let cancel = cancel.clone();
tokio::spawn(async move {
loop {
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = time::sleep(INTERVAL_LINKS_CHECK) => {
handle_check_links(handler.lock().await).await;
}
}
}
});
}
{
let handler = handler.clone();
let cancel = cancel.clone();
tokio::spawn(async move {
loop {
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = time::sleep(INTERVAL_OUTPUT_LINK_KEEP) => {
handle_keep_links(handler.lock().await).await;
}
}
}
});
}
{
let handler = handler.clone();
let cancel = cancel.clone();
tokio::spawn(async move {
loop {
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = time::sleep(INTERVAL_IFACE_CLEANUP) => {
handle_cleanup(handler.lock().await).await;
}
}
}
});
}
{
let handler = handler.clone();
let cancel = cancel.clone();
tokio::spawn(async move {
loop {
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = time::sleep(INTERVAL_PACKET_CACHE_CLEANUP) => {
let mut handler = handler.lock().await;
handler
.packet_cache
.lock()
.await
.release(INTERVAL_KEEP_PACKET_CACHED);
handler.link_table.remove_stale();
},
}
}
});
}
if retransmit {
let handler = handler.clone();
let cancel = cancel.clone();
tokio::spawn(async move {
loop {
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = time::sleep(INTERVAL_ANNOUNCES_RETRANSMIT) => {
retransmit_announces(handler.lock().await).await;
}
}
}
});
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::packet::HeaderType;
#[tokio::test]
async fn drop_duplicates() {
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | true |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/identity.rs | src/identity.rs | use alloc::fmt::Write;
use hkdf::Hkdf;
use rand_core::CryptoRngCore;
use ed25519_dalek::{ed25519::signature::Signer, Signature, SigningKey, VerifyingKey};
use sha2::{Digest, Sha256};
use x25519_dalek::{EphemeralSecret, PublicKey, SharedSecret, StaticSecret};
use crate::{
crypt::fernet::{Fernet, PlainText, Token},
error::RnsError,
hash::{AddressHash, Hash},
};
pub const PUBLIC_KEY_LENGTH: usize = ed25519_dalek::PUBLIC_KEY_LENGTH;
#[cfg(feature = "fernet-aes128")]
pub const DERIVED_KEY_LENGTH: usize = 256 / 8;
#[cfg(not(feature = "fernet-aes128"))]
pub const DERIVED_KEY_LENGTH: usize = 512 / 8;
pub trait EncryptIdentity {
fn encrypt<'a, R: CryptoRngCore + Copy>(
&self,
rng: R,
text: &[u8],
derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError>;
}
pub trait DecryptIdentity {
fn decrypt<'a, R: CryptoRngCore + Copy>(
&self,
rng: R,
data: &[u8],
derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError>;
}
pub trait HashIdentity {
fn as_address_hash_slice(&self) -> &[u8];
}
#[derive(Copy, Clone)]
pub struct Identity {
pub public_key: PublicKey,
pub verifying_key: VerifyingKey,
pub address_hash: AddressHash,
}
impl Identity {
pub fn new(public_key: PublicKey, verifying_key: VerifyingKey) -> Self {
let hash = Hash::new(
Hash::generator()
.chain_update(public_key.as_bytes())
.chain_update(verifying_key.as_bytes())
.finalize()
.into(),
);
let address_hash = AddressHash::new_from_hash(&hash);
Self {
public_key,
verifying_key,
address_hash,
}
}
pub fn new_from_slices(public_key: &[u8], verifying_key: &[u8]) -> Self {
let public_key = {
let mut key_data = [0u8; PUBLIC_KEY_LENGTH];
key_data.copy_from_slice(&public_key);
PublicKey::from(key_data)
};
let verifying_key = {
let mut key_data = [0u8; PUBLIC_KEY_LENGTH];
key_data.copy_from_slice(&verifying_key);
VerifyingKey::from_bytes(&key_data).unwrap_or_default()
};
Self::new(public_key, verifying_key)
}
pub fn new_from_hex_string(hex_string: &str) -> Result<Self, RnsError> {
if hex_string.len() < PUBLIC_KEY_LENGTH * 2 * 2 {
return Err(RnsError::IncorrectHash);
}
let mut public_key_bytes = [0u8; PUBLIC_KEY_LENGTH];
let mut verifying_key_bytes = [0u8; PUBLIC_KEY_LENGTH];
for i in 0..PUBLIC_KEY_LENGTH {
public_key_bytes[i] = u8::from_str_radix(&hex_string[i * 2..(i * 2) + 2], 16).unwrap();
verifying_key_bytes[i] = u8::from_str_radix(
&hex_string[PUBLIC_KEY_LENGTH * 2 + (i * 2)..PUBLIC_KEY_LENGTH * 2 + (i * 2) + 2],
16,
)
.unwrap();
}
Ok(Self::new_from_slices(
&public_key_bytes[..],
&verifying_key_bytes[..],
))
}
pub fn to_hex_string(&self) -> String {
let mut hex_string = String::with_capacity((PUBLIC_KEY_LENGTH * 2) * 2);
for byte in self.public_key.as_bytes() {
write!(&mut hex_string, "{:02x}", byte).unwrap();
}
for byte in self.verifying_key.as_bytes() {
write!(&mut hex_string, "{:02x}", byte).unwrap();
}
hex_string
}
pub fn public_key_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
self.public_key.as_bytes()
}
pub fn verifying_key_bytes(&self) -> &[u8; PUBLIC_KEY_LENGTH] {
self.verifying_key.as_bytes()
}
pub fn verify(&self, data: &[u8], signature: &Signature) -> Result<(), RnsError> {
self.verifying_key
.verify_strict(data, signature)
.map_err(|_| RnsError::IncorrectSignature)
}
pub fn derive_key<R: CryptoRngCore + Copy>(&self, rng: R, salt: Option<&[u8]>) -> DerivedKey {
DerivedKey::new_from_ephemeral_key(rng, &self.public_key, salt)
}
}
impl Default for Identity {
fn default() -> Self {
let empty_key = [0u8; PUBLIC_KEY_LENGTH];
Self::new(PublicKey::from(empty_key), VerifyingKey::default())
}
}
impl HashIdentity for Identity {
fn as_address_hash_slice(&self) -> &[u8] {
self.address_hash.as_slice()
}
}
impl EncryptIdentity for Identity {
fn encrypt<'a, R: CryptoRngCore + Copy>(
&self,
rng: R,
text: &[u8],
derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError> {
let mut out_offset = 0;
let ephemeral_key = EphemeralSecret::random_from_rng(rng);
{
let ephemeral_public = PublicKey::from(&ephemeral_key);
let ephemeral_public_bytes = ephemeral_public.as_bytes();
if out_buf.len() >= ephemeral_public_bytes.len() {
out_buf[..ephemeral_public_bytes.len()].copy_from_slice(ephemeral_public_bytes);
out_offset += ephemeral_public_bytes.len();
} else {
return Err(RnsError::InvalidArgument);
}
}
let token = Fernet::new_from_slices(
&derived_key.as_bytes()[..16],
&derived_key.as_bytes()[16..],
rng,
)
.encrypt(PlainText::from(text), &mut out_buf[out_offset..])?;
out_offset += token.as_bytes().len();
Ok(&out_buf[..out_offset])
}
}
pub struct EmptyIdentity;
impl HashIdentity for EmptyIdentity {
fn as_address_hash_slice(&self) -> &[u8] {
&[]
}
}
impl EncryptIdentity for EmptyIdentity {
fn encrypt<'a, R: CryptoRngCore + Copy>(
&self,
_rng: R,
text: &[u8],
_derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError> {
if text.len() > out_buf.len() {
return Err(RnsError::OutOfMemory);
}
let result = &mut out_buf[..text.len()];
result.copy_from_slice(&text);
Ok(result)
}
}
impl DecryptIdentity for EmptyIdentity {
fn decrypt<'a, R: CryptoRngCore + Copy>(
&self,
_rng: R,
data: &[u8],
_derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError> {
if data.len() > out_buf.len() {
return Err(RnsError::OutOfMemory);
}
let result = &mut out_buf[..data.len()];
result.copy_from_slice(&data);
Ok(result)
}
}
#[derive(Clone)]
pub struct PrivateIdentity {
identity: Identity,
private_key: StaticSecret,
sign_key: SigningKey,
}
impl PrivateIdentity {
pub fn new(private_key: StaticSecret, sign_key: SigningKey) -> Self {
Self {
identity: Identity::new((&private_key).into(), sign_key.verifying_key()),
private_key,
sign_key,
}
}
pub fn new_from_rand<R: CryptoRngCore>(mut rng: R) -> Self {
let sign_key = SigningKey::generate(&mut rng);
let private_key = StaticSecret::random_from_rng(rng);
Self::new(private_key, sign_key)
}
pub fn new_from_name(name: &str) -> Self {
let hash = Hash::new_from_slice(name.as_bytes());
let private_key = StaticSecret::from(hash.to_bytes());
let hash = Hash::new_from_slice(hash.as_bytes());
let sign_key = SigningKey::from_bytes(hash.as_bytes());
Self::new(private_key, sign_key)
}
pub fn new_from_hex_string(hex_string: &str) -> Result<Self, RnsError> {
if hex_string.len() < PUBLIC_KEY_LENGTH * 2 * 2 {
return Err(RnsError::IncorrectHash);
}
let mut private_key_bytes = [0u8; PUBLIC_KEY_LENGTH];
let mut sign_key_bytes = [0u8; PUBLIC_KEY_LENGTH];
for i in 0..PUBLIC_KEY_LENGTH {
private_key_bytes[i] = u8::from_str_radix(&hex_string[i * 2..(i * 2) + 2], 16).unwrap();
sign_key_bytes[i] = u8::from_str_radix(
&hex_string[PUBLIC_KEY_LENGTH * 2 + (i * 2)..PUBLIC_KEY_LENGTH * 2 + (i * 2) + 2],
16,
)
.unwrap();
}
Ok(Self::new(
StaticSecret::from(private_key_bytes),
SigningKey::from_bytes(&sign_key_bytes),
))
}
pub fn sign_key(&self) -> &SigningKey {
&self.sign_key
}
pub fn into(&self) -> &Identity {
&self.identity
}
pub fn as_identity(&self) -> &Identity {
&self.identity
}
pub fn address_hash(&self) -> &AddressHash {
&self.identity.address_hash
}
pub fn to_hex_string(&self) -> String {
let mut hex_string = String::with_capacity((PUBLIC_KEY_LENGTH * 2) * 2);
for byte in self.private_key.as_bytes() {
write!(&mut hex_string, "{:02x}", byte).unwrap();
}
for byte in self.sign_key.as_bytes() {
write!(&mut hex_string, "{:02x}", byte).unwrap();
}
hex_string
}
pub fn verify(&self, data: &[u8], signature: &Signature) -> Result<(), RnsError> {
self.identity.verify(data, signature)
}
pub fn sign(&self, data: &[u8]) -> Signature {
self.sign_key.try_sign(data).expect("signature")
}
pub fn exchange(&self, public_key: &PublicKey) -> SharedSecret {
self.private_key.diffie_hellman(public_key)
}
pub fn derive_key(&self, public_key: &PublicKey, salt: Option<&[u8]>) -> DerivedKey {
DerivedKey::new_from_private_key(&self.private_key, public_key, salt)
}
}
impl HashIdentity for PrivateIdentity {
fn as_address_hash_slice(&self) -> &[u8] {
self.identity.address_hash.as_slice()
}
}
impl EncryptIdentity for PrivateIdentity {
fn encrypt<'a, R: CryptoRngCore + Copy>(
&self,
rng: R,
text: &[u8],
derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError> {
let mut out_offset = 0;
let token = Fernet::new_from_slices(
&derived_key.as_bytes()[..DERIVED_KEY_LENGTH / 2],
&derived_key.as_bytes()[DERIVED_KEY_LENGTH / 2..],
rng,
)
.encrypt(PlainText::from(text), &mut out_buf[out_offset..])?;
out_offset += token.len();
Ok(&out_buf[..out_offset])
}
}
impl DecryptIdentity for PrivateIdentity {
fn decrypt<'a, R: CryptoRngCore + Copy>(
&self,
rng: R,
data: &[u8],
derived_key: &DerivedKey,
out_buf: &'a mut [u8],
) -> Result<&'a [u8], RnsError> {
if data.len() <= PUBLIC_KEY_LENGTH {
return Err(RnsError::InvalidArgument);
}
let fernet = Fernet::new_from_slices(
&derived_key.as_bytes()[..DERIVED_KEY_LENGTH / 2],
&derived_key.as_bytes()[DERIVED_KEY_LENGTH / 2..],
rng,
);
let token = Token::from(&data[..]);
let token = fernet.verify(token)?;
let plain_text = fernet.decrypt(token, out_buf)?;
Ok(plain_text.as_slice())
}
}
pub struct GroupIdentity {}
pub struct DerivedKey {
key: [u8; DERIVED_KEY_LENGTH],
}
impl DerivedKey {
pub fn new(shared_key: &SharedSecret, salt: Option<&[u8]>) -> Self {
let mut key = [0u8; DERIVED_KEY_LENGTH];
let _ = Hkdf::<Sha256>::new(salt, shared_key.as_bytes()).expand(&[], &mut key[..]);
Self { key }
}
pub fn new_empty() -> Self {
Self {
key: [0u8; DERIVED_KEY_LENGTH],
}
}
pub fn new_from_private_key(
priv_key: &StaticSecret,
pub_key: &PublicKey,
salt: Option<&[u8]>,
) -> Self {
Self::new(&priv_key.diffie_hellman(pub_key), salt)
}
pub fn new_from_ephemeral_key<R: CryptoRngCore + Copy>(
rng: R,
pub_key: &PublicKey,
salt: Option<&[u8]>,
) -> Self {
let secret = EphemeralSecret::random_from_rng(rng);
let shared_key = secret.diffie_hellman(pub_key);
Self::new(&shared_key, salt)
}
pub fn as_bytes(&self) -> &[u8; DERIVED_KEY_LENGTH] {
&self.key
}
pub fn as_slice(&self) -> &[u8] {
&self.key[..]
}
}
#[cfg(test)]
mod tests {
use rand_core::OsRng;
use super::PrivateIdentity;
#[test]
fn private_identity_hex_string() {
let original_id = PrivateIdentity::new_from_rand(OsRng);
let original_hex = original_id.to_hex_string();
let actual_id =
PrivateIdentity::new_from_hex_string(&original_hex).expect("valid identity");
assert_eq!(
actual_id.private_key.as_bytes(),
original_id.private_key.as_bytes()
);
assert_eq!(
actual_id.sign_key.as_bytes(),
original_id.sign_key.as_bytes()
);
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/buffer.rs | src/buffer.rs | use core::cmp::min;
use core::fmt;
use crate::error::RnsError;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub struct StaticBuffer<const N: usize> {
buffer: [u8; N],
len: usize,
}
impl<const N: usize> StaticBuffer<N> {
pub const fn new() -> Self {
Self {
buffer: [0u8; N],
len: 0,
}
}
pub fn new_from_slice(data: &[u8]) -> Self {
let mut buffer = Self::new();
buffer.safe_write(data);
buffer
}
pub fn reset(&mut self) {
self.len = 0;
}
pub fn resize(&mut self, len: usize) {
self.len = min(len, self.buffer.len());
}
pub fn len(&self) -> usize {
self.len
}
pub fn chain_write(&mut self, data: &[u8]) -> Result<&mut Self, RnsError> {
self.write(data)?;
Ok(self)
}
pub fn finalize(self) -> Self {
self
}
pub fn safe_write(&mut self, data: &[u8]) -> usize {
let data_size = data.len();
let max_size = core::cmp::min(data_size, N - self.len);
self.write(&data[..max_size]).unwrap_or(0)
}
pub fn chain_safe_write(&mut self, data: &[u8]) -> &mut Self {
self.safe_write(data);
self
}
pub fn write(&mut self, data: &[u8]) -> Result<usize, RnsError> {
let data_size = data.len();
// Nothing to write
if data_size == 0 {
return Ok(0);
}
if (self.len + data_size) > N {
return Err(RnsError::OutOfMemory);
}
self.buffer[self.len..(self.len + data_size)].copy_from_slice(data);
self.len += data_size;
Ok(data_size)
}
pub fn rotate_left(&mut self, mid: usize) -> Result<usize, RnsError> {
if mid > self.len {
return Err(RnsError::InvalidArgument);
}
self.len = self.len - mid;
self.buffer.rotate_left(mid);
Ok(self.len)
}
pub fn as_slice(&self) -> &[u8] {
&self.buffer[..self.len]
}
pub fn as_mut_slice(&mut self) -> &mut [u8] {
&mut self.buffer[..self.len]
}
pub fn accuire_buf(&mut self, len: usize) -> &mut [u8] {
self.len = len;
&mut self.buffer[..self.len]
}
pub fn accuire_buf_max(&mut self) -> &mut [u8] {
self.len = self.buffer.len();
&mut self.buffer[..self.len]
}
}
impl<const N: usize> Default for StaticBuffer<N> {
fn default() -> Self {
Self {
buffer: [0u8; N],
len: 0,
}
}
}
pub struct OutputBuffer<'a> {
buffer: &'a mut [u8],
offset: usize,
}
impl<'a> OutputBuffer<'a> {
pub fn new(buffer: &'a mut [u8]) -> Self {
Self { offset: 0, buffer }
}
pub fn write(&mut self, data: &[u8]) -> Result<usize, RnsError> {
let data_size = data.len();
// Nothing to write
if data_size == 0 {
return Ok(0);
}
if (self.offset + data_size) > self.buffer.len() {
return Err(RnsError::OutOfMemory);
}
self.buffer[self.offset..(self.offset + data_size)].copy_from_slice(data);
self.offset += data_size;
Ok(data_size)
}
pub fn write_byte(&mut self, byte: u8) -> Result<usize, RnsError> {
self.write(&[byte])
}
pub fn reset(&mut self) {
self.offset = 0;
}
pub fn is_full(&self) -> bool {
self.offset == self.buffer.len()
}
pub fn offset(&self) -> usize {
self.offset
}
pub fn as_slice(&self) -> &[u8] {
&self.buffer[..self.offset]
}
pub fn as_mut_slice(&mut self) -> &mut [u8] {
&mut self.buffer[..self.offset]
}
}
impl<'a> fmt::Display for OutputBuffer<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[ 0x")?;
for i in 0..self.offset {
write!(f, "{:0>2x}", self.buffer[i])?;
}
write!(f, " ]",)
}
}
impl<const N: usize> fmt::Display for StaticBuffer<N> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "[ 0x")?;
for i in 0..self.len {
write!(f, "{:0>2x}", self.buffer[i])?;
}
write!(f, " ]",)
}
}
pub struct InputBuffer<'a> {
buffer: &'a [u8],
offset: usize,
}
impl<'a> InputBuffer<'a> {
pub fn new(buffer: &'a [u8]) -> Self {
Self { offset: 0, buffer }
}
pub fn read(&mut self, buf: &mut [u8]) -> Result<usize, RnsError> {
let size = buf.len();
if (self.offset + size) > self.buffer.len() {
return Err(RnsError::OutOfMemory);
}
buf.copy_from_slice(&self.buffer[self.offset..(self.offset + size)]);
self.offset += size;
Ok(size)
}
pub fn read_size(&mut self, buf: &mut [u8], size: usize) -> Result<usize, RnsError> {
if (self.offset + size) > self.buffer.len() {
return Err(RnsError::OutOfMemory);
}
if buf.len() < size {
return Err(RnsError::OutOfMemory);
}
buf[..size].copy_from_slice(&self.buffer[self.offset..(self.offset + size)]);
self.offset += size;
Ok(size)
}
pub fn read_byte(&mut self) -> Result<u8, RnsError> {
let mut buf = [0u8; 1];
self.read(&mut buf)?;
Ok(buf[0])
}
pub fn read_slice(&mut self, size: usize) -> Result<&[u8], RnsError> {
if (self.offset + size) > self.buffer.len() {
return Err(RnsError::OutOfMemory);
}
let slice = &self.buffer[self.offset..self.offset + size];
self.offset += size;
Ok(slice)
}
pub fn bytes_left(&self) -> usize {
self.buffer.len() - self.offset
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/utils/cache_set.rs | src/utils/cache_set.rs | use std::collections::{HashSet, VecDeque};
pub struct CacheSet<T: std::hash::Hash + Eq + Clone> {
capacity: usize,
set: HashSet<T>,
queue: VecDeque<T>,
}
impl<T: std::hash::Hash + Eq + Clone> CacheSet<T> {
pub fn new(capacity: usize) -> Self {
Self {
capacity,
set: HashSet::new(),
queue: VecDeque::new(),
}
}
pub fn insert(&mut self, value: &T) -> bool {
if self.set.contains(&value) {
return false;
}
if self.set.len() == self.capacity {
if let Some(oldest) = self.queue.pop_front() {
self.set.remove(&oldest);
}
}
self.set.insert(value.clone());
self.queue.push_back(value.clone());
return true;
}
pub fn contains(&self, value: &T) -> bool {
self.set.contains(&value)
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/crypt/fernet.rs | src/crypt/fernet.rs | use core::cmp;
use core::convert::From;
use aes::cipher::block_padding::Pkcs7;
use aes::cipher::BlockDecryptMut;
use aes::cipher::Key;
use aes::cipher::Unsigned;
use cbc::cipher::BlockEncryptMut;
use cbc::cipher::KeyIvInit;
use crypto_common::{IvSizeUser, KeySizeUser, OutputSizeUser};
use hmac::{Hmac, Mac};
use rand_core::CryptoRngCore;
use sha2::Sha256;
use crate::error::RnsError;
#[cfg(feature = "fernet-aes128")]
type AesAlgo = aes::Aes128;
#[cfg(not(feature = "fernet-aes128"))]
type AesAlgo = aes::Aes256;
type AesCbcEnc = cbc::Encryptor<AesAlgo>;
type AesCbcDec = cbc::Decryptor<AesAlgo>;
type AesKey = Key<AesAlgo>;
type HmacSha256 = Hmac<Sha256>;
const HMAC_OUT_SIZE: usize = <<HmacSha256 as OutputSizeUser>::OutputSize as Unsigned>::USIZE;
const AES_KEY_SIZE: usize = <<AesAlgo as KeySizeUser>::KeySize as Unsigned>::USIZE;
const IV_KEY_SIZE: usize = <<AesCbcEnc as IvSizeUser>::IvSize as Unsigned>::USIZE;
const FERNET_OVERHEAD_SIZE: usize = IV_KEY_SIZE + HMAC_OUT_SIZE;
pub struct PlainText<'a>(&'a [u8]);
pub struct VerifiedToken<'a>(&'a [u8]);
pub struct Token<'a>(&'a [u8]);
// This class provides a slightly modified implementation of the Fernet spec
// found at: https://github.com/fernet/spec/blob/master/Spec.md
//
// According to the spec, a Fernet token includes a one byte VERSION and
// eight byte TIMESTAMP field at the start of each token. These fields are
// not relevant to Reticulum. They are therefore stripped from this
// implementation, since they incur overhead and leak initiator metadata.
pub struct Fernet<R: CryptoRngCore> {
rng: R,
sign_key: [u8; AES_KEY_SIZE],
enc_key: AesKey,
}
impl<'a> PlainText<'a> {
pub fn as_slice(&self) -> &'a [u8] {
self.0
}
}
impl<'a> From<&'a str> for PlainText<'a> {
fn from(item: &'a str) -> Self {
Self { 0: item.as_bytes() }
}
}
impl<'a> From<&'a [u8]> for PlainText<'a> {
fn from(item: &'a [u8]) -> Self {
Self { 0: item }
}
}
impl<'a> Token<'a> {
pub fn as_bytes(&self) -> &'a [u8] {
self.0
}
pub fn len(&self) -> usize {
self.0.len()
}
}
impl<'a> From<&'a [u8]> for Token<'a> {
fn from(item: &'a [u8]) -> Self {
Self { 0: item }
}
}
impl<R: CryptoRngCore + Copy> Fernet<R> {
pub fn new(sign_key: [u8; AES_KEY_SIZE], enc_key: AesKey, rng: R) -> Self {
Self {
rng,
sign_key,
enc_key,
}
}
pub fn new_from_slices(sign_key: &[u8], enc_key: &[u8], rng: R) -> Self {
let mut sign_key_bytes = [0u8; AES_KEY_SIZE];
sign_key_bytes[..cmp::min(AES_KEY_SIZE, sign_key.len())].copy_from_slice(sign_key);
let mut enc_key_bytes = [0u8; AES_KEY_SIZE];
enc_key_bytes[..cmp::min(AES_KEY_SIZE, enc_key.len())].copy_from_slice(enc_key);
Self {
rng,
sign_key: sign_key_bytes.into(),
enc_key: enc_key_bytes.into(),
}
}
pub fn new_rand(mut rng: R) -> Self {
let mut sign_key = [0u8; AES_KEY_SIZE];
rng.fill_bytes(&mut sign_key);
let enc_key = AesCbcEnc::generate_key(&mut rng);
Self {
rng,
sign_key,
enc_key,
}
}
pub fn encrypt<'a>(
&self,
text: PlainText,
out_buf: &'a mut [u8],
) -> Result<Token<'a>, RnsError> {
if out_buf.len() <= FERNET_OVERHEAD_SIZE {
return Err(RnsError::InvalidArgument);
}
let mut out_len = 0;
// Generate random IV
let iv = AesCbcEnc::generate_iv(self.rng);
out_buf[..iv.len()].copy_from_slice(iv.as_slice());
out_len += iv.len();
let chiper_len = AesCbcEnc::new(&self.enc_key, &iv)
.encrypt_padded_b2b_mut::<Pkcs7>(text.0, &mut out_buf[out_len..])
.unwrap()
.len();
out_len += chiper_len;
let mut hmac = <HmacSha256 as Mac>::new_from_slice(&self.sign_key)
.map_err(|_| RnsError::InvalidArgument)?;
hmac.update(&out_buf[..out_len]);
let tag = hmac.finalize().into_bytes();
out_buf[out_len..out_len + tag.len()].copy_from_slice(tag.as_slice());
out_len += tag.len();
Ok(Token {
0: &out_buf[..out_len],
})
}
pub fn verify<'a>(&self, token: Token<'a>) -> Result<VerifiedToken<'a>, RnsError> {
let token_data = token.0;
if token_data.len() <= FERNET_OVERHEAD_SIZE {
return Err(RnsError::InvalidArgument);
}
let expected_tag = &token_data[token_data.len() - HMAC_OUT_SIZE..];
let mut hmac = <HmacSha256 as Mac>::new_from_slice(&self.sign_key)
.map_err(|_| RnsError::InvalidArgument)?;
hmac.update(&token_data[..token_data.len() - HMAC_OUT_SIZE]);
let actual_tag = hmac.finalize().into_bytes();
let valid = expected_tag
.iter()
.zip(actual_tag.as_slice())
.map(|(x, y)| x.cmp(y))
.find(|&ord| ord != cmp::Ordering::Equal)
.unwrap_or(actual_tag.len().cmp(&expected_tag.len()))
== cmp::Ordering::Equal;
if valid {
Ok(VerifiedToken { 0: token_data })
} else {
Err(RnsError::IncorrectSignature)
}
}
pub fn decrypt<'a, 'b>(
&self,
token: VerifiedToken<'a>,
out_buf: &'b mut [u8],
) -> Result<PlainText<'b>, RnsError> {
let token_data = token.0;
if token_data.len() <= FERNET_OVERHEAD_SIZE {
return Err(RnsError::InvalidArgument);
}
let tag_start_index = token_data.len() - HMAC_OUT_SIZE;
let iv: [u8; IV_KEY_SIZE] = token_data[..IV_KEY_SIZE].try_into().unwrap();
let ciphertext = &token_data[IV_KEY_SIZE..tag_start_index];
let msg = AesCbcDec::new(&self.enc_key, &iv.into())
.decrypt_padded_b2b_mut::<Pkcs7>(ciphertext, out_buf)
.map_err(|_| RnsError::CryptoError)?;
return Ok(PlainText { 0: msg });
}
}
#[cfg(test)]
mod tests {
use crate::crypt::fernet::Fernet;
use core::str;
use rand_core::OsRng;
#[test]
fn encrypt_then_decrypt() {
const BUF_SIZE: usize = 4096;
let fernet = Fernet::new_rand(OsRng);
let out_msg: &str = "#FERNET_TEST_MESSAGE#";
let mut out_buf = [0u8; BUF_SIZE];
let token = fernet
.encrypt(out_msg.into(), &mut out_buf[..])
.expect("cipher token");
let token = fernet.verify(token).expect("verified token");
let mut in_buf = [0u8; BUF_SIZE];
let in_msg = str::from_utf8(fernet.decrypt(token, &mut in_buf).expect("decoded token").0)
.expect("valid string");
assert_eq!(in_msg, out_msg);
}
#[test]
fn small_buffer() {
let fernet = Fernet::new_rand(OsRng);
let test_msg: &str = "#FERNET_TEST_MESSAGE#";
let mut out_buf = [0u8; 12];
assert!(fernet.encrypt(test_msg.into(), &mut out_buf[..]).is_err());
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/transport/announce_table.rs | src/transport/announce_table.rs | use alloc::vec::Vec;
use std::collections::HashMap;
use tokio::time::{Duration, Instant};
use crate::hash::AddressHash;
use crate::packet::{
DestinationType, Header, HeaderType, IfacFlag,
Packet, PacketContext, PacketType, PropagationType
};
pub struct AnnounceEntry {
pub packet: Packet,
pub timestamp: Instant,
pub timeout: Instant,
pub received_from: AddressHash,
pub retries: u8,
pub hops: u8,
}
impl AnnounceEntry {
pub fn retransmit(
&mut self,
transport_id: &AddressHash,
) -> Option<(AddressHash, Packet)> {
if self.retries == 0 || Instant::now() >= self.timeout {
return None;
}
self.retries = self.retries.saturating_sub(1);
let new_packet = Packet {
header: Header {
ifac_flag: IfacFlag::Open,
header_type: HeaderType::Type2,
propagation_type: PropagationType::Broadcast,
destination_type: DestinationType::Single,
packet_type: PacketType::Announce,
hops: self.hops,
},
ifac: None,
destination: self.packet.destination, // TODO
transport: Some(transport_id.clone()),
context: PacketContext::None,
data: self.packet.data,
};
Some((self.received_from, new_packet))
}
}
pub struct AnnounceTable {
map: HashMap<AddressHash, AnnounceEntry>,
stale: Vec<AddressHash>,
}
impl AnnounceTable {
pub fn new() -> Self {
Self {
map: HashMap::new(),
stale: Vec::new(),
}
}
pub fn add(
&mut self,
announce: &Packet,
destination: AddressHash,
received_from: AddressHash
) {
if self.map.contains_key(&destination) {
return;
}
let now = Instant::now();
let hops = announce.header.hops + 1;
let entry = AnnounceEntry {
packet: announce.clone(),
timestamp: now,
timeout: now + Duration::from_secs(60), // TODO
received_from,
retries: 20, // TODO
hops,
};
self.map.insert(destination, entry);
}
pub fn clear(&mut self) {
self.map.clear();
self.stale.clear();
}
pub fn stale(&mut self, destination: &AddressHash) {
self.map.remove(destination);
}
pub fn new_packet(
&mut self,
dest_hash: &AddressHash,
transport_id: &AddressHash,
) -> Option<(AddressHash, Packet)> {
// temporary hack
self.map.get_mut(dest_hash).map_or(None, |e| e.retransmit(transport_id))
}
pub fn to_retransmit(
&mut self,
transport_id: &AddressHash,
) -> Vec<(AddressHash, Packet)> {
let mut packets = vec![];
let mut completed = vec![];
for (destination, ref mut entry) in &mut self.map {
if let Some(pair) = entry.retransmit(transport_id) {
packets.push(pair);
} else {
completed.push(destination.clone());
}
}
if !(packets.is_empty() && completed.is_empty()) {
log::trace!(
"Announce cache: {} to retransmit, {} dropped",
packets.len(),
completed.len(),
);
}
for destination in completed {
self.map.remove(&destination);
}
packets
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/transport/link_table.rs | src/transport/link_table.rs | use std::collections::HashMap;
use tokio::time::{Duration, Instant};
use crate::destination::link::LinkId;
use crate::hash::AddressHash;
use crate::packet::{Header, HeaderType, IfacFlag, Packet};
pub struct LinkEntry {
pub timestamp: Instant,
pub proof_timeout: Instant,
pub next_hop: AddressHash,
pub next_hop_iface: AddressHash,
pub received_from: AddressHash,
pub original_destination: AddressHash,
pub taken_hops: u8,
pub remaining_hops: u8,
pub validated: bool,
}
fn send_backwards(packet: &Packet, entry: &LinkEntry) -> (Packet, AddressHash) {
let propagated = Packet {
header: Header {
ifac_flag: IfacFlag::Authenticated,
header_type: HeaderType::Type2,
propagation_type: packet.header.propagation_type,
destination_type: packet.header.destination_type,
packet_type: packet.header.packet_type,
hops: packet.header.hops + 1,
},
ifac: None,
destination: packet.destination,
transport: Some(entry.next_hop),
context: packet.context,
data: packet.data,
};
(propagated, entry.received_from)
}
pub struct LinkTable(HashMap<LinkId, LinkEntry>);
impl LinkTable {
pub fn new() -> Self {
Self(HashMap::new())
}
pub fn add(
&mut self,
link_request: &Packet,
destination: AddressHash,
received_from: AddressHash,
next_hop: AddressHash,
iface: AddressHash,
) {
let link_id = LinkId::from(link_request);
if self.0.contains_key(&link_id) {
return;
}
let now = Instant::now();
let taken_hops = link_request.header.hops + 1;
let entry = LinkEntry {
timestamp: now,
proof_timeout: now + Duration::from_secs(600), // TODO
next_hop: next_hop,
next_hop_iface: iface,
received_from,
original_destination: destination,
taken_hops,
remaining_hops: 0,
validated: false
};
self.0.insert(link_id, entry);
}
pub fn original_destination(&self, link_id: &LinkId) -> Option<AddressHash> {
self.0.get(&link_id).filter(|e| e.validated).map(|e| e.original_destination)
}
pub fn handle_keepalive(&self, packet: &Packet) -> Option<(Packet, AddressHash)> {
self.0.get(&packet.destination).map(|entry| send_backwards(packet, entry))
}
pub fn handle_proof(&mut self, proof: &Packet) -> Option<(Packet, AddressHash)> {
match self.0.get_mut(&proof.destination) {
Some(entry) => {
entry.remaining_hops = proof.header.hops;
entry.validated = true;
Some(send_backwards(proof, entry))
},
None => None
}
}
pub fn remove_stale(&mut self) {
let mut stale = vec![];
let now = Instant::now();
for (link_id, entry) in &self.0 {
if entry.validated {
// TODO remove active timed out links
} else {
if entry.proof_timeout <= now {
stale.push(link_id.clone());
}
}
}
for link_id in stale {
self.0.remove(&link_id);
}
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/transport/announce_limits.rs | src/transport/announce_limits.rs | use alloc::collections::BTreeMap;
use tokio::time::Duration;
use tokio::time::Instant;
use crate::hash::AddressHash;
pub struct AnnounceRateLimit {
pub target: Duration,
pub grace: u32,
pub penalty: Option<Duration>
}
impl Default for AnnounceRateLimit {
fn default() -> Self {
Self {
target: Duration::from_secs(3600),
grace: 10,
penalty: Some(Duration::from_secs(7200)),
}
}
}
struct AnnounceLimitEntry {
rate_limit: Option<AnnounceRateLimit>,
violations: u32,
last_announce: Instant,
blocked_until: Instant,
}
impl AnnounceLimitEntry {
pub fn new(rate_limit: Option<AnnounceRateLimit>) -> Self {
Self {
rate_limit,
violations: 0,
last_announce: Instant::now(),
blocked_until: Instant::now(),
}
}
pub fn handle_announce(&mut self) -> Option<Duration> {
let mut is_blocked = false;
let now = Instant::now();
if let Some(ref rate_limit) = self.rate_limit {
if now < self.blocked_until {
self.blocked_until = now + rate_limit.target;
if let Some(penalty) = rate_limit.penalty {
self.blocked_until += penalty;
}
is_blocked = true;
} else {
let next_allowed = self.last_announce + rate_limit.target;
if now < next_allowed {
self.violations += 1;
if self.violations >= rate_limit.grace {
self.violations = 0;
self.blocked_until = now + rate_limit.target;
is_blocked = true;
}
}
}
}
self.last_announce = now;
if is_blocked {
Some(self.blocked_until - now)
} else {
None
}
}
}
pub struct AnnounceLimits {
limits: BTreeMap<AddressHash, AnnounceLimitEntry>
}
impl AnnounceLimits {
pub fn new() -> Self {
Self { limits: BTreeMap::new() }
}
pub fn check(&mut self, destination: &AddressHash) -> Option<Duration> {
if let Some(entry) = self.limits.get_mut(destination) {
return entry.handle_announce();
}
self.limits.insert(
destination.clone(),
AnnounceLimitEntry::new(Default::default())
);
None
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/transport/path_table.rs | src/transport/path_table.rs | use std::{collections::HashMap, time::Instant};
use crate::{
hash::{AddressHash, Hash},
packet::{DestinationType, Header, HeaderType, IfacFlag, Packet, PacketType},
};
pub struct PathEntry {
pub timestamp: Instant,
pub received_from: AddressHash,
pub hops: u8,
pub iface: AddressHash,
pub packet_hash: Hash,
}
pub struct PathTable {
map: HashMap<AddressHash, PathEntry>,
}
impl PathTable {
pub fn new() -> Self {
Self {
map: HashMap::new(),
}
}
pub fn next_hop_full(&self, destination: &AddressHash) -> Option<(AddressHash, AddressHash)> {
self.map.get(destination).map(|entry| (entry.received_from, entry.iface))
}
pub fn next_hop_iface(&self, destination: &AddressHash) -> Option<AddressHash> {
self.map.get(destination).map(|entry| entry.iface)
}
pub fn next_hop(&self, destination: &AddressHash) -> Option<AddressHash> {
self.map.get(destination).map(|entry| entry.received_from)
}
pub fn handle_announce(
&mut self,
announce: &Packet,
transport_id: Option<AddressHash>,
iface: AddressHash,
) {
let hops = announce.header.hops + 1;
if let Some(existing_entry) = self.map.get(&announce.destination) {
if hops >= existing_entry.hops {
return;
}
}
let received_from = transport_id.unwrap_or(announce.destination);
let new_entry = PathEntry {
timestamp: Instant::now(),
received_from,
hops,
iface,
packet_hash: announce.hash(),
};
self.map.insert(announce.destination, new_entry);
log::info!(
"{} is now reachable over {} hops through {}",
announce.destination,
hops,
received_from,
);
}
pub fn handle_inbound_packet(
&self,
original_packet: &Packet,
lookup: Option<AddressHash>,
) -> (Packet, Option<AddressHash>) {
let lookup = lookup.unwrap_or(original_packet.destination);
let entry = match self.map.get(&lookup) {
Some(entry) => entry,
None => return (*original_packet, None),
};
(
Packet {
header: Header {
ifac_flag: IfacFlag::Authenticated,
header_type: HeaderType::Type2,
propagation_type: original_packet.header.propagation_type,
destination_type: original_packet.header.destination_type,
packet_type: original_packet.header.packet_type,
hops: original_packet.header.hops + 1,
},
ifac: None,
destination: original_packet.destination,
transport: Some(entry.received_from),
context: original_packet.context,
data: original_packet.data,
},
Some(entry.iface),
)
}
pub fn refresh(&mut self, destination: &AddressHash) {
if let Some(entry) = self.map.get_mut(destination) {
entry.timestamp = Instant::now();
}
}
pub fn handle_packet(&mut self, original_packet: &Packet) -> (Packet, Option<AddressHash>) {
if original_packet.header.header_type == HeaderType::Type2 {
return (*original_packet, None);
}
if original_packet.header.packet_type == PacketType::Announce {
return (*original_packet, None);
}
if original_packet.header.destination_type == DestinationType::Plain
|| original_packet.header.destination_type == DestinationType::Group
{
return (*original_packet, None);
}
let entry = match self.map.get(&original_packet.destination) {
Some(entry) => entry,
None => return (*original_packet, None),
};
(
Packet {
header: Header {
ifac_flag: IfacFlag::Authenticated,
header_type: HeaderType::Type2,
propagation_type: original_packet.header.propagation_type,
destination_type: original_packet.header.destination_type,
packet_type: original_packet.header.packet_type,
hops: original_packet.header.hops,
},
ifac: original_packet.ifac,
destination: original_packet.destination,
transport: Some(entry.received_from),
context: original_packet.context,
data: original_packet.data,
},
Some(entry.iface),
)
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/transport/packet_cache.rs | src/transport/packet_cache.rs | use std::{
cmp::min,
collections::HashMap,
time::{Duration, Instant},
};
use crate::{hash::Hash, packet::Packet};
pub struct PacketTrack {
pub time: Instant,
pub min_hops: u8,
}
pub struct PacketCache {
map: HashMap<Hash, PacketTrack>,
remove_cache: Vec<Hash>,
}
impl PacketCache {
pub fn new() -> Self {
Self {
map: HashMap::new(),
remove_cache: Vec::new(),
}
}
pub fn release(&mut self, duration: Duration) {
for entry in &self.map {
if entry.1.time.elapsed() > duration {
self.remove_cache.push(*entry.0);
}
}
for hash in &self.remove_cache {
self.map.remove(hash);
}
self.remove_cache.clear();
}
pub fn update(&mut self, packet: &Packet) -> bool {
let hash = packet.hash();
let mut is_new_packet = false;
let track = self.map.get_mut(&hash);
if let Some(track) = track {
track.time = Instant::now();
track.min_hops = min(packet.header.hops, track.min_hops);
} else {
is_new_packet = true;
self.map.insert(
hash,
PacketTrack {
time: Instant::now(),
min_hops: packet.header.hops,
},
);
}
is_new_packet
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface/hdlc.rs | src/iface/hdlc.rs | use crate::{buffer::OutputBuffer, error::RnsError};
const HDLC_FRAME_FLAG: u8 = 0x7e;
const HDLC_ESCAPE_BYTE: u8 = 0x7d;
const HDLC_ESCAPE_MASK: u8 = 0b00100000;
pub struct Hdlc {}
impl Hdlc {
pub fn encode(data: &[u8], buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
buffer.write_byte(HDLC_FRAME_FLAG)?;
for &byte in data {
match byte {
HDLC_FRAME_FLAG | HDLC_ESCAPE_BYTE => {
buffer.write(&[HDLC_ESCAPE_BYTE, byte ^ HDLC_ESCAPE_MASK])?;
}
_ => {
buffer.write_byte(byte)?;
}
}
}
buffer.write_byte(HDLC_FRAME_FLAG)?;
Ok(buffer.offset())
}
/// Returns start and end index of HDLC frame or None
pub fn find(data: &[u8]) -> Option<(usize, usize)> {
let mut start = false;
let mut end = false;
let mut start_index: usize = 0;
let mut end_index: usize = 0;
for i in 0..data.len() {
// Search for HDLC frame flags only
if data[i] != HDLC_FRAME_FLAG {
continue;
}
// Find start of HDLC frame
if !start {
start_index = i;
start = true;
}
// Find end of HDLC frame
else if !end {
end_index = i;
end = true;
}
if start && end {
return Option::Some((start_index, end_index));
}
}
return Option::None;
}
pub fn decode(data: &[u8], output: &mut OutputBuffer) -> Result<usize, RnsError> {
let mut started = false;
let mut finished = false;
let mut escape = false;
for &byte in data {
if escape {
escape = false;
output.write_byte(byte ^ HDLC_ESCAPE_MASK)?;
} else {
match byte {
HDLC_FRAME_FLAG => {
if started {
finished = true;
break;
}
started = true;
}
HDLC_ESCAPE_BYTE => {
escape = true;
}
_ => {
output.write_byte(byte)?;
}
}
}
}
if !finished {
return Err(RnsError::OutOfMemory);
}
Ok(output.offset())
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface/kaonic.rs | src/iface/kaonic.rs | use kaonic_grpc::proto::ConfigurationRequest;
pub mod kaonic_grpc;
pub const RADIO_FRAME_MAX_SIZE: usize = 2048usize;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum RadioModule {
RadioA = 0x00,
RadioB = 0x01,
}
pub type RadioConfig = ConfigurationRequest;
impl RadioConfig {
pub fn new_for_module(module: RadioModule) -> Self {
Self {
module: module as i32,
freq: 869535,
channel: 11,
channel_spacing: 200,
tx_power: 10,
phy_config: Some(kaonic_grpc::proto::configuration_request::PhyConfig::Ofdm(
kaonic_grpc::proto::RadioPhyConfigOfdm { mcs: 6, opt: 0 },
)),
}
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface/tcp_client.rs | src/iface/tcp_client.rs | use std::sync::Arc;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;
use tokio_util::sync::CancellationToken;
use crate::buffer::{InputBuffer, OutputBuffer};
use crate::error::RnsError;
use crate::iface::RxMessage;
use crate::packet::Packet;
use crate::serde::Serialize;
use tokio::io::AsyncReadExt;
use alloc::string::String;
use super::hdlc::Hdlc;
use super::{Interface, InterfaceContext};
// TODO: Configure via features
const PACKET_TRACE: bool = false;
pub struct TcpClient {
addr: String,
stream: Option<TcpStream>,
}
impl TcpClient {
pub fn new<T: Into<String>>(addr: T) -> Self {
Self {
addr: addr.into(),
stream: None,
}
}
pub fn new_from_stream<T: Into<String>>(addr: T, stream: TcpStream) -> Self {
Self {
addr: addr.into(),
stream: Some(stream),
}
}
pub async fn spawn(context: InterfaceContext<TcpClient>) {
let iface_stop = context.channel.stop.clone();
let addr = { context.inner.lock().unwrap().addr.clone() };
let iface_address = context.channel.address;
let mut stream = { context.inner.lock().unwrap().stream.take() };
let (rx_channel, tx_channel) = context.channel.split();
let tx_channel = Arc::new(tokio::sync::Mutex::new(tx_channel));
let mut running = true;
loop {
if !running || context.cancel.is_cancelled() {
break;
}
let stream = {
match stream.take() {
Some(stream) => {
running = false;
Ok(stream)
}
None => TcpStream::connect(addr.clone())
.await
.map_err(|_| RnsError::ConnectionError),
}
};
if let Err(_) = stream {
log::info!("tcp_client: couldn't connect to <{}>", addr);
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
continue;
}
let cancel = context.cancel.clone();
let stop = CancellationToken::new();
let stream = stream.unwrap();
let (read_stream, write_stream) = stream.into_split();
log::info!("tcp_client connected to <{}>", addr);
const BUFFER_SIZE: usize = core::mem::size_of::<Packet>() * 2;
// Start receive task
let rx_task = {
let cancel = cancel.clone();
let stop = stop.clone();
let mut stream = read_stream;
let rx_channel = rx_channel.clone();
tokio::spawn(async move {
let mut hdlc_rx_buffer = [0u8; BUFFER_SIZE];
let mut rx_buffer = [0u8; BUFFER_SIZE + (BUFFER_SIZE / 2)];
let mut tcp_buffer = [0u8; (BUFFER_SIZE * 16)];
loop {
tokio::select! {
_ = cancel.cancelled() => {
break;
}
_ = stop.cancelled() => {
break;
}
result = stream.read(&mut tcp_buffer[..]) => {
match result {
Ok(0) => {
log::warn!("tcp_client: connection closed");
stop.cancel();
break;
}
Ok(n) => {
// TCP stream may contain several or partial HDLC frames
for i in 0..n {
// Push new byte from the end of buffer
rx_buffer[BUFFER_SIZE-1] = tcp_buffer[i];
// Check if it is contains a HDLC frame
let frame = Hdlc::find(&rx_buffer[..]);
if let Some(frame) = frame {
// Decode HDLC frame and deserialize packet
let frame_buffer = &mut rx_buffer[frame.0..frame.1+1];
let mut output = OutputBuffer::new(&mut hdlc_rx_buffer[..]);
if let Ok(_) = Hdlc::decode(frame_buffer, &mut output) {
if let Ok(packet) = Packet::deserialize(&mut InputBuffer::new(output.as_slice())) {
if PACKET_TRACE {
log::trace!("tcp_client: rx << ({}) {}", iface_address, packet);
}
let _ = rx_channel.send(RxMessage { address: iface_address, packet }).await;
} else {
log::warn!("tcp_client: couldn't decode packet");
}
} else {
log::warn!("tcp_client: couldn't decode hdlc frame");
}
// Remove current HDLC frame data
frame_buffer.fill(0);
} else {
// Move data left
rx_buffer.copy_within(1.., 0);
}
}
}
Err(e) => {
log::warn!("tcp_client: connection error {}", e);
break;
}
}
},
};
}
})
};
// Start transmit task
let tx_task = {
let cancel = cancel.clone();
let tx_channel = tx_channel.clone();
let mut stream = write_stream;
tokio::spawn(async move {
loop {
if stop.is_cancelled() {
break;
}
let mut hdlc_tx_buffer = [0u8; BUFFER_SIZE];
let mut tx_buffer = [0u8; BUFFER_SIZE];
let mut tx_channel = tx_channel.lock().await;
tokio::select! {
_ = cancel.cancelled() => {
break;
}
_ = stop.cancelled() => {
break;
}
Some(message) = tx_channel.recv() => {
let packet = message.packet;
if PACKET_TRACE {
log::trace!("tcp_client: tx >> ({}) {}", iface_address, packet);
}
let mut output = OutputBuffer::new(&mut tx_buffer);
if let Ok(_) = packet.serialize(&mut output) {
let mut hdlc_output = OutputBuffer::new(&mut hdlc_tx_buffer[..]);
if let Ok(_) = Hdlc::encode(output.as_slice(), &mut hdlc_output) {
let _ = stream.write_all(hdlc_output.as_slice()).await;
let _ = stream.flush().await;
}
}
}
};
}
})
};
tx_task.await.unwrap();
rx_task.await.unwrap();
log::info!("tcp_client: disconnected from <{}>", addr);
}
iface_stop.cancel();
}
}
impl Interface for TcpClient {
fn mtu() -> usize {
2048
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface/udp.rs | src/iface/udp.rs | use std::sync::Arc;
use tokio::net::UdpSocket;
use tokio_util::sync::CancellationToken;
use crate::buffer::{InputBuffer, OutputBuffer};
use crate::error::RnsError;
use crate::iface::RxMessage;
use crate::packet::Packet;
use crate::serde::Serialize;
use super::{Interface, InterfaceContext};
// TODO: Configure via features
const PACKET_TRACE: bool = true;
pub struct UdpInterface {
bind_addr: String,
forward_addr: Option<String>
}
impl UdpInterface {
pub fn new<T: Into<String>>(
bind_addr: T,
forward_addr: Option<T>
) -> Self {
Self {
bind_addr: bind_addr.into(),
forward_addr: forward_addr.map(Into::into),
}
}
pub async fn spawn(context: InterfaceContext<Self>) {
let bind_addr = { context.inner.lock().unwrap().bind_addr.clone() };
let forward_addr = { context.inner.lock().unwrap().forward_addr.clone() };
let iface_address = context.channel.address;
let (rx_channel, tx_channel) = context.channel.split();
let tx_channel = Arc::new(tokio::sync::Mutex::new(tx_channel));
loop {
if context.cancel.is_cancelled() {
break;
}
let socket = UdpSocket::bind(bind_addr.clone())
.await
.map_err(|_| RnsError::ConnectionError);
if let Err(_) = socket {
log::info!("udp_interface: couldn't bind to <{}>", bind_addr);
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
continue;
}
let cancel = context.cancel.clone();
let stop = CancellationToken::new();
let socket = socket.unwrap();
let read_socket = Arc::new(socket);
let write_socket = read_socket.clone();
log::info!("udp_interface bound to <{}>", bind_addr);
const BUFFER_SIZE: usize = core::mem::size_of::<Packet>() * 3;
// Start receive task
let rx_task = {
let cancel = cancel.clone();
let stop = stop.clone();
let socket = read_socket;
let rx_channel = rx_channel.clone();
tokio::spawn(async move {
loop {
let mut rx_buffer = [0u8; BUFFER_SIZE];
tokio::select! {
_ = cancel.cancelled() => {
break;
}
_ = stop.cancelled() => {
break;
}
result = socket.recv_from(&mut rx_buffer) => {
match result {
Ok((0, _)) => {
log::warn!("udp_interface: connection closed");
stop.cancel();
break;
}
Ok((n, _in_addr)) => {
if let Ok(packet) = Packet::deserialize(&mut InputBuffer::new(&rx_buffer[..n])) {
if PACKET_TRACE {
log::trace!("udp_interface: rx << ({}) {}", iface_address, packet);
}
let _ = rx_channel.send(RxMessage { address: iface_address, packet }).await;
} else {
log::warn!("udp_interface: couldn't decode packet");
}
}
Err(e) => {
log::warn!("udp_interface: connection error {}", e);
break;
}
}
},
};
}
})
};
if let Some(forward_addr) = forward_addr.clone() {
// Start transmit task
let tx_task = {
let cancel = cancel.clone();
let tx_channel = tx_channel.clone();
let socket = write_socket;
tokio::spawn(async move {
loop {
if stop.is_cancelled() {
break;
}
let mut tx_buffer = [0u8; BUFFER_SIZE];
let mut tx_channel = tx_channel.lock().await;
tokio::select! {
_ = cancel.cancelled() => {
break;
}
_ = stop.cancelled() => {
break;
}
Some(message) = tx_channel.recv() => {
let packet = message.packet;
if PACKET_TRACE {
log::trace!("udp_interface: tx >> ({}) {}", iface_address, packet);
}
let mut output = OutputBuffer::new(&mut tx_buffer);
if let Ok(_) = packet.serialize(&mut output) {
let _ = socket.send_to(output.as_slice(), &forward_addr).await;
}
}
};
}
})
};
tx_task.await.unwrap();
}
rx_task.await.unwrap();
log::info!("udp_interface <{}>: closed", bind_addr);
}
}
}
impl Interface for UdpInterface {
fn mtu() -> usize {
2048
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface/tcp_server.rs | src/iface/tcp_server.rs | use alloc::string::String;
use std::sync::Arc;
use tokio::net::TcpListener;
use crate::error::RnsError;
use super::tcp_client::TcpClient;
use super::{Interface, InterfaceContext, InterfaceManager};
pub struct TcpServer {
addr: String,
iface_manager: Arc<tokio::sync::Mutex<InterfaceManager>>,
}
impl TcpServer {
pub fn new<T: Into<String>>(
addr: T,
iface_manager: Arc<tokio::sync::Mutex<InterfaceManager>>,
) -> Self {
Self {
addr: addr.into(),
iface_manager,
}
}
pub async fn spawn(context: InterfaceContext<Self>) {
let addr = { context.inner.lock().unwrap().addr.clone() };
let iface_manager = { context.inner.lock().unwrap().iface_manager.clone() };
let (_, tx_channel) = context.channel.split();
let tx_channel = Arc::new(tokio::sync::Mutex::new(tx_channel));
loop {
if context.cancel.is_cancelled() {
break;
}
let listener = TcpListener::bind(addr.clone())
.await
.map_err(|_| RnsError::ConnectionError);
if let Err(_) = listener {
log::warn!("tcp_server: couldn't bind to <{}>", addr);
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
continue;
}
log::info!("tcp_server: listen on <{}>", addr);
let listener = listener.unwrap();
let tx_task = {
let cancel = context.cancel.clone();
let tx_channel = tx_channel.clone();
tokio::spawn(async move {
loop {
if cancel.is_cancelled() {
break;
}
let mut tx_channel = tx_channel.lock().await;
tokio::select! {
_ = cancel.cancelled() => {
break;
}
// Skip all tx messages
_ = tx_channel.recv() => {}
}
}
})
};
let cancel = context.cancel.clone();
loop {
if cancel.is_cancelled() {
break;
}
tokio::select! {
_ = cancel.cancelled() => {
break;
}
client = listener.accept() => {
if let Ok(client) = client {
log::info!(
"tcp_server: new client <{}> connected to <{}>",
client.1,
addr
);
let mut iface_manager = iface_manager.lock().await;
iface_manager.spawn(
TcpClient::new_from_stream(client.1.to_string(), client.0),
TcpClient::spawn,
);
}
}
}
}
let _ = tokio::join!(tx_task);
}
}
}
impl Interface for TcpServer {
fn mtu() -> usize {
2048
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/iface/kaonic/kaonic_grpc.rs | src/iface/kaonic/kaonic_grpc.rs | pub mod proto {
tonic::include_proto!("kaonic");
}
use std::sync::Arc;
use std::time::Duration;
use proto::device_client::DeviceClient;
use proto::radio_client::RadioClient;
use proto::RadioFrame;
use tokio::sync::mpsc::Receiver;
use tokio::sync::Mutex;
use tokio_stream::StreamExt;
use tokio_util::sync::CancellationToken;
use tonic::transport::Channel;
use crate::buffer::{InputBuffer, OutputBuffer};
use crate::error::RnsError;
use crate::iface::{Interface, InterfaceContext, RxMessage};
use crate::packet::Packet;
use crate::serde::Serialize;
use alloc::string::String;
use super::RadioConfig;
pub const KAONIC_GRPC_URL: &str = "http://192.168.10.1:8080";
pub struct KaonicGrpc {
addr: String,
config: Arc<Mutex<RadioConfig>>,
config_channel: Arc<Mutex<Option<Receiver<RadioConfig>>>>,
}
impl KaonicGrpc {
pub fn new<T: Into<String>>(
addr: T,
config: RadioConfig,
config_channel: Option<Receiver<RadioConfig>>,
) -> Self {
Self {
addr: addr.into(),
config: Arc::new(Mutex::new(config)),
config_channel: Arc::new(Mutex::new(config_channel)),
}
}
pub async fn spawn(context: InterfaceContext<Self>) {
let addr = { context.inner.lock().unwrap().addr.clone() };
let current_config = { context.inner.lock().unwrap().config.clone() };
let iface_address = context.channel.address;
let (rx_channel, tx_channel) = context.channel.split();
let tx_channel = Arc::new(tokio::sync::Mutex::new(tx_channel));
let config_channel = context.inner.lock().unwrap().config_channel.clone();
loop {
if context.cancel.is_cancelled() {
break;
}
let grpc_channel = Channel::from_shared(addr.to_string())
.unwrap()
.connect_timeout(Duration::from_secs(30))
.connect()
.await;
if let Err(err) = grpc_channel {
log::warn!("kaonic_grpc: couldn't connect to <{}> = '{}'", addr, err);
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
continue;
}
let grpc_channel = grpc_channel.unwrap();
let mut radio_client = RadioClient::new(grpc_channel.clone());
let mut _device_client = DeviceClient::new(grpc_channel.clone());
let mut recv_stream = radio_client
.receive_stream(proto::ReceiveRequest {
module: 0, // Currently not used by kaonic-commd
timeout: 0,
})
.await
.unwrap()
.into_inner();
log::info!("kaonic_grpc: connected to <{}>", addr);
const BUFFER_SIZE: usize = std::mem::size_of::<Packet>() * 2;
let cancel = context.cancel.clone();
let stop = CancellationToken::new();
let rx_task = {
let cancel = cancel.clone();
let stop = stop.clone();
let rx_channel = rx_channel.clone();
let current_config = current_config.clone();
tokio::spawn(async move {
let mut rx_buffer = [0u8; BUFFER_SIZE];
log::trace!("kaonic_grpc: start rx task");
loop {
tokio::select! {
_ = cancel.cancelled() => {
break;
}
_ = stop.cancelled() => {
break;
}
Some(result) = recv_stream.next() => {
if let Ok(response) = result {
if let Some(frame) = response.frame {
let module = current_config.lock().await.module;
if frame.length > 0 && response.module == module {
if let Ok(buf) = decode_frame_to_buffer(&frame, &mut rx_buffer[..]) {
if let Ok(packet) = Packet::deserialize(&mut InputBuffer::new(buf)) {
let _ = rx_channel.send(RxMessage { address: iface_address, packet }).await;
} else {
log::warn!("kaonic_grpc: couldn't decode packet");
}
}
}
}
}
}
}
}
stop.cancel();
})
};
if config_channel.lock().await.is_some() {
let _config_task = {
let mut radio_client = radio_client.clone();
let cancel = cancel.clone();
let stop = stop.clone();
let config_channel = config_channel.clone();
let current_config = current_config.clone();
tokio::spawn(async move {
loop {
let mut config_channel = config_channel.lock().await;
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = stop.cancelled() => {
break;
},
Some(config) = config_channel.as_mut().unwrap().recv() => {
log::warn!("kaonic_grpc: change config");
if let Ok(_) = radio_client.configure(config).await {
let mut current_config = current_config.lock().await;
*current_config = config;
log::info!("kaonic_grpc: config has been changed");
} else {
log::error!("kaonic_grpc: config error");
}
}
}
}
})
};
}
let tx_task = {
let cancel = cancel.clone();
let stop = stop.clone();
let tx_channel = tx_channel.clone();
let current_config = current_config.clone();
tokio::spawn(async move {
let mut tx_buffer = [0u8; BUFFER_SIZE];
log::trace!("kaonic_grpc: start tx task");
loop {
let mut tx_channel = tx_channel.lock().await;
tokio::select! {
_ = cancel.cancelled() => {
break;
},
_ = stop.cancelled() => {
break;
},
Some(message) = tx_channel.recv() => {
let packet = message.packet;
let mut output = OutputBuffer::new(&mut tx_buffer);
if let Ok(_) = packet.serialize(&mut output) {
let frame = encode_buffer_to_frame(output.as_mut_slice());
let module = current_config.lock().await.module;
let result = radio_client.transmit(proto::TransmitRequest{
module: module,
frame: Some(frame),
}).await;
if let Err(err) = result {
log::warn!("kaonic_grpc: tx err = '{}'", err);
if err.code() == tonic::Code::Unknown || err.code() == tonic::Code::Unavailable {
break;
}
}
}
}
};
}
stop.cancel();
})
};
tx_task.await.unwrap();
rx_task.await.unwrap();
log::info!("kaonic_grpc: disconnected from <{}>", addr);
}
}
}
fn encode_buffer_to_frame(buffer: &mut [u8]) -> RadioFrame {
// Convert the packet bytes to a list of words
// TODO: Optimize dynamic allocation
let words = buffer
.chunks(4)
.map(|chunk| {
let mut work = 0u32;
let chunk = chunk.iter().as_slice();
for i in 0..chunk.len() {
work |= (chunk[i] as u32) << (i * 8);
}
work
})
.collect::<Vec<_>>();
proto::RadioFrame {
data: words,
length: buffer.len() as u32,
}
}
fn decode_frame_to_buffer<'a>(
frame: &RadioFrame,
buffer: &'a mut [u8],
) -> Result<&'a [u8], RnsError> {
if buffer.len() < (frame.length as usize) {
return Err(RnsError::OutOfMemory);
}
let length = frame.length as usize;
let mut index = 0usize;
for word in &frame.data {
for i in 0..4 {
buffer[index] = ((word >> i * 8) & 0xFF) as u8;
index += 1;
if index >= length {
break;
}
}
if index >= length {
break;
}
}
Ok(&buffer[..length])
}
impl Interface for KaonicGrpc {
fn mtu() -> usize {
2048
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/destination/link.rs | src/destination/link.rs | use std::{
cmp::min,
time::{Duration, Instant},
};
use ed25519_dalek::{Signature, SigningKey, PUBLIC_KEY_LENGTH, SIGNATURE_LENGTH};
use rand_core::OsRng;
use sha2::Digest;
use x25519_dalek::StaticSecret;
use crate::{
buffer::OutputBuffer,
error::RnsError,
hash::{AddressHash, Hash, ADDRESS_HASH_SIZE},
identity::{DecryptIdentity, DerivedKey, EncryptIdentity, Identity, PrivateIdentity},
packet::{
DestinationType, Header, Packet, PacketContext, PacketDataBuffer, PacketType, PACKET_MDU,
},
};
use super::DestinationDesc;
const LINK_MTU_SIZE: usize = 3;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum LinkStatus {
Pending = 0x00,
Handshake = 0x01,
Active = 0x02,
Stale = 0x03,
Closed = 0x04,
}
impl LinkStatus {
pub fn not_yet_active(&self) -> bool {
*self == LinkStatus::Pending || *self == LinkStatus::Handshake
}
}
pub type LinkId = AddressHash;
#[derive(Clone)]
pub struct LinkPayload {
buffer: [u8; PACKET_MDU],
len: usize,
}
impl LinkPayload {
pub fn new() -> Self {
Self {
buffer: [0u8; PACKET_MDU],
len: 0,
}
}
pub fn new_from_slice(data: &[u8]) -> Self {
let mut buffer = [0u8; PACKET_MDU];
let len = min(data.len(), buffer.len());
buffer[..len].copy_from_slice(&data[..len]);
Self { buffer, len }
}
pub fn new_from_vec(data: &Vec<u8>) -> Self {
let mut buffer = [0u8; PACKET_MDU];
for i in 0..min(buffer.len(), data.len()) {
buffer[i] = data[i];
}
Self {
buffer,
len: data.len(),
}
}
pub fn len(&self) -> usize {
self.len
}
pub fn as_slice(&self) -> &[u8] {
&self.buffer[..self.len]
}
}
impl From<&Packet> for LinkId {
fn from(packet: &Packet) -> Self {
let data = packet.data.as_slice();
let data_diff = if data.len() > PUBLIC_KEY_LENGTH * 2 {
data.len() - PUBLIC_KEY_LENGTH * 2
} else {
0
};
let hashable_data = &data[..data.len() - data_diff];
AddressHash::new_from_hash(&Hash::new(
Hash::generator()
.chain_update(&[packet.header.to_meta() & 0b00001111])
.chain_update(packet.destination.as_slice())
.chain_update(&[packet.context as u8])
.chain_update(hashable_data)
.finalize()
.into(),
))
}
}
pub enum LinkHandleResult {
None,
Activated,
KeepAlive,
}
#[derive(Clone)]
pub enum LinkEvent {
Activated,
Data(LinkPayload),
Closed,
}
#[derive(Clone)]
pub struct LinkEventData {
pub id: LinkId,
pub address_hash: AddressHash,
pub event: LinkEvent,
}
pub struct Link {
id: LinkId,
destination: DestinationDesc,
priv_identity: PrivateIdentity,
peer_identity: Identity,
derived_key: DerivedKey,
status: LinkStatus,
request_time: Instant,
rtt: Duration,
event_tx: tokio::sync::broadcast::Sender<LinkEventData>,
}
impl Link {
pub fn new(
destination: DestinationDesc,
event_tx: tokio::sync::broadcast::Sender<LinkEventData>,
) -> Self {
Self {
id: AddressHash::new_empty(),
destination,
priv_identity: PrivateIdentity::new_from_rand(OsRng),
peer_identity: Identity::default(),
derived_key: DerivedKey::new_empty(),
status: LinkStatus::Pending,
request_time: Instant::now(),
rtt: Duration::from_secs(0),
event_tx,
}
}
pub fn new_from_request(
packet: &Packet,
signing_key: SigningKey,
destination: DestinationDesc,
event_tx: tokio::sync::broadcast::Sender<LinkEventData>,
) -> Result<Self, RnsError> {
if packet.data.len() < PUBLIC_KEY_LENGTH * 2 {
return Err(RnsError::InvalidArgument);
}
let peer_identity = Identity::new_from_slices(
&packet.data.as_slice()[..PUBLIC_KEY_LENGTH],
&packet.data.as_slice()[PUBLIC_KEY_LENGTH..PUBLIC_KEY_LENGTH * 2],
);
let link_id = LinkId::from(packet);
log::debug!("link: create from request {}", link_id);
let mut link = Self {
id: link_id,
destination,
priv_identity: PrivateIdentity::new(StaticSecret::random_from_rng(OsRng), signing_key),
peer_identity,
derived_key: DerivedKey::new_empty(),
status: LinkStatus::Pending,
request_time: Instant::now(),
rtt: Duration::from_secs(0),
event_tx,
};
link.handshake(peer_identity);
Ok(link)
}
pub fn request(&mut self) -> Packet {
let mut packet_data = PacketDataBuffer::new();
packet_data.safe_write(self.priv_identity.as_identity().public_key.as_bytes());
packet_data.safe_write(self.priv_identity.as_identity().verifying_key.as_bytes());
let packet = Packet {
header: Header {
packet_type: PacketType::LinkRequest,
..Default::default()
},
ifac: None,
destination: self.destination.address_hash,
transport: None,
context: PacketContext::None,
data: packet_data,
};
self.status = LinkStatus::Pending;
self.id = LinkId::from(&packet);
self.request_time = Instant::now();
packet
}
pub fn prove(&mut self) -> Packet {
log::debug!("link({}): prove", self.id);
if self.status != LinkStatus::Active {
self.status = LinkStatus::Active;
self.post_event(LinkEvent::Activated);
}
let mut packet_data = PacketDataBuffer::new();
packet_data.safe_write(self.id.as_slice());
packet_data.safe_write(self.priv_identity.as_identity().public_key.as_bytes());
packet_data.safe_write(self.priv_identity.as_identity().verifying_key.as_bytes());
let signature = self.priv_identity.sign(packet_data.as_slice());
packet_data.reset();
packet_data.safe_write(&signature.to_bytes()[..]);
packet_data.safe_write(self.priv_identity.as_identity().public_key.as_bytes());
let packet = Packet {
header: Header {
packet_type: PacketType::Proof,
..Default::default()
},
ifac: None,
destination: self.id,
transport: None,
context: PacketContext::LinkRequestProof,
data: packet_data,
};
packet
}
fn handle_data_packet(&mut self, packet: &Packet) -> LinkHandleResult {
if self.status != LinkStatus::Active {
log::warn!("link({}): handling data packet in inactive state", self.id);
}
match packet.context {
PacketContext::None => {
let mut buffer = [0u8; PACKET_MDU];
if let Ok(plain_text) = self.decrypt(packet.data.as_slice(), &mut buffer[..]) {
log::trace!("link({}): data {}B", self.id, plain_text.len());
self.request_time = Instant::now();
self.post_event(LinkEvent::Data(LinkPayload::new_from_slice(plain_text)));
} else {
log::error!("link({}): can't decrypt packet", self.id);
}
}
PacketContext::KeepAlive => {
if packet.data.len() >= 1 && packet.data.as_slice()[0] == 0xFF {
self.request_time = Instant::now();
log::trace!("link({}): keep-alive request", self.id);
return LinkHandleResult::KeepAlive;
}
if packet.data.len() >= 1 && packet.data.as_slice()[0] == 0xFE {
log::trace!("link({}): keep-alive response", self.id);
self.request_time = Instant::now();
return LinkHandleResult::None;
}
}
_ => {}
}
LinkHandleResult::None
}
pub fn handle_packet(&mut self, packet: &Packet) -> LinkHandleResult {
if packet.destination != self.id {
return LinkHandleResult::None;
}
match packet.header.packet_type {
PacketType::Data => return self.handle_data_packet(packet),
PacketType::Proof => {
if self.status == LinkStatus::Pending
&& packet.context == PacketContext::LinkRequestProof
{
if let Ok(identity) = validate_proof_packet(&self.destination, &self.id, packet)
{
log::debug!("link({}): has been proved", self.id);
self.handshake(identity);
self.status = LinkStatus::Active;
self.rtt = self.request_time.elapsed();
log::debug!("link({}): activated", self.id);
self.post_event(LinkEvent::Activated);
return LinkHandleResult::Activated;
} else {
log::warn!("link({}): proof is not valid", self.id);
}
}
}
_ => {}
}
return LinkHandleResult::None;
}
pub fn data_packet(&self, data: &[u8]) -> Result<Packet, RnsError> {
if self.status != LinkStatus::Active {
log::warn!("link: can't create data packet for closed link");
}
let mut packet_data = PacketDataBuffer::new();
let cipher_text_len = {
let cipher_text = self.encrypt(data, packet_data.accuire_buf_max())?;
cipher_text.len()
};
packet_data.resize(cipher_text_len);
Ok(Packet {
header: Header {
destination_type: DestinationType::Link,
packet_type: PacketType::Data,
..Default::default()
},
ifac: None,
destination: self.id,
transport: None,
context: PacketContext::None,
data: packet_data,
})
}
pub fn keep_alive_packet(&self, data: u8) -> Packet {
log::trace!("link({}): create keep alive {}", self.id, data);
let mut packet_data = PacketDataBuffer::new();
packet_data.safe_write(&[data]);
Packet {
header: Header {
destination_type: DestinationType::Link,
packet_type: PacketType::Data,
..Default::default()
},
ifac: None,
destination: self.id,
transport: None,
context: PacketContext::KeepAlive,
data: packet_data,
}
}
pub fn encrypt<'a>(&self, text: &[u8], out_buf: &'a mut [u8]) -> Result<&'a [u8], RnsError> {
self.priv_identity
.encrypt(OsRng, text, &self.derived_key, out_buf)
}
pub fn decrypt<'a>(&self, text: &[u8], out_buf: &'a mut [u8]) -> Result<&'a [u8], RnsError> {
self.priv_identity
.decrypt(OsRng, text, &self.derived_key, out_buf)
}
pub fn destination(&self) -> &DestinationDesc {
&self.destination
}
pub fn create_rtt(&self) -> Packet {
let rtt = self.rtt.as_secs_f32();
let mut buf = Vec::new();
{
buf.reserve(4);
rmp::encode::write_f32(&mut buf, rtt).unwrap();
}
let mut packet_data = PacketDataBuffer::new();
let token_len = {
let token = self
.encrypt(buf.as_slice(), packet_data.accuire_buf_max())
.expect("encrypted data");
token.len()
};
packet_data.resize(token_len);
log::trace!("link: {} create rtt packet = {} sec", self.id, rtt);
Packet {
header: Header {
destination_type: DestinationType::Link,
..Default::default()
},
ifac: None,
destination: self.id,
transport: None,
context: PacketContext::LinkRTT,
data: packet_data,
}
}
fn handshake(&mut self, peer_identity: Identity) {
log::debug!("link({}): handshake", self.id);
self.status = LinkStatus::Handshake;
self.peer_identity = peer_identity;
self.derived_key = self
.priv_identity
.derive_key(&self.peer_identity.public_key, Some(&self.id.as_slice()));
}
fn post_event(&self, event: LinkEvent) {
let _ = self.event_tx.send(LinkEventData {
id: self.id,
address_hash: self.destination.address_hash,
event,
});
}
pub fn close(&mut self) {
self.status = LinkStatus::Closed;
self.post_event(LinkEvent::Closed);
log::warn!("link: close {}", self.id);
}
pub fn restart(&mut self) {
log::warn!(
"link({}): restart after {}s",
self.id,
self.request_time.elapsed().as_secs()
);
self.status = LinkStatus::Pending;
}
pub fn elapsed(&self) -> Duration {
self.request_time.elapsed()
}
pub fn status(&self) -> LinkStatus {
self.status
}
pub fn id(&self) -> &LinkId {
&self.id
}
}
fn validate_proof_packet(
destination: &DestinationDesc,
id: &LinkId,
packet: &Packet,
) -> Result<Identity, RnsError> {
const MIN_PROOF_LEN: usize = SIGNATURE_LENGTH + PUBLIC_KEY_LENGTH;
const MTU_PROOF_LEN: usize = SIGNATURE_LENGTH + PUBLIC_KEY_LENGTH + LINK_MTU_SIZE;
const SIGN_DATA_LEN: usize = ADDRESS_HASH_SIZE + PUBLIC_KEY_LENGTH * 2 + LINK_MTU_SIZE;
if packet.data.len() < MIN_PROOF_LEN {
return Err(RnsError::PacketError);
}
let mut proof_data = [0u8; SIGN_DATA_LEN];
let verifying_key = destination.identity.verifying_key.as_bytes();
let sign_data_len = {
let mut output = OutputBuffer::new(&mut proof_data[..]);
output.write(id.as_slice())?;
output.write(
&packet.data.as_slice()[SIGNATURE_LENGTH..SIGNATURE_LENGTH + PUBLIC_KEY_LENGTH],
)?;
output.write(verifying_key)?;
if packet.data.len() >= MTU_PROOF_LEN {
let mtu_bytes = &packet.data.as_slice()[SIGNATURE_LENGTH + PUBLIC_KEY_LENGTH..];
output.write(mtu_bytes)?;
}
output.offset()
};
let identity = Identity::new_from_slices(
&proof_data[ADDRESS_HASH_SIZE..ADDRESS_HASH_SIZE + PUBLIC_KEY_LENGTH],
verifying_key,
);
let signature = Signature::from_slice(&packet.data.as_slice()[..SIGNATURE_LENGTH])
.map_err(|_| RnsError::CryptoError)?;
identity
.verify(&proof_data[..sign_data_len], &signature)
.map_err(|_| RnsError::IncorrectSignature)?;
Ok(identity)
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/src/destination/link_map.rs | src/destination/link_map.rs | use std::collections::HashMap;
use crate::hash::AddressHash;
use super::link::LinkId;
pub struct LinkMap {
map: HashMap<AddressHash, LinkId>,
}
impl LinkMap {
pub fn new() -> Self {
Self {
map: HashMap::new(),
}
}
pub fn resolve(&self, address: &AddressHash) -> Option<LinkId> {
self.map.get(address).copied()
}
pub fn insert(&mut self, address: &AddressHash, id: &LinkId) {
self.map.insert(*address, *id);
}
pub fn remove(&mut self, address: &AddressHash) {
self.map.remove(address);
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/tests/hop_test.rs | tests/hop_test.rs | use std::time::Duration;
use rand_core::OsRng;
use reticulum::{
destination::DestinationName,
identity::PrivateIdentity,
iface::{tcp_client::TcpClient, tcp_server::TcpServer},
transport::{Transport, TransportConfig},
};
use tokio::time;
async fn build_transport(name: &str, server_addr: &str, client_addr: &[&str]) -> Transport {
let transport = Transport::new(TransportConfig::new(
name,
&PrivateIdentity::new_from_rand(OsRng),
true,
));
transport.iface_manager().lock().await.spawn(
TcpServer::new(server_addr, transport.iface_manager()),
TcpServer::spawn,
);
for &addr in client_addr {
transport
.iface_manager()
.lock()
.await
.spawn(TcpClient::new(addr), TcpClient::spawn);
}
log::info!("test: transport {} created", name);
transport
}
#[tokio::test]
async fn calculate_hop_distance() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let mut transport_a = build_transport("a", "127.0.0.1:8081", &[]).await;
let mut transport_b = build_transport("b", "127.0.0.1:8082", &["127.0.0.1:8081"]).await;
let mut transport_c =
build_transport("c", "127.0.0.1:8083", &["127.0.0.1:8081", "127.0.0.1:8082"]).await;
let id_a = PrivateIdentity::new_from_name("a");
let id_b = PrivateIdentity::new_from_name("b");
let id_c = PrivateIdentity::new_from_name("c");
let dest_a = transport_a
.add_destination(id_a, DestinationName::new("test", "hop"))
.await;
let dest_b = transport_b
.add_destination(id_b, DestinationName::new("test", "hop"))
.await;
let dest_c = transport_c
.add_destination(id_c, DestinationName::new("test", "hop"))
.await;
time::sleep(Duration::from_secs(2)).await;
println!("======");
transport_a.send_announce(&dest_a, None).await;
transport_b.recv_announces().await;
transport_c.recv_announces().await;
time::sleep(Duration::from_secs(2)).await;
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/tests/tcp_hdlc_test.rs | tests/tcp_hdlc_test.rs | use rand_core::OsRng;
use reticulum::{
identity::PrivateIdentity,
iface::{tcp_client::TcpClient, tcp_server::TcpServer},
packet::Packet,
transport::{Transport, TransportConfig},
};
use tokio_util::sync::CancellationToken;
async fn build_transport(name: &str, server_addr: &str, client_addr: &[&str]) -> Transport {
let transport = Transport::new(TransportConfig::new(
name,
&PrivateIdentity::new_from_rand(OsRng),
true,
));
transport.iface_manager().lock().await.spawn(
TcpServer::new(server_addr, transport.iface_manager()),
TcpServer::spawn,
);
for &addr in client_addr {
transport
.iface_manager()
.lock()
.await
.spawn(TcpClient::new(addr), TcpClient::spawn);
}
log::info!("test: transport {} created", name);
transport
}
#[tokio::test]
async fn packet_overload() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let transport_a = build_transport("a", "127.0.0.1:8081", &[]).await;
let transport_b = build_transport("b", "127.0.0.1:8082", &["127.0.0.1:8081"]).await;
let stop = CancellationToken::new();
let producer_task = {
let stop = stop.clone();
tokio::spawn(async move {
let mut tx_counter = 0;
let mut payload_size = 0;
loop {
tokio::select! {
_ = stop.cancelled() => {
break;
},
_ = tokio::time::sleep(std::time::Duration::from_micros(1)) => {
let mut packet = Packet::default();
packet.data.resize(payload_size);
payload_size += 1;
if payload_size >= 3072 {
payload_size = 0;
}
transport_a.send_packet(packet).await;
tx_counter += 1;
},
};
}
return tx_counter;
})
};
let consumer_task = {
let stop = stop.clone();
let mut messages = transport_b.iface_rx();
tokio::spawn(async move {
let mut rx_counter = 0;
loop {
tokio::select! {
_ = stop.cancelled() => {
break;
},
Ok(_) = messages.recv() => {
rx_counter += 1;
},
};
}
return rx_counter;
})
};
tokio::time::sleep(std::time::Duration::from_secs(5)).await;
stop.cancel();
let tx_counter = producer_task.await.unwrap();
let rx_counter = consumer_task.await.unwrap();
log::info!("TX: {}, RX: {}", tx_counter, rx_counter);
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/kaonic_client.rs | examples/kaonic_client.rs | use std::env;
use std::sync::Arc;
use std::time::Duration;
use rand_core::OsRng;
use reticulum::destination::DestinationName;
use reticulum::identity::PrivateIdentity;
use reticulum::iface::kaonic::kaonic_grpc::KaonicGrpc;
use reticulum::iface::kaonic::{RadioConfig, RadioModule};
use reticulum::transport::{Transport, TransportConfig};
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let args: Vec<String> = env::args().collect();
if args.len() < 2 {
println!("Usage: {} <grpc-addr>", args[0]);
return;
}
let grpc_addr = &args[1];
let transport = Arc::new(Mutex::new(Transport::new(TransportConfig::default())));
log::info!("start kaonic client");
let _ = transport.lock().await.iface_manager().lock().await.spawn(
KaonicGrpc::new(
format!("http://{}", grpc_addr),
RadioConfig::new_for_module(RadioModule::RadioA),
None,
),
KaonicGrpc::spawn,
);
let identity = PrivateIdentity::new_from_name("kaonic-example");
let in_destination = transport
.lock()
.await
.add_destination(
identity,
DestinationName::new("example_utilities", "linkexample"),
)
.await;
// Announce task
{
let transport = transport.clone();
tokio::spawn(async move {
loop {
log::trace!("announce");
let _ = transport
.lock()
.await
.send_packet(in_destination.lock().await.announce(OsRng, None).unwrap())
.await;
tokio::time::sleep(Duration::from_secs(3)).await;
}
});
}
loop {
tokio::time::sleep(Duration::from_secs(10)).await;
}
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/kaonic_mesh.rs | examples/kaonic_mesh.rs | use std::sync::Arc;
use reticulum::iface::kaonic::kaonic_grpc::KaonicGrpc;
use reticulum::iface::kaonic::{RadioConfig, RadioModule};
use reticulum::transport::{Transport, TransportConfig};
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
log::info!(">> packet retransmitter <<");
let mut config = TransportConfig::default();
config.set_retransmit(true);
config.set_broadcast(false);
let transport = Arc::new(Mutex::new(Transport::new(config)));
let _ = transport.lock().await.iface_manager().lock().await.spawn(
KaonicGrpc::new(
"http://127.0.0.1:8080",
RadioConfig::new_for_module(RadioModule::RadioA),
None,
),
KaonicGrpc::spawn,
);
let _ = tokio::signal::ctrl_c().await;
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/link_client.rs | examples/link_client.rs | use rand_core::OsRng;
use reticulum::destination::link::LinkEvent;
use reticulum::destination::{DestinationAnnounce, DestinationName};
use reticulum::identity::PrivateIdentity;
use reticulum::iface::tcp_client::TcpClient;
use reticulum::transport::{Transport, TransportConfig};
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let mut transport = Transport::new(TransportConfig::default());
log::info!("start tcp app");
{
transport
.iface_manager()
.lock()
.await
.spawn(TcpClient::new("127.0.0.1:4242"), TcpClient::spawn);
}
let identity = PrivateIdentity::new_from_name("link-example");
let in_destination = transport
.add_destination(
identity,
DestinationName::new("example_utilities", "linkexample"),
)
.await;
transport
.send_packet(in_destination.lock().await.announce(OsRng, None).unwrap())
.await;
tokio::spawn(async move {
let recv = transport.recv_announces();
let mut recv = recv.await;
loop {
if let Ok(announce) = recv.recv().await {
log::debug!(
"destination announce {}",
announce.destination.lock().await.desc.address_hash
);
let _link = transport.link(announce.destination.lock().await.desc).await;
}
}
});
let _ = tokio::signal::ctrl_c().await;
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/tcp_client.rs | examples/tcp_client.rs | use std::time::Duration;
use rand_core::OsRng;
use reticulum::destination::{DestinationName, SingleInputDestination};
use reticulum::identity::PrivateIdentity;
use reticulum::iface::tcp_client::TcpClient;
use reticulum::transport::{Transport, TransportConfig};
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
log::info!(">>> TCP CLIENT APP <<<");
let transport = Transport::new(TransportConfig::default());
let client_addr = transport
.iface_manager()
.lock()
.await
.spawn(TcpClient::new("127.0.0.1:4242"), TcpClient::spawn);
let id = PrivateIdentity::new_from_rand(OsRng);
let destination = SingleInputDestination::new(id, DestinationName::new("example", "app"));
tokio::time::sleep(Duration::from_secs(3)).await;
transport
.send_direct(client_addr, destination.announce(OsRng, None).unwrap())
.await;
let _ = tokio::signal::ctrl_c().await;
log::info!("exit");
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/testnet_client.rs | examples/testnet_client.rs | use std::sync::Arc;
use reticulum::iface::tcp_client::TcpClient;
use reticulum::transport::{Transport, TransportConfig};
use tokio::select;
use tokio::sync::Mutex;
use tokio_util::sync::CancellationToken;
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
log::info!(">>> TESTNET CLIENT <<<");
let transport = Transport::new(TransportConfig::default());
// https://reticulum.network/manual/gettingstartedfast.html#connect-to-the-public-testnet
transport.iface_manager().lock().await.spawn(
TcpClient::new("amsterdam.connect.reticulum.network:4965"),
TcpClient::spawn,
);
let transport = Arc::new(Mutex::new(transport));
let cancel = CancellationToken::new();
{
let transport = transport.clone();
let cancel = cancel.clone();
tokio::spawn(async move {
let mut announce = transport.lock().await.recv_announces().await;
loop {
select! {
_ = cancel.cancelled() => {
break;
},
Ok(announce) = announce.recv() => {
let destination = announce.destination.lock().await;
log::debug!("new announce {}", destination.desc.address_hash);
},
}
}
});
}
let _ = tokio::signal::ctrl_c().await;
cancel.cancel();
log::info!("exit");
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/tcp_server.rs | examples/tcp_server.rs | use rand_core::OsRng;
use reticulum::identity::PrivateIdentity;
use reticulum::iface::tcp_server::TcpServer;
use reticulum::transport::{Transport, TransportConfig};
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
log::info!(">>> TCP SERVER APP <<<");
let transport = Transport::new(TransportConfig::new(
"server",
&PrivateIdentity::new_from_rand(OsRng),
true,
));
let _ = transport.iface_manager().lock().await.spawn(
TcpServer::new("0.0.0.0:4242", transport.iface_manager()),
TcpServer::spawn,
);
let _ = tokio::signal::ctrl_c().await;
log::info!("exit");
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/udp_link.rs | examples/udp_link.rs | //! To communicate with a local instance of Python RNS should use a config like:
//!
//! ```text
//! [[UDP Interface]]
//! type = UDPInterface
//! enabled = yes
//! listen_ip = 0.0.0.0
//! listen_port = 4242
//! forward_ip = 127.0.0.1
//! forward_port = 4243
//! ```
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
use rand_core::OsRng;
use reticulum::destination::{DestinationName, SingleInputDestination};
use reticulum::destination::link::{Link, LinkEvent, LinkStatus};
use reticulum::hash::AddressHash;
use reticulum::identity::PrivateIdentity;
use reticulum::iface::udp::UdpInterface;
use reticulum::transport::{Transport, TransportConfig};
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();
log::info!(">>> UDP LINK APP <<<");
let id = PrivateIdentity::new_from_rand(OsRng);
let destination = SingleInputDestination::new(id.clone(), DestinationName::new("example", "app"));
let transport = Transport::new(TransportConfig::new("server", &id, true));
let _ = transport.iface_manager().lock().await.spawn(
UdpInterface::new("0.0.0.0:4243", Some("127.0.0.1:4242")),
UdpInterface::spawn);
let dest = Arc::new(tokio::sync::Mutex::new (destination));
let mut announce_recv = transport.recv_announces().await;
let mut out_link_events = transport.out_link_events();
let mut links = HashMap::<AddressHash, Arc<tokio::sync::Mutex<Link>>>::new();
loop {
while let Ok(announce) = announce_recv.try_recv() {
let destination = announce.destination.lock().await;
//println!("ANNOUNCE: {}", destination.desc.address_hash);
let link = match links.get(&destination.desc.address_hash) {
Some(link) => link.clone(),
None => {
let link = transport.link(destination.desc).await;
links.insert(destination.desc.address_hash, link.clone());
link
}
};
let link = link.lock().await;
log::info!("link {}: {:?}", link.id(), link.status());
if link.status() == LinkStatus::Active {
let packet = link.data_packet (b"foo").unwrap();
transport.send_packet(packet).await;
}
}
while let Ok(link_event) = out_link_events.try_recv() {
match link_event.event {
LinkEvent::Activated => log::info!("link {} activated", link_event.id),
LinkEvent::Closed => log::info!("link {} closed", link_event.id),
LinkEvent::Data(payload) => log::info!("link {} data payload: {}", link_event.id,
std::str::from_utf8(payload.as_slice())
.map(str::to_string)
.unwrap_or_else(|_| format!("{:?}", payload.as_slice()))),
}
}
transport
.send_announce(&dest, None)
.await;
tokio::time::sleep(Duration::from_secs(1)).await;
}
//log::info!("exit");
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/kaonic_tcp_mesh.rs | examples/kaonic_tcp_mesh.rs | use std::env;
use std::sync::Arc;
use reticulum::iface::kaonic::kaonic_grpc::KaonicGrpc;
use reticulum::iface::kaonic::{RadioConfig, RadioModule};
use reticulum::iface::tcp_client::TcpClient;
use reticulum::transport::{Transport, TransportConfig};
use tokio::sync::Mutex;
#[tokio::main]
async fn main() {
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
let args: Vec<String> = env::args().collect();
let mut config = TransportConfig::default();
config.set_retransmit(true);
config.set_broadcast(false);
let transport = Arc::new(Mutex::new(Transport::new(config)));
if args.len() < 3 {
println!("Usage: {} <tcp-server> <kaonic-grpc>", args[0]);
return;
}
log::info!("start kaonic client");
let _ = transport.lock().await.iface_manager().lock().await.spawn(
KaonicGrpc::new(
format!("http://{}", &args[2]),
RadioConfig::new_for_module(RadioModule::RadioA),
None,
),
KaonicGrpc::spawn,
);
log::info!("start tcp client");
let _ = transport
.lock()
.await
.iface_manager()
.lock()
.await
.spawn(TcpClient::new(&args[1]), TcpClient::spawn);
log::info!("start tcp client");
let _ = tokio::signal::ctrl_c().await;
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
BeechatNetworkSystemsLtd/Reticulum-rs | https://github.com/BeechatNetworkSystemsLtd/Reticulum-rs/blob/5012cf2c48044034775207ab7ee2c67d285276bb/examples/multihop.rs | examples/multihop.rs | use std::env::args;
use std::str::from_utf8;
use tokio::io::AsyncBufReadExt;
use rand_core::OsRng;
use reticulum::destination::{DestinationName, SingleInputDestination};
use reticulum::destination::link::{LinkEvent, LinkStatus};
use reticulum::hash::AddressHash;
use reticulum::identity::PrivateIdentity;
use reticulum::iface::tcp_client::TcpClient;
use reticulum::iface::tcp_server::TcpServer;
use reticulum::packet::{HeaderType, Packet, PacketDataBuffer, PropagationType};
use reticulum::transport::{Transport, TransportConfig};
fn create_data_packet(message: &String, destination: AddressHash) -> Packet {
let mut packet: Packet = Default::default();
packet.header.propagation_type = PropagationType::Transport;
packet.destination = destination;
packet.data = PacketDataBuffer::new_from_slice(message.as_bytes());
packet
}
#[tokio::main]
async fn main() {
// Call: cargo run --example multihop <number of our hop> <number of last hop>
// Once the chain is set up, type a line to send it as a message to the last hop
// or type "link" to request a link to the last hop.
let mut args = args();
let our_hop = args.nth(1).map_or(0, |s| s.parse::<u16>().unwrap_or(0));
let last_hop = args.next().map_or(128, |s| s.parse::<u16>().unwrap_or(128));
env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("trace")).init();
log::info!(">>> MULTIHOP EXAMPLE (place in chain: {}/{}) <<<", our_hop, last_hop);
let identity = PrivateIdentity::new_from_rand(OsRng);
let transport_id = identity.address_hash().clone();
let last_hop_id = PrivateIdentity::new_from_name("last_hop");
let last_hop_name = DestinationName::new("last_hop", "app");
let last_hop_destination = SingleInputDestination::new(
last_hop_id.clone(),
last_hop_name,
);
let last_hop_address = last_hop_destination.desc.address_hash.clone();
log::info!("Destination on last hop will be {}", last_hop_destination.desc);
let mut config = TransportConfig::new("server", &identity, false);
config.set_retransmit(true);
let mut transport = Transport::new(config);
let our_address = format!("0.0.0.0:{}", our_hop + 5101);
let _ = transport.iface_manager().lock().await.spawn(
TcpServer::new(our_address, transport.iface_manager()),
TcpServer::spawn,
);
if our_hop > 0 {
let connect_to = format!("127.0.0.1:{}", our_hop + 5100);
let client_addr = transport.iface_manager().lock().await.spawn(
TcpClient::new(connect_to),
TcpClient::spawn,
);
let destination;
if our_hop == last_hop {
destination = transport.add_destination(
last_hop_id,
last_hop_name
).await;
} else {
let id = PrivateIdentity::new_from_rand(OsRng);
let name = DestinationName::new(&format!("hop-{}", our_hop), "app");
destination = transport.add_destination(id, name).await;
}
log::info!("Created destination {}", destination.lock().await.desc);
let mut announce = destination
.lock()
.await
.announce(OsRng, None)
.unwrap();
announce.transport = Some(transport_id);
announce.header.header_type = HeaderType::Type2;
transport.send_direct(client_addr, announce).await;
}
if our_hop == last_hop {
let mut data_event = transport.received_data_events();
let mut link_event = transport.in_link_events();
loop {
tokio::select! {
_ = tokio::signal::ctrl_c() => {
break;
},
event = data_event.recv() => {
if let Ok(event) = event {
if let Ok(text) = from_utf8(event.data.as_slice()) {
log::info!("Message received: {}", text);
} else {
log::info!("Broken message received (invalid utf8)");
}
}
},
result = link_event.recv() => {
match result {
Ok(event_data) => match event_data.event {
LinkEvent::Activated => {
log::info!("Inbound link {} established", event_data.id);
},
LinkEvent::Data(payload) => {
if let Ok(text) = from_utf8(payload.as_slice()) {
log::info!("Message over link received: {}", text);
} else {
log::info!("Broken message over link (invalid utf8)");
}
},
LinkEvent::Closed => {
log::info!("Link closed");
}
},
Err(error) => {
log::info!("Link error: {}", error);
}
}
}
}
}
} else {
let mut lines = tokio::io::BufReader::new(tokio::io::stdin()).lines();
let mut link = None;
loop {
tokio::select! {
_ = tokio::signal::ctrl_c() => {
break;
},
input = lines.next_line() => {
let message = match input {
Ok(m) => m.unwrap_or("foo".to_string()),
Err(e) => {
log::info!("Error reading from stdin: {}", e);
continue;
}
};
if link.is_none() && message == "link" {
log::info!("Requesting link to last hop");
link = Some(transport.link(last_hop_destination.desc).await);
continue;
}
if let Some(ref link) = link {
let link = link.lock().await;
if link.status() == LinkStatus::Active {
log::info!("Sending message over link: {}", &message);
let packet = link.data_packet(message.as_bytes()).unwrap();
transport.send_packet(packet).await;
continue;
}
}
log::info!("Sending message: {}", &message);
let packet = create_data_packet(&message, last_hop_address);
transport.outbound(&packet).await;
}
}
}
}
log::info!("exit");
}
| rust | MIT | 5012cf2c48044034775207ab7ee2c67d285276bb | 2026-01-04T20:21:06.485960Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/contract.rs | contracts/mirror_staking/src/contract.rs | use crate::rewards::{adjust_premium, deposit_reward, query_reward_info, withdraw_reward};
use crate::staking::{
auto_stake, auto_stake_hook, bond, decrease_short_token, increase_short_token, unbond,
};
use crate::state::{
read_config, read_pool_info, store_config, store_pool_info, Config, MigrationParams, PoolInfo,
};
#[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{
attr, from_binary, to_binary, Addr, Binary, Decimal, Deps, DepsMut, Env, MessageInfo, Response,
StdError, StdResult, Uint128,
};
use mirror_protocol::staking::{
ConfigResponse, Cw20HookMsg, ExecuteMsg, InstantiateMsg, MigrateMsg, PoolInfoResponse, QueryMsg,
};
use cw20::Cw20ReceiveMsg;
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
deps: DepsMut,
_env: Env,
_info: MessageInfo,
msg: InstantiateMsg,
) -> StdResult<Response> {
store_config(
deps.storage,
&Config {
owner: deps.api.addr_canonicalize(&msg.owner)?,
mirror_token: deps.api.addr_canonicalize(&msg.mirror_token)?,
mint_contract: deps.api.addr_canonicalize(&msg.mint_contract)?,
oracle_contract: deps.api.addr_canonicalize(&msg.oracle_contract)?,
terraswap_factory: deps.api.addr_canonicalize(&msg.terraswap_factory)?,
base_denom: msg.base_denom,
premium_min_update_interval: msg.premium_min_update_interval,
short_reward_contract: deps.api.addr_canonicalize(&msg.short_reward_contract)?,
},
)?;
Ok(Response::default())
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> StdResult<Response> {
match msg {
ExecuteMsg::Receive(msg) => receive_cw20(deps, info, msg),
ExecuteMsg::UpdateConfig {
owner,
premium_min_update_interval,
short_reward_contract,
} => {
let owner_addr = if let Some(owner_addr) = owner {
Some(deps.api.addr_validate(&owner_addr)?)
} else {
None
};
let short_reward_contract_addr =
if let Some(short_reward_contract) = short_reward_contract {
Some(deps.api.addr_validate(&short_reward_contract)?)
} else {
None
};
update_config(
deps,
info,
owner_addr,
premium_min_update_interval,
short_reward_contract_addr,
)
}
ExecuteMsg::RegisterAsset {
asset_token,
staking_token,
} => {
let api = deps.api;
register_asset(
deps,
info,
api.addr_validate(&asset_token)?,
api.addr_validate(&staking_token)?,
)
}
ExecuteMsg::DeprecateStakingToken {
asset_token,
new_staking_token,
} => {
let api = deps.api;
deprecate_staking_token(
deps,
info,
api.addr_validate(&asset_token)?,
api.addr_validate(&new_staking_token)?,
)
}
ExecuteMsg::Unbond {
asset_token,
amount,
} => {
let api = deps.api;
unbond(deps, info.sender, api.addr_validate(&asset_token)?, amount)
}
ExecuteMsg::Withdraw { asset_token } => {
let asset_addr = if let Some(asset_addr) = asset_token {
Some(deps.api.addr_validate(&asset_addr)?)
} else {
None
};
withdraw_reward(deps, info, asset_addr)
}
ExecuteMsg::AdjustPremium { asset_tokens } => adjust_premium(deps, env, asset_tokens),
ExecuteMsg::IncreaseShortToken {
staker_addr,
asset_token,
amount,
} => {
let api = deps.api;
increase_short_token(
deps,
info,
api.addr_validate(&staker_addr)?,
api.addr_validate(&asset_token)?,
amount,
)
}
ExecuteMsg::DecreaseShortToken {
staker_addr,
asset_token,
amount,
} => {
let api = deps.api;
decrease_short_token(
deps,
info,
api.addr_validate(&staker_addr)?,
api.addr_validate(&asset_token)?,
amount,
)
}
ExecuteMsg::AutoStake {
assets,
slippage_tolerance,
} => auto_stake(deps, env, info, assets, slippage_tolerance),
ExecuteMsg::AutoStakeHook {
asset_token,
staking_token,
staker_addr,
prev_staking_token_amount,
} => {
let api = deps.api;
auto_stake_hook(
deps,
env,
info,
api.addr_validate(&asset_token)?,
api.addr_validate(&staking_token)?,
api.addr_validate(&staker_addr)?,
prev_staking_token_amount,
)
}
}
}
pub fn receive_cw20(
deps: DepsMut,
info: MessageInfo,
cw20_msg: Cw20ReceiveMsg,
) -> StdResult<Response> {
match from_binary(&cw20_msg.msg) {
Ok(Cw20HookMsg::Bond { asset_token }) => {
let pool_info: PoolInfo =
read_pool_info(deps.storage, &deps.api.addr_canonicalize(&asset_token)?)?;
// only staking token contract can execute this message
let token_raw = deps.api.addr_canonicalize(info.sender.as_str())?;
if pool_info.staking_token != token_raw {
// if user is trying to bond old token, return friendly error message
if let Some(params) = pool_info.migration_params {
if params.deprecated_staking_token == token_raw {
let staking_token_addr =
deps.api.addr_humanize(&pool_info.staking_token)?;
return Err(StdError::generic_err(format!(
"The staking token for this asset has been migrated to {}",
staking_token_addr
)));
}
}
return Err(StdError::generic_err("unauthorized"));
}
let api = deps.api;
bond(
deps,
api.addr_validate(cw20_msg.sender.as_str())?,
api.addr_validate(asset_token.as_str())?,
cw20_msg.amount,
)
}
Ok(Cw20HookMsg::DepositReward { rewards }) => {
let config: Config = read_config(deps.storage)?;
// only reward token contract can execute this message
if config.mirror_token != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
let mut rewards_amount = Uint128::zero();
for (_, amount) in rewards.iter() {
rewards_amount += *amount;
}
if rewards_amount != cw20_msg.amount {
return Err(StdError::generic_err("rewards amount miss matched"));
}
deposit_reward(deps, rewards, rewards_amount)
}
Err(_) => Err(StdError::generic_err("invalid cw20 hook message")),
}
}
pub fn update_config(
deps: DepsMut,
info: MessageInfo,
owner: Option<Addr>,
premium_min_update_interval: Option<u64>,
short_reward_contract: Option<Addr>,
) -> StdResult<Response> {
let mut config: Config = read_config(deps.storage)?;
if deps.api.addr_canonicalize(info.sender.as_str())? != config.owner {
return Err(StdError::generic_err("unauthorized"));
}
if let Some(owner) = owner {
config.owner = deps.api.addr_canonicalize(owner.as_str())?;
}
if let Some(premium_min_update_interval) = premium_min_update_interval {
config.premium_min_update_interval = premium_min_update_interval;
}
if let Some(short_reward_contract) = short_reward_contract {
config.short_reward_contract =
deps.api.addr_canonicalize(short_reward_contract.as_str())?;
}
store_config(deps.storage, &config)?;
Ok(Response::new().add_attributes(vec![attr("action", "update_config")]))
}
fn register_asset(
deps: DepsMut,
info: MessageInfo,
asset_token: Addr,
staking_token: Addr,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let asset_token_raw = deps.api.addr_canonicalize(asset_token.as_str())?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
if read_pool_info(deps.storage, &asset_token_raw).is_ok() {
return Err(StdError::generic_err("Asset was already registered"));
}
store_pool_info(
deps.storage,
&asset_token_raw,
&PoolInfo {
staking_token: deps.api.addr_canonicalize(staking_token.as_str())?,
total_bond_amount: Uint128::zero(),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_params: None,
},
)?;
Ok(Response::new().add_attributes(vec![
attr("action", "register_asset"),
attr("asset_token", asset_token.as_str()),
]))
}
fn deprecate_staking_token(
deps: DepsMut,
info: MessageInfo,
asset_token: Addr,
new_staking_token: Addr,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let asset_token_raw = deps.api.addr_canonicalize(asset_token.as_str())?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
let mut pool_info: PoolInfo = read_pool_info(deps.storage, &asset_token_raw)?;
if pool_info.migration_params.is_some() {
return Err(StdError::generic_err(
"This asset LP token has already been migrated",
));
}
let deprecated_token_addr: Addr = deps.api.addr_humanize(&pool_info.staking_token)?;
pool_info.total_bond_amount = Uint128::zero();
pool_info.migration_params = Some(MigrationParams {
index_snapshot: pool_info.reward_index,
deprecated_staking_token: pool_info.staking_token,
});
pool_info.staking_token = deps.api.addr_canonicalize(new_staking_token.as_str())?;
store_pool_info(deps.storage, &asset_token_raw, &pool_info)?;
Ok(Response::new().add_attributes(vec![
attr("action", "depcrecate_staking_token"),
attr("asset_token", asset_token.to_string()),
attr(
"deprecated_staking_token",
deprecated_token_addr.to_string(),
),
attr("new_staking_token", new_staking_token.to_string()),
]))
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
match msg {
QueryMsg::Config {} => to_binary(&query_config(deps)?),
QueryMsg::PoolInfo { asset_token } => to_binary(&query_pool_info(deps, asset_token)?),
QueryMsg::RewardInfo {
staker_addr,
asset_token,
} => to_binary(&query_reward_info(deps, staker_addr, asset_token)?),
}
}
pub fn query_config(deps: Deps) -> StdResult<ConfigResponse> {
let state = read_config(deps.storage)?;
let resp = ConfigResponse {
owner: deps.api.addr_humanize(&state.owner)?.to_string(),
mirror_token: deps.api.addr_humanize(&state.mirror_token)?.to_string(),
mint_contract: deps.api.addr_humanize(&state.mint_contract)?.to_string(),
oracle_contract: deps.api.addr_humanize(&state.oracle_contract)?.to_string(),
terraswap_factory: deps
.api
.addr_humanize(&state.terraswap_factory)?
.to_string(),
base_denom: state.base_denom,
premium_min_update_interval: state.premium_min_update_interval,
short_reward_contract: deps
.api
.addr_humanize(&state.short_reward_contract)?
.to_string(),
};
Ok(resp)
}
pub fn query_pool_info(deps: Deps, asset_token: String) -> StdResult<PoolInfoResponse> {
let asset_token_raw = deps.api.addr_canonicalize(&asset_token)?;
let pool_info: PoolInfo = read_pool_info(deps.storage, &asset_token_raw)?;
Ok(PoolInfoResponse {
asset_token,
staking_token: deps
.api
.addr_humanize(&pool_info.staking_token)?
.to_string(),
total_bond_amount: pool_info.total_bond_amount,
total_short_amount: pool_info.total_short_amount,
reward_index: pool_info.reward_index,
short_reward_index: pool_info.short_reward_index,
pending_reward: pool_info.pending_reward,
short_pending_reward: pool_info.short_pending_reward,
premium_rate: pool_info.premium_rate,
short_reward_weight: pool_info.short_reward_weight,
premium_updated_time: pool_info.premium_updated_time,
migration_deprecated_staking_token: pool_info.migration_params.clone().map(|params| {
deps.api
.addr_humanize(¶ms.deprecated_staking_token)
.unwrap()
.to_string()
}),
migration_index_snapshot: pool_info
.migration_params
.map(|params| params.index_snapshot),
})
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn migrate(deps: DepsMut, _env: Env, msg: MigrateMsg) -> StdResult<Response> {
// change the oracle address for the tefi oracle address
let mut config: Config = read_config(deps.storage)?;
config.oracle_contract = deps.api.addr_canonicalize(&msg.tefi_oracle_contract)?;
store_config(deps.storage, &config)?;
Ok(Response::default())
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/lib.rs | contracts/mirror_staking/src/lib.rs | pub mod contract;
mod math;
mod querier;
mod rewards;
mod staking;
mod state;
#[cfg(test)]
mod testing;
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/math.rs | contracts/mirror_staking/src/math.rs | use cosmwasm_std::{Decimal, Uint128};
const DECIMAL_FRACTIONAL: Uint128 = Uint128::new(1_000_000_000u128);
/// return a / b
pub fn decimal_division(a: Decimal, b: Decimal) -> Decimal {
Decimal::from_ratio(DECIMAL_FRACTIONAL * a, b * DECIMAL_FRACTIONAL)
}
pub fn decimal_subtraction(a: Decimal, b: Decimal) -> Decimal {
Decimal::from_ratio(
(DECIMAL_FRACTIONAL * a)
.checked_sub(DECIMAL_FRACTIONAL * b)
.unwrap(),
DECIMAL_FRACTIONAL,
)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/state.rs | contracts/mirror_staking/src/state.rs | use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use cosmwasm_std::{CanonicalAddr, Decimal, StdResult, Storage, Uint128};
use cosmwasm_storage::{singleton, singleton_read, Bucket, ReadonlyBucket};
pub static KEY_CONFIG: &[u8] = b"config";
pub static PREFIX_POOL_INFO: &[u8] = b"pool_info";
static PREFIX_REWARD: &[u8] = b"reward";
static PREFIX_SHORT_REWARD: &[u8] = b"short_reward";
static PREFIX_IS_MIGRATED: &[u8] = b"is_migrated";
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
pub owner: CanonicalAddr,
pub mirror_token: CanonicalAddr,
pub mint_contract: CanonicalAddr,
pub oracle_contract: CanonicalAddr,
pub terraswap_factory: CanonicalAddr,
pub base_denom: String,
pub premium_min_update_interval: u64,
pub short_reward_contract: CanonicalAddr,
}
pub fn store_config(storage: &mut dyn Storage, config: &Config) -> StdResult<()> {
singleton(storage, KEY_CONFIG).save(config)
}
pub fn read_config(storage: &dyn Storage) -> StdResult<Config> {
singleton_read(storage, KEY_CONFIG).load()
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct PoolInfo {
pub staking_token: CanonicalAddr,
pub pending_reward: Uint128, // not distributed amount due to zero bonding
pub short_pending_reward: Uint128, // not distributed amount due to zero bonding
pub total_bond_amount: Uint128,
pub total_short_amount: Uint128,
pub reward_index: Decimal,
pub short_reward_index: Decimal,
pub premium_rate: Decimal,
pub short_reward_weight: Decimal,
pub premium_updated_time: u64,
pub migration_params: Option<MigrationParams>,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct MigrationParams {
pub index_snapshot: Decimal,
pub deprecated_staking_token: CanonicalAddr,
}
pub fn store_pool_info(
storage: &mut dyn Storage,
asset_token: &CanonicalAddr,
pool_info: &PoolInfo,
) -> StdResult<()> {
Bucket::new(storage, PREFIX_POOL_INFO).save(asset_token.as_slice(), pool_info)
}
pub fn read_pool_info(storage: &dyn Storage, asset_token: &CanonicalAddr) -> StdResult<PoolInfo> {
ReadonlyBucket::new(storage, PREFIX_POOL_INFO).load(asset_token.as_slice())
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct RewardInfo {
pub index: Decimal,
pub bond_amount: Uint128,
pub pending_reward: Uint128,
}
/// returns a bucket with all rewards owned by this owner (query it by owner)
pub fn rewards_store<'a>(
storage: &'a mut dyn Storage,
owner: &CanonicalAddr,
is_short: bool,
) -> Bucket<'a, RewardInfo> {
if is_short {
Bucket::multilevel(storage, &[PREFIX_SHORT_REWARD, owner.as_slice()])
} else {
Bucket::multilevel(storage, &[PREFIX_REWARD, owner.as_slice()])
}
}
/// returns a bucket with all rewards owned by this owner (query it by owner)
/// (read-only version for queries)
pub fn rewards_read<'a>(
storage: &'a dyn Storage,
owner: &CanonicalAddr,
is_short: bool,
) -> ReadonlyBucket<'a, RewardInfo> {
if is_short {
ReadonlyBucket::multilevel(storage, &[PREFIX_SHORT_REWARD, owner.as_slice()])
} else {
ReadonlyBucket::multilevel(storage, &[PREFIX_REWARD, owner.as_slice()])
}
}
pub fn store_is_migrated(
storage: &mut dyn Storage,
asset_token: &CanonicalAddr,
staker: &CanonicalAddr,
) -> StdResult<()> {
Bucket::multilevel(storage, &[PREFIX_IS_MIGRATED, staker.as_slice()])
.save(asset_token.as_slice(), &true)
}
pub fn read_is_migrated(
storage: &dyn Storage,
asset_token: &CanonicalAddr,
staker: &CanonicalAddr,
) -> bool {
ReadonlyBucket::multilevel(storage, &[PREFIX_IS_MIGRATED, staker.as_slice()])
.load(asset_token.as_slice())
.unwrap_or(false)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/staking.rs | contracts/mirror_staking/src/staking.rs | use cosmwasm_std::{
attr, to_binary, Addr, CanonicalAddr, Coin, CosmosMsg, Decimal, DepsMut, Env, MessageInfo,
Response, StdError, StdResult, Storage, Uint128, WasmMsg,
};
use crate::rewards::before_share_change;
use crate::state::{
read_config, read_is_migrated, read_pool_info, rewards_read, rewards_store, store_is_migrated,
store_pool_info, Config, PoolInfo, RewardInfo,
};
use cw20::Cw20ExecuteMsg;
use mirror_protocol::staking::ExecuteMsg;
use terraswap::asset::{Asset, AssetInfo, PairInfo};
use terraswap::pair::ExecuteMsg as PairExecuteMsg;
use terraswap::querier::{query_pair_info, query_token_balance};
pub fn bond(
deps: DepsMut,
staker_addr: Addr,
asset_token: Addr,
amount: Uint128,
) -> StdResult<Response> {
let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(staker_addr.as_str())?;
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(asset_token.as_str())?;
_increase_bond_amount(
deps.storage,
&staker_addr_raw,
&asset_token_raw,
amount,
false,
)?;
Ok(Response::new().add_attributes(vec![
attr("action", "bond"),
attr("staker_addr", staker_addr.as_str()),
attr("asset_token", asset_token.as_str()),
attr("amount", amount.to_string()),
]))
}
pub fn unbond(
deps: DepsMut,
staker_addr: Addr,
asset_token: Addr,
amount: Uint128,
) -> StdResult<Response> {
let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(staker_addr.as_str())?;
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(asset_token.as_str())?;
let staking_token: CanonicalAddr = _decrease_bond_amount(
deps.storage,
&staker_addr_raw,
&asset_token_raw,
amount,
false,
)?;
let staking_token_addr: Addr = deps.api.addr_humanize(&staking_token)?;
Ok(Response::new()
.add_message(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps.api.addr_humanize(&staking_token)?.to_string(),
msg: to_binary(&Cw20ExecuteMsg::Transfer {
recipient: staker_addr.to_string(),
amount,
})?,
funds: vec![],
}))
.add_attributes(vec![
attr("action", "unbond"),
attr("staker_addr", staker_addr.as_str()),
attr("asset_token", asset_token.as_str()),
attr("amount", amount.to_string()),
attr("staking_token", staking_token_addr.as_str()),
]))
}
// only mint contract can execute the operation
pub fn increase_short_token(
deps: DepsMut,
info: MessageInfo,
staker_addr: Addr,
asset_token: Addr,
amount: Uint128,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
if deps.api.addr_canonicalize(info.sender.as_str())? != config.mint_contract {
return Err(StdError::generic_err("unauthorized"));
}
let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(staker_addr.as_str())?;
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(asset_token.as_str())?;
_increase_bond_amount(
deps.storage,
&staker_addr_raw,
&asset_token_raw,
amount,
true,
)?;
Ok(Response::new().add_attributes(vec![
attr("action", "increase_short_token"),
attr("staker_addr", staker_addr.as_str()),
attr("asset_token", asset_token.as_str()),
attr("amount", amount.to_string()),
]))
}
// only mint contract can execute the operation
pub fn decrease_short_token(
deps: DepsMut,
info: MessageInfo,
staker_addr: Addr,
asset_token: Addr,
amount: Uint128,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
if deps.api.addr_canonicalize(info.sender.as_str())? != config.mint_contract {
return Err(StdError::generic_err("unauthorized"));
}
let staker_addr_raw: CanonicalAddr = deps.api.addr_canonicalize(staker_addr.as_str())?;
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(asset_token.as_str())?;
// not used
let _ = _decrease_bond_amount(
deps.storage,
&staker_addr_raw,
&asset_token_raw,
amount,
true,
)?;
Ok(Response::new().add_attributes(vec![
attr("action", "decrease_short_token"),
attr("staker_addr", staker_addr.as_str()),
attr("asset_token", asset_token.as_str()),
attr("amount", amount.to_string()),
]))
}
pub fn auto_stake(
deps: DepsMut,
env: Env,
info: MessageInfo,
assets: [Asset; 2],
slippage_tolerance: Option<Decimal>,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let terraswap_factory: Addr = deps.api.addr_humanize(&config.terraswap_factory)?;
let mut native_asset_op: Option<Asset> = None;
let mut token_info_op: Option<(Addr, Uint128)> = None;
for asset in assets.iter() {
match asset.info.clone() {
AssetInfo::NativeToken { .. } => {
asset.assert_sent_native_token_balance(&info)?;
native_asset_op = Some(asset.clone())
}
AssetInfo::Token { contract_addr } => {
token_info_op = Some((deps.api.addr_validate(&contract_addr)?, asset.amount))
}
}
}
// will fail if one of them is missing
let native_asset: Asset = match native_asset_op {
Some(v) => v,
None => return Err(StdError::generic_err("Missing native asset")),
};
let (token_addr, token_amount) = match token_info_op {
Some(v) => v,
None => return Err(StdError::generic_err("Missing token asset")),
};
// query pair info to obtain pair contract address
let asset_infos: [AssetInfo; 2] = [assets[0].info.clone(), assets[1].info.clone()];
let terraswap_pair: PairInfo = query_pair_info(&deps.querier, terraswap_factory, &asset_infos)?;
// assert the token and lp token match with pool info
let pool_info: PoolInfo = read_pool_info(
deps.storage,
&deps.api.addr_canonicalize(token_addr.as_str())?,
)?;
if pool_info.staking_token
!= deps
.api
.addr_canonicalize(terraswap_pair.liquidity_token.as_str())?
{
return Err(StdError::generic_err("Invalid staking token"));
}
// get current lp token amount to later compute the recived amount
let prev_staking_token_amount = query_token_balance(
&deps.querier,
deps.api.addr_validate(&terraswap_pair.liquidity_token)?,
env.contract.address.clone(),
)?;
// compute tax
let tax_amount: Uint128 = native_asset.compute_tax(&deps.querier)?;
// 1. Transfer token asset to staking contract
// 2. Increase allowance of token for pair contract
// 3. Provide liquidity
// 4. Execute staking hook, will stake in the name of the sender
Ok(Response::new()
.add_messages(vec![
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: token_addr.to_string(),
msg: to_binary(&Cw20ExecuteMsg::TransferFrom {
owner: info.sender.to_string(),
recipient: env.contract.address.to_string(),
amount: token_amount,
})?,
funds: vec![],
}),
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: token_addr.to_string(),
msg: to_binary(&Cw20ExecuteMsg::IncreaseAllowance {
spender: terraswap_pair.contract_addr.to_string(),
amount: token_amount,
expires: None,
})?,
funds: vec![],
}),
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: terraswap_pair.contract_addr.to_string(),
msg: to_binary(&PairExecuteMsg::ProvideLiquidity {
assets: [
Asset {
amount: native_asset.amount.checked_sub(tax_amount)?,
info: native_asset.info.clone(),
},
Asset {
amount: token_amount,
info: AssetInfo::Token {
contract_addr: token_addr.to_string(),
},
},
],
slippage_tolerance,
receiver: None,
})?,
funds: vec![Coin {
denom: native_asset.info.to_string(),
amount: native_asset.amount.checked_sub(tax_amount)?,
}],
}),
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: env.contract.address.to_string(),
msg: to_binary(&ExecuteMsg::AutoStakeHook {
asset_token: token_addr.to_string(),
staking_token: terraswap_pair.liquidity_token,
staker_addr: info.sender.to_string(),
prev_staking_token_amount,
})?,
funds: vec![],
}),
])
.add_attributes(vec![
attr("action", "auto_stake"),
attr("asset_token", token_addr.to_string()),
attr("tax_amount", tax_amount.to_string()),
]))
}
pub fn auto_stake_hook(
deps: DepsMut,
env: Env,
info: MessageInfo,
asset_token: Addr,
staking_token: Addr,
staker_addr: Addr,
prev_staking_token_amount: Uint128,
) -> StdResult<Response> {
// only can be called by itself
if info.sender != env.contract.address {
return Err(StdError::generic_err("unauthorized"));
}
// stake all lp tokens received, compare with staking token amount before liquidity provision was executed
let current_staking_token_amount =
query_token_balance(&deps.querier, staking_token, env.contract.address)?;
let amount_to_stake = current_staking_token_amount.checked_sub(prev_staking_token_amount)?;
bond(deps, staker_addr, asset_token, amount_to_stake)
}
fn _increase_bond_amount(
storage: &mut dyn Storage,
staker_addr: &CanonicalAddr,
asset_token: &CanonicalAddr,
amount: Uint128,
is_short: bool,
) -> StdResult<()> {
let mut pool_info: PoolInfo = read_pool_info(storage, asset_token)?;
let mut reward_info: RewardInfo = rewards_read(storage, staker_addr, is_short)
.load(asset_token.as_slice())
.unwrap_or_else(|_| RewardInfo {
index: Decimal::zero(),
bond_amount: Uint128::zero(),
pending_reward: Uint128::zero(),
});
// check if the position should be migrated
let is_position_migrated = read_is_migrated(storage, asset_token, staker_addr);
if !is_short && pool_info.migration_params.is_some() {
// the pool has been migrated, if position is not migrated and has tokens bonded, return error
if !reward_info.bond_amount.is_zero() && !is_position_migrated {
return Err(StdError::generic_err("The LP token for this asset has been deprecated, withdraw all your deprecated tokens to migrate your position"));
} else if !is_position_migrated {
// if the position is not migrated, but bond amount is zero, it means it's a new position, so store it as migrated
store_is_migrated(storage, asset_token, staker_addr)?;
}
}
let pool_index = if is_short {
pool_info.short_reward_index
} else {
pool_info.reward_index
};
// Withdraw reward to pending reward; before changing share
before_share_change(pool_index, &mut reward_info)?;
// Increase total short or bond amount
if is_short {
pool_info.total_short_amount += amount;
} else {
pool_info.total_bond_amount += amount;
}
reward_info.bond_amount += amount;
rewards_store(storage, staker_addr, is_short).save(asset_token.as_slice(), &reward_info)?;
store_pool_info(storage, asset_token, &pool_info)?;
Ok(())
}
fn _decrease_bond_amount(
storage: &mut dyn Storage,
staker_addr: &CanonicalAddr,
asset_token: &CanonicalAddr,
amount: Uint128,
is_short: bool,
) -> StdResult<CanonicalAddr> {
let mut pool_info: PoolInfo = read_pool_info(storage, asset_token)?;
let mut reward_info: RewardInfo =
rewards_read(storage, staker_addr, is_short).load(asset_token.as_slice())?;
if reward_info.bond_amount < amount {
return Err(StdError::generic_err("Cannot unbond more than bond amount"));
}
// if the lp token was migrated, and the user did not close their position yet, cap the reward at the snapshot
let should_migrate = !read_is_migrated(storage, asset_token, staker_addr)
&& !is_short
&& pool_info.migration_params.is_some();
let (pool_index, staking_token) = if is_short {
(
pool_info.short_reward_index,
pool_info.staking_token.clone(),
) // actually not used later
} else if should_migrate {
let migraton_params = pool_info.migration_params.clone().unwrap();
(
migraton_params.index_snapshot,
migraton_params.deprecated_staking_token,
)
} else {
(pool_info.reward_index, pool_info.staking_token.clone())
};
// Distribute reward to pending reward; before changing share
before_share_change(pool_index, &mut reward_info)?;
// Decrease total short or bond amount
if is_short {
pool_info.total_short_amount = pool_info.total_short_amount.checked_sub(amount)?;
} else if !should_migrate {
// if it should migrate, we dont need to decrease from the current total bond amount
pool_info.total_bond_amount = pool_info.total_bond_amount.checked_sub(amount)?;
}
// Update rewards info
reward_info.bond_amount = reward_info.bond_amount.checked_sub(amount)?;
if reward_info.bond_amount.is_zero() && should_migrate {
store_is_migrated(storage, asset_token, staker_addr)?;
}
if reward_info.pending_reward.is_zero() && reward_info.bond_amount.is_zero() {
rewards_store(storage, staker_addr, is_short).remove(asset_token.as_slice());
} else {
rewards_store(storage, staker_addr, is_short).save(asset_token.as_slice(), &reward_info)?;
}
// Update pool info
store_pool_info(storage, asset_token, &pool_info)?;
Ok(staking_token)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/querier.rs | contracts/mirror_staking/src/querier.rs | use crate::math::{decimal_division, decimal_subtraction};
use cosmwasm_std::{
to_binary, Addr, Decimal, Deps, QuerierWrapper, QueryRequest, StdResult, Uint128, WasmQuery,
};
use mirror_protocol::short_reward::{QueryMsg as ShortRewardQueryMsg, ShortRewardWeightResponse};
use tefi_oracle::hub::{HubQueryMsg as OracleQueryMsg, PriceResponse};
use terraswap::{
asset::AssetInfo, asset::PairInfo, pair::PoolResponse, pair::QueryMsg as PairQueryMsg,
querier::query_pair_info,
};
pub fn compute_premium_rate(
deps: Deps,
oracle_contract: Addr,
factory_contract: Addr,
asset_token: Addr,
base_denom: String,
) -> StdResult<(Decimal, bool)> {
let pair_info: PairInfo = query_pair_info(
&deps.querier,
factory_contract,
&[
AssetInfo::NativeToken { denom: base_denom },
AssetInfo::Token {
contract_addr: asset_token.to_string(),
},
],
)?;
let pool: PoolResponse = deps.querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: pair_info.contract_addr,
msg: to_binary(&PairQueryMsg::Pool {})?,
}))?;
let terraswap_price: Decimal = if pool.assets[0].is_native_token() {
if pool.assets[1].amount.is_zero() {
Decimal::from_ratio(pool.assets[0].amount, Uint128::from(1u128))
} else {
Decimal::from_ratio(pool.assets[0].amount, pool.assets[1].amount)
}
} else if pool.assets[0].amount.is_zero() {
Decimal::from_ratio(pool.assets[1].amount, Uint128::from(1u128))
} else {
Decimal::from_ratio(pool.assets[1].amount, pool.assets[0].amount)
};
let oracle_price: Decimal = query_price(deps, oracle_contract, asset_token.to_string())?;
if oracle_price.is_zero() {
Ok((Decimal::zero(), true))
} else if terraswap_price > oracle_price {
Ok((
decimal_division(
decimal_subtraction(terraswap_price, oracle_price),
oracle_price,
),
false,
))
} else {
Ok((Decimal::zero(), false))
}
}
pub fn compute_short_reward_weight(
querier: &QuerierWrapper,
short_reward_contract: Addr,
premium_rate: Decimal,
) -> StdResult<Decimal> {
let res: ShortRewardWeightResponse = querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: short_reward_contract.to_string(),
msg: to_binary(&ShortRewardQueryMsg::ShortRewardWeight { premium_rate })?,
}))?;
Ok(res.short_reward_weight)
}
pub fn query_price(deps: Deps, oracle: Addr, quote_asset: String) -> StdResult<Decimal> {
let res: PriceResponse = deps.querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: oracle.to_string(),
msg: to_binary(&OracleQueryMsg::Price {
asset_token: quote_asset,
timeframe: None,
})?,
}))?;
Ok(res.rate)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/rewards.rs | contracts/mirror_staking/src/rewards.rs | use cosmwasm_std::{
attr, to_binary, Addr, Api, CanonicalAddr, CosmosMsg, Decimal, Deps, DepsMut, Env, MessageInfo,
Order, Response, StdError, StdResult, Storage, Uint128, WasmMsg,
};
use crate::querier::{compute_premium_rate, compute_short_reward_weight};
use crate::state::{
read_config, read_is_migrated, read_pool_info, rewards_read, rewards_store, store_pool_info,
Config, PoolInfo, RewardInfo,
};
use mirror_protocol::staking::{RewardInfoResponse, RewardInfoResponseItem};
use cw20::Cw20ExecuteMsg;
pub fn adjust_premium(deps: DepsMut, env: Env, asset_tokens: Vec<String>) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let oracle_contract = deps.api.addr_humanize(&config.oracle_contract)?;
let terraswap_factory = deps.api.addr_humanize(&config.terraswap_factory)?;
let short_reward_contract = deps.api.addr_humanize(&config.short_reward_contract)?;
for asset_token in asset_tokens.iter() {
let asset_token_raw = deps.api.addr_canonicalize(asset_token)?;
let pool_info: PoolInfo = read_pool_info(deps.storage, &asset_token_raw)?;
if env.block.time.seconds()
< pool_info.premium_updated_time + config.premium_min_update_interval
{
return Err(StdError::generic_err(
"cannot adjust premium before premium_min_update_interval passed",
));
}
let asset_token_addr = deps.api.addr_validate(asset_token)?;
let (premium_rate, no_price_feed) = compute_premium_rate(
deps.as_ref(),
oracle_contract.clone(),
terraswap_factory.clone(),
asset_token_addr,
config.base_denom.to_string(),
)?;
// if asset does not have price feed, set short reward weight directly to zero
let short_reward_weight = if no_price_feed {
Decimal::zero()
} else {
compute_short_reward_weight(&deps.querier, short_reward_contract.clone(), premium_rate)?
};
store_pool_info(
deps.storage,
&asset_token_raw,
&PoolInfo {
premium_rate,
short_reward_weight,
premium_updated_time: env.block.time.seconds(),
..pool_info
},
)?;
}
Ok(Response::new().add_attributes(vec![attr("action", "premium_adjustment")]))
}
// deposit_reward must be from reward token contract
pub fn deposit_reward(
deps: DepsMut,
rewards: Vec<(String, Uint128)>,
rewards_amount: Uint128,
) -> StdResult<Response> {
for (asset_token, amount) in rewards.iter() {
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(asset_token)?;
let mut pool_info: PoolInfo = read_pool_info(deps.storage, &asset_token_raw)?;
// Decimal::from_ratio(1, 5).mul()
// erf(pool_info.premium_rate.0)
// 3.0f64
let total_reward = *amount;
let mut short_reward = total_reward * pool_info.short_reward_weight;
let mut normal_reward = total_reward.checked_sub(short_reward).unwrap();
if pool_info.total_bond_amount.is_zero() {
pool_info.pending_reward += normal_reward;
} else {
normal_reward += pool_info.pending_reward;
let normal_reward_per_bond =
Decimal::from_ratio(normal_reward, pool_info.total_bond_amount);
pool_info.reward_index = pool_info.reward_index + normal_reward_per_bond;
pool_info.pending_reward = Uint128::zero();
}
if pool_info.total_short_amount.is_zero() {
pool_info.short_pending_reward += short_reward;
} else {
short_reward += pool_info.short_pending_reward;
let short_reward_per_bond =
Decimal::from_ratio(short_reward, pool_info.total_short_amount);
pool_info.short_reward_index = pool_info.short_reward_index + short_reward_per_bond;
pool_info.short_pending_reward = Uint128::zero();
}
store_pool_info(deps.storage, &asset_token_raw, &pool_info)?;
}
Ok(Response::new().add_attributes(vec![
attr("action", "deposit_reward"),
attr("rewards_amount", rewards_amount.to_string()),
]))
}
// withdraw all rewards or single reward depending on asset_token
pub fn withdraw_reward(
deps: DepsMut,
info: MessageInfo,
asset_token: Option<Addr>,
) -> StdResult<Response> {
let staker_addr = deps.api.addr_canonicalize(info.sender.as_str())?;
let asset_token = asset_token.map(|a| deps.api.addr_canonicalize(a.as_str()).unwrap());
let normal_reward = _withdraw_reward(deps.storage, &staker_addr, &asset_token, false)?;
let short_reward = _withdraw_reward(deps.storage, &staker_addr, &asset_token, true)?;
let amount = normal_reward + short_reward;
let config: Config = read_config(deps.storage)?;
Ok(Response::new()
.add_message(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps.api.addr_humanize(&config.mirror_token)?.to_string(),
msg: to_binary(&Cw20ExecuteMsg::Transfer {
recipient: info.sender.to_string(),
amount,
})?,
funds: vec![],
}))
.add_attributes(vec![
attr("action", "withdraw"),
attr("amount", amount.to_string()),
]))
}
fn _withdraw_reward(
storage: &mut dyn Storage,
staker_addr: &CanonicalAddr,
asset_token: &Option<CanonicalAddr>,
is_short: bool,
) -> StdResult<Uint128> {
let rewards_bucket = rewards_read(storage, staker_addr, is_short);
// single reward withdraw
let reward_pairs: Vec<(CanonicalAddr, RewardInfo)> = if let Some(asset_token) = asset_token {
let reward_info = rewards_bucket.may_load(asset_token.as_slice())?;
if let Some(reward_info) = reward_info {
vec![(asset_token.clone(), reward_info)]
} else {
vec![]
}
} else {
rewards_bucket
.range(None, None, Order::Ascending)
.map(|item| {
let (k, v) = item?;
Ok((CanonicalAddr::from(k), v))
})
.collect::<StdResult<Vec<(CanonicalAddr, RewardInfo)>>>()?
};
let mut amount: Uint128 = Uint128::zero();
for reward_pair in reward_pairs {
let (asset_token_raw, mut reward_info) = reward_pair;
let pool_info: PoolInfo = read_pool_info(storage, &asset_token_raw)?;
// Withdraw reward to pending reward
// if the lp token was migrated, and the user did not close their position yet, cap the reward at the snapshot
let pool_index = if is_short {
pool_info.short_reward_index
} else if pool_info.migration_params.is_some()
&& !read_is_migrated(storage, &asset_token_raw, staker_addr)
{
pool_info.migration_params.unwrap().index_snapshot
} else {
pool_info.reward_index
};
before_share_change(pool_index, &mut reward_info)?;
amount += reward_info.pending_reward;
reward_info.pending_reward = Uint128::zero();
// Update rewards info
if reward_info.bond_amount.is_zero() {
rewards_store(storage, staker_addr, is_short).remove(asset_token_raw.as_slice());
} else {
rewards_store(storage, staker_addr, is_short)
.save(asset_token_raw.as_slice(), &reward_info)?;
}
}
Ok(amount)
}
// withdraw reward to pending reward
pub fn before_share_change(pool_index: Decimal, reward_info: &mut RewardInfo) -> StdResult<()> {
let pending_reward = (reward_info.bond_amount * pool_index)
.checked_sub(reward_info.bond_amount * reward_info.index)?;
reward_info.index = pool_index;
reward_info.pending_reward += pending_reward;
Ok(())
}
pub fn query_reward_info(
deps: Deps,
staker_addr: String,
asset_token: Option<String>,
) -> StdResult<RewardInfoResponse> {
let staker_addr_raw = deps.api.addr_canonicalize(staker_addr.as_str())?;
let reward_infos: Vec<RewardInfoResponseItem> = vec![
_read_reward_infos(
deps.api,
deps.storage,
&staker_addr_raw,
&asset_token,
false,
)?,
_read_reward_infos(deps.api, deps.storage, &staker_addr_raw, &asset_token, true)?,
]
.concat();
Ok(RewardInfoResponse {
staker_addr,
reward_infos,
})
}
fn _read_reward_infos(
api: &dyn Api,
storage: &dyn Storage,
staker_addr: &CanonicalAddr,
asset_token: &Option<String>,
is_short: bool,
) -> StdResult<Vec<RewardInfoResponseItem>> {
let rewards_bucket = rewards_read(storage, staker_addr, is_short);
let reward_infos: Vec<RewardInfoResponseItem> = if let Some(asset_token) = asset_token {
let asset_token_raw = api.addr_canonicalize(asset_token.as_str())?;
if let Some(mut reward_info) = rewards_bucket.may_load(asset_token_raw.as_slice())? {
let pool_info = read_pool_info(storage, &asset_token_raw)?;
let (pool_index, should_migrate) = if is_short {
(pool_info.short_reward_index, None)
} else if pool_info.migration_params.is_some()
&& !read_is_migrated(storage, &asset_token_raw, staker_addr)
{
(
pool_info.migration_params.unwrap().index_snapshot,
Some(true),
)
} else {
(pool_info.reward_index, None)
};
before_share_change(pool_index, &mut reward_info)?;
vec![RewardInfoResponseItem {
asset_token: asset_token.clone(),
bond_amount: reward_info.bond_amount,
pending_reward: reward_info.pending_reward,
is_short,
should_migrate,
}]
} else {
vec![]
}
} else {
rewards_bucket
.range(None, None, Order::Ascending)
.map(|item| {
let (k, v) = item?;
let asset_token_raw = CanonicalAddr::from(k);
let mut reward_info = v;
let pool_info = read_pool_info(storage, &asset_token_raw)?;
let (pool_index, should_migrate) = if is_short {
(pool_info.short_reward_index, None)
} else if pool_info.migration_params.is_some()
&& !read_is_migrated(storage, &asset_token_raw, staker_addr)
{
(
pool_info.migration_params.unwrap().index_snapshot,
Some(true),
)
} else {
(pool_info.reward_index, None)
};
before_share_change(pool_index, &mut reward_info)?;
Ok(RewardInfoResponseItem {
asset_token: api.addr_humanize(&asset_token_raw)?.to_string(),
bond_amount: reward_info.bond_amount,
pending_reward: reward_info.pending_reward,
is_short,
should_migrate,
})
})
.collect::<StdResult<Vec<RewardInfoResponseItem>>>()?
};
Ok(reward_infos)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/testing/deprecate_test.rs | contracts/mirror_staking/src/testing/deprecate_test.rs | use crate::contract::{execute, instantiate, query};
use crate::state::{read_pool_info, store_pool_info, PoolInfo};
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
use cosmwasm_std::{
from_binary, to_binary, Api, CosmosMsg, Decimal, StdError, SubMsg, Uint128, WasmMsg,
};
use cw20::{Cw20ExecuteMsg, Cw20ReceiveMsg};
use mirror_protocol::staking::{
Cw20HookMsg, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg, RewardInfoResponse,
RewardInfoResponseItem,
};
#[test]
fn test_deprecate() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// bond 100 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// bond 200 short token
let msg = ExecuteMsg::IncreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::new(200u128),
};
let info = mock_info("mint", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// factory deposit 100 reward tokens
// distribute weight => 80:20
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// query pool and reward info
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
let res_cmp = res.clone();
assert_eq!(
res_cmp,
PoolInfoResponse {
total_bond_amount: Uint128::new(100u128),
total_short_amount: Uint128::new(200u128),
reward_index: Decimal::from_ratio(80u128, 100u128),
short_reward_index: Decimal::from_ratio(20u128, 200u128),
short_pending_reward: Uint128::zero(),
migration_index_snapshot: None,
migration_deprecated_staking_token: None,
..res
}
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(100u128),
pending_reward: Uint128::new(80u128),
is_short: false,
should_migrate: None,
},
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(200u128),
pending_reward: Uint128::new(20u128),
is_short: true,
should_migrate: None,
},
],
}
);
// execute deprecate
let msg = ExecuteMsg::DeprecateStakingToken {
asset_token: "asset".to_string(),
new_staking_token: "new_staking".to_string(),
};
let info = mock_info("owner", &[]);
execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// deposit more rewards
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// query again
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
let res_cmp = res.clone();
assert_eq!(
res_cmp,
PoolInfoResponse {
staking_token: "new_staking".to_string(),
total_bond_amount: Uint128::zero(), // reset
total_short_amount: Uint128::new(200u128),
reward_index: Decimal::from_ratio(80u128, 100u128), // stays the same
short_reward_index: Decimal::from_ratio(40u128, 200u128), // increased 20
short_pending_reward: Uint128::zero(),
migration_index_snapshot: Some(Decimal::from_ratio(80u128, 100u128)),
migration_deprecated_staking_token: Some("staking".to_string()),
pending_reward: Uint128::new(80u128), // new reward waiting here
..res
}
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(100u128),
pending_reward: Uint128::new(80u128), // did not change
is_short: false,
should_migrate: Some(true), // non-short pos should migrate
},
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(200u128),
pending_reward: Uint128::new(40u128), // more rewards here
is_short: true,
should_migrate: None,
},
],
}
);
// try to bond new or old staking token, should fail both
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let err = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err();
assert_eq!(
err,
StdError::generic_err("The staking token for this asset has been migrated to new_staking")
);
let info = mock_info("new_staking", &[]);
let err = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
assert_eq!(
err,
StdError::generic_err("The LP token for this asset has been deprecated, withdraw all your deprecated tokens to migrate your position")
);
// unbond all the old tokens
let msg = ExecuteMsg::Unbond {
asset_token: "asset".to_string(),
amount: Uint128::new(100u128),
};
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// make sure that we are receiving deprecated lp tokens tokens
assert_eq!(
res.messages,
vec![SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "staking".to_string(),
msg: to_binary(&Cw20ExecuteMsg::Transfer {
recipient: "addr".to_string(),
amount: Uint128::new(100u128),
})
.unwrap(),
funds: vec![],
}))]
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::zero(),
pending_reward: Uint128::new(80u128), // still the same
is_short: false,
should_migrate: None, // now its back to empty
},
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(200u128),
pending_reward: Uint128::new(40u128),
is_short: true,
should_migrate: None,
},
],
}
);
// now can bond the new staking token
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("new_staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// deposit new rewards
// will also add to the index the pending rewards from before the migration
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// expect to have 80 * 3 rewards
// initial + deposit after deprecation + deposit after bonding again
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(100u128),
pending_reward: Uint128::new(240u128), // 80 * 3
is_short: false,
should_migrate: None,
},
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(200u128),
pending_reward: Uint128::new(60u128), // 40 + 20
is_short: true,
should_migrate: None,
},
],
}
);
// completely new users can bond
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "newaddr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("new_staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "newaddr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "newaddr".to_string(),
reward_infos: vec![RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(100u128),
pending_reward: Uint128::zero(),
is_short: false,
should_migrate: None,
},],
}
);
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/testing/staking_test.rs | contracts/mirror_staking/src/testing/staking_test.rs | use crate::contract::{execute, instantiate, query};
use crate::testing::mock_querier::mock_dependencies_with_querier;
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info, MOCK_CONTRACT_ADDR};
use cosmwasm_std::{
attr, from_binary, to_binary, Addr, Coin, CosmosMsg, Decimal, StdError, SubMsg, Uint128,
WasmMsg,
};
use cw20::{Cw20ExecuteMsg, Cw20ReceiveMsg};
use mirror_protocol::staking::{
Cw20HookMsg, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg, RewardInfoResponse,
RewardInfoResponseItem,
};
use terraswap::asset::{Asset, AssetInfo};
use terraswap::pair::ExecuteMsg as PairExecuteMsg;
#[test]
fn test_bond_tokens() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: Some("asset".to_string()),
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![RewardInfoResponseItem {
asset_token: "asset".to_string(),
pending_reward: Uint128::zero(),
bond_amount: Uint128::new(100u128),
is_short: false,
should_migrate: None,
}],
}
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&data).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
total_bond_amount: Uint128::new(100u128),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
// bond 100 more tokens from other account
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr2".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&data).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
total_bond_amount: Uint128::new(200u128),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
// failed with unauthorized
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking2", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg);
match res {
Err(StdError::GenericErr { msg, .. }) => assert_eq!(msg, "unauthorized"),
_ => panic!("Must return unauthorized error"),
}
}
#[test]
fn test_unbond() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
// register asset
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// bond 100 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// unbond 150 tokens; failed
let msg = ExecuteMsg::Unbond {
asset_token: "asset".to_string(),
amount: Uint128::new(150u128),
};
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => {
assert_eq!(msg, "Cannot unbond more than bond amount");
}
_ => panic!("Must return generic error"),
};
// normal unbond
let msg = ExecuteMsg::Unbond {
asset_token: "asset".to_string(),
amount: Uint128::new(100u128),
};
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
res.messages,
vec![SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "staking".to_string(),
msg: to_binary(&Cw20ExecuteMsg::Transfer {
recipient: "addr".to_string(),
amount: Uint128::new(100u128),
})
.unwrap(),
funds: vec![],
}))]
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&data).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
total_bond_amount: Uint128::zero(),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![],
}
);
}
#[test]
fn test_increase_short_token() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::IncreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::from(100u128),
};
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg.clone());
match res {
Err(StdError::GenericErr { msg, .. }) => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
let info = mock_info("mint", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
vec![
attr("action", "increase_short_token"),
attr("staker_addr", "addr"),
attr("asset_token", "asset"),
attr("amount", "100"),
],
res.attributes
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&data).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
total_bond_amount: Uint128::zero(),
total_short_amount: Uint128::from(100u128),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![RewardInfoResponseItem {
asset_token: "asset".to_string(),
pending_reward: Uint128::zero(),
bond_amount: Uint128::new(100u128),
is_short: true,
should_migrate: None,
}],
}
);
}
#[test]
fn test_decrease_short_token() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::IncreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::from(100u128),
};
let info = mock_info("mint", &[]);
let _ = execute(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::DecreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::from(100u128),
};
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
vec![
attr("action", "decrease_short_token"),
attr("staker_addr", "addr"),
attr("asset_token", "asset"),
attr("amount", "100"),
],
res.attributes
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&data).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
total_bond_amount: Uint128::zero(),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![],
}
);
}
#[test]
fn test_auto_stake() {
let mut deps = mock_dependencies_with_querier(&[]);
deps.querier.with_pair_info(Addr::unchecked("pair"));
deps.querier.with_pool_assets([
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::from(100u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::from(1u128),
},
]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "lptoken".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// no token asset
let msg = ExecuteMsg::AutoStake {
assets: [
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::new(100u128),
},
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::new(100u128),
},
],
slippage_tolerance: None,
};
let info = mock_info(
"addr0000",
&[Coin {
denom: "uusd".to_string(),
amount: Uint128::new(100u128),
}],
);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
assert_eq!(res, StdError::generic_err("Missing token asset"));
// no native asset
let msg = ExecuteMsg::AutoStake {
assets: [
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::from(1u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::from(1u128),
},
],
slippage_tolerance: None,
};
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
assert_eq!(res, StdError::generic_err("Missing native asset"));
let msg = ExecuteMsg::AutoStake {
assets: [
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::new(100u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::new(1u128),
},
],
slippage_tolerance: None,
};
// attempt with no coins
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err();
assert_eq!(
res,
StdError::generic_err(
"Native token balance mismatch between the argument and the transferred"
)
);
let info = mock_info(
"addr0000",
&[Coin {
denom: "uusd".to_string(),
amount: Uint128::new(100u128),
}],
);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
res.messages,
vec![
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "asset".to_string(),
msg: to_binary(&Cw20ExecuteMsg::TransferFrom {
owner: "addr0000".to_string(),
recipient: MOCK_CONTRACT_ADDR.to_string(),
amount: Uint128::new(1u128),
})
.unwrap(),
funds: vec![],
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "asset".to_string(),
msg: to_binary(&Cw20ExecuteMsg::IncreaseAllowance {
spender: "pair".to_string(),
amount: Uint128::new(1),
expires: None,
})
.unwrap(),
funds: vec![],
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "pair".to_string(),
msg: to_binary(&PairExecuteMsg::ProvideLiquidity {
assets: [
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string()
},
amount: Uint128::new(99u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string()
},
amount: Uint128::new(1u128),
},
],
slippage_tolerance: None,
receiver: None,
})
.unwrap(),
funds: vec![Coin {
denom: "uusd".to_string(),
amount: Uint128::new(99u128), // 1% tax
}],
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: MOCK_CONTRACT_ADDR.to_string(),
msg: to_binary(&ExecuteMsg::AutoStakeHook {
asset_token: "asset".to_string(),
staking_token: "lptoken".to_string(),
staker_addr: "addr0000".to_string(),
prev_staking_token_amount: Uint128::new(0),
})
.unwrap(),
funds: vec![],
}))
]
);
deps.querier.with_token_balance(Uint128::new(100u128)); // recive 100 lptoken
// wrong asset
let msg = ExecuteMsg::AutoStakeHook {
asset_token: "asset1".to_string(),
staking_token: "lptoken".to_string(),
staker_addr: "addr0000".to_string(),
prev_staking_token_amount: Uint128::new(0),
};
let info = mock_info(MOCK_CONTRACT_ADDR, &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err(); // pool not found error
// valid msg
let msg = ExecuteMsg::AutoStakeHook {
asset_token: "asset".to_string(),
staking_token: "lptoken".to_string(),
staker_addr: "addr0000".to_string(),
prev_staking_token_amount: Uint128::new(0),
};
// unauthorized attempt
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err();
assert_eq!(res, StdError::generic_err("unauthorized"));
// successfull attempt
let info = mock_info(MOCK_CONTRACT_ADDR, &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
res.attributes,
vec![
attr("action", "bond"),
attr("staker_addr", "addr0000"),
attr("asset_token", "asset"),
attr("amount", "100"),
]
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&data).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "lptoken".to_string(),
total_bond_amount: Uint128::new(100u128),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/testing/mock_querier.rs | contracts/mirror_staking/src/testing/mock_querier.rs | use cosmwasm_std::testing::{MockApi, MockQuerier, MockStorage, MOCK_CONTRACT_ADDR};
use cosmwasm_std::{
from_binary, from_slice, to_binary, Addr, Coin, ContractResult, Decimal, OwnedDeps, Querier,
QuerierResult, QueryRequest, SystemError, SystemResult, Uint128, WasmQuery,
};
use cosmwasm_storage::to_length_prefixed;
use mirror_protocol::short_reward::ShortRewardWeightResponse;
use serde::Deserialize;
use tefi_oracle::hub::PriceResponse;
use terra_cosmwasm::{TaxCapResponse, TaxRateResponse, TerraQuery, TerraQueryWrapper, TerraRoute};
use terraswap::{asset::Asset, asset::AssetInfo, asset::PairInfo, pair::PoolResponse};
pub struct WasmMockQuerier {
base: MockQuerier<TerraQueryWrapper>,
pair_addr: Addr,
pool_assets: [Asset; 2],
oracle_price: Decimal,
token_balance: Uint128,
tax: (Decimal, Uint128),
short_reward_weight: Decimal,
}
pub fn mock_dependencies_with_querier(
contract_balance: &[Coin],
) -> OwnedDeps<MockStorage, MockApi, WasmMockQuerier> {
let custom_querier: WasmMockQuerier =
WasmMockQuerier::new(MockQuerier::new(&[(MOCK_CONTRACT_ADDR, contract_balance)]));
OwnedDeps {
api: MockApi::default(),
storage: MockStorage::default(),
querier: custom_querier,
}
}
impl Querier for WasmMockQuerier {
fn raw_query(&self, bin_request: &[u8]) -> QuerierResult {
// MockQuerier doesn't support Custom, so we ignore it completely here
let request: QueryRequest<TerraQueryWrapper> = match from_slice(bin_request) {
Ok(v) => v,
Err(e) => {
return SystemResult::Err(SystemError::InvalidRequest {
error: format!("Parsing query request: {}", e),
request: bin_request.into(),
})
}
};
self.handle_query(&request)
}
}
#[derive(Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum MockQueryMsg {
Pair {
asset_infos: [AssetInfo; 2],
},
Price {
asset_token: String,
timeframe: Option<u64>,
},
Pool {},
ShortRewardWeight {
premium_rate: Decimal,
},
Balance {
address: String,
},
}
impl WasmMockQuerier {
pub fn handle_query(&self, request: &QueryRequest<TerraQueryWrapper>) -> QuerierResult {
match &request {
QueryRequest::Custom(TerraQueryWrapper { route, query_data }) => {
if route == &TerraRoute::Treasury {
match query_data {
TerraQuery::TaxRate {} => {
let res = TaxRateResponse { rate: self.tax.0 };
SystemResult::Ok(ContractResult::from(to_binary(&res)))
}
TerraQuery::TaxCap { .. } => {
let res = TaxCapResponse { cap: self.tax.1 };
SystemResult::Ok(ContractResult::from(to_binary(&res)))
}
_ => panic!("DO NOT ENTER HERE"),
}
} else {
panic!("DO NOT ENTER HERE")
}
}
QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: _,
msg,
}) => match from_binary(msg).unwrap() {
MockQueryMsg::Pair { asset_infos } => {
SystemResult::Ok(ContractResult::from(to_binary(&PairInfo {
asset_infos,
contract_addr: self.pair_addr.to_string(),
liquidity_token: "lptoken".to_string(),
})))
}
MockQueryMsg::ShortRewardWeight { .. } => SystemResult::Ok(ContractResult::from(
to_binary(&ShortRewardWeightResponse {
short_reward_weight: self.short_reward_weight,
}),
)),
MockQueryMsg::Pool {} => {
SystemResult::Ok(ContractResult::from(to_binary(&PoolResponse {
assets: self.pool_assets.clone(),
total_share: Uint128::zero(),
})))
}
MockQueryMsg::Price {
asset_token: _,
timeframe: _,
} => SystemResult::Ok(ContractResult::from(to_binary(&PriceResponse {
rate: self.oracle_price,
last_updated: 100,
}))),
MockQueryMsg::Balance { address: _ } => {
SystemResult::Ok(ContractResult::from(to_binary(&cw20::BalanceResponse {
balance: self.token_balance,
})))
}
},
QueryRequest::Wasm(WasmQuery::Raw {
contract_addr: _,
key,
}) => {
let key: &[u8] = key.as_slice();
let prefix_balance = to_length_prefixed(b"balance").to_vec();
if key[..prefix_balance.len()].to_vec() == prefix_balance {
SystemResult::Ok(ContractResult::from(to_binary(&self.token_balance)))
} else {
panic!("DO NOT ENTER HERE")
}
}
_ => self.base.handle_query(request),
}
}
}
impl WasmMockQuerier {
pub fn new(base: MockQuerier<TerraQueryWrapper>) -> Self {
WasmMockQuerier {
base,
pair_addr: Addr::unchecked(""),
pool_assets: [
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::zero(),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::zero(),
},
],
oracle_price: Decimal::zero(),
token_balance: Uint128::zero(),
tax: (Decimal::percent(1), Uint128::new(1000000)),
short_reward_weight: Decimal::percent(20),
}
}
pub fn with_pair_info(&mut self, pair_addr: Addr) {
self.pair_addr = pair_addr;
}
pub fn with_pool_assets(&mut self, pool_assets: [Asset; 2]) {
self.pool_assets = pool_assets;
}
pub fn with_oracle_price(&mut self, oracle_price: Decimal) {
self.oracle_price = oracle_price;
}
pub fn with_token_balance(&mut self, token_balance: Uint128) {
self.token_balance = token_balance;
}
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/testing/reward_test.rs | contracts/mirror_staking/src/testing/reward_test.rs | use crate::contract::{execute, instantiate, query};
use crate::state::{read_pool_info, rewards_read, store_pool_info, PoolInfo, RewardInfo};
use crate::testing::mock_querier::mock_dependencies_with_querier;
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
use cosmwasm_std::{
from_binary, to_binary, Addr, Api, CosmosMsg, Decimal, StdError, SubMsg, Uint128, WasmMsg,
};
use cw20::{Cw20ExecuteMsg, Cw20ReceiveMsg};
use mirror_protocol::staking::{
Cw20HookMsg, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg, RewardInfoResponse,
RewardInfoResponseItem,
};
use terraswap::asset::{Asset, AssetInfo};
#[test]
fn test_deposit_reward() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// store 3% premium rate
let token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// bond 100 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// bond 100 short token
let msg = ExecuteMsg::IncreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::new(100u128),
};
let info = mock_info("mint", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// factory deposit 100 reward tokens
// premium is 0, so rewards distributed 80:20
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info.clone(), msg.clone()).unwrap();
// Check pool state
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
let res_cmp = res.clone();
assert_eq!(
res_cmp,
PoolInfoResponse {
total_bond_amount: Uint128::new(100u128),
total_short_amount: Uint128::new(100u128),
reward_index: Decimal::from_ratio(80u128, 100u128),
short_reward_index: Decimal::from_ratio(20u128, 100u128),
..res
}
);
// if premium_rate is over threshold, distribution weight should be 60:40
let asset_token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info: PoolInfo = read_pool_info(&deps.storage, &asset_token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&asset_token_raw,
&PoolInfo {
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
premium_rate: Decimal::percent(10),
short_reward_weight: Decimal::percent(40),
..pool_info
},
)
.unwrap();
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
let res_cmp = res.clone();
assert_eq!(
res_cmp,
PoolInfoResponse {
total_bond_amount: Uint128::new(100u128),
total_short_amount: Uint128::new(100u128),
reward_index: Decimal::from_ratio(60u128, 100u128),
short_reward_index: Decimal::from_ratio(40u128, 100u128),
..res
}
);
}
#[test]
fn test_deposit_reward_when_no_bonding() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// store 3% premium rate
let token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// factory deposit 100 reward tokens
// premium is 0, so rewards distributed 80:20
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info.clone(), msg.clone()).unwrap();
// Check pool state
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
let res_cmp = res.clone();
assert_eq!(
res_cmp,
PoolInfoResponse {
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::new(80u128),
short_pending_reward: Uint128::new(20u128),
..res
}
);
// if premium_rate is over threshold, distribution weight should be 60:40
let asset_token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info: PoolInfo = read_pool_info(&deps.storage, &asset_token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&asset_token_raw,
&PoolInfo {
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::percent(10),
short_reward_weight: Decimal::percent(40),
..pool_info
},
)
.unwrap();
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
let res_cmp = res.clone();
assert_eq!(
res_cmp,
PoolInfoResponse {
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::new(60u128),
short_pending_reward: Uint128::new(40u128),
..res
}
);
}
#[test]
fn test_before_share_changes() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// store 3% premium rate
let token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// bond 100 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// bond 100 short token
let msg = ExecuteMsg::IncreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::new(100u128),
};
let info = mock_info("mint", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// factory deposit 100 reward tokens
// premium is 0, so rewards distributed 80:20
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let asset_raw = deps.api.addr_canonicalize("asset").unwrap();
let addr_raw = deps.api.addr_canonicalize("addr").unwrap();
let reward_bucket = rewards_read(&deps.storage, &addr_raw, false);
let reward_info: RewardInfo = reward_bucket.load(asset_raw.as_slice()).unwrap();
assert_eq!(
RewardInfo {
pending_reward: Uint128::zero(),
bond_amount: Uint128::new(100u128),
index: Decimal::zero(),
},
reward_info
);
// bond 100 more tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let reward_bucket = rewards_read(&deps.storage, &addr_raw, false);
let reward_info: RewardInfo = reward_bucket.load(asset_raw.as_slice()).unwrap();
assert_eq!(
RewardInfo {
pending_reward: Uint128::new(80u128),
bond_amount: Uint128::new(200u128),
index: Decimal::from_ratio(80u128, 100u128),
},
reward_info
);
// factory deposit 100 reward tokens; = 0.8 + 0.4 = 1.2 is reward_index
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// unbond
let msg = ExecuteMsg::Unbond {
asset_token: "asset".to_string(),
amount: Uint128::new(100u128),
};
let info = mock_info("addr", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let reward_bucket = rewards_read(&deps.storage, &addr_raw, false);
let reward_info: RewardInfo = reward_bucket.load(asset_raw.as_slice()).unwrap();
assert_eq!(
RewardInfo {
pending_reward: Uint128::new(160u128),
bond_amount: Uint128::new(100u128),
index: Decimal::from_ratio(120u128, 100u128),
},
reward_info
);
}
#[test]
fn test_withdraw() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// store 3% premium rate
let token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// bond 100 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// factory deposit 100 reward tokens
// premium_rate is zero; distribute weight => 80:20
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![("asset".to_string(), Uint128::new(100u128))],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::Withdraw {
asset_token: Some("asset".to_string()),
};
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
res.messages,
vec![SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "reward".to_string(),
msg: to_binary(&Cw20ExecuteMsg::Transfer {
recipient: "addr".to_string(),
amount: Uint128::new(80u128),
})
.unwrap(),
funds: vec![],
}))]
);
}
#[test]
fn withdraw_multiple_rewards() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset2".to_string(),
staking_token: "staking2".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// store 3% premium rate
let token_raw = deps.api.addr_canonicalize("asset").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// store 3% premium rate for asset2
let token_raw = deps.api.addr_canonicalize("asset2").unwrap();
let pool_info = read_pool_info(&deps.storage, &token_raw).unwrap();
store_pool_info(
&mut deps.storage,
&token_raw,
&PoolInfo {
premium_rate: Decimal::percent(2),
short_reward_weight: Decimal::percent(20),
..pool_info
},
)
.unwrap();
// bond 100 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(100u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset".to_string(),
})
.unwrap(),
});
let info = mock_info("staking", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// bond second 1000 tokens
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "addr".to_string(),
amount: Uint128::new(1000u128),
msg: to_binary(&Cw20HookMsg::Bond {
asset_token: "asset2".to_string(),
})
.unwrap(),
});
let info = mock_info("staking2", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// bond 50 short token
let msg = ExecuteMsg::IncreaseShortToken {
asset_token: "asset".to_string(),
staker_addr: "addr".to_string(),
amount: Uint128::new(50u128),
};
let info = mock_info("mint", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// factory deposit asset
let msg = ExecuteMsg::Receive(Cw20ReceiveMsg {
sender: "factory".to_string(),
amount: Uint128::new(300u128),
msg: to_binary(&Cw20HookMsg::DepositReward {
rewards: vec![
("asset".to_string(), Uint128::new(100u128)),
("asset2".to_string(), Uint128::new(200u128)),
],
})
.unwrap(),
});
let info = mock_info("reward", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(100u128),
pending_reward: Uint128::new(80u128),
is_short: false,
should_migrate: None,
},
RewardInfoResponseItem {
asset_token: "asset2".to_string(),
bond_amount: Uint128::new(1000u128),
pending_reward: Uint128::new(160u128),
is_short: false,
should_migrate: None,
},
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(50u128),
pending_reward: Uint128::new(20u128),
is_short: true,
should_migrate: None,
},
],
}
);
// withdraw all
let msg = ExecuteMsg::Withdraw { asset_token: None };
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
res.messages,
vec![SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "reward".to_string(),
msg: to_binary(&Cw20ExecuteMsg::Transfer {
recipient: "addr".to_string(),
amount: Uint128::new(260u128),
})
.unwrap(),
funds: vec![],
}))]
);
let data = query(
deps.as_ref(),
mock_env(),
QueryMsg::RewardInfo {
asset_token: None,
staker_addr: "addr".to_string(),
},
)
.unwrap();
let res: RewardInfoResponse = from_binary(&data).unwrap();
assert_eq!(
res,
RewardInfoResponse {
staker_addr: "addr".to_string(),
reward_infos: vec![
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(100u128),
pending_reward: Uint128::zero(),
is_short: false,
should_migrate: None,
},
RewardInfoResponseItem {
asset_token: "asset2".to_string(),
bond_amount: Uint128::new(1000u128),
pending_reward: Uint128::zero(),
is_short: false,
should_migrate: None,
},
RewardInfoResponseItem {
asset_token: "asset".to_string(),
bond_amount: Uint128::new(50u128),
pending_reward: Uint128::zero(),
is_short: true,
should_migrate: None,
},
],
}
);
}
#[test]
fn test_adjust_premium() {
let mut deps = mock_dependencies_with_querier(&[]);
// terraswap price 100
// oracle price 100
// premium zero
deps.querier.with_pair_info(Addr::unchecked("pair"));
deps.querier.with_pool_assets([
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::from(100u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::from(1u128),
},
]);
deps.querier
.with_oracle_price(Decimal::from_ratio(100u128, 1u128));
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
let info = mock_info("owner", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::AdjustPremium {
asset_tokens: vec!["asset".to_string()],
};
let mut env = mock_env();
let info = mock_info("addr", &[]);
let _ = execute(deps.as_mut(), env.clone(), info.clone(), msg.clone()).unwrap();
// Check pool state
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
assert_eq!(res.premium_rate, Decimal::zero());
assert_eq!(res.premium_updated_time, env.block.time.seconds());
// terraswap price = 90
// premium rate = 0
deps.querier.with_pool_assets([
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::from(90u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::from(1u128),
},
]);
// assert premium update interval
let res = execute(deps.as_mut(), env.clone(), info.clone(), msg.clone());
match res {
Err(StdError::GenericErr { msg, .. }) => assert_eq!(
msg,
"cannot adjust premium before premium_min_update_interval passed"
),
_ => panic!("DO NOT ENTER HERE"),
}
env.block.time = env.block.time.plus_seconds(3600);
let _ = execute(deps.as_mut(), env.clone(), info.clone(), msg.clone()).unwrap();
// Check pool state
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
assert_eq!(res.premium_rate, Decimal::zero());
assert_eq!(res.premium_updated_time, env.block.time.seconds());
// terraswap price = 105
// premium rate = 5%
deps.querier.with_pool_assets([
Asset {
info: AssetInfo::NativeToken {
denom: "uusd".to_string(),
},
amount: Uint128::from(105u128),
},
Asset {
info: AssetInfo::Token {
contract_addr: "asset".to_string(),
},
amount: Uint128::from(1u128),
},
]);
env.block.time = env.block.time.plus_seconds(3600);
let _ = execute(deps.as_mut(), env.clone(), info, msg).unwrap();
// Check pool state
let res: PoolInfoResponse = from_binary(
&query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap(),
)
.unwrap();
assert_eq!(res.premium_rate, Decimal::percent(5));
assert_eq!(res.premium_updated_time, env.block.time.seconds());
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/testing/mod.rs | contracts/mirror_staking/src/testing/mod.rs | mod contract_test;
mod deprecate_test;
mod mock_querier;
mod reward_test;
mod staking_test;
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/src/testing/contract_test.rs | contracts/mirror_staking/src/testing/contract_test.rs | use crate::contract::{execute, instantiate, query};
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
use cosmwasm_std::{attr, from_binary, Addr, Decimal, StdError, Uint128};
use mirror_protocol::staking::{
ConfigResponse, ExecuteMsg, InstantiateMsg, PoolInfoResponse, QueryMsg,
};
#[test]
fn proper_initialization() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: "short_reward".to_string(),
};
let info = mock_info("addr", &[]);
// we can just call .unwrap() to assert this was a success
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
// it worked, let's query the state
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!(
ConfigResponse {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: Addr::unchecked("short_reward").to_string(),
},
config
);
}
#[test]
fn update_config() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: Addr::unchecked("short_reward").to_string(),
};
let info = mock_info("addr", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
// update owner
let info = mock_info("owner", &[]);
let msg = ExecuteMsg::UpdateConfig {
owner: Some("owner2".to_string()),
premium_min_update_interval: Some(7200),
short_reward_contract: Some(Addr::unchecked("new_short_reward").to_string()),
};
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(0, res.messages.len());
// it worked, let's query the state
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!(
ConfigResponse {
owner: "owner2".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 7200,
short_reward_contract: Addr::unchecked("new_short_reward").to_string(),
},
config
);
// unauthorized err
let info = mock_info("owner", &[]);
let msg = ExecuteMsg::UpdateConfig {
owner: None,
premium_min_update_interval: Some(7200),
short_reward_contract: None,
};
let res = execute(deps.as_mut(), mock_env(), info, msg);
match res {
Err(StdError::GenericErr { msg, .. }) => assert_eq!(msg, "unauthorized"),
_ => panic!("Must return unauthorized error"),
}
}
#[test]
fn test_register() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner".to_string(),
mirror_token: "reward".to_string(),
mint_contract: "mint".to_string(),
oracle_contract: "oracle".to_string(),
terraswap_factory: "terraswap_factory".to_string(),
base_denom: "uusd".to_string(),
premium_min_update_interval: 3600,
short_reward_contract: Addr::unchecked("short_reward").to_string(),
};
let info = mock_info("addr", &[]);
// we can just call .unwrap() to assert this was a success
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
};
// failed with unauthorized error
let info = mock_info("addr", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
let info = mock_info("owner", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(
res.attributes,
vec![
attr("action", "register_asset"),
attr("asset_token", "asset"),
]
);
let res = query(
deps.as_ref(),
mock_env(),
QueryMsg::PoolInfo {
asset_token: "asset".to_string(),
},
)
.unwrap();
let pool_info: PoolInfoResponse = from_binary(&res).unwrap();
assert_eq!(
pool_info,
PoolInfoResponse {
asset_token: "asset".to_string(),
staking_token: "staking".to_string(),
total_bond_amount: Uint128::zero(),
total_short_amount: Uint128::zero(),
reward_index: Decimal::zero(),
short_reward_index: Decimal::zero(),
pending_reward: Uint128::zero(),
short_pending_reward: Uint128::zero(),
premium_rate: Decimal::zero(),
short_reward_weight: Decimal::zero(),
premium_updated_time: 0,
migration_deprecated_staking_token: None,
migration_index_snapshot: None,
}
);
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_staking/examples/schema.rs | contracts/mirror_staking/examples/schema.rs | use std::env::current_dir;
use std::fs::create_dir_all;
use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
use mirror_protocol::staking::{
ConfigResponse, Cw20HookMsg, ExecuteMsg, InstantiateMsg, MigrateMsg, PoolInfoResponse,
QueryMsg, RewardInfoResponse,
};
fn main() {
let mut out_dir = current_dir().unwrap();
out_dir.push("schema");
create_dir_all(&out_dir).unwrap();
remove_schemas(&out_dir).unwrap();
export_schema(&schema_for!(InstantiateMsg), &out_dir);
export_schema(&schema_for!(ExecuteMsg), &out_dir);
export_schema(&schema_for!(Cw20HookMsg), &out_dir);
export_schema(&schema_for!(QueryMsg), &out_dir);
export_schema(&schema_for!(MigrateMsg), &out_dir);
export_schema(&schema_for!(ConfigResponse), &out_dir);
export_schema(&schema_for!(RewardInfoResponse), &out_dir);
export_schema(&schema_for!(PoolInfoResponse), &out_dir);
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_oracle/src/contract.rs | contracts/mirror_oracle/src/contract.rs | #[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{
attr, to_binary, Binary, Decimal, Deps, DepsMut, Env, MessageInfo, Response, StdError,
StdResult,
};
use crate::math::decimal_division;
use crate::state::{
read_config, read_feeder, read_price, read_prices, store_config, store_feeder, store_price,
Config, PriceInfo,
};
use mirror_protocol::common::OrderBy;
use mirror_protocol::oracle::{
ConfigResponse, ExecuteMsg, FeederResponse, InstantiateMsg, MigrateMsg, PriceResponse,
PricesResponse, PricesResponseElem, QueryMsg,
};
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
deps: DepsMut,
_env: Env,
_info: MessageInfo,
msg: InstantiateMsg,
) -> StdResult<Response> {
store_config(
deps.storage,
&Config {
owner: deps.api.addr_canonicalize(&msg.owner)?,
base_asset: msg.base_asset,
},
)?;
Ok(Response::default())
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> StdResult<Response> {
match msg {
ExecuteMsg::UpdateConfig { owner } => try_update_config(deps, info, owner),
ExecuteMsg::RegisterAsset {
asset_token,
feeder,
} => try_register_asset(deps, info, asset_token, feeder),
ExecuteMsg::FeedPrice { prices } => try_feed_price(deps, env, info, prices),
}
}
pub fn try_update_config(
deps: DepsMut,
info: MessageInfo,
owner: Option<String>,
) -> StdResult<Response> {
let mut config: Config = read_config(deps.storage)?;
if deps.api.addr_canonicalize(info.sender.as_str())? != config.owner {
return Err(StdError::generic_err("unauthorized"));
}
if let Some(owner) = owner {
config.owner = deps.api.addr_canonicalize(&owner)?;
}
store_config(deps.storage, &config)?;
Ok(Response::default())
}
pub fn try_register_asset(
deps: DepsMut,
info: MessageInfo,
asset_token: String,
feeder: String,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
let asset_token_raw = deps.api.addr_canonicalize(&asset_token)?;
// check if it is a new asset
if read_feeder(deps.storage, &asset_token_raw).is_err() {
store_price(
deps.storage,
&asset_token_raw,
&PriceInfo {
price: Decimal::zero(),
last_updated_time: 0u64,
},
)?;
}
// update/store feeder
store_feeder(
deps.storage,
&asset_token_raw,
&deps.api.addr_canonicalize(&feeder)?,
)?;
Ok(Response::default())
}
pub fn try_feed_price(
deps: DepsMut,
env: Env,
info: MessageInfo,
prices: Vec<(String, Decimal)>,
) -> StdResult<Response> {
let feeder_raw = deps.api.addr_canonicalize(info.sender.as_str())?;
let mut attributes = vec![attr("action", "price_feed")];
for price in prices {
attributes.push(attr("asset", price.0.to_string()));
attributes.push(attr("price", price.1.to_string()));
// Check feeder permission
let asset_token_raw = deps.api.addr_canonicalize(&price.0)?;
if feeder_raw != read_feeder(deps.storage, &asset_token_raw)? {
return Err(StdError::generic_err("unauthorized"));
}
let mut state: PriceInfo = read_price(deps.storage, &asset_token_raw)?;
state.last_updated_time = env.block.time.seconds();
state.price = price.1;
store_price(deps.storage, &asset_token_raw, &state)?;
}
Ok(Response::new().add_attributes(attributes))
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
match msg {
QueryMsg::Config {} => to_binary(&query_config(deps)?),
QueryMsg::Feeder { asset_token } => to_binary(&query_feeder(deps, asset_token)?),
QueryMsg::Price {
base_asset,
quote_asset,
} => to_binary(&query_price(deps, base_asset, quote_asset)?),
QueryMsg::Prices {
start_after,
limit,
order_by,
} => to_binary(&query_prices(deps, start_after, limit, order_by)?),
}
}
fn query_config(deps: Deps) -> StdResult<ConfigResponse> {
let state = read_config(deps.storage)?;
let resp = ConfigResponse {
owner: deps.api.addr_humanize(&state.owner)?.to_string(),
base_asset: state.base_asset,
};
Ok(resp)
}
fn query_feeder(deps: Deps, asset_token: String) -> StdResult<FeederResponse> {
let feeder = read_feeder(deps.storage, &deps.api.addr_canonicalize(&asset_token)?)?;
let resp = FeederResponse {
asset_token,
feeder: deps.api.addr_humanize(&feeder)?.to_string(),
};
Ok(resp)
}
fn query_price(deps: Deps, base: String, quote: String) -> StdResult<PriceResponse> {
let config: Config = read_config(deps.storage)?;
let quote_price = if config.base_asset == quote {
PriceInfo {
price: Decimal::one(),
last_updated_time: u64::MAX,
}
} else {
read_price(deps.storage, &deps.api.addr_canonicalize(quote.as_str())?)?
};
let base_price = if config.base_asset == base {
PriceInfo {
price: Decimal::one(),
last_updated_time: u64::MAX,
}
} else {
read_price(deps.storage, &deps.api.addr_canonicalize(base.as_str())?)?
};
Ok(PriceResponse {
rate: decimal_division(base_price.price, quote_price.price),
last_updated_base: base_price.last_updated_time,
last_updated_quote: quote_price.last_updated_time,
})
}
fn query_prices(
deps: Deps,
start_after: Option<String>,
limit: Option<u32>,
order_by: Option<OrderBy>,
) -> StdResult<PricesResponse> {
let start_after = if let Some(start_after) = start_after {
Some(deps.api.addr_canonicalize(&start_after)?)
} else {
None
};
let prices: Vec<PricesResponseElem> = read_prices(deps, start_after, limit, order_by)?;
Ok(PricesResponse { prices })
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn migrate(_deps: DepsMut, _env: Env, _msg: MigrateMsg) -> StdResult<Response> {
Ok(Response::default())
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_oracle/src/lib.rs | contracts/mirror_oracle/src/lib.rs | pub mod contract;
pub mod math;
pub mod state;
#[cfg(test)]
mod tests;
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_oracle/src/tests.rs | contracts/mirror_oracle/src/tests.rs | use crate::contract::{execute, instantiate, query};
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
use cosmwasm_std::{from_binary, Decimal, StdError};
use mirror_protocol::common::OrderBy;
use mirror_protocol::oracle::{
ConfigResponse, ExecuteMsg, FeederResponse, InstantiateMsg, PriceResponse, PricesResponse,
PricesResponseElem, QueryMsg,
};
#[test]
fn proper_initialization() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner0000".to_string(),
base_asset: "base0000".to_string(),
};
let info = mock_info("addr0000", &[]);
// we can just call .unwrap() to assert this was a success
let res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(0, res.messages.len());
// it worked, let's query the state
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!("owner0000", config.owner);
assert_eq!("base0000", config.base_asset);
}
#[test]
fn update_config() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner0000".to_string(),
base_asset: "base0000".to_string(),
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
// update owner
let info = mock_info("owner0000", &[]);
let msg = ExecuteMsg::UpdateConfig {
owner: Some("owner0001".to_string()),
};
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(0, res.messages.len());
// it worked, let's query the state
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!("owner0001", config.owner);
assert_eq!("base0000", config.base_asset);
// Unauthorized err
let info = mock_info("owner0000", &[]);
let msg = ExecuteMsg::UpdateConfig { owner: None };
let res = execute(deps.as_mut(), mock_env(), info, msg);
match res {
Err(StdError::GenericErr { msg, .. }) => assert_eq!(msg, "unauthorized"),
_ => panic!("Must return unauthorized error"),
}
}
#[test]
fn update_price() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner0000".to_string(),
base_asset: "base0000".to_string(),
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
// register asset
let msg = ExecuteMsg::RegisterAsset {
asset_token: "mAAPL".to_string(),
feeder: "addr0000".to_string(),
};
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
let msg = ExecuteMsg::RegisterAsset {
asset_token: "mAAPL".to_string(),
feeder: "addr0001".to_string(),
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// try update an asset already exists
let msg = ExecuteMsg::RegisterAsset {
asset_token: "mAAPL".to_string(),
feeder: "addr0000".to_string(),
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// update price
let msg = ExecuteMsg::FeedPrice {
prices: vec![("mAAPL".to_string(), Decimal::from_ratio(12u128, 10u128))],
};
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
assert_eq!(0, res.messages.len());
// it worked, let's query the state
let query_result = query(
deps.as_ref(),
mock_env(),
QueryMsg::Price {
base_asset: "mAAPL".to_string(),
quote_asset: "base0000".to_string(),
},
)
.unwrap();
let value: PriceResponse = from_binary(&query_result).unwrap();
assert_eq!("1.2", format!("{}", value.rate));
// Unauthorzied err
let info = mock_info("addr0001", &[]);
let msg = ExecuteMsg::FeedPrice {
prices: vec![("mAAPL".to_string(), Decimal::from_ratio(12u128, 10u128))],
};
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
}
#[test]
fn feed_price() {
let mut deps = mock_dependencies(&[]);
let msg = InstantiateMsg {
owner: "owner0000".to_string(),
base_asset: "base0000".to_string(),
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();
// update price
let info = mock_info("addr0000", &[]);
let msg = ExecuteMsg::FeedPrice {
prices: vec![("mAAPL".to_string(), Decimal::from_ratio(12u128, 10u128))],
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "mAAPL".to_string(),
feeder: "addr0000".to_string(),
};
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
let msg = ExecuteMsg::RegisterAsset {
asset_token: "mAAPL".to_string(),
feeder: "addr0000".to_string(),
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::RegisterAsset {
asset_token: "mGOGL".to_string(),
feeder: "addr0000".to_string(),
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let res = query(
deps.as_ref(),
mock_env(),
QueryMsg::Feeder {
asset_token: "mAAPL".to_string(),
},
)
.unwrap();
let feeder_res: FeederResponse = from_binary(&res).unwrap();
assert_eq!(
feeder_res,
FeederResponse {
asset_token: "mAAPL".to_string(),
feeder: "addr0000".to_string(),
}
);
let res = query(
deps.as_ref(),
mock_env(),
QueryMsg::Price {
base_asset: "mAAPL".to_string(),
quote_asset: "base0000".to_string(),
},
)
.unwrap();
let price_res: PriceResponse = from_binary(&res).unwrap();
assert_eq!(
price_res,
PriceResponse {
rate: Decimal::zero(),
last_updated_base: 0u64,
last_updated_quote: u64::MAX,
}
);
let msg = ExecuteMsg::FeedPrice {
prices: vec![
("mAAPL".to_string(), Decimal::from_ratio(12u128, 10u128)),
("mGOGL".to_string(), Decimal::from_ratio(22u128, 10u128)),
],
};
let info = mock_info("addr0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let env = mock_env();
let res = query(
deps.as_ref(),
env.clone(),
QueryMsg::Price {
base_asset: "mAAPL".to_string(),
quote_asset: "base0000".to_string(),
},
)
.unwrap();
let price_res: PriceResponse = from_binary(&res).unwrap();
assert_eq!(
price_res,
PriceResponse {
rate: Decimal::from_ratio(12u128, 10u128),
last_updated_base: env.block.time.seconds(),
last_updated_quote: u64::MAX,
}
);
let env = mock_env();
let res = query(
deps.as_ref(),
env.clone(),
QueryMsg::Prices {
start_after: None,
limit: None,
order_by: Some(OrderBy::Asc),
},
)
.unwrap();
let prices_res: PricesResponse = from_binary(&res).unwrap();
assert_eq!(
prices_res,
PricesResponse {
prices: vec![
PricesResponseElem {
asset_token: "mAAPL".to_string(),
price: Decimal::from_ratio(12u128, 10u128),
last_updated_time: env.block.time.seconds(),
},
PricesResponseElem {
asset_token: "mGOGL".to_string(),
price: Decimal::from_ratio(22u128, 10u128),
last_updated_time: env.block.time.seconds(),
}
],
}
);
// Unautorized try
let info = mock_info("addr0001", &[]);
let msg = ExecuteMsg::FeedPrice {
prices: vec![("mAAPL".to_string(), Decimal::from_ratio(12u128, 10u128))],
};
let res = execute(deps.as_mut(), mock_env(), info, msg);
match res {
Err(StdError::GenericErr { msg, .. }) => assert_eq!(msg, "unauthorized"),
_ => panic!("Must return unauthorized error"),
}
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_oracle/src/math.rs | contracts/mirror_oracle/src/math.rs | use cosmwasm_std::{Decimal, Uint128};
const DECIMAL_FRACTIONAL: Uint128 = Uint128::new(1_000_000_000u128);
/// return a / b
pub fn decimal_division(a: Decimal, b: Decimal) -> Decimal {
Decimal::from_ratio(DECIMAL_FRACTIONAL * a, b * DECIMAL_FRACTIONAL)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_oracle/src/state.rs | contracts/mirror_oracle/src/state.rs | use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use cosmwasm_std::{CanonicalAddr, Decimal, Deps, StdResult, Storage};
use cosmwasm_storage::{singleton, singleton_read, Bucket, ReadonlyBucket};
use mirror_protocol::common::OrderBy;
use mirror_protocol::oracle::PricesResponseElem;
static PREFIX_FEEDER: &[u8] = b"feeder";
static PREFIX_PRICE: &[u8] = b"price";
static KEY_CONFIG: &[u8] = b"config";
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
pub owner: CanonicalAddr,
pub base_asset: String,
}
pub fn store_config(storage: &mut dyn Storage, config: &Config) -> StdResult<()> {
singleton(storage, KEY_CONFIG).save(config)
}
pub fn read_config(storage: &dyn Storage) -> StdResult<Config> {
singleton_read(storage, KEY_CONFIG).load()
}
pub fn store_feeder(
storage: &mut dyn Storage,
asset_token: &CanonicalAddr,
feeder: &CanonicalAddr,
) -> StdResult<()> {
let mut feeder_bucket: Bucket<CanonicalAddr> = Bucket::new(storage, PREFIX_FEEDER);
feeder_bucket.save(asset_token.as_slice(), feeder)
}
pub fn read_feeder(storage: &dyn Storage, asset_token: &CanonicalAddr) -> StdResult<CanonicalAddr> {
let feeder_bucket: ReadonlyBucket<CanonicalAddr> = ReadonlyBucket::new(storage, PREFIX_FEEDER);
feeder_bucket.load(asset_token.as_slice())
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct PriceInfo {
pub price: Decimal,
pub last_updated_time: u64,
}
pub fn store_price(
storage: &mut dyn Storage,
asset_token: &CanonicalAddr,
price: &PriceInfo,
) -> StdResult<()> {
let mut price_bucket: Bucket<PriceInfo> = Bucket::new(storage, PREFIX_PRICE);
price_bucket.save(asset_token.as_slice(), price)
}
pub fn read_price(storage: &dyn Storage, asset_token: &CanonicalAddr) -> StdResult<PriceInfo> {
let price_bucket: ReadonlyBucket<PriceInfo> = ReadonlyBucket::new(storage, PREFIX_PRICE);
price_bucket.load(asset_token.as_slice())
}
// settings for pagination
const MAX_LIMIT: u32 = 30;
const DEFAULT_LIMIT: u32 = 10;
pub fn read_prices(
deps: Deps,
start_after: Option<CanonicalAddr>,
limit: Option<u32>,
order_by: Option<OrderBy>,
) -> StdResult<Vec<PricesResponseElem>> {
let price_bucket: ReadonlyBucket<PriceInfo> = ReadonlyBucket::new(deps.storage, PREFIX_PRICE);
let limit = limit.unwrap_or(DEFAULT_LIMIT).min(MAX_LIMIT) as usize;
let (start, end, order_by) = match order_by {
Some(OrderBy::Asc) => (calc_range_start(start_after), None, OrderBy::Asc),
_ => (None, calc_range_end(start_after), OrderBy::Desc),
};
price_bucket
.range(start.as_deref(), end.as_deref(), order_by.into())
.take(limit)
.map(|item| {
let (k, v) = item?;
let asset_token = deps.api.addr_humanize(&CanonicalAddr::from(k))?.to_string();
Ok(PricesResponseElem {
asset_token,
price: v.price,
last_updated_time: v.last_updated_time,
})
})
.collect()
}
// this will set the first key after the provided key, by appending a 1 byte
fn calc_range_start(start_after: Option<CanonicalAddr>) -> Option<Vec<u8>> {
start_after.map(|idx| {
let mut v = idx.as_slice().to_vec();
v.push(1);
v
})
}
// this will set the first key after the provided key in Desc
fn calc_range_end(start_after: Option<CanonicalAddr>) -> Option<Vec<u8>> {
start_after.map(|idx| idx.as_slice().to_vec())
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_oracle/examples/schema.rs | contracts/mirror_oracle/examples/schema.rs | use std::env::current_dir;
use std::fs::create_dir_all;
use cosmwasm_schema::{export_schema, remove_schemas, schema_for};
use mirror_protocol::oracle::{
ConfigResponse, ExecuteMsg, FeederResponse, InstantiateMsg, MigrateMsg, PriceResponse,
PricesResponse, QueryMsg,
};
fn main() {
let mut out_dir = current_dir().unwrap();
out_dir.push("schema");
create_dir_all(&out_dir).unwrap();
remove_schemas(&out_dir).unwrap();
export_schema(&schema_for!(InstantiateMsg), &out_dir);
export_schema(&schema_for!(ExecuteMsg), &out_dir);
export_schema(&schema_for!(MigrateMsg), &out_dir);
export_schema(&schema_for!(QueryMsg), &out_dir);
export_schema(&schema_for!(FeederResponse), &out_dir);
export_schema(&schema_for!(ConfigResponse), &out_dir);
export_schema(&schema_for!(PriceResponse), &out_dir);
export_schema(&schema_for!(PricesResponse), &out_dir);
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/contract.rs | contracts/mirror_factory/src/contract.rs | #[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use cosmwasm_std::{
attr, to_binary, Addr, Attribute, Binary, CanonicalAddr, CosmosMsg, Decimal, Deps, DepsMut,
Env, MessageInfo, Reply, ReplyOn, Response, StdError, StdResult, SubMsg, Uint128, WasmMsg,
};
use crate::querier::{load_mint_asset_config, query_last_price};
use crate::response::MsgInstantiateContractResponse;
use crate::state::{
decrease_total_weight, increase_total_weight, read_all_weight, read_config,
read_last_distributed, read_tmp_asset, read_tmp_whitelist_info, read_total_weight, read_weight,
remove_tmp_whitelist_info, remove_weight, store_config, store_last_distributed,
store_tmp_asset, store_tmp_whitelist_info, store_total_weight, store_weight, Config,
WhitelistTmpInfo,
};
use mirror_protocol::factory::{
ConfigResponse, DistributionInfoResponse, ExecuteMsg, InstantiateMsg, MigrateMsg, Params,
QueryMsg,
};
use mirror_protocol::mint::{ExecuteMsg as MintExecuteMsg, IPOParams};
use mirror_protocol::staking::Cw20HookMsg as StakingCw20HookMsg;
use mirror_protocol::staking::ExecuteMsg as StakingExecuteMsg;
use tefi_oracle::hub::HubExecuteMsg as TeFiOracleExecuteMsg;
use protobuf::Message;
use cw20::{Cw20ExecuteMsg, MinterResponse};
use terraswap::asset::{AssetInfo, PairInfo};
use terraswap::factory::ExecuteMsg as TerraswapFactoryExecuteMsg;
use terraswap::querier::query_pair_info;
use terraswap::token::InstantiateMsg as TokenInstantiateMsg;
const MIRROR_TOKEN_WEIGHT: u32 = 300u32;
const NORMAL_TOKEN_WEIGHT: u32 = 30u32;
const DISTRIBUTION_INTERVAL: u64 = 60u64;
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
deps: DepsMut,
env: Env,
_info: MessageInfo,
msg: InstantiateMsg,
) -> StdResult<Response> {
store_config(
deps.storage,
&Config {
owner: CanonicalAddr::from(vec![]),
mirror_token: CanonicalAddr::from(vec![]),
mint_contract: CanonicalAddr::from(vec![]),
oracle_contract: CanonicalAddr::from(vec![]),
terraswap_factory: CanonicalAddr::from(vec![]),
staking_contract: CanonicalAddr::from(vec![]),
commission_collector: CanonicalAddr::from(vec![]),
token_code_id: msg.token_code_id,
base_denom: msg.base_denom,
genesis_time: env.block.time.seconds(),
distribution_schedule: msg.distribution_schedule,
},
)?;
store_total_weight(deps.storage, 0u32)?;
store_last_distributed(deps.storage, env.block.time.seconds())?;
Ok(Response::default())
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> StdResult<Response> {
match msg {
ExecuteMsg::PostInitialize {
owner,
mirror_token,
mint_contract,
oracle_contract,
terraswap_factory,
staking_contract,
commission_collector,
} => post_initialize(
deps,
env,
owner,
mirror_token,
mint_contract,
oracle_contract,
terraswap_factory,
staking_contract,
commission_collector,
),
ExecuteMsg::UpdateConfig {
owner,
token_code_id,
distribution_schedule,
} => update_config(deps, info, owner, token_code_id, distribution_schedule),
ExecuteMsg::UpdateWeight {
asset_token,
weight,
} => update_weight(deps, info, asset_token, weight),
ExecuteMsg::Whitelist {
name,
symbol,
oracle_proxy,
params,
} => whitelist(deps, info, name, symbol, oracle_proxy, params),
ExecuteMsg::Distribute {} => distribute(deps, env),
ExecuteMsg::PassCommand { contract_addr, msg } => {
pass_command(deps, info, contract_addr, msg)
}
ExecuteMsg::RevokeAsset { asset_token } => revoke_asset(deps, info, asset_token),
ExecuteMsg::MigrateAsset {
name,
symbol,
from_token,
oracle_proxy,
} => migrate_asset(deps, info, name, symbol, from_token, oracle_proxy),
}
}
#[allow(clippy::too_many_arguments)]
pub fn post_initialize(
deps: DepsMut,
env: Env,
owner: String,
mirror_token: String,
mint_contract: String,
oracle_contract: String,
terraswap_factory: String,
staking_contract: String,
commission_collector: String,
) -> StdResult<Response> {
let mut config: Config = read_config(deps.storage)?;
if config.owner != CanonicalAddr::from(vec![]) {
return Err(StdError::generic_err("unauthorized"));
}
config.owner = deps.api.addr_canonicalize(&owner)?;
config.mirror_token = deps.api.addr_canonicalize(&mirror_token)?;
config.mint_contract = deps.api.addr_canonicalize(&mint_contract)?;
config.oracle_contract = deps.api.addr_canonicalize(&oracle_contract)?;
config.terraswap_factory = deps.api.addr_canonicalize(&terraswap_factory)?;
config.staking_contract = deps.api.addr_canonicalize(&staking_contract)?;
config.commission_collector = deps.api.addr_canonicalize(&commission_collector)?;
store_config(deps.storage, &config)?;
// MIR Token and Pair are registered externally, update weights,
// and register to staking contract
store_weight(deps.storage, &config.mirror_token, MIRROR_TOKEN_WEIGHT)?;
increase_total_weight(deps.storage, MIRROR_TOKEN_WEIGHT)?;
let mir_addr = deps.api.addr_humanize(&config.mirror_token)?;
terraswap_creation_hook(deps, env, mir_addr)
}
pub fn update_config(
deps: DepsMut,
info: MessageInfo,
owner: Option<String>,
token_code_id: Option<u64>,
distribution_schedule: Option<Vec<(u64, u64, Uint128)>>,
) -> StdResult<Response> {
let mut config: Config = read_config(deps.storage)?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
if let Some(owner) = owner {
config.owner = deps.api.addr_canonicalize(&owner)?;
}
if let Some(distribution_schedule) = distribution_schedule {
config.distribution_schedule = distribution_schedule;
}
if let Some(token_code_id) = token_code_id {
config.token_code_id = token_code_id;
}
store_config(deps.storage, &config)?;
Ok(Response::new().add_attribute("action", "update_config"))
}
pub fn update_weight(
deps: DepsMut,
info: MessageInfo,
asset_token: String,
weight: u32,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
let asset_token_raw = deps.api.addr_canonicalize(&asset_token)?;
let origin_weight = read_weight(deps.storage, &asset_token_raw)?;
store_weight(deps.storage, &asset_token_raw, weight)?;
let origin_total_weight = read_total_weight(deps.storage)?;
let updated_total_weight = origin_total_weight + weight - origin_weight;
store_total_weight(deps.storage, updated_total_weight)?;
Ok(Response::new().add_attributes(vec![
attr("action", "update_weight"),
attr("asset_token", asset_token),
attr("weight", weight.to_string()),
]))
}
// just for by passing command to other contract like update config
pub fn pass_command(
deps: DepsMut,
info: MessageInfo,
contract_addr: String,
msg: Binary,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
Ok(
Response::new().add_message(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr,
msg,
funds: vec![],
})),
)
}
/// Whitelisting process
/// 1. Create asset token contract with `config.token_code_id` with `minter` argument
/// 2. Call `TokenCreationHook`
/// 2-1. Initialize distribution info
/// 2-2. Register asset to mint contract
/// 2-3. Register asset and oracle proxy to oracle contract
/// 2-4. Create terraswap pair through terraswap factory
/// 3. Call `TerraswapCreationHook`
/// 3-1. Register asset to staking contract
pub fn whitelist(
deps: DepsMut,
info: MessageInfo,
name: String,
symbol: String,
oracle_proxy: String,
params: Params,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
if config.owner != deps.api.addr_canonicalize(info.sender.as_str())? {
return Err(StdError::generic_err("unauthorized"));
}
if read_tmp_whitelist_info(deps.storage).is_ok() {
// this error should never happen
return Err(StdError::generic_err("A whitelist process is in progress"));
}
// checks format and returns uppercase
let symbol = format_symbol(&symbol)?;
let cw20_symbol = format!("m{}", symbol);
store_tmp_whitelist_info(
deps.storage,
&WhitelistTmpInfo {
params,
oracle_proxy: deps.api.addr_canonicalize(&oracle_proxy)?, // validates and converts
symbol: symbol.to_string(),
},
)?;
Ok(Response::new()
.add_submessage(SubMsg {
// create asset token
msg: WasmMsg::Instantiate {
admin: None,
code_id: config.token_code_id,
funds: vec![],
label: "".to_string(),
msg: to_binary(&TokenInstantiateMsg {
name: name.clone(),
symbol: cw20_symbol.to_string(),
decimals: 6u8,
initial_balances: vec![],
mint: Some(MinterResponse {
minter: deps.api.addr_humanize(&config.mint_contract)?.to_string(),
cap: None,
}),
})?,
}
.into(),
gas_limit: None,
id: 1,
reply_on: ReplyOn::Success,
})
.add_attributes(vec![
attr("action", "whitelist"),
attr("symbol", symbol),
attr("cw20_symbol", cw20_symbol),
attr("name", name),
]))
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn reply(deps: DepsMut, env: Env, msg: Reply) -> StdResult<Response> {
match msg.id {
1 => {
// fetch tmp whitelist info
let whitelist_info = read_tmp_whitelist_info(deps.storage)?;
// get new token's contract address
let res: MsgInstantiateContractResponse = Message::parse_from_bytes(
msg.result.unwrap().data.unwrap().as_slice(),
)
.map_err(|_| {
StdError::parse_err("MsgInstantiateContractResponse", "failed to parse data")
})?;
let asset_token = Addr::unchecked(res.get_contract_address());
token_creation_hook(deps, env, asset_token, whitelist_info)
}
2 => {
// fetch saved asset_token from temp state
let asset_token = read_tmp_asset(deps.storage)?;
terraswap_creation_hook(deps, env, asset_token)
}
_ => Err(StdError::generic_err("reply id is invalid")),
}
}
/// TokenCreationHook
/// 1. Initialize distribution info
/// 2. Register asset to mint contract
/// 3. Register asset and oracle proxy to oracle hub contract
/// 4. Create terraswap pair through terraswap factory with `TerraswapCreationHook`
pub fn token_creation_hook(
deps: DepsMut,
env: Env,
asset_token: Addr,
whitelist_info: WhitelistTmpInfo,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let asset_token_raw = deps.api.addr_canonicalize(asset_token.as_str())?;
let params = whitelist_info.params;
// If weight is given as params, we use that or just use default
let weight = if let Some(weight) = params.weight {
weight
} else {
NORMAL_TOKEN_WEIGHT
};
// Increase total weight
store_weight(deps.storage, &asset_token_raw, weight)?;
increase_total_weight(deps.storage, weight)?;
// Remove tmp info
remove_tmp_whitelist_info(deps.storage);
let mut attributes: Vec<Attribute> = vec![];
// Check if all IPO params exist
let ipo_params: Option<IPOParams> = if let (
Some(mint_period),
Some(min_collateral_ratio_after_ipo),
Some(pre_ipo_price),
Some(trigger_addr),
) = (
params.mint_period,
params.min_collateral_ratio_after_ipo,
params.pre_ipo_price,
params.ipo_trigger_addr,
) {
let mint_end: u64 = env.block.time.plus_seconds(mint_period).seconds();
attributes = vec![
attr("is_pre_ipo", "true"),
attr("mint_end", mint_end.to_string()),
attr(
"min_collateral_ratio_after_ipo",
min_collateral_ratio_after_ipo.to_string(),
),
attr("pre_ipo_price", pre_ipo_price.to_string()),
attr("ipo_trigger_addr", trigger_addr.to_string()),
];
Some(IPOParams {
mint_end,
pre_ipo_price,
min_collateral_ratio_after_ipo,
trigger_addr,
})
} else {
attributes.push(attr("is_pre_ipo", "false"));
None
};
// store asset_token in temp storage to use in reply callback
store_tmp_asset(deps.storage, &asset_token)?;
// Register asset to mint contract
// Register price source to oracle contract
// Register asset mapping to oracle contract
// Create terraswap pair
Ok(Response::new()
.add_messages(vec![
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps.api.addr_humanize(&config.mint_contract)?.to_string(),
funds: vec![],
msg: to_binary(&MintExecuteMsg::RegisterAsset {
asset_token: asset_token.to_string(),
auction_discount: params.auction_discount,
min_collateral_ratio: params.min_collateral_ratio,
ipo_params,
})?,
}),
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps.api.addr_humanize(&config.oracle_contract)?.to_string(),
funds: vec![],
msg: to_binary(&TeFiOracleExecuteMsg::RegisterSource {
// if the source already exists, will skip and return gracefully
symbol: whitelist_info.symbol.to_string(),
proxy_addr: deps
.api
.addr_humanize(&whitelist_info.oracle_proxy)?
.to_string(),
priority: None, // default priority
})?,
}),
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps.api.addr_humanize(&config.oracle_contract)?.to_string(),
funds: vec![],
msg: to_binary(&TeFiOracleExecuteMsg::InsertAssetSymbolMap {
// map asset_token to symbol on oracle
map: vec![(asset_token.to_string(), whitelist_info.symbol)],
})?,
}),
])
.add_submessage(SubMsg {
// create terraswap pair
msg: WasmMsg::Execute {
contract_addr: deps
.api
.addr_humanize(&config.terraswap_factory)?
.to_string(),
funds: vec![],
msg: to_binary(&TerraswapFactoryExecuteMsg::CreatePair {
asset_infos: [
AssetInfo::NativeToken {
denom: config.base_denom,
},
AssetInfo::Token {
contract_addr: asset_token.to_string(),
},
],
})?,
}
.into(),
gas_limit: None,
id: 2,
reply_on: ReplyOn::Success,
})
.add_attributes(
vec![
vec![attr("asset_token_addr", asset_token.as_str())],
attributes,
]
.concat(),
))
}
/// TerraswapCreationHook
/// 1. Register asset and liquidity(LP) token to staking contract
pub fn terraswap_creation_hook(deps: DepsMut, _env: Env, asset_token: Addr) -> StdResult<Response> {
// Now terraswap contract is already created,
// and liquidity token also created
let config: Config = read_config(deps.storage)?;
let asset_infos = [
AssetInfo::NativeToken {
denom: config.base_denom,
},
AssetInfo::Token {
contract_addr: asset_token.to_string(),
},
];
// Load terraswap pair info
let pair_info: PairInfo = query_pair_info(
&deps.querier,
deps.api.addr_humanize(&config.terraswap_factory)?,
&asset_infos,
)?;
// Execute staking contract to register staking token of newly created asset
Ok(
Response::new().add_message(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps
.api
.addr_humanize(&config.staking_contract)?
.to_string(),
funds: vec![],
msg: to_binary(&StakingExecuteMsg::RegisterAsset {
asset_token: asset_token.to_string(),
staking_token: pair_info.liquidity_token,
})?,
})),
)
}
/// Distribute
/// Anyone can execute distribute operation to distribute
/// mirror inflation rewards on the staking pool
pub fn distribute(deps: DepsMut, env: Env) -> StdResult<Response> {
let last_distributed = read_last_distributed(deps.storage)?;
if last_distributed + DISTRIBUTION_INTERVAL > env.block.time.seconds() {
return Err(StdError::generic_err(
"Cannot distribute mirror token before interval",
));
}
let config: Config = read_config(deps.storage)?;
let time_elapsed = env.block.time.seconds() - config.genesis_time;
let last_time_elapsed = last_distributed - config.genesis_time;
let mut target_distribution_amount: Uint128 = Uint128::zero();
for s in config.distribution_schedule.iter() {
if s.0 > time_elapsed || s.1 < last_time_elapsed {
continue;
}
// min(s.1, time_elapsed) - max(s.0, last_time_elapsed)
let time_duration =
std::cmp::min(s.1, time_elapsed) - std::cmp::max(s.0, last_time_elapsed);
let time_slot = s.1 - s.0;
let distribution_amount_per_sec: Decimal = Decimal::from_ratio(s.2, time_slot);
target_distribution_amount +=
distribution_amount_per_sec * Uint128::from(time_duration as u128);
}
let staking_contract = deps.api.addr_humanize(&config.staking_contract)?;
let mirror_token = deps.api.addr_humanize(&config.mirror_token)?;
let total_weight: u32 = read_total_weight(deps.storage)?;
let mut distribution_amount: Uint128 = Uint128::zero();
let weights: Vec<(CanonicalAddr, u32)> = read_all_weight(deps.storage)?;
let rewards: Vec<(String, Uint128)> = weights
.iter()
.map(|w| {
let amount = Uint128::from(
target_distribution_amount.u128() * (w.1 as u128) / (total_weight as u128),
);
if amount.is_zero() {
return Err(StdError::generic_err("cannot distribute zero amount"));
}
distribution_amount += amount;
Ok((deps.api.addr_humanize(&w.0)?.to_string(), amount))
})
.filter(|m| m.is_ok())
.collect::<StdResult<Vec<(String, Uint128)>>>()?;
// store last distributed
store_last_distributed(deps.storage, env.block.time.seconds())?;
// send token rewards to staking contract
const SPLIT_UNIT: usize = 10;
Ok(Response::new()
.add_messages(
rewards
.chunks(SPLIT_UNIT)
.map(|v| v.to_vec())
.into_iter()
.map(|rewards| {
Ok(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: mirror_token.to_string(),
msg: to_binary(&Cw20ExecuteMsg::Send {
contract: staking_contract.to_string(),
amount: rewards.iter().map(|v| v.1.u128()).sum::<u128>().into(),
msg: to_binary(&StakingCw20HookMsg::DepositReward { rewards })?,
})?,
funds: vec![],
}))
})
.collect::<StdResult<Vec<CosmosMsg>>>()?,
)
.add_attributes(vec![
attr("action", "distribute"),
attr("distribution_amount", distribution_amount.to_string()),
]))
}
pub fn revoke_asset(deps: DepsMut, info: MessageInfo, asset_token: String) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(&asset_token)?;
let sender_raw: CanonicalAddr = deps.api.addr_canonicalize(info.sender.as_str())?;
let mint: Addr = deps.api.addr_humanize(&config.mint_contract)?;
let oracle: Addr = deps.api.addr_humanize(&config.oracle_contract)?;
// only owner can revoke asset
if config.owner != sender_raw {
return Err(StdError::generic_err("unauthorized"));
}
// check if the asset has a preIPO price
let (_, _, pre_ipo_price) = load_mint_asset_config(&deps.querier, mint, &asset_token_raw)?;
let end_price: Decimal = pre_ipo_price.unwrap_or(
// if there is no pre_ipo_price, fetch last reported price from oracle
query_last_price(&deps.querier, oracle, asset_token.to_string())?,
);
let weight = read_weight(deps.storage, &asset_token_raw)?;
remove_weight(deps.storage, &asset_token_raw);
decrease_total_weight(deps.storage, weight)?;
Ok(Response::new()
.add_message(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: deps.api.addr_humanize(&config.mint_contract)?.to_string(),
funds: vec![],
msg: to_binary(&MintExecuteMsg::RegisterMigration {
asset_token: asset_token.clone(),
end_price,
})?,
}))
.add_attributes(vec![
attr("action", "revoke_asset"),
attr("end_price", end_price.to_string()),
attr("asset_token", asset_token),
]))
}
pub fn migrate_asset(
deps: DepsMut,
info: MessageInfo,
name: String,
symbol: String,
asset_token: String,
oracle_proxy: String,
) -> StdResult<Response> {
let config: Config = read_config(deps.storage)?;
let asset_token_raw: CanonicalAddr = deps.api.addr_canonicalize(&asset_token)?;
let sender_raw: CanonicalAddr = deps.api.addr_canonicalize(info.sender.as_str())?;
let oracle_proxy_raw: CanonicalAddr = deps.api.addr_canonicalize(&oracle_proxy)?;
let mint: Addr = deps.api.addr_humanize(&config.mint_contract)?;
let oracle: Addr = deps.api.addr_humanize(&config.oracle_contract)?;
if sender_raw != config.owner {
return Err(StdError::generic_err("unauthorized"));
}
// check if the asset has a preIPO price
let (auction_discount, min_collateral_ratio, pre_ipo_price) =
load_mint_asset_config(&deps.querier, mint.clone(), &asset_token_raw)?;
if pre_ipo_price.is_some() {
return Err(StdError::generic_err("Can not migrate a preIPO asset"));
}
let end_price = query_last_price(&deps.querier, oracle, asset_token.to_string())?;
let weight = read_weight(deps.storage, &asset_token_raw)?;
remove_weight(deps.storage, &asset_token_raw);
decrease_total_weight(deps.storage, weight)?;
// checks format and returns uppercase
let symbol = format_symbol(&symbol)?;
let cw20_symbol = format!("m{}", symbol);
store_tmp_whitelist_info(
deps.storage,
&WhitelistTmpInfo {
params: Params {
auction_discount,
min_collateral_ratio,
weight: Some(weight),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
symbol,
oracle_proxy: oracle_proxy_raw,
},
)?;
Ok(Response::new()
.add_message(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: mint.to_string(),
funds: vec![],
msg: to_binary(&MintExecuteMsg::RegisterMigration {
asset_token: asset_token.clone(),
end_price,
})?,
}))
.add_submessage(SubMsg {
// create asset token
msg: WasmMsg::Instantiate {
admin: None,
code_id: config.token_code_id,
funds: vec![],
label: "".to_string(),
msg: to_binary(&TokenInstantiateMsg {
name,
symbol: cw20_symbol,
decimals: 6u8,
initial_balances: vec![],
mint: Some(MinterResponse {
minter: mint.to_string(),
cap: None,
}),
})?,
}
.into(),
gas_limit: None,
id: 1,
reply_on: ReplyOn::Success,
})
.add_attributes(vec![
attr("action", "migration"),
attr("end_price", end_price.to_string()),
attr("asset_token", asset_token),
]))
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
match msg {
QueryMsg::Config {} => to_binary(&query_config(deps)?),
QueryMsg::DistributionInfo {} => to_binary(&query_distribution_info(deps)?),
}
}
pub fn query_config(deps: Deps) -> StdResult<ConfigResponse> {
let state = read_config(deps.storage)?;
let resp = ConfigResponse {
owner: deps.api.addr_humanize(&state.owner)?.to_string(),
mirror_token: deps.api.addr_humanize(&state.mirror_token)?.to_string(),
mint_contract: deps.api.addr_humanize(&state.mint_contract)?.to_string(),
oracle_contract: deps.api.addr_humanize(&state.oracle_contract)?.to_string(),
terraswap_factory: deps
.api
.addr_humanize(&state.terraswap_factory)?
.to_string(),
staking_contract: deps.api.addr_humanize(&state.staking_contract)?.to_string(),
commission_collector: deps
.api
.addr_humanize(&state.commission_collector)?
.to_string(),
token_code_id: state.token_code_id,
base_denom: state.base_denom,
genesis_time: state.genesis_time,
distribution_schedule: state.distribution_schedule,
};
Ok(resp)
}
pub fn query_distribution_info(deps: Deps) -> StdResult<DistributionInfoResponse> {
let weights: Vec<(CanonicalAddr, u32)> = read_all_weight(deps.storage)?;
let last_distributed = read_last_distributed(deps.storage)?;
let resp = DistributionInfoResponse {
last_distributed,
weights: weights
.iter()
.map(|w| Ok((deps.api.addr_humanize(&w.0)?.to_string(), w.1)))
.collect::<StdResult<Vec<(String, u32)>>>()?,
};
Ok(resp)
}
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn migrate(deps: DepsMut, _env: Env, msg: MigrateMsg) -> StdResult<Response> {
// change oracle address to point to new tefi hub
let mut config: Config = read_config(deps.storage)?;
config.oracle_contract = deps.api.addr_canonicalize(&msg.tefi_oracle_contract)?;
store_config(deps.storage, &config)?;
Ok(Response::default())
}
fn format_symbol(symbol: &str) -> StdResult<String> {
let first_char = symbol
.chars()
.next()
.ok_or_else(|| StdError::generic_err("invalid symbol format"))?;
if first_char == 'm' {
return Err(StdError::generic_err("symbol should not start with 'm'"));
}
Ok(symbol.to_uppercase())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_format_masset_symbol() {
format_symbol("mAAPL").unwrap_err();
format_symbol("mTSLA").unwrap_err();
assert_eq!(format_symbol("aAPL").unwrap(), "AAPL".to_string(),);
assert_eq!(
format_symbol("MSFT").unwrap(), // starts with 'M' not 'm'
"MSFT".to_string(),
);
assert_eq!(format_symbol("tsla").unwrap(), "TSLA".to_string(),);
assert_eq!(format_symbol("ANC").unwrap(), "ANC".to_string(),)
}
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/lib.rs | contracts/mirror_factory/src/lib.rs | pub mod contract;
pub mod math;
pub mod querier;
mod response;
pub mod state;
#[cfg(test)]
mod testing;
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/response.rs | contracts/mirror_factory/src/response.rs | // This file is generated by rust-protobuf 2.23.0. Do not edit
// @generated
// https://github.com/rust-lang/rust-clippy/issues/702
#![allow(unknown_lints)]
#![allow(clippy::all)]
#![allow(unused_attributes)]
#![cfg_attr(rustfmt, rustfmt::skip)]
#![allow(box_pointers)]
#![allow(dead_code)]
#![allow(missing_docs)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]
#![allow(non_upper_case_globals)]
#![allow(trivial_casts)]
#![allow(unused_imports)]
#![allow(unused_results)]
//! Generated file from `src/response.proto`
/// Generated files are compatible only with the same version
/// of protobuf runtime.
// const _PROTOBUF_VERSION_CHECK: () = ::protobuf::VERSION_2_23_0;
#[derive(PartialEq,Clone,Default)]
pub struct MsgInstantiateContractResponse {
// message fields
pub contract_address: ::std::string::String,
pub data: ::std::vec::Vec<u8>,
// special fields
pub unknown_fields: ::protobuf::UnknownFields,
pub cached_size: ::protobuf::CachedSize,
}
impl<'a> ::std::default::Default for &'a MsgInstantiateContractResponse {
fn default() -> &'a MsgInstantiateContractResponse {
<MsgInstantiateContractResponse as ::protobuf::Message>::default_instance()
}
}
impl MsgInstantiateContractResponse {
pub fn new() -> MsgInstantiateContractResponse {
::std::default::Default::default()
}
// string contract_address = 1;
pub fn get_contract_address(&self) -> &str {
&self.contract_address
}
pub fn clear_contract_address(&mut self) {
self.contract_address.clear();
}
// Param is passed by value, moved
pub fn set_contract_address(&mut self, v: ::std::string::String) {
self.contract_address = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_contract_address(&mut self) -> &mut ::std::string::String {
&mut self.contract_address
}
// Take field
pub fn take_contract_address(&mut self) -> ::std::string::String {
::std::mem::replace(&mut self.contract_address, ::std::string::String::new())
}
// bytes data = 2;
pub fn get_data(&self) -> &[u8] {
&self.data
}
pub fn clear_data(&mut self) {
self.data.clear();
}
// Param is passed by value, moved
pub fn set_data(&mut self, v: ::std::vec::Vec<u8>) {
self.data = v;
}
// Mutable pointer to the field.
// If field is not initialized, it is initialized with default value first.
pub fn mut_data(&mut self) -> &mut ::std::vec::Vec<u8> {
&mut self.data
}
// Take field
pub fn take_data(&mut self) -> ::std::vec::Vec<u8> {
::std::mem::replace(&mut self.data, ::std::vec::Vec::new())
}
}
impl ::protobuf::Message for MsgInstantiateContractResponse {
fn is_initialized(&self) -> bool {
true
}
fn merge_from(&mut self, is: &mut ::protobuf::CodedInputStream<'_>) -> ::protobuf::ProtobufResult<()> {
while !is.eof()? {
let (field_number, wire_type) = is.read_tag_unpack()?;
match field_number {
1 => {
::protobuf::rt::read_singular_proto3_string_into(wire_type, is, &mut self.contract_address)?;
},
2 => {
::protobuf::rt::read_singular_proto3_bytes_into(wire_type, is, &mut self.data)?;
},
_ => {
::protobuf::rt::read_unknown_or_skip_group(field_number, wire_type, is, self.mut_unknown_fields())?;
},
};
}
::std::result::Result::Ok(())
}
// Compute sizes of nested messages
#[allow(unused_variables)]
fn compute_size(&self) -> u32 {
let mut my_size = 0;
if !self.contract_address.is_empty() {
my_size += ::protobuf::rt::string_size(1, &self.contract_address);
}
if !self.data.is_empty() {
my_size += ::protobuf::rt::bytes_size(2, &self.data);
}
my_size += ::protobuf::rt::unknown_fields_size(self.get_unknown_fields());
self.cached_size.set(my_size);
my_size
}
fn write_to_with_cached_sizes(&self, os: &mut ::protobuf::CodedOutputStream<'_>) -> ::protobuf::ProtobufResult<()> {
if !self.contract_address.is_empty() {
os.write_string(1, &self.contract_address)?;
}
if !self.data.is_empty() {
os.write_bytes(2, &self.data)?;
}
os.write_unknown_fields(self.get_unknown_fields())?;
::std::result::Result::Ok(())
}
fn get_cached_size(&self) -> u32 {
self.cached_size.get()
}
fn get_unknown_fields(&self) -> &::protobuf::UnknownFields {
&self.unknown_fields
}
fn mut_unknown_fields(&mut self) -> &mut ::protobuf::UnknownFields {
&mut self.unknown_fields
}
fn as_any(&self) -> &dyn (::std::any::Any) {
self as &dyn (::std::any::Any)
}
fn as_any_mut(&mut self) -> &mut dyn (::std::any::Any) {
self as &mut dyn (::std::any::Any)
}
fn into_any(self: ::std::boxed::Box<Self>) -> ::std::boxed::Box<dyn (::std::any::Any)> {
self
}
fn descriptor(&self) -> &'static ::protobuf::reflect::MessageDescriptor {
Self::descriptor_static()
}
fn new() -> MsgInstantiateContractResponse {
MsgInstantiateContractResponse::new()
}
fn descriptor_static() -> &'static ::protobuf::reflect::MessageDescriptor {
static descriptor: ::protobuf::rt::LazyV2<::protobuf::reflect::MessageDescriptor> = ::protobuf::rt::LazyV2::INIT;
descriptor.get(|| {
let mut fields = ::std::vec::Vec::new();
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeString>(
"contract_address",
|m: &MsgInstantiateContractResponse| { &m.contract_address },
|m: &mut MsgInstantiateContractResponse| { &mut m.contract_address },
));
fields.push(::protobuf::reflect::accessor::make_simple_field_accessor::<_, ::protobuf::types::ProtobufTypeBytes>(
"data",
|m: &MsgInstantiateContractResponse| { &m.data },
|m: &mut MsgInstantiateContractResponse| { &mut m.data },
));
::protobuf::reflect::MessageDescriptor::new_pb_name::<MsgInstantiateContractResponse>(
"MsgInstantiateContractResponse",
fields,
file_descriptor_proto()
)
})
}
fn default_instance() -> &'static MsgInstantiateContractResponse {
static instance: ::protobuf::rt::LazyV2<MsgInstantiateContractResponse> = ::protobuf::rt::LazyV2::INIT;
instance.get(MsgInstantiateContractResponse::new)
}
}
impl ::protobuf::Clear for MsgInstantiateContractResponse {
fn clear(&mut self) {
self.contract_address.clear();
self.data.clear();
self.unknown_fields.clear();
}
}
impl ::std::fmt::Debug for MsgInstantiateContractResponse {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
::protobuf::text_format::fmt(self, f)
}
}
impl ::protobuf::reflect::ProtobufValue for MsgInstantiateContractResponse {
fn as_ref(&self) -> ::protobuf::reflect::ReflectValueRef {
::protobuf::reflect::ReflectValueRef::Message(self)
}
}
static file_descriptor_proto_data: &'static [u8] = b"\
\n\x12src/response.proto\"_\n\x1eMsgInstantiateContractResponse\x12)\n\
\x10contract_address\x18\x01\x20\x01(\tR\x0fcontractAddress\x12\x12\n\
\x04data\x18\x02\x20\x01(\x0cR\x04dataJ\xf8\x02\n\x06\x12\x04\0\0\x08\
\x03\n\x08\n\x01\x0c\x12\x03\0\0\x12\n_\n\x02\x04\0\x12\x04\x03\0\x08\
\x03\x1aS\x20MsgInstantiateContractResponse\x20defines\x20the\x20Msg/Ins\
tantiateContract\x20response\x20type.\n\n\n\n\x03\x04\0\x01\x12\x03\x03\
\x08&\nR\n\x04\x04\0\x02\0\x12\x03\x05\x04\x20\x1aE\x20ContractAddress\
\x20is\x20the\x20bech32\x20address\x20of\x20the\x20new\x20contract\x20in\
stance.\n\n\x0c\n\x05\x04\0\x02\0\x05\x12\x03\x05\x04\n\n\x0c\n\x05\x04\
\0\x02\0\x01\x12\x03\x05\x0b\x1b\n\x0c\n\x05\x04\0\x02\0\x03\x12\x03\x05\
\x1e\x1f\nO\n\x04\x04\0\x02\x01\x12\x03\x07\x04\x13\x1aB\x20Data\x20cont\
ains\x20base64-encoded\x20bytes\x20to\x20returned\x20from\x20the\x20cont\
ract\n\n\x0c\n\x05\x04\0\x02\x01\x05\x12\x03\x07\x04\t\n\x0c\n\x05\x04\0\
\x02\x01\x01\x12\x03\x07\n\x0e\n\x0c\n\x05\x04\0\x02\x01\x03\x12\x03\x07\
\x11\x12b\x06proto3\
";
static file_descriptor_proto_lazy: ::protobuf::rt::LazyV2<::protobuf::descriptor::FileDescriptorProto> = ::protobuf::rt::LazyV2::INIT;
fn parse_descriptor_proto() -> ::protobuf::descriptor::FileDescriptorProto {
::protobuf::Message::parse_from_bytes(file_descriptor_proto_data).unwrap()
}
pub fn file_descriptor_proto() -> &'static ::protobuf::descriptor::FileDescriptorProto {
file_descriptor_proto_lazy.get(|| {
parse_descriptor_proto()
})
} | rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/math.rs | contracts/mirror_factory/src/math.rs | use cosmwasm_std::{Decimal, Uint128};
const DECIMAL_FRACTIONAL: Uint128 = Uint128::new(1_000_000_000u128);
pub fn reverse_decimal(decimal: Decimal) -> Decimal {
Decimal::from_ratio(DECIMAL_FRACTIONAL, decimal * DECIMAL_FRACTIONAL)
}
pub fn decimal_multiplication(a: Decimal, b: Decimal) -> Decimal {
Decimal::from_ratio(a * DECIMAL_FRACTIONAL * b, DECIMAL_FRACTIONAL)
}
pub fn decimal_subtraction(a: Decimal, b: Decimal) -> Decimal {
Decimal::from_ratio(
(DECIMAL_FRACTIONAL * a)
.checked_sub(DECIMAL_FRACTIONAL * b)
.unwrap(),
DECIMAL_FRACTIONAL,
)
}
/// return a / b
pub fn decimal_division(a: Decimal, b: Decimal) -> Decimal {
Decimal::from_ratio(DECIMAL_FRACTIONAL * a, b * DECIMAL_FRACTIONAL)
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/state.rs | contracts/mirror_factory/src/state.rs | use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use cosmwasm_std::{Addr, CanonicalAddr, Order, StdError, StdResult, Storage, Uint128};
use cosmwasm_storage::{singleton, singleton_read, Bucket, ReadonlyBucket, Singleton};
use mirror_protocol::factory::Params;
static KEY_CONFIG: &[u8] = b"config";
static KEY_TOTAL_WEIGHT: &[u8] = b"total_weight";
static KEY_LAST_DISTRIBUTED: &[u8] = b"last_distributed";
static KEY_WHITELIST_TMP_INFO: &[u8] = b"tmp_whitelist_info";
static KEY_TMP_ASSET: &[u8] = b"tmp_asset_token";
static PREFIX_WEIGHT: &[u8] = b"weight";
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
pub owner: CanonicalAddr,
pub mirror_token: CanonicalAddr,
pub mint_contract: CanonicalAddr,
pub oracle_contract: CanonicalAddr,
pub terraswap_factory: CanonicalAddr,
pub staking_contract: CanonicalAddr,
pub commission_collector: CanonicalAddr,
pub token_code_id: u64, // used to create asset token
pub base_denom: String,
pub genesis_time: u64,
pub distribution_schedule: Vec<(u64, u64, Uint128)>, // [[start_time, end_time, distribution_amount], [], ...]
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct WhitelistTmpInfo {
pub params: Params,
pub oracle_proxy: CanonicalAddr,
pub symbol: String,
}
pub fn store_tmp_asset(storage: &mut dyn Storage, tmp_asset: &Addr) -> StdResult<()> {
singleton(storage, KEY_TMP_ASSET).save(tmp_asset)
}
pub fn read_tmp_asset(storage: &dyn Storage) -> StdResult<Addr> {
singleton_read(storage, KEY_TMP_ASSET).load()
}
pub fn store_config(storage: &mut dyn Storage, config: &Config) -> StdResult<()> {
singleton(storage, KEY_CONFIG).save(config)
}
pub fn read_config(storage: &dyn Storage) -> StdResult<Config> {
singleton_read(storage, KEY_CONFIG).load()
}
pub fn store_tmp_whitelist_info(
storage: &mut dyn Storage,
info: &WhitelistTmpInfo,
) -> StdResult<()> {
singleton(storage, KEY_WHITELIST_TMP_INFO).save(info)
}
pub fn remove_tmp_whitelist_info(storage: &mut dyn Storage) {
let mut store: Singleton<WhitelistTmpInfo> = singleton(storage, KEY_WHITELIST_TMP_INFO);
store.remove()
}
pub fn read_tmp_whitelist_info(storage: &dyn Storage) -> StdResult<WhitelistTmpInfo> {
singleton_read(storage, KEY_WHITELIST_TMP_INFO).load()
}
pub fn store_total_weight(storage: &mut dyn Storage, total_weight: u32) -> StdResult<()> {
singleton(storage, KEY_TOTAL_WEIGHT).save(&total_weight)
}
pub fn increase_total_weight(storage: &mut dyn Storage, weight_increase: u32) -> StdResult<u32> {
let mut store: Singleton<u32> = singleton(storage, KEY_TOTAL_WEIGHT);
store.update(|total_weight| Ok(total_weight + weight_increase))
}
pub fn decrease_total_weight(storage: &mut dyn Storage, weight_decrease: u32) -> StdResult<u32> {
let mut store: Singleton<u32> = singleton(storage, KEY_TOTAL_WEIGHT);
store.update(|total_weight| Ok(total_weight - weight_decrease))
}
pub fn read_total_weight(storage: &dyn Storage) -> StdResult<u32> {
singleton_read(storage, KEY_TOTAL_WEIGHT).load()
}
pub fn store_last_distributed(storage: &mut dyn Storage, last_distributed: u64) -> StdResult<()> {
let mut store: Singleton<u64> = singleton(storage, KEY_LAST_DISTRIBUTED);
store.save(&last_distributed)
}
pub fn read_last_distributed(storage: &dyn Storage) -> StdResult<u64> {
singleton_read(storage, KEY_LAST_DISTRIBUTED).load()
}
pub fn store_weight(
storage: &mut dyn Storage,
asset_token: &CanonicalAddr,
weight: u32,
) -> StdResult<()> {
let mut weight_bucket: Bucket<u32> = Bucket::new(storage, PREFIX_WEIGHT);
weight_bucket.save(asset_token.as_slice(), &weight)
}
pub fn read_weight(storage: &dyn Storage, asset_token: &CanonicalAddr) -> StdResult<u32> {
let weight_bucket: ReadonlyBucket<u32> = ReadonlyBucket::new(storage, PREFIX_WEIGHT);
match weight_bucket.load(asset_token.as_slice()) {
Ok(v) => Ok(v),
_ => Err(StdError::generic_err("No distribution info stored")),
}
}
pub fn remove_weight(storage: &mut dyn Storage, asset_token: &CanonicalAddr) {
let mut weight_bucket: Bucket<u32> = Bucket::new(storage, PREFIX_WEIGHT);
weight_bucket.remove(asset_token.as_slice());
}
pub fn read_all_weight(storage: &dyn Storage) -> StdResult<Vec<(CanonicalAddr, u32)>> {
let weight_bucket: ReadonlyBucket<u32> = ReadonlyBucket::new(storage, PREFIX_WEIGHT);
weight_bucket
.range(None, None, Order::Ascending)
.map(|item| {
let (k, v) = item?;
Ok((CanonicalAddr::from(k), v))
})
.collect()
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/querier.rs | contracts/mirror_factory/src/querier.rs | use cosmwasm_std::{
to_binary, Addr, Binary, CanonicalAddr, Decimal, QuerierWrapper, QueryRequest, StdError,
StdResult, WasmQuery,
};
use cosmwasm_storage::to_length_prefixed;
use mirror_protocol::mint::IPOParams;
use serde::{Deserialize, Serialize};
use tefi_oracle::hub::{HubQueryMsg as OracleQueryMsg, PriceResponse};
/// Query asset price igonoring price age
pub fn query_last_price(
querier: &QuerierWrapper,
oracle: Addr,
asset: String,
) -> StdResult<Decimal> {
let res: PriceResponse = querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: oracle.to_string(),
msg: to_binary(&OracleQueryMsg::Price {
asset_token: asset,
timeframe: None,
})?,
}))?;
Ok(res.rate)
}
#[derive(Serialize, Deserialize)]
pub struct MintAssetConfig {
pub token: CanonicalAddr,
pub auction_discount: Decimal,
pub min_collateral_ratio: Decimal,
pub ipo_params: Option<IPOParams>,
}
pub fn load_mint_asset_config(
querier: &QuerierWrapper,
contract_addr: Addr,
asset_token: &CanonicalAddr,
) -> StdResult<(Decimal, Decimal, Option<Decimal>)> {
let res: StdResult<MintAssetConfig> = querier.query(&QueryRequest::Wasm(WasmQuery::Raw {
contract_addr: contract_addr.to_string(),
key: Binary::from(concat(
&to_length_prefixed(b"asset_config"),
asset_token.as_slice(),
)),
}));
// let asset_config: StdResult<MintAssetConfig> = from_binary(&res);
let asset_config: MintAssetConfig = match res {
Ok(v) => v,
Err(_) => {
return Err(StdError::generic_err(
"Failed to fetch the mint asset config",
));
}
};
let pre_ipo_price: Option<Decimal> = asset_config
.ipo_params
.map(|ipo_params| ipo_params.pre_ipo_price);
Ok((
asset_config.auction_discount,
asset_config.min_collateral_ratio,
pre_ipo_price,
))
}
#[inline]
fn concat(namespace: &[u8], key: &[u8]) -> Vec<u8> {
let mut k = namespace.to_vec();
k.extend_from_slice(key);
k
}
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | false |
Mirror-Protocol/mirror-contracts | https://github.com/Mirror-Protocol/mirror-contracts/blob/56cc6946b9457293ede6aa0feb296ee1d16f6974/contracts/mirror_factory/src/testing/tests.rs | contracts/mirror_factory/src/testing/tests.rs | use crate::contract::{execute, instantiate, query, reply};
use crate::response::MsgInstantiateContractResponse;
use crate::testing::mock_querier::{mock_dependencies, WasmMockQuerier};
use crate::state::{
read_tmp_asset, read_tmp_whitelist_info, read_total_weight, read_weight, store_total_weight,
store_weight, WhitelistTmpInfo,
};
use cosmwasm_std::testing::{mock_env, mock_info, MockApi, MockStorage};
use cosmwasm_std::{
attr, from_binary, to_binary, CanonicalAddr, ContractResult, CosmosMsg, Decimal, Env,
OwnedDeps, Reply, ReplyOn, StdError, SubMsg, Timestamp, Uint128, WasmMsg,
};
use cosmwasm_std::{Api, SubMsgExecutionResponse};
use cw20::{Cw20ExecuteMsg, MinterResponse};
use mirror_protocol::factory::{
ConfigResponse, DistributionInfoResponse, ExecuteMsg, InstantiateMsg, Params, QueryMsg,
};
use mirror_protocol::mint::{ExecuteMsg as MintExecuteMsg, IPOParams};
use mirror_protocol::staking::Cw20HookMsg as StakingCw20HookMsg;
use mirror_protocol::staking::ExecuteMsg as StakingExecuteMsg;
use tefi_oracle::hub::HubExecuteMsg as TeFiOracleExecuteMsg;
use protobuf::Message;
use terraswap::asset::AssetInfo;
use terraswap::factory::ExecuteMsg as TerraswapFactoryExecuteMsg;
use terraswap::token::InstantiateMsg as TokenInstantiateMsg;
fn mock_env_time(time: u64) -> Env {
let mut env = mock_env();
env.block.time = Timestamp::from_seconds(time);
env
}
static TOKEN_CODE_ID: u64 = 10u64;
static BASE_DENOM: &str = "uusd";
#[test]
fn proper_initialization() {
let mut deps = mock_dependencies(&[]);
deps.querier
.with_terraswap_pairs(&[(&"uusdmirror0000".to_string(), &"MIRLP0000".to_string())]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
// cannot update mirror token after initialization
let msg = ExecuteMsg::PostInitialize {
owner: "owner0001".to_string(),
mirror_token: "mirror0001".to_string(),
mint_contract: "mint0001".to_string(),
staking_contract: "staking0001".to_string(),
commission_collector: "collector0001".to_string(),
oracle_contract: "oracle0001".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
// it worked, let's query the state
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!(
config,
ConfigResponse {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
genesis_time: 1_571_797_419,
distribution_schedule: vec![],
}
);
}
#[test]
fn test_update_config() {
let mut deps = mock_dependencies(&[]);
deps.querier
.with_terraswap_pairs(&[(&"uusdmirror0000".to_string(), &"MIRLP0000".to_string())]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// upate owner
let msg = ExecuteMsg::UpdateConfig {
owner: Some("owner0001".to_string()),
distribution_schedule: None,
token_code_id: None,
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!(
config,
ConfigResponse {
owner: "owner0001".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
genesis_time: 1_571_797_419,
distribution_schedule: vec![],
}
);
// update rest part
let msg = ExecuteMsg::UpdateConfig {
owner: None,
distribution_schedule: Some(vec![(1, 2, Uint128::from(123u128))]),
token_code_id: Some(TOKEN_CODE_ID + 1),
};
let info = mock_info("owner0001", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let res = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
let config: ConfigResponse = from_binary(&res).unwrap();
assert_eq!(
config,
ConfigResponse {
owner: "owner0001".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID + 1,
genesis_time: 1_571_797_419,
distribution_schedule: vec![(1, 2, Uint128::from(123u128))],
}
);
// failed unauthoirzed
let msg = ExecuteMsg::UpdateConfig {
owner: None,
distribution_schedule: None,
token_code_id: Some(TOKEN_CODE_ID + 1),
};
let info = mock_info("owner0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
}
#[test]
fn test_update_weight() {
let mut deps = mock_dependencies(&[]);
deps.querier
.with_terraswap_pairs(&[(&"uusdmirror0000".to_string(), &"MIRLP0000".to_string())]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
store_total_weight(&mut deps.storage, 100).unwrap();
store_weight(
&mut deps.storage,
&deps.api.addr_canonicalize("asset0000").unwrap(),
10,
)
.unwrap();
// increase weight
let msg = ExecuteMsg::UpdateWeight {
asset_token: "asset0000".to_string(),
weight: 20,
};
let info = mock_info("owner0001", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let res = query(deps.as_ref(), mock_env(), QueryMsg::DistributionInfo {}).unwrap();
let distribution_info: DistributionInfoResponse = from_binary(&res).unwrap();
assert_eq!(
distribution_info,
DistributionInfoResponse {
weights: vec![
("asset0000".to_string(), 20),
("mirror0000".to_string(), 300)
],
last_distributed: 1_571_797_419,
}
);
assert_eq!(
read_weight(
&deps.storage,
&deps.api.addr_canonicalize("asset0000").unwrap()
)
.unwrap(),
20u32
);
assert_eq!(read_total_weight(&deps.storage).unwrap(), 110u32)
}
#[test]
fn test_whitelist() {
let mut deps = mock_dependencies(&[]);
deps.querier
.with_terraswap_pairs(&[(&"uusdmirror0000".to_string(), &"MIRLP0000".to_string())]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::Whitelist {
name: "apple derivative".to_string(),
symbol: "APPL".to_string(),
oracle_proxy: "oracleproxy0000".to_string(),
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: Some(100u32),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
};
let info = mock_info("owner0000", &[]);
let res = execute(deps.as_mut(), mock_env(), info.clone(), msg.clone()).unwrap();
assert_eq!(
res.attributes,
vec![
attr("action", "whitelist"),
attr("symbol", "APPL"),
attr("cw20_symbol", "mAPPL"),
attr("name", "apple derivative")
]
);
// token creation msg should be returned
assert_eq!(
res.messages,
vec![SubMsg {
msg: WasmMsg::Instantiate {
admin: None,
code_id: TOKEN_CODE_ID,
funds: vec![],
label: "".to_string(),
msg: to_binary(&TokenInstantiateMsg {
name: "apple derivative".to_string(),
symbol: "mAPPL".to_string(),
decimals: 6u8,
initial_balances: vec![],
mint: Some(MinterResponse {
minter: "mint0000".to_string(),
cap: None,
}),
})
.unwrap(),
}
.into(),
gas_limit: None,
id: 1,
reply_on: ReplyOn::Success,
}]
);
let wl_info: WhitelistTmpInfo = read_tmp_whitelist_info(&deps.storage).unwrap();
assert_eq!(
wl_info,
WhitelistTmpInfo {
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: Some(100u32),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
oracle_proxy: deps.api.addr_canonicalize("oracleproxy0000").unwrap(),
symbol: "APPL".to_string(),
}
);
let res = execute(deps.as_mut(), mock_env(), info, msg.clone()).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "A whitelist process is in progress"),
_ => panic!("DO NOT ENTER HERE"),
}
let info = mock_info("addr0001", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg).unwrap_err();
match res {
StdError::GenericErr { msg, .. } => assert_eq!(msg, "unauthorized"),
_ => panic!("DO NOT ENTER HERE"),
}
}
#[test]
fn test_token_creation_hook() {
let mut deps = mock_dependencies(&[]);
deps.querier
.with_terraswap_pairs(&[(&"uusdmirror0000".to_string(), &"MIRLP0000".to_string())]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::Whitelist {
name: "apple derivative".to_string(),
symbol: "APPL".to_string(),
oracle_proxy: "oracleproxy0000".to_string(),
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: Some(100u32),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let mut token_inst_res = MsgInstantiateContractResponse::new();
token_inst_res.set_contract_address("asset0000".to_string());
let reply_msg = Reply {
id: 1,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: Some(token_inst_res.write_to_bytes().unwrap().into()),
}),
};
let res = reply(deps.as_mut(), mock_env(), reply_msg).unwrap();
//ensure asset token was stored
let tmp_asset = read_tmp_asset(&deps.storage).unwrap();
assert_eq!(tmp_asset.to_string(), "asset0000");
assert_eq!(
res.messages,
vec![
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "mint0000".to_string(),
funds: vec![],
msg: to_binary(&MintExecuteMsg::RegisterAsset {
asset_token: "asset0000".to_string(),
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
ipo_params: None,
})
.unwrap(),
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "oracle0000".to_string(),
funds: vec![],
msg: to_binary(&TeFiOracleExecuteMsg::RegisterSource {
symbol: "APPL".to_string(),
proxy_addr: "oracleproxy0000".to_string(),
priority: None,
})
.unwrap(),
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "oracle0000".to_string(),
funds: vec![],
msg: to_binary(&TeFiOracleExecuteMsg::InsertAssetSymbolMap {
map: vec![("asset0000".to_string(), "APPL".to_string())]
})
.unwrap(),
})),
SubMsg {
msg: WasmMsg::Execute {
contract_addr: "terraswapfactory".to_string(),
funds: vec![],
msg: to_binary(&TerraswapFactoryExecuteMsg::CreatePair {
asset_infos: [
AssetInfo::NativeToken {
denom: BASE_DENOM.to_string(),
},
AssetInfo::Token {
contract_addr: "asset0000".to_string(),
},
],
})
.unwrap(),
}
.into(),
gas_limit: None,
id: 2,
reply_on: ReplyOn::Success,
}
]
);
assert_eq!(
res.attributes,
vec![
attr("asset_token_addr", "asset0000"),
attr("is_pre_ipo", "false"),
]
);
let res = query(deps.as_ref(), mock_env(), QueryMsg::DistributionInfo {}).unwrap();
let distribution_info: DistributionInfoResponse = from_binary(&res).unwrap();
assert_eq!(
distribution_info,
DistributionInfoResponse {
weights: vec![
("asset0000".to_string(), 100),
("mirror0000".to_string(), 300)
],
last_distributed: 1_571_797_419,
}
);
}
#[test]
fn test_token_creation_hook_without_weight() {
let mut deps = mock_dependencies(&[]);
deps.querier
.with_terraswap_pairs(&[(&"uusdmirror0000".to_string(), &"MIRLP0000".to_string())]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::Whitelist {
name: "apple derivative".to_string(),
symbol: "APPL".to_string(),
oracle_proxy: "oracleproxy0000".to_string(),
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: None,
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let mut token_inst_res = MsgInstantiateContractResponse::new();
token_inst_res.set_contract_address("asset0000".to_string());
let reply_msg = Reply {
id: 1,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: Some(token_inst_res.write_to_bytes().unwrap().into()),
}),
};
let res = reply(deps.as_mut(), mock_env(), reply_msg).unwrap();
//ensure asset token was stored
let tmp_asset = read_tmp_asset(&deps.storage).unwrap();
assert_eq!(tmp_asset.to_string(), "asset0000");
assert_eq!(
res.messages,
vec![
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "mint0000".to_string(),
funds: vec![],
msg: to_binary(&MintExecuteMsg::RegisterAsset {
asset_token: "asset0000".to_string(),
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
ipo_params: None,
})
.unwrap(),
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "oracle0000".to_string(),
funds: vec![],
msg: to_binary(&TeFiOracleExecuteMsg::RegisterSource {
symbol: "APPL".to_string(),
proxy_addr: "oracleproxy0000".to_string(),
priority: None,
})
.unwrap(),
})),
SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "oracle0000".to_string(),
funds: vec![],
msg: to_binary(&TeFiOracleExecuteMsg::InsertAssetSymbolMap {
map: vec![("asset0000".to_string(), "APPL".to_string())]
})
.unwrap(),
})),
SubMsg {
msg: WasmMsg::Execute {
contract_addr: "terraswapfactory".to_string(),
funds: vec![],
msg: to_binary(&TerraswapFactoryExecuteMsg::CreatePair {
asset_infos: [
AssetInfo::NativeToken {
denom: BASE_DENOM.to_string(),
},
AssetInfo::Token {
contract_addr: "asset0000".to_string(),
},
],
})
.unwrap(),
}
.into(),
gas_limit: None,
id: 2,
reply_on: ReplyOn::Success,
}
]
);
let res = query(deps.as_ref(), mock_env(), QueryMsg::DistributionInfo {}).unwrap();
let distribution_info: DistributionInfoResponse = from_binary(&res).unwrap();
assert_eq!(
distribution_info,
DistributionInfoResponse {
weights: vec![
("asset0000".to_string(), 30),
("mirror0000".to_string(), 300)
],
last_distributed: 1_571_797_419,
}
);
}
#[test]
fn test_terraswap_creation_hook() {
let mut deps = mock_dependencies(&[]);
deps.querier.with_terraswap_pairs(&[
(&"uusdmirror0000".to_string(), &"MIRLP000".to_string()),
(&"uusdasset0000".to_string(), &"LP0000".to_string()),
]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let msg = ExecuteMsg::Whitelist {
name: "apple derivative".to_string(),
symbol: "APPL".to_string(),
oracle_proxy: "oracleproxy0000".to_string(),
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: Some(100u32),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let mut token_inst_res = MsgInstantiateContractResponse::new();
token_inst_res.set_contract_address("asset0000".to_string());
let reply_msg = Reply {
id: 1,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: Some(token_inst_res.write_to_bytes().unwrap().into()),
}),
};
let _res = reply(deps.as_mut(), mock_env(), reply_msg).unwrap();
//ensure asset token was stored
let tmp_asset = read_tmp_asset(&deps.storage).unwrap();
assert_eq!(tmp_asset.to_string(), "asset0000");
let reply_msg2 = Reply {
id: 2,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: None,
}),
};
let res = reply(deps.as_mut(), mock_env(), reply_msg2).unwrap();
assert_eq!(
res.messages,
vec![SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "staking0000".to_string(),
funds: vec![],
msg: to_binary(&StakingExecuteMsg::RegisterAsset {
asset_token: "asset0000".to_string(),
staking_token: "LP0000".to_string(),
})
.unwrap(),
}))]
);
}
#[test]
fn test_distribute() {
let mut deps = mock_dependencies(&[]);
deps.querier.with_terraswap_pairs(&[
(&"uusdmirror0000".to_string(), &"MIRLP000".to_string()),
(&"uusdasset0000".to_string(), &"LP0000".to_string()),
(&"uusdasset0001".to_string(), &"LP0001".to_string()),
]);
let msg = InstantiateMsg {
base_denom: BASE_DENOM.to_string(),
token_code_id: TOKEN_CODE_ID,
distribution_schedule: vec![
(1800, 3600, Uint128::from(3600u128)),
(3600, 3600 + 3600, Uint128::from(7200u128)),
],
};
let info = mock_info("addr0000", &[]);
let _res = instantiate(deps.as_mut(), mock_env(), info.clone(), msg).unwrap();
let msg = ExecuteMsg::PostInitialize {
owner: "owner0000".to_string(),
mirror_token: "mirror0000".to_string(),
mint_contract: "mint0000".to_string(),
staking_contract: "staking0000".to_string(),
commission_collector: "collector0000".to_string(),
oracle_contract: "oracle0000".to_string(),
terraswap_factory: "terraswapfactory".to_string(),
};
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
// whitelist first item with weight 1.5
let msg = ExecuteMsg::Whitelist {
name: "apple derivative".to_string(),
symbol: "APPL".to_string(),
oracle_proxy: "oracleproxy0000".to_string(),
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: Some(100u32),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let mut token_inst_res = MsgInstantiateContractResponse::new();
token_inst_res.set_contract_address("asset0000".to_string());
let reply_msg = Reply {
id: 1,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: Some(token_inst_res.write_to_bytes().unwrap().into()),
}),
};
let _res = reply(deps.as_mut(), mock_env(), reply_msg).unwrap();
//ensure asset token was stored
let tmp_asset = read_tmp_asset(&deps.storage).unwrap();
assert_eq!(tmp_asset.to_string(), "asset0000");
let reply_msg2 = Reply {
id: 2,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: None,
}),
};
let _res = reply(deps.as_mut(), mock_env(), reply_msg2).unwrap();
// Whitelist second item with weight 1
let msg = ExecuteMsg::Whitelist {
name: "google derivative".to_string(),
symbol: "GOGL".to_string(),
oracle_proxy: "oracleproxy0000".to_string(),
params: Params {
auction_discount: Decimal::percent(5),
min_collateral_ratio: Decimal::percent(150),
weight: Some(100u32),
mint_period: None,
min_collateral_ratio_after_ipo: None,
pre_ipo_price: None,
ipo_trigger_addr: None,
},
};
let info = mock_info("owner0000", &[]);
let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();
let mut token_inst_res = MsgInstantiateContractResponse::new();
token_inst_res.set_contract_address("asset0001".to_string());
let reply_msg = Reply {
id: 1,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: Some(token_inst_res.write_to_bytes().unwrap().into()),
}),
};
let _res = reply(deps.as_mut(), mock_env(), reply_msg).unwrap();
//ensure asset token was stored
let tmp_asset = read_tmp_asset(&deps.storage).unwrap();
assert_eq!(tmp_asset.to_string(), "asset0001");
let reply_msg2 = Reply {
id: 2,
result: ContractResult::Ok(SubMsgExecutionResponse {
events: vec![],
data: None,
}),
};
let _res = reply(deps.as_mut(), mock_env(), reply_msg2).unwrap();
// height is not increased so zero amount will be minted
let msg = ExecuteMsg::Distribute {};
let info = mock_info("anyone", &[]);
let res = execute(deps.as_mut(), mock_env(), info, msg);
match res {
Err(StdError::GenericErr { msg, .. }) => {
assert_eq!(msg, "Cannot distribute mirror token before interval")
}
_ => panic!("DO NOT ENTER HERE"),
}
// one height increase
let msg = ExecuteMsg::Distribute {};
let env = mock_env_time(1_571_797_419u64 + 5400u64);
let info = mock_info("addr0000", &[]);
let res = execute(deps.as_mut(), env, info, msg).unwrap();
assert_eq!(
res.attributes,
vec![
attr("action", "distribute"),
attr("distribution_amount", "7200"),
]
);
// MIR -> 7200 * 3/5
// asset0000 -> 7200 * 1/5
// asset0001 -> 7200 * 1/5
assert_eq!(
res.messages,
vec![SubMsg::new(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: "mirror0000".to_string(),
msg: to_binary(&Cw20ExecuteMsg::Send {
contract: "staking0000".to_string(),
amount: Uint128::from(7200u128),
msg: to_binary(&StakingCw20HookMsg::DepositReward {
rewards: vec![
("asset0000".to_string(), Uint128::from(7200u128 / 5)),
("asset0001".to_string(), Uint128::from(7200u128 / 5)),
("mirror0000".to_string(), Uint128::from(7200u128 * 3 / 5)),
],
})
.unwrap(),
})
.unwrap(),
funds: vec![],
}))],
);
let res = query(deps.as_ref(), mock_env(), QueryMsg::DistributionInfo {}).unwrap();
let distribution_info: DistributionInfoResponse = from_binary(&res).unwrap();
assert_eq!(
distribution_info,
DistributionInfoResponse {
weights: vec![
("asset0000".to_string(), 100),
("asset0001".to_string(), 100),
("mirror0000".to_string(), 300),
],
last_distributed: 1_571_802_819,
}
);
}
fn whitelist_token(
deps: &mut OwnedDeps<MockStorage, MockApi, WasmMockQuerier>,
name: &str,
symbol: &str,
asset_token: &str,
| rust | Apache-2.0 | 56cc6946b9457293ede6aa0feb296ee1d16f6974 | 2026-01-04T20:21:07.037869Z | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.