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

use super::*;

pub(crate) fn extract_bytes(item: &StackItem) -> Result<Vec<u8>, VMBridgeError> {
    Ok(match item {
        StackItem::ByteArray(bytes) => bytes.borrow().clone(),
        StackItem::UnsignedInteger(value) => value.to_be_bytes().to_vec(),
        StackItem::Integer(value) => {
            if *value < 0 {
                return Err(VMBridgeError::StackOperationFailed {
                    message: "Negative integers not supported for byte extraction".to_string(),
                });
            }
            (*value as u64).to_be_bytes().to_vec()
        }
        StackItem::Array(_) => {
            return Err(VMBridgeError::StackOperationFailed {
                message: "Cannot extract bytes from array stack item".to_string(),
            })
        }
        StackItem::Map(_) => {
            return Err(VMBridgeError::StackOperationFailed {
                message: "Cannot extract bytes from map".to_string(),
            })
        }
        StackItem::Boolean(flag) => vec![if *flag { 1 } else { 0 }],
        StackItem::Null => Vec::new(),
    })
}

pub(crate) fn extract_integer(item: &StackItem) -> Result<u128, VMBridgeError> {
    Ok(match item {
        StackItem::UnsignedInteger(value) => *value as u128,
        StackItem::Integer(value) => {
            if *value < 0 {
                return Err(VMBridgeError::StackOperationFailed {
                    message: "Negative integers not supported here".to_string(),
                });
            }
            *value as u128
        }
        StackItem::ByteArray(bytes) => {
            let bytes = bytes.borrow();
            if bytes.is_empty() {
                0
            } else {
                let mut padded = [0u8; 16];
                let copy_len = bytes.len().min(16);
                padded[16 - copy_len..].copy_from_slice(&bytes[bytes.len() - copy_len..]);
                u128::from_be_bytes(padded)
            }
        }
        StackItem::Array(_) => {
            return Err(VMBridgeError::StackOperationFailed {
                message: "Arrays not supported for integer extraction".to_string(),
            });
        }
        StackItem::Map(_) => {
            return Err(VMBridgeError::StackOperationFailed {
                message: "Maps not supported for integer extraction".to_string(),
            });
        }
        StackItem::Boolean(flag) => {
            if *flag {
                1
            } else {
                0
            }
        }
        StackItem::Null => 0,
    })
}