feat (runtime): Wasmer ExceptionCode support

chain/jsonrpc/build_errors_schema.sh

@@ -1,3 +1,4 @@
 #!/bin/bash
+rm ../../target/rpc_errors_schema.json
 cargo build --features dump_errors_schema
 cp ../../target/rpc_errors_schema.json ./res/rpc_errors_schema.json

chain/jsonrpc/res/rpc_errors_schema.json

@@ -15,6 +15,11 @@
       "subtypes": [],
       "props": {}
     },
+    "CallIndirectOOB": {
+      "name": "CallIndirectOOB",
+      "subtypes": [],
+      "props": {}
+    },
     "CannotAppendActionToJointPromise": {
       "name": "CannotAppendActionToJointPromise",
       "subtypes": [],
@@ -73,6 +78,7 @@
         "LinkError",
         "MethodResolveError",
         "WasmTrap",
+        "WasmUnknownError",
         "HostError"
       ],
       "props": {}
@@ -135,6 +141,16 @@
       ],
       "props": {}
     },
+    "IllegalArithmetic": {
+      "name": "IllegalArithmetic",
+      "subtypes": [],
+      "props": {}
+    },
+    "IncorrectCallIndirectSignature": {
+      "name": "IncorrectCallIndirectSignature",
+      "subtypes": [],
+      "props": {}
+    },
     "Instantiate": {
       "name": "Instantiate",
       "subtypes": [],
@@ -232,6 +248,11 @@
       "subtypes": [],
       "props": {}
     },
+    "MemoryOutOfBounds": {
+      "name": "MemoryOutOfBounds",
+      "subtypes": [],
+      "props": {}
+    },
     "MethodEmptyName": {
       "name": "MethodEmptyName",
       "subtypes": [],
@@ -262,6 +283,11 @@
       "subtypes": [],
       "props": {}
     },
+    "MisalignedAtomicAccess": {
+      "name": "MisalignedAtomicAccess",
+      "subtypes": [],
+      "props": {}
+    },
     "NumberInputDataDependenciesExceeded": {
       "name": "NumberInputDataDependenciesExceeded",
       "subtypes": [],
@@ -331,6 +357,11 @@
         "limit": ""
       }
     },
+    "Unreachable": {
+      "name": "Unreachable",
+      "subtypes": [],
+      "props": {}
+    },
     "ValueLengthExceeded": {
       "name": "ValueLengthExceeded",
       "subtypes": [],
@@ -341,10 +372,20 @@
     },
     "WasmTrap": {
       "name": "WasmTrap",
+      "subtypes": [
+        "Unreachable",
+        "IncorrectCallIndirectSignature",
+        "MemoryOutOfBounds",
+        "CallIndirectOOB",
+        "IllegalArithmetic",
+        "MisalignedAtomicAccess"
+      ],
+      "props": {}
+    },
+    "WasmUnknownError": {
+      "name": "WasmUnknownError",
       "subtypes": [],
-      "props": {
-        "msg": ""
-      }
+      "props": {}
     },
     "WasmerCompileError": {
       "name": "WasmerCompileError",

runtime/near-vm-errors/src/lib.rs

@@ -17,12 +17,37 @@ pub enum VMError {
     Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize, Deserialize, Serialize, RpcError,
 )]
 pub enum FunctionCallError {
+    /// Wasm compilation error
     CompilationError(CompilationError),
-    LinkError { msg: String },
+    /// Wasm binary env link error
+    LinkError {
+        msg: String,
+    },
+    /// Import/export resolve error
     MethodResolveError(MethodResolveError),
-    WasmTrap { msg: String },
+    /// A trap happened during execution of a binary
+    WasmTrap(WasmTrap),
+    WasmUnknownError,
     HostError(HostError),
 }
+/// A kind of a trap happened during execution of a binary
+#[derive(
+    Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize, Deserialize, Serialize, RpcError,
+)]
+pub enum WasmTrap {
+    /// An `unreachable` opcode was executed.
+    Unreachable,
+    /// Call indirect incorrect signature trap.
+    IncorrectCallIndirectSignature,
+    /// Memory out of bounds trap.
+    MemoryOutOfBounds,
+    /// Call indirect out of bounds trap.
+    CallIndirectOOB,
+    /// An arithmetic exception, e.g. divided by zero.
+    IllegalArithmetic,
+    /// Misaligned atomic access trap.
+    MisalignedAtomicAccess,
+}
 
 #[derive(
     Debug, Clone, PartialEq, Eq, BorshDeserialize, BorshSerialize, Deserialize, Serialize, RpcError,
