Skip to content

feat: streaming refill buffers for WASM state transfer #63

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
iduartgomez merged 1 commit into from
Mar 24, 2026
Merged

feat: streaming refill buffers for WASM state transfer #63

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion rust/Cargo.toml
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
[package]
name = "freenet-stdlib"
version = "0.3.3"
version = "0.3.4"
edition = "2021"
rust-version = "1.80"
publish = true
Expand Down
116 changes: 57 additions & 59 deletions rust/src/memory.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,20 @@ pub mod wasm_interface {
Ok(())
}

use std::io::Read;

/// Read all bytes from a streaming buffer into a Vec.
fn read_streaming_bytes(ptr: i64) -> Result<Vec<u8>, ContractInterfaceResult> {
let mut reader = unsafe { super::buf::StreamingBuffer::from_ptr(ptr) };
let mut bytes = Vec::with_capacity(reader.total_remaining());
reader.read_to_end(&mut bytes).map_err(|e| {
ContractInterfaceResult::from(Err::<ValidateResult, _>(ContractError::Other(format!(
"streaming read failed: {e}"
))))
})?;
Ok(bytes)
}

pub fn inner_validate_state<T: ContractInterface>(
parameters: i64,
state: i64,
Expand All @@ -53,31 +67,28 @@ pub mod wasm_interface {
if let Err(e) = set_logger().map_err(|e| e.into_raw()) {
return e;
}
let parameters = unsafe {
let param_buf = &*(parameters as *const super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(param_buf.start(), param_buf.bytes_written());
Parameters::from(bytes)
let parameters = match read_streaming_bytes(parameters) {
Ok(bytes) => Parameters::from(bytes),
Err(e) => return e.into_raw(),
};
let state = unsafe {
let state_buf = &*(state as *const super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(state_buf.start(), state_buf.bytes_written());
State::from(bytes)
let state = match read_streaming_bytes(state) {
Ok(bytes) => State::from(bytes),
Err(e) => return e.into_raw(),
};
let related: RelatedContracts = unsafe {
let related = &*(related as *const super::buf::BufferBuilder);
let bytes = &*std::ptr::slice_from_raw_parts(related.start(), related.bytes_written());
match bincode::deserialize(bytes) {
Ok(v) => v,
let related_bytes = match read_streaming_bytes(related) {
Ok(bytes) => bytes,
Err(e) => return e.into_raw(),
};
let related: RelatedContracts<'static> =
match bincode::deserialize::<RelatedContracts>(&related_bytes) {
Ok(v) => v.into_owned(),
Err(err) => {
return ContractInterfaceResult::from(Err::<::core::primitive::bool, _>(
ContractError::Deser(format!("{}", err)),
))
.into_raw()
}
}
};
};
let result = <T as ContractInterface>::validate_state(parameters, state, related);
ContractInterfaceResult::from(result).into_raw()
}
Expand All @@ -90,31 +101,28 @@ pub mod wasm_interface {
if let Err(e) = set_logger().map_err(|e| e.into_raw()) {
return e;
}
let parameters = unsafe {
let param_buf = &mut *(parameters as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(param_buf.start(), param_buf.bytes_written());
Parameters::from(bytes)
let parameters = match read_streaming_bytes(parameters) {
Ok(bytes) => Parameters::from(bytes),
Err(e) => return e.into_raw(),
};
let state = match read_streaming_bytes(state) {
Ok(bytes) => State::from(bytes),
Err(e) => return e.into_raw(),
};
let state = unsafe {
let state_buf = &mut *(state as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(state_buf.start(), state_buf.bytes_written());
State::from(bytes)
let updates_bytes = match read_streaming_bytes(updates) {
Ok(bytes) => bytes,
Err(e) => return e.into_raw(),
};
let updates = unsafe {
let updates = &mut *(updates as *mut super::buf::BufferBuilder);
let bytes = &*std::ptr::slice_from_raw_parts(updates.start(), updates.bytes_written());
match bincode::deserialize(bytes) {
Ok(v) => v,
let updates: Vec<UpdateData<'static>> =
match bincode::deserialize::<Vec<UpdateData>>(&updates_bytes) {
Ok(v) => v.into_iter().map(|u| u.into_owned()).collect(),
Err(err) => {
return ContractInterfaceResult::from(Err::<ValidateResult, _>(
ContractError::Deser(format!("{}", err)),
))
.into_raw()
}
}
};
};
let result = <T as ContractInterface>::update_state(parameters, state, updates);
ContractInterfaceResult::from(result).into_raw()
}
Expand All @@ -123,17 +131,13 @@ pub mod wasm_interface {
if let Err(e) = set_logger().map_err(|e| e.into_raw()) {
return e;
}
let parameters = unsafe {
let param_buf = &mut *(parameters as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(param_buf.start(), param_buf.bytes_written());
Parameters::from(bytes)
let parameters = match read_streaming_bytes(parameters) {
Ok(bytes) => Parameters::from(bytes),
Err(e) => return e.into_raw(),
};
let state = unsafe {
let state_buf = &mut *(state as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(state_buf.start(), state_buf.bytes_written());
State::from(bytes)
let state = match read_streaming_bytes(state) {
Ok(bytes) => State::from(bytes),
Err(e) => return e.into_raw(),
};
let summary = <T as ContractInterface>::summarize_state(parameters, state);
ContractInterfaceResult::from(summary).into_raw()
Expand All @@ -147,23 +151,17 @@ pub mod wasm_interface {
if let Err(e) = set_logger().map_err(|e| e.into_raw()) {
return e;
}
let parameters = unsafe {
let param_buf = &mut *(parameters as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(param_buf.start(), param_buf.bytes_written());
Parameters::from(bytes)
let parameters = match read_streaming_bytes(parameters) {
Ok(bytes) => Parameters::from(bytes),
Err(e) => return e.into_raw(),
};
let state = unsafe {
let state_buf = &mut *(state as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(state_buf.start(), state_buf.bytes_written());
State::from(bytes)
let state = match read_streaming_bytes(state) {
Ok(bytes) => State::from(bytes),
Err(e) => return e.into_raw(),
};
let summary = unsafe {
let summary_buf = &mut *(summary as *mut super::buf::BufferBuilder);
let bytes =
&*std::ptr::slice_from_raw_parts(summary_buf.start(), summary_buf.bytes_written());
StateSummary::from(bytes)
let summary = match read_streaming_bytes(summary) {
Ok(bytes) => StateSummary::from(bytes),
Err(e) => return e.into_raw(),
};
let new_delta = <T as ContractInterface>::get_state_delta(parameters, state, summary);
ContractInterfaceResult::from(new_delta).into_raw()
Expand Down
Loading
Loading