rootchain_std/

lib.rs

#![no_std]

extern crate alloc;

pub mod error;
pub mod rrc721;
pub mod traits;
pub mod types;

pub use rootchain_core::types::{Address, Hash};
pub use rootchain_macros::rootchain_contract;
pub use traits::{Ownable, RRC20, RRC721};

// Host function declarations
#[cfg(not(feature = "test-utils"))]
extern "C" {
    pub fn state_get(
        key_ptr: *const u8,
        key_len: usize,
        value_ptr: *mut u8,
        value_len: usize,
    ) -> i32;
    pub fn state_set(
        key_ptr: *const u8,
        key_len: usize,
        value_ptr: *const u8,
        value_len: usize,
    ) -> i32;
    pub fn get_caller(addr_ptr: *mut u8) -> i32;
    pub fn host_input_len() -> u32;
    pub fn host_read_input(ptr: *mut u8) -> u32;
    pub fn host_write_output(ptr: *const u8, len: usize) -> i32;
    pub fn host_log(ptr: *const u8, len: usize, level: u32) -> i32;
    pub fn host_log_event(
        topics_ptr: *const u8,
        topics_count: usize,
        data_ptr: *const u8,
        data_len: usize,
    ) -> i32;
    pub fn host_set_metadata(ptr: *const u8, len: usize) -> i32;
    pub fn host_hash(ptr: *const u8, len: usize, out_ptr: *mut u8) -> i32;
}

#[cfg(feature = "test-utils")]
pub use mock::*;

#[cfg(feature = "test-utils")]
mod mock {
    extern crate std;
    use core::cell::RefCell;
    use std::collections::HashMap;
    use std::vec::Vec;

    std::thread_local! {
        static STATE: RefCell<HashMap<Vec<u8>, Vec<u8>>> = RefCell::new(HashMap::new());
        static CALLER: RefCell<[u8; 32]> = const { RefCell::new([0u8; 32]) };
    }

    /// # Safety
    /// This function dereferences raw pointers. The caller must ensure that `key_ptr` and `value_ptr`
    /// are valid pointers to memory of at least `key_len` and `value_len` bytes respectively.
    pub unsafe fn state_get(
        key_ptr: *const u8,
        key_len: usize,
        value_ptr: *mut u8,
        value_len: usize,
    ) -> i32 {
        let key = core::slice::from_raw_parts(key_ptr, key_len).to_vec();
        STATE.with(|s| {
            if let Some(val) = s.borrow().get(&key) {
                let len = core::cmp::min(val.len(), value_len);
                core::ptr::copy_nonoverlapping(val.as_ptr(), value_ptr, len);
                0
            } else {
                -1
            }
        })
    }

    /// # Safety
    /// This function dereferences raw pointers. The caller must ensure that `key_ptr` and `value_ptr`
    /// are valid pointers to memory of at least `key_len` and `value_len` bytes respectively.
    pub unsafe fn state_set(
        key_ptr: *const u8,
        key_len: usize,
        value_ptr: *const u8,
        value_len: usize,
    ) -> i32 {
        let key = core::slice::from_raw_parts(key_ptr, key_len).to_vec();
        let val = core::slice::from_raw_parts(value_ptr, value_len).to_vec();
        STATE.with(|s| {
            s.borrow_mut().insert(key, val);
            0
        })
    }

    /// # Safety
    /// This function dereferences raw pointers. The caller must ensure that `addr_ptr`
    /// is a valid pointer to memory of at least 32 bytes.
    pub unsafe fn get_caller(addr_ptr: *mut u8) -> i32 {
        CALLER.with(|c| {
            core::ptr::copy_nonoverlapping(c.borrow().as_ptr(), addr_ptr, 32);
            0
        })
    }

    /// # Safety
    /// Caller must ensure `_ptr` points to a buffer of sufficient size to hold the input data.
    pub unsafe fn host_input_len() -> u32 {
        0
    }

    /// # Safety
    /// Caller must ensure `_ptr` points to a buffer of sufficient size to hold the input data.
    pub unsafe fn host_read_input(_ptr: *mut u8) -> u32 {
        0
    }

    /// # Safety
    /// Caller must ensure `_ptr` points to valid memory of at least `_len` bytes.
    pub unsafe fn host_write_output(_ptr: *const u8, _len: usize) -> i32 {
        0
    }

    /// # Safety
    /// Caller must ensure `_ptr` points to valid UTF-8 memory of at least `_len` bytes.
    pub unsafe fn host_log(_ptr: *const u8, _len: usize, _level: u32) -> i32 {
        0
    }

    /// # Safety
    /// This function is a mock implementation for testing.
    pub unsafe fn host_log_event(
        _topics_ptr: *const u8,
        _topics_count: usize,
        _data_ptr: *const u8,
        _data_len: usize,
    ) -> i32 {
        0
    }

    /// # Safety
    /// This function is a mock implementation for testing.
    pub unsafe fn host_set_metadata(_ptr: *const u8, _len: usize) -> i32 {
        0
    }

    /// # Safety
    /// This function is a mock implementation for testing.
    pub unsafe fn host_hash(_ptr: *const u8, _len: usize, _out_ptr: *mut u8) -> i32 {
        0
    }

    pub fn set_mock_caller(addr: [u8; 32]) {
        CALLER.with(|c| *c.borrow_mut() = addr);
    }
}

#[cfg(all(not(feature = "std"), target_arch = "wasm32"))]
#[global_allocator]
static ALLOC: lol_alloc::AssumeSingleThreaded<lol_alloc::LeakingPageAllocator> =
    unsafe { lol_alloc::AssumeSingleThreaded::new(lol_alloc::LeakingPageAllocator) };

#[cfg(all(not(feature = "std"), target_arch = "wasm32"))]
#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

pub fn read_input() -> alloc::vec::Vec<u8> {
    #[cfg(not(feature = "test-utils"))]
    {
        let len = unsafe { host_input_len() } as usize;
        let mut buf = alloc::vec::Vec::with_capacity(len);
        buf.resize(len, 0);
        unsafe { host_read_input(buf.as_mut_ptr()) };
        buf
    }
    #[cfg(feature = "test-utils")]
    {
        alloc::vec::Vec::new()
    }
}

pub fn hash_bytes(data: &[u8]) -> Hash {
    let mut hash = [0u8; 32];
    unsafe { host_hash(data.as_ptr(), data.len(), hash.as_mut_ptr()) };
    Hash(hash)
}

pub fn write_output(data: &[u8]) {
    unsafe { host_write_output(data.as_ptr(), data.len()) };
}

pub fn log(msg: &str, level: u32) {
    unsafe { host_log(msg.as_ptr(), msg.len(), level) };
}

pub fn log_event(topics: &[Hash], data: &[u8]) {
    unsafe {
        host_log_event(
            topics.as_ptr() as *const u8,
            topics.len(),
            data.as_ptr(),
            data.len(),
        )
    };
}

pub fn set_metadata(metadata: &[u8]) {
    unsafe { host_set_metadata(metadata.as_ptr(), metadata.len()) };
}

#[macro_export]
macro_rules! log_event {
    ($topic:expr, $data:expr) => {
        $crate::log_event(&[$topic], &$data);
    };
    ($topics:expr, $data:expr) => {
        $crate::log_event(&$topics, &$data);
    };
}