ethcontract 0.25.8

Runtime library and proc macro for interacting and generating type-safe bindings to Ethereum smart contracts.
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! This module implements Nethermind specific error decoding in order to try and
//! provide more accurate errors from Nethermind nodes.

use crate::errors::{revert, ExecutionError};
use jsonrpc_core::Error as JsonrpcError;

/// Revert error discriminant.
const REVERTED: &str = "Reverted 0x";
/// Invalid op-code error discriminant.
const INVALID: &str = "Bad instruction";
/// Error messages for VM execution errors.
const MESSAGES: &[&str] = &["VM execution error", "VM execution error."];

/// Tries to get a more accurate error from a generic Nethermind JSON RPC error.
/// Returns `None` when a more accurate error cannot be determined.
pub fn get_encoded_error(err: &JsonrpcError) -> Option<ExecutionError> {
    let message = get_error_message(err);
    if let Some(hex) = message.strip_prefix(REVERTED) {
        if hex.is_empty() {
            return Some(ExecutionError::Revert(None));
        } else {
            match hex::decode(hex)
                .ok()
                .and_then(|bytes| revert::decode_reason(&bytes))
            {
                Some(reason) => return Some(ExecutionError::Revert(Some(reason))),
                None => return Some(ExecutionError::Revert(None)),
            }
        }
    } else if message.starts_with(INVALID) {
        return Some(ExecutionError::InvalidOpcode);
    }

    if MESSAGES.contains(&&*err.message) {
        return Some(ExecutionError::Revert(None));
    }

    None
}

/// Returns the error message from the JSON RPC error data.
fn get_error_message(err: &JsonrpcError) -> &str {
    err.data
        .as_ref()
        .and_then(|data| data.as_str())
        .unwrap_or(&err.message)
}

#[allow(unused)]
#[cfg(test)]
pub use tests::*;

#[cfg(test)]
mod tests {
    use super::*;
    use crate::test::prelude::*;
    use jsonrpc_core::ErrorCode;

    pub fn rpc_errors(data: &str) -> Vec<JsonrpcError> {
        // Nethermind has two flavours of revert errors:
        // ```
        // {"jsonrpc":"2.0","error":{"code":-32015,"message":"VM execution error.","data":"Reverted 0x..."},"id":0}
        // {"jsonrpc":"2.0","error":{"code":-32015,"message":"Reverted 0x..."},"id":1}
        // ```
        vec![
            JsonrpcError {
                code: ErrorCode::from(-32015),
                message: "VM execution error".to_owned(),
                data: Some(json!(data)),
            },
            JsonrpcError {
                code: ErrorCode::from(-32015),
                message: data.to_owned(),
                data: None,
            },
        ]
    }

    #[test]
    fn execution_error_from_revert_with_message() {
        for jsonrpc_err in rpc_errors(&format!(
            "Reverted {}",
            revert::encode_reason_hex("message")
        )) {
            let err = get_encoded_error(&jsonrpc_err);

            assert!(
                matches!(
                    &err,
                    Some(ExecutionError::Revert(Some(reason))) if reason == "message"
                ),
                "bad error conversion {:?}",
                err
            );
        }
    }

    #[test]
    fn execution_error_from_revert() {
        for jsonrpc_err in rpc_errors("Reverted 0x") {
            let err = get_encoded_error(&jsonrpc_err);

            assert!(
                matches!(err, Some(ExecutionError::Revert(None))),
                "bad error conversion {:?}",
                err
            );
        }
    }

    #[test]
    fn execution_error_from_revert_failed_decode() {
        for jsonrpc_err in rpc_errors("Reverted 0x01020304") {
            let err = get_encoded_error(&jsonrpc_err);

            assert!(
                matches!(err, Some(ExecutionError::Revert(None))),
                "bad error conversion {:?}",
                err
            );
        }
    }

    #[test]
    fn execution_error_from_invalid_opcode() {
        for jsonrpc_err in rpc_errors("Bad instruction fd") {
            let err = get_encoded_error(&jsonrpc_err);

            assert!(
                matches!(err, Some(ExecutionError::InvalidOpcode)),
                "bad error conversion {:?}",
                err
            );
        }
    }

    #[test]
    fn execution_error_from_message() {
        let jsonrpc_err = JsonrpcError {
            code: ErrorCode::from(-32015),
            message: "VM execution error.".to_owned(),
            data: Some(json!("revert")),
        };
        let err = get_encoded_error(&jsonrpc_err);

        assert!(
            matches!(err, Some(ExecutionError::Revert(None))),
            "bad error conversion {:?}",
            err
        );
    }
}