Implement ExitCode as u32 wrapper, and use new spec codes (#431)

Author: anorth

fvm/src/call_manager/default.rs

@@ -323,7 +323,7 @@ where
                         .data()
                         .kernel
                         .block_get(return_block_id)
-                        .map_err(|e| Abort::from_error(ExitCode::SysErrIllegalActor, e))?;
+                        .map_err(|e| Abort::from_error(ExitCode::SYS_MISSING_RETURN, e))?;
                     debug_assert_eq!(code, DAG_CBOR);
                     RawBytes::new(ret)
                 } else {
@@ -350,14 +350,12 @@ where
                             (code, message, Ok(InvocationResult::Failure(code)))
                         }
                         Abort::OutOfGas => (
-                            ExitCode::SysErrOutOfGas,
+                            ExitCode::SYS_OUT_OF_GAS,
                             "out of gas".to_owned(),
                             Err(ExecutionError::OutOfGas),
                         ),
                         Abort::Fatal(err) => (
-                            // TODO: will be changed to a SysErrAssertionFailed when we
-                            // introduce the new exit codes.
-                            ExitCode::SysErrIllegalArgument,
+                            ExitCode::SYS_ASSERTION_FAILED,
                             "fatal error".to_owned(),
                             Err(ExecutionError::Fatal(err)),
                         ),

fvm/src/call_manager/mod.rs

