neo-runtime 0.1.1

Neo N3 Runtime Stubs
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// Copyright (c) 2025-2026 R3E Network
// Licensed under the MIT License

use neo_syscalls::NeoVMSyscall;
use neo_types::*;

use crate::NeoStorage;

/// Direct wrappers for the canonical System.Runtime syscalls.
pub struct NeoRuntime;

impl NeoRuntime {
    pub fn get_time() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_time()
    }

    pub fn get_time_i64() -> NeoResult<i64> {
        NeoVMSyscall::get_time_i64()
    }

    pub fn check_witness(account: &NeoByteString) -> NeoResult<NeoBoolean> {
        NeoVMSyscall::check_witness(account)
    }

    pub fn check_witness_bytes(account: &[u8]) -> NeoResult<NeoBoolean> {
        NeoVMSyscall::check_witness_bytes(account)
    }

    pub fn check_witness_i64(account: i64) -> NeoResult<NeoBoolean> {
        NeoVMSyscall::check_witness_i64(account)
    }

    pub fn notify(event: &NeoString, state: &NeoArray<NeoValue>) -> NeoResult<()> {
        NeoVMSyscall::notify(event, state)
    }

    pub fn notify_event(event: &str) -> NeoResult<()> {
        NeoVMSyscall::notify_event(event)
    }

    pub fn log(message: &NeoString) -> NeoResult<()> {
        NeoVMSyscall::log(message)
    }

    pub fn platform() -> NeoResult<NeoString> {
        NeoVMSyscall::platform()
    }

    pub fn get_trigger() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_trigger()
    }

    pub fn get_invocation_counter() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_invocation_counter()
    }

    pub fn get_random() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_random()
    }

    pub fn get_network() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_network()
    }

    pub fn get_address_version() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_address_version()
    }

    pub fn get_gas_left() -> NeoResult<NeoInteger> {
        NeoVMSyscall::get_gas_left()
    }

    pub fn get_calling_script_hash() -> NeoResult<NeoByteString> {
        NeoVMSyscall::get_calling_script_hash()
    }

    pub fn get_calling_script_hash_i64() -> NeoResult<i64> {
        NeoVMSyscall::get_calling_script_hash_i64()
    }

    pub fn get_entry_script_hash() -> NeoResult<NeoByteString> {
        NeoVMSyscall::get_entry_script_hash()
    }

    pub fn get_entry_script_hash_i64() -> NeoResult<i64> {
        NeoVMSyscall::get_entry_script_hash_i64()
    }

    pub fn get_executing_script_hash() -> NeoResult<NeoByteString> {
        NeoVMSyscall::get_executing_script_hash()
    }

    pub fn get_executing_script_hash_i64() -> NeoResult<i64> {
        NeoVMSyscall::get_executing_script_hash_i64()
    }

    pub fn get_notifications(script_hash: Option<&NeoByteString>) -> NeoResult<NeoArray<NeoValue>> {
        NeoVMSyscall::get_notifications(script_hash)
    }

    pub fn get_script_container() -> NeoResult<NeoArray<NeoValue>> {
        NeoVMSyscall::get_script_container()
    }

    pub fn get_storage_context() -> NeoResult<NeoStorageContext> {
        NeoStorage::get_context()
    }

    /// Burn the specified amount of GAS from the calling contract.
    pub fn burn_gas(gas: &NeoInteger) -> NeoResult<()> {
        NeoVMSyscall::burn_gas(gas)
    }

    /// Get the signers of the current transaction.
    pub fn current_signers() -> NeoResult<NeoArray<NeoValue>> {
        NeoVMSyscall::current_signers()
    }

    /// Load and execute a script dynamically.
    pub fn load_script(
        script: &NeoByteString,
        call_flags: &NeoInteger,
        args: &NeoArray<NeoValue>,
    ) -> NeoResult<()> {
        NeoVMSyscall::load_script(script, call_flags, args)
    }
}