Replace 'UnknownError' with concrete errors.

chain-extensions/types/xvm/Cargo.toml

@@ -9,6 +9,7 @@ homepage.workspace = true
 repository.workspace = true
 
 [dependencies]
+astar-primitives = { workspace = true }
 parity-scale-codec = { workspace = true }
 scale-info = { workspace = true }
 sp-runtime = { workspace = true }
@@ -21,4 +22,5 @@ std = [
 	"scale-info/std",
 	"sp-runtime/std",
 	"sp-std/std",
+	"astar-primitives/std",
 ]

chain-extensions/types/xvm/src/lib.rs

@@ -18,31 +18,41 @@
 
 #![cfg_attr(not(feature = "std"), no_std)]
 
+use astar_primitives::xvm::CallError;
 use parity_scale_codec::{Decode, Encode};
-use sp_runtime::{DispatchError, ModuleError};
 use sp_std::vec::Vec;
 
 #[cfg_attr(feature = "std", derive(scale_info::TypeInfo))]
 #[derive(PartialEq, Eq, Copy, Clone, Encode, Decode, Debug)]
 pub enum XvmExecutionResult {
     /// Success
-    Success = 0,
-    // TODO: expand this with concrete XVM errors
-    /// Error not (yet) covered by a dedidacted code
-    UnknownError = 255,
+    Ok,
+    /// Failure
+    Err(u32),
 }
 
-impl TryFrom<DispatchError> for XvmExecutionResult {
-    type Error = DispatchError;
+impl From<CallError> for XvmExecutionResult {
+    fn from(input: CallError) -> Self {
+        use CallError::*;
 
-    fn try_from(input: DispatchError) -> Result<Self, Self::Error> {
-        let _error_text = match input {
-            DispatchError::Module(ModuleError { message, .. }) => message,
-            _ => Some("No module error Info"),
+        // `0` is reserved for `Ok`
+        let error_code = match input {
+            InvalidVmId => 1,
+            SameVmCallNotAllowed => 2,
+            InvalidTarget => 3,
+            InputTooLarge => 4,
+            ExecutionFailed(_) => 5,
         };
+        Self::Err(error_code)
+    }
+}
 
-        // TODO: expand this with concrete XVM errors (see dapps-staking types for example)
-        Ok(XvmExecutionResult::UnknownError)
+impl From<XvmExecutionResult> for u32 {
+    fn from(input: XvmExecutionResult) -> Self {
+        match input {
+            XvmExecutionResult::Ok => 0,
+            XvmExecutionResult::Err(code) => code,
+        }
     }
 }
 
@@ -55,6 +65,3 @@ pub struct XvmCallArgs {
     /// Encoded call params
     pub input: Vec<u8>,
 }
-
-pub const FRONTIER_VM_ID: u8 = 0x0F;
-pub const PARITY_WASM_VM_ID: u8 = 0x1F;

chain-extensions/xvm/src/lib.rs

@@ -84,12 +84,12 @@ where
                 };
 
                 let vm_id = {
-                    let result = vm_id.try_into();
-                    match result {
+                    match TryInto::<VmId>::try_into(vm_id) {
                         Ok(id) => id,
-                        Err(_) => {
+                        Err(err) => {
                             // TODO: Propagate error
-                            return Ok(RetVal::Converging(XvmExecutionResult::UnknownError as u32));
+                            let result = Into::<XvmExecutionResult>::into(err);
+                            return Ok(RetVal::Converging(result.into()));
                         }
                     }
                 };
@@ -103,25 +103,26 @@ where
                 env.adjust_weight(charged_weight, actual_weight);
 
                 match call_result {
-                    Ok(success) => {
+                    Ok(info) => {
                         log::trace!(
                             target: "xvm-extension::xvm_call",
-                            "success: {:?}", success
+                            "info: {:?}", info
                         );
 
-                        let buffer: sp_std::vec::Vec<_> = success.output.encode();
+                        let buffer: sp_std::vec::Vec<_> = info.output.encode();
                         env.write(&buffer, false, None)?;
-                        Ok(RetVal::Converging(XvmExecutionResult::Success as u32))
+                        Ok(RetVal::Converging(XvmExecutionResult::Ok.into()))
                     }
 
-                    Err(failure) => {
+                    Err(err) => {
                         log::trace!(
                             target: "xvm-extension::xvm_call",
-                            "failure: {:?}", failure
+                            "err: {:?}", err
                         );
 
                         // TODO Propagate error
-                        Ok(RetVal::Converging(XvmExecutionResult::UnknownError as u32))
+                        let result = Into::<XvmExecutionResult>::into(err.error);
+                        Ok(RetVal::Converging(result.into()))
                     }
                 }
             }

pallets/xvm/Cargo.toml

@@ -44,13 +44,12 @@ std = [
 	"pallet-contracts/std",
 	"pallet-evm/std",
 	"scale-info/std",
-	"serde/std",
+	"serde",
 	"sp-core/std",
 	"sp-runtime/std",
 	"sp-std/std",
 	"astar-primitives/std",
 	"pallet-ethereum-checked/std",
-	"frame-benchmarking?/std",
 ]
 
 runtime-benchmarks = [

precompiles/xvm/Cargo.toml

@@ -39,10 +39,10 @@ precompile-utils = { workspace = true, features = ["testing"] }
 
 pallet-balances = { workspace = true }
 pallet-contracts = { workspace = true }
-pallet-timestamp = { workspace = true }
 pallet-ethereum = { workspace = true }
 pallet-ethereum-checked = { workspace = true }
 pallet-insecure-randomness-collective-flip = { workspace = true }
+pallet-timestamp = { workspace = true }
 sp-runtime = { workspace = true }
 
 [features]
@@ -60,6 +60,6 @@ std = [
 	"sp-runtime/std",
 	"pallet-xvm/std",
 	"astar-primitives/std",
-    "pallet-balances/std",
-    "pallet-ethereum/std",
+	"pallet-balances/std",
+	"pallet-ethereum/std",
 ]

primitives/src/xvm.rs

@@ -58,14 +58,14 @@ pub struct CallInfo {
 pub enum CallError {
     /// Invalid VM id.
     InvalidVmId,
-    /// The call failed on EVM or WASM execution.
-    ExecutionFailed(Vec<u8>),
-    /// Input is too large.
-    InputTooLarge,
-    /// Target contract address is invalid.
-    InvalidTarget,
     /// Calling the contracts in the same VM is not allowed.
     SameVmCallNotAllowed,
+    /// Target contract address is invalid.
+    InvalidTarget,
+    /// Input is too large.
+    InputTooLarge,
+    /// The call failed on EVM or WASM execution.
+    ExecutionFailed(Vec<u8>),
 }
 
 /// XVM call error with used weight info.