@@ -198,7 +223,27 @@ impl fmt::Display for FunctionCallError {
             FunctionCallError::MethodResolveError(e) => e.fmt(f),
             FunctionCallError::HostError(e) => e.fmt(f),
             FunctionCallError::LinkError { msg } => write!(f, "{}", msg),
-            FunctionCallError::WasmTrap { msg } => write!(f, "WebAssembly trap: {}", msg),
+            FunctionCallError::WasmTrap(trap) => write!(f, "WebAssembly trap: {}", trap),
+            FunctionCallError::WasmUnknownError => {
+                write!(f, "Unknown error during Wasm contract execution")
+            }
+        }
+    }
+}
+
+impl fmt::Display for WasmTrap {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        match self {
+            WasmTrap::Unreachable => write!(f, "An `unreachable` opcode was executed."),
+            WasmTrap::IncorrectCallIndirectSignature => {
+                write!(f, "Call indirect incorrect signature trap.")
+            }
+            WasmTrap::MemoryOutOfBounds => write!(f, "Memory out of bounds trap."),
+            WasmTrap::CallIndirectOOB => write!(f, "Call indirect out of bounds trap."),
+            WasmTrap::IllegalArithmetic => {
+                write!(f, "An arithmetic exception, e.g. divided by zero.")
+            }
+            WasmTrap::MisalignedAtomicAccess => write!(f, "Misaligned atomic access trap."),
         }
     }
 }

runtime/near-vm-runner/Cargo.toml

@@ -14,8 +14,8 @@ This crate implements the specification of the interface that Near blockchain ex
 
 [dependencies]
 cached = "0.12.0"
-wasmer-runtime = { version = "0.13.1", features = ["default-backend-singlepass"], default-features = false }
-wasmer-runtime-core = { version = "0.13.1" }
+wasmer-runtime = { version = "0.16.2", features = ["default-backend-singlepass"], default-features = false }
+wasmer-runtime-core = { version = "0.16.2" }
 near-runtime-fees = { path="../near-runtime-fees", version = "0.8.0" }
 near-vm-logic = { path="../near-vm-logic", version = "0.8.0", default-features = false, features = []}
 near-vm-errors = { path = "../near-vm-errors", version = "0.8.0" }

runtime/near-vm-runner/src/errors.rs

