use serde::Serialize;
#[cfg(target_arch = "wasm32")]
use std::alloc::{alloc as sys_alloc, dealloc as sys_dealloc, Layout};
#[cfg(target_arch = "wasm32")]
#[doc(hidden)]
pub fn sdk_alloc(size: u32) -> u32 {
if size == 0 {
return 1;
}
unsafe {
let layout = Layout::from_size_align(size as usize, 1).unwrap();
sys_alloc(layout) as u32
}
}
#[cfg(target_arch = "wasm32")]
#[doc(hidden)]
pub fn sdk_dealloc(ptr: u32, size: u32) {
if ptr == 0 || size == 0 {
return;
}
unsafe {
let layout = Layout::from_size_align(size as usize, 1).unwrap();
sys_dealloc(ptr as *mut u8, layout);
}
}
#[cfg(target_arch = "wasm32")]
pub(crate) fn read_bytes(ptr: u32, len: u32) -> &'static [u8] {
if ptr == 0 || len == 0 {
return &[];
}
unsafe { std::slice::from_raw_parts(ptr as *const u8, len as usize) }
}
#[cfg(target_arch = "wasm32")]
pub(crate) fn write_bytes(data: &[u8]) -> (u32, u32) {
let ptr = sdk_alloc(data.len() as u32);
if !data.is_empty() {
unsafe {
let dst = std::slice::from_raw_parts_mut(ptr as *mut u8, data.len());
dst.copy_from_slice(data);
}
}
(ptr, data.len() as u32)
}
#[cfg(not(target_arch = "wasm32"))]
mod native_mem {
use std::cell::RefCell;
use std::collections::HashMap;
thread_local! {
static SLAB: RefCell<(u32, HashMap<u32, &'static mut [u8]>)> =
RefCell::new((1, HashMap::new()));
}
pub(super) fn alloc(size: u32) -> u32 {
SLAB.with(|slab| {
let mut slab = slab.borrow_mut();
let id = slab.0;
slab.0 = slab.0.checked_add(1).unwrap_or(1);
let buf: &'static mut [u8] = vec![0u8; size as usize].leak();
slab.1.insert(id, buf);
id
})
}
pub(super) fn write(id: u32, data: &[u8]) {
SLAB.with(|slab| {
if let Some(buf) = slab.borrow_mut().1.get_mut(&id) {
buf[..data.len()].copy_from_slice(data);
}
});
}
pub(super) fn read(id: u32, len: u32) -> &'static [u8] {
SLAB.with(|slab| match slab.borrow().1.get(&id) {
Some(buf) => unsafe { std::slice::from_raw_parts(buf.as_ptr(), (len as usize).min(buf.len())) },
None => &[],
})
}
}
#[cfg(not(target_arch = "wasm32"))]
#[doc(hidden)]
pub fn sdk_alloc(size: u32) -> u32 {
native_mem::alloc(size)
}
#[cfg(not(target_arch = "wasm32"))]
#[doc(hidden)]
pub fn sdk_dealloc(_ptr: u32, _size: u32) {}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn read_bytes(ptr: u32, len: u32) -> &'static [u8] {
if ptr == 0 || len == 0 {
return &[];
}
native_mem::read(ptr, len)
}
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn write_bytes(data: &[u8]) -> (u32, u32) {
let ptr = sdk_alloc(data.len() as u32);
native_mem::write(ptr, data);
(ptr, data.len() as u32)
}
pub(crate) fn pack(ptr: u32, len: u32) -> u64 {
((ptr as u64) << 32) | (len as u64)
}
pub(crate) fn unpack(packed: u64) -> (u32, u32) {
((packed >> 32) as u32, packed as u32)
}
#[derive(Serialize, serde::Deserialize)]
pub(crate) struct Envelope<T> {
pub(crate) ok: bool,
#[serde(skip_serializing_if = "Option::is_none")]
pub(crate) data: Option<T>,
#[serde(default)]
pub(crate) error: String,
#[serde(default)]
pub(crate) code: String,
#[serde(default, skip_serializing_if = "String::is_empty")]
pub(crate) retry_after: String,
}
pub(crate) fn respond_ok<T: Serialize>(data: &T) -> u64 {
let body = serde_json::to_vec(&Envelope {
ok: true,
data: Some(data),
error: String::new(),
code: String::new(),
retry_after: String::new(),
})
.unwrap_or_else(|_| br#"{"ok":false,"error":"failed to encode response"}"#.to_vec());
let (ptr, len) = write_bytes(&body);
pack(ptr, len)
}
pub(crate) fn respond_err(msg: &str) -> u64 {
respond_err_code(msg, "")
}
pub(crate) fn respond_err_code(msg: &str, code: &str) -> u64 {
respond_err_retry(msg, code, "")
}
pub(crate) fn respond_err_retry(msg: &str, code: &str, retry_after: &str) -> u64 {
let body = serde_json::to_vec(&Envelope::<()> {
ok: false,
data: None,
error: msg.to_string(),
code: code.to_string(),
retry_after: retry_after.to_string(),
})
.unwrap_or_else(|_| br#"{"ok":false,"error":"failed to encode error response"}"#.to_vec());
let (ptr, len) = write_bytes(&body);
pack(ptr, len)
}