neo-devpack-solidity 0.22.0

Production-focused Solidity-to-NeoVM compilation system
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

use super::*;

impl ExecutionContext {
    pub(crate) fn invoke_native_notary(&mut self, method: &str, params: StackItem) -> StackItem {
        match method {
            "verify" => StackItem::Boolean(true),

            "balanceof" => {
                let account = Self::extract_first_bytes(&params);
                let balance = self
                    .notary_deposits
                    .get(&account)
                    .map(|d| d.amount)
                    .unwrap_or(0);
                StackItem::UnsignedInteger(balance)
            }

            "expirationof" => {
                let account = Self::extract_first_bytes(&params);
                let till = self
                    .notary_deposits
                    .get(&account)
                    .map(|d| d.till as u64)
                    .unwrap_or(0);
                StackItem::UnsignedInteger(till)
            }

            "lockdeposituntil" => {
                let account = Self::extract_first_bytes(&params);
                let till = if let StackItem::Array(args) = &params {
                    let borrowed = args.borrow();
                    Self::stack_item_to_int(borrowed.get(1).cloned().unwrap_or(StackItem::Null))
                        as u32
                } else {
                    0
                };
                if let Some(deposit) = self.notary_deposits.get_mut(&account) {
                    if till > deposit.till {
                        deposit.till = till;
                        return StackItem::Boolean(true);
                    }
                }
                StackItem::Boolean(false)
            }

            "withdraw" => {
                let account = Self::extract_first_bytes(&params);
                if self.notary_deposits.remove(&account).is_some() {
                    StackItem::Boolean(true)
                } else {
                    StackItem::Boolean(false)
                }
            }

            "getmaxnotvalidbeforedelta" => {
                StackItem::UnsignedInteger(self.notary_max_not_valid_before_delta as u64)
            }

            "setmaxnotvalidbeforedelta" => {
                self.notary_max_not_valid_before_delta = Self::extract_first_int(&params) as u32;
                StackItem::Null
            }

            "onnep17payment" => {
                // Track deposit from NEP-17 payment
                if let StackItem::Array(args) = &params {
                    let borrowed = args.borrow();
                    let from = Self::stack_item_to_bytes(
                        borrowed.first().cloned().unwrap_or(StackItem::Null),
                    );
                    let amount = Self::stack_item_to_int(
                        borrowed.get(1).cloned().unwrap_or(StackItem::Null),
                    ) as u64;
                    let till = Self::stack_item_to_int(
                        borrowed.get(2).cloned().unwrap_or(StackItem::Null),
                    ) as u32;

                    let deposit =
                        self.notary_deposits
                            .entry(from.clone())
                            .or_insert_with(|| NotaryDeposit {
                                account: from,
                                amount: 0,
                                till: 0,
                            });
                    deposit.amount += amount;
                    if till > deposit.till {
                        deposit.till = till;
                    }
                }
                StackItem::Null
            }

            _ => StackItem::Null,
        }
    }
}