@@ -1,4 +1,4 @@
-use near_vm_errors::{CompilationError, FunctionCallError, MethodResolveError, VMError};
+use near_vm_errors::{CompilationError, FunctionCallError, MethodResolveError, VMError, WasmTrap};
 use near_vm_logic::VMLogicError;
 
 pub trait IntoVMError {
@@ -33,9 +33,15 @@ impl IntoVMError for wasmer_runtime::error::CallError {
 
 impl IntoVMError for wasmer_runtime::error::CompileError {
     fn into_vm_error(self) -> VMError {
-        VMError::FunctionCallError(FunctionCallError::CompilationError(
-            CompilationError::WasmerCompileError { msg: self.to_string() },
-        ))
+        match self {
+            wasmer_runtime::error::CompileError::InternalError { .. } => {
+                // An internal Wasmer error the most probably is a result of a node malfunction
+                panic!("Internal Wasmer error on Wasm compilation: {}", self);
+            }
+            _ => VMError::FunctionCallError(FunctionCallError::CompilationError(
+                CompilationError::WasmerCompileError { msg: self.to_string() },
+            )),
+        }
     }
 }
 
@@ -58,33 +64,51 @@ impl IntoVMError for wasmer_runtime::error::ResolveError {
 
 impl IntoVMError for wasmer_runtime::error::RuntimeError {
     fn into_vm_error(self) -> VMError {
-        use wasmer_runtime::error::RuntimeError;
-        match &self {
-            RuntimeError::Trap { msg } => {
-                VMError::FunctionCallError(FunctionCallError::WasmTrap { msg: msg.to_string() })
+        use wasmer_runtime::ExceptionCode;
+        let data = &*self.0;
+
+        if let Some(err) = data.downcast_ref::<VMLogicError>() {
+            match err {
+                VMLogicError::HostError(h) => {
+                    VMError::FunctionCallError(FunctionCallError::HostError(h.clone()))
+                }
+                VMLogicError::ExternalError(s) => VMError::ExternalError(s.clone()),
+                VMLogicError::InconsistentStateError(e) => {
+                    VMError::InconsistentStateError(e.clone())
+                }
             }
-            RuntimeError::Error { data } => {
-                if let Some(err) = data.downcast_ref::<VMLogicError>() {
-                    match err {
-                        VMLogicError::HostError(h) => {
-                            VMError::FunctionCallError(FunctionCallError::HostError(h.clone()))
-                        }
-                        VMLogicError::ExternalError(s) => VMError::ExternalError(s.clone()),
-                        VMLogicError::InconsistentStateError(e) => {
-                            VMError::InconsistentStateError(e.clone())
-                        }
-                    }
-                } else {
-                    eprintln!(
-                        "Bad error case! Output is non-deterministic {:?} {:?}",
-                        data.type_id(),
-                        self.to_string()
-                    );
-                    VMError::FunctionCallError(FunctionCallError::WasmTrap {
-                        msg: "unknown".to_string(),
-                    })
+        } else if let Some(err) = data.downcast_ref::<ExceptionCode>() {
+            use wasmer_runtime::ExceptionCode::*;
+            match err {
+                Unreachable => {
+                    VMError::FunctionCallError(FunctionCallError::WasmTrap(WasmTrap::Unreachable))
                 }
+                IncorrectCallIndirectSignature => VMError::FunctionCallError(
+                    FunctionCallError::WasmTrap(WasmTrap::IncorrectCallIndirectSignature),
+                ),
+                MemoryOutOfBounds => VMError::FunctionCallError(FunctionCallError::WasmTrap(
+                    WasmTrap::MemoryOutOfBounds,
+                )),
+                CallIndirectOOB => VMError::FunctionCallError(FunctionCallError::WasmTrap(
+                    WasmTrap::CallIndirectOOB,
+                )),
+                IllegalArithmetic => VMError::FunctionCallError(FunctionCallError::WasmTrap(
+                    WasmTrap::IllegalArithmetic,
+                )),
+                MisalignedAtomicAccess => VMError::FunctionCallError(FunctionCallError::WasmTrap(
+                    WasmTrap::MisalignedAtomicAccess,
+                )),
             }
+        } else {
+            // TODO: Wasmer provides no way to distingush runtime Internal Wasmer errors or host panics
+            // (at least for a single-pass backend)
+            // https://github.com/wasmerio/wasmer/issues/1338
+            eprintln!(
+                "Bad error case! Output might be non-deterministic {:?} {:?}",
+                data.type_id(),
+                self.to_string()
+            );
+            VMError::FunctionCallError(FunctionCallError::WasmUnknownError)
         }
     }
 }

runtime/near-vm-runner/tests/test_error_cases.rs

@@ -131,9 +131,7 @@ fn test_trap_contract() {
         make_simple_contract_call(&trap_contract(), b"hello"),
         (
             Some(vm_outcome_with_gas(3856371)),
-            Some(VMError::FunctionCallError(FunctionCallError::WasmTrap {
-                msg: "unknown".to_string()
-            }))
+            Some(VMError::FunctionCallError(FunctionCallError::WasmUnknownError))
         )
     );
 }
@@ -157,9 +155,7 @@ fn test_trap_initializer() {
         make_simple_contract_call(&trap_initializer(), b"hello"),
         (
             Some(vm_outcome_with_gas(3856371)),
-            Some(VMError::FunctionCallError(FunctionCallError::WasmTrap {
-                msg: "unknown".to_string()
-            }))
+            Some(VMError::FunctionCallError(FunctionCallError::WasmUnknownError))
         )
     );
 }
@@ -257,9 +253,7 @@ fn test_stack_overflow() {
         make_simple_contract_call(&stack_overflow(), b"hello"),
         (
             Some(vm_outcome_with_gas(63182782464)),
-            Some(VMError::FunctionCallError(FunctionCallError::WasmTrap {
-                msg: "unknown".to_string()
-            }))
+            Some(VMError::FunctionCallError(FunctionCallError::WasmUnknownError))
         )
     );
 }

runtime/near-vm-runner/tests/test_rs_contract.rs

@@ -172,10 +172,5 @@ pub fn test_out_of_memory() {
         &fees,
         &promise_results,
     );
-    assert_eq!(
-        result.1,
-        Some(VMError::FunctionCallError(FunctionCallError::WasmTrap {
-            msg: "unknown".to_string()
-        }))
-    );
+    assert_eq!(result.1, Some(VMError::FunctionCallError(FunctionCallError::WasmUnknownError)));
 }