fvm_sdk 2.12.0

Filecoin Virtual Machine actor development SDK
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

pub use inner::*;

#[cfg(not(feature = "debug"))]
mod inner {
    #[inline(always)]
    pub fn init_logging() {}

    #[inline(always)]
    pub fn enabled() -> bool {
        false
    }
    #[inline(always)]
    pub fn log(_: String) {}

    #[inline(always)]
    pub fn store_artifact(_: impl AsRef<str>, _: impl AsRef<[u8]>) {}
}

#[cfg(feature = "debug")]
mod inner {
    use lazy_static::lazy_static;

    use crate::sys;

    lazy_static! {
        /// Lazily memoizes if debug mode is enabled.
        static ref DEBUG_ENABLED: bool = unsafe { sys::debug::enabled().unwrap() >= 0 };
    }

    /// Logs a message on the node.
    #[inline]
    pub fn log(msg: String) {
        unsafe {
            sys::debug::log(msg.as_ptr(), msg.len() as u32).unwrap();
        }
    }
    /// Initialize logging if debugging is enabled.
    pub fn init_logging() {
        if enabled() {
            log::set_logger(&Logger).expect("failed to enable logging");
            log::set_max_level(log::LevelFilter::Trace);
        }
    }

    /// Saves an artifact to the host env. New artifacts with the same name will overwrite old ones
    pub fn store_artifact(name: impl AsRef<str>, data: impl AsRef<[u8]>) {
        let name = name.as_ref();
        let data = data.as_ref();
        unsafe {
            sys::debug::store_artifact(
                name.as_ptr(),
                name.len() as u32,
                data.as_ptr(),
                data.len() as u32,
            )
            .unwrap();
        }
    }

    /// Returns whether debug mode is enabled.
    #[inline(always)]
    pub fn enabled() -> bool {
        *DEBUG_ENABLED
    }

    /// Logger is a debug-only logger that uses the FVM syscalls.
    struct Logger;

    impl log::Log for Logger {
        fn enabled(&self, _: &log::Metadata) -> bool {
            // TODO: per-level?
            enabled()
        }

        fn log(&self, record: &log::Record) {
            if enabled() {
                log(format!("[{}] {}", record.level(), record.args()));
            }
        }

        fn flush(&self) {}
    }
}