@@ -135,7 +135,7 @@ impl InvocationResult {
     /// from the [`Failure`](InvocationResult::Failure) variant otherwise.
     pub fn exit_code(&self) -> ExitCode {
         match self {
-            Self::Return(_) => ExitCode::Ok,
+            Self::Return(_) => ExitCode::OK,
             Self::Failure(e) => *e,
         }
     }

fvm/src/executor/default.rs

@@ -88,7 +88,7 @@ where
             Ok(InvocationResult::Return(return_data)) => {
                 backtrace.clear();
                 Receipt {
-                    exit_code: ExitCode::Ok,
+                    exit_code: ExitCode::OK,
                     return_data,
                     gas_used,
                 }
@@ -104,16 +104,19 @@ where
                 }
             }
             Err(ExecutionError::OutOfGas) => Receipt {
-                exit_code: ExitCode::SysErrOutOfGas,
+                exit_code: ExitCode::SYS_OUT_OF_GAS,
                 return_data: Default::default(),
                 gas_used,
             },
             Err(ExecutionError::Syscall(err)) => {
+                // Errors indicate the message couldn't be dispatched at all.
+                // Some of these errors are mapped to exit codes that persist on chain.
+                // The remainder propagate in the Result as error numbers and cannot be persisted.
+                // TODO: map them all to exit codes, https://github.com/filecoin-project/ref-fvm/issues/438
                 let exit_code = match err.1 {
-                    ErrorNumber::IllegalOperation => ExitCode::SysErrIllegalActor,
-                    ErrorNumber::AssertionFailed => ExitCode::SysErrIllegalArgument,
-                    ErrorNumber::InsufficientFunds => ExitCode::SysErrInsufficientFunds,
-                    ErrorNumber::NotFound => ExitCode::SysErrInvalidReceiver,
+                    ErrorNumber::AssertionFailed => ExitCode::SYS_ASSERTION_FAILED,
+                    ErrorNumber::InsufficientFunds => ExitCode::SYS_INSUFFICIENT_FUNDS,
+                    ErrorNumber::NotFound => ExitCode::SYS_INVALID_RECEIVER,
                     code => {
                         return Err(anyhow!(
                             "unexpected syscall error when processing message: {} ({})",
@@ -207,7 +210,7 @@ where
                 // Verify the cost of the message is not over the message gas limit.
                 if inclusion_total > msg.gas_limit {
                     return Ok(Err(ApplyRet::prevalidation_fail(
-                        ExitCode::SysErrOutOfGas,
+                        ExitCode::SYS_OUT_OF_GAS,
                         format!("Out of gas ({} > {})", inclusion_total, msg.gas_limit),
                         &self.context().base_fee * inclusion_total,
                     )));
@@ -227,7 +230,7 @@ where
             Some(id) => id,
             None => {
                 return Ok(Err(ApplyRet::prevalidation_fail(
-                    ExitCode::SysErrSenderInvalid,
+                    ExitCode::SYS_SENDER_INVALID,
                     "Sender invalid",
                     miner_penalty_amount,
                 )))
@@ -246,7 +249,7 @@ where
             Some(act) => act,
             None => {
                 return Ok(Err(ApplyRet::prevalidation_fail(
-                    ExitCode::SysErrSenderInvalid,
+                    ExitCode::SYS_SENDER_INVALID,
                     "Sender invalid",
                     miner_penalty_amount,
                 )))
@@ -262,7 +265,7 @@ where
 
         if !sender_is_account {
             return Ok(Err(ApplyRet::prevalidation_fail(
-                ExitCode::SysErrSenderInvalid,
+                ExitCode::SYS_SENDER_INVALID,
                 "Send not from account actor",
                 miner_penalty_amount,
             )));
@@ -271,7 +274,7 @@ where
         // Check sequence is correct
         if msg.sequence != sender.sequence {
             return Ok(Err(ApplyRet::prevalidation_fail(
-                ExitCode::SysErrSenderStateInvalid,
+                ExitCode::SYS_SENDER_STATE_INVALID,
                 format!(
                     "Actor sequence invalid: {} != {}",
                     msg.sequence, sender.sequence
@@ -284,7 +287,7 @@ where
         let gas_cost: TokenAmount = msg.gas_fee_cap.clone() * msg.gas_limit;
         if sender.balance < gas_cost {
             return Ok(Err(ApplyRet::prevalidation_fail(
-                ExitCode::SysErrSenderStateInvalid,
+                ExitCode::SYS_SENDER_STATE_INVALID,
                 format!(
                     "Actor balance less than needed: {} < {}",
                     sender.balance, gas_cost

fvm/src/syscalls/error.rs

@@ -50,7 +50,7 @@ impl From<Trap> for Abort {
 
         // Actor panic/wasm error.
         if let Some(code) = t.trap_code() {
-            return Abort::Exit(ExitCode::SysErrActorPanic, code.to_string());
+            return Abort::Exit(ExitCode::SYS_ILLEGAL_INSTRUCTION, code.to_string());
         }
 
         // Try to get a smuggled error back.

fvm/src/syscalls/send.rs

@@ -11,10 +11,6 @@ use crate::Kernel;
 
 /// Send a message to another actor. The result is placed as a CBOR-encoded
 /// receipt in the block registry, and can be retrieved by the returned BlockId.
-///
-/// TODO result is a Receipt, but messages within a call stack don't
-///  actually produce receipts.
-///  See https://github.com/filecoin-project/fvm/issues/168.
 pub fn send(
     context: Context<'_, impl Kernel>,
     recipient_off: u32,
@@ -41,10 +37,10 @@ pub fn send(
             .send(&recipient, method, &params.into(), &value)?
         {
             InvocationResult::Return(value) => (
-                ExitCode::Ok as u32,
+                ExitCode::OK.value(),
                 context.kernel.block_create(DAG_CBOR, value.bytes())?,
             ),
-            InvocationResult::Failure(code) => (code as u32, 0),
+            InvocationResult::Failure(code) => (code.value(), 0),
         };
     Ok(sys::out::send::Send {
         exit_code,

fvm/src/syscalls/vm.rs

@@ -1,5 +1,4 @@
 use fvm_shared::error::ExitCode;
-use num_traits::FromPrimitive;
 
 use super::error::Abort;
 use super::Context;
@@ -18,11 +17,14 @@ pub fn abort(
     message_off: u32,
     message_len: u32,
 ) -> Result<Never, Abort> {
-    // Get the error and convert it into a "system illegal argument error" if it's invalid.
-    // BUG: https://github.com/filecoin-project/fvm/issues/253
-    let code = ExitCode::from_u32(code)
-        //.filter(|c| !c.is_system_error())
-        .unwrap_or(ExitCode::SysErrIllegalActor); // TODO: will become "illegal exit"
+    let code = ExitCode::new(code);
+    // Uncomment to fix https://github.com/filecoin-project/ref-fvm/issues/253
+    // if code.is_system_error() {
+    //     return Err(Abort::Exit(
+    //         SystemExitCode::ILLEGAL_EXIT_CODE,
+    //         format!("actor aborted with code {}", code),
+    //     ));
+    // }
 
     let message = if message_len == 0 {
         "actor aborted".to_owned()

sdk/src/message.rs

@@ -1,10 +1,9 @@
-use fvm_ipld_encoding::{Cbor, DAG_CBOR};
+use fvm_ipld_encoding::DAG_CBOR;
 use fvm_shared::econ::TokenAmount;
-use fvm_shared::error::{ErrorNumber, ExitCode};
 use fvm_shared::sys::{BlockId, Codec};
 use fvm_shared::{ActorID, MethodNum};
 
-use crate::{sys, vm, SyscallResult};
+use crate::{sys, SyscallResult};
 
 /// BlockID representing nil parameters or return data.
 pub const NO_DATA_BLOCK_ID: u32 = 0;
@@ -63,23 +62,3 @@ pub fn value_received() -> TokenAmount {
             .into()
     }
 }
-
-/// Fetches the input parameters as raw bytes, and decodes them locally
-/// into type T using cbor serde. Failing to decode will abort execution.
-///
-/// This function errors with ErrIllegalArgument when no parameters have been
-/// provided.
-pub fn params_cbor<T: Cbor>(id: BlockId) -> SyscallResult<T> {
-    if id == NO_DATA_BLOCK_ID {
-        return Err(ErrorNumber::IllegalArgument);
-    }
-    let (codec, raw) = params_raw(id)?;
-    debug_assert!(codec == DAG_CBOR, "parameters codec was not cbor");
-    match fvm_ipld_encoding::from_slice(raw.as_slice()) {
-        Ok(v) => Ok(v),
-        Err(e) => vm::abort(
-            ExitCode::ErrSerialization as u32,
-            Some(format!("could not deserialize parameters as cbor: {:?}", e).as_str()),
-        ),
-    }
-}

sdk/src/send.rs

@@ -6,7 +6,6 @@ use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::{ErrorNumber, ExitCode};
 use fvm_shared::receipt::Receipt;
 use fvm_shared::MethodNum;
-use num_traits::FromPrimitive;
 
 use crate::message::NO_DATA_BLOCK_ID;
 use crate::{sys, SyscallResult};
@@ -47,9 +46,9 @@ pub fn send(
         )?;
 
         // Process the result.
-        let exit_code = ExitCode::from_u32(exit_code).unwrap_or(ExitCode::SysErrIllegalActor);
+        let exit_code = ExitCode::new(exit_code);
         let return_data = match exit_code {
-            ExitCode::Ok if return_id != NO_DATA_BLOCK_ID => {
+            ExitCode::OK if return_id != NO_DATA_BLOCK_ID => {
                 // Allocate a buffer to read the return data.
                 let fvm_shared::sys::out::ipld::IpldStat { size, .. } = sys::ipld::stat(return_id)?;
                 let mut bytes = vec![0; size as usize];