refactor to use apply exit codes in the actor directly

actors/account/src/lib.rs

@@ -4,14 +4,15 @@
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::address::{Address, Protocol};
+use fvm_shared::error::ExitCode;
 use fvm_shared::{MethodNum, METHOD_CONSTRUCTOR};
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
 
 use fil_actors_runtime::builtin::singletons::SYSTEM_ACTOR_ADDR;
-use fil_actors_runtime::cbor;
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
 use fil_actors_runtime::{actor_error, ActorError};
+use fil_actors_runtime::{cbor, ActorContext2};
 
 pub use self::state::State;
 
@@ -80,7 +81,7 @@ impl ActorCode for Actor {
             }
             Some(Method::PubkeyAddress) => {
                 let addr = Self::pubkey_address(rt)?;
-                Ok(RawBytes::serialize(addr)?)
+                Ok(RawBytes::serialize(addr).exit_code(ExitCode::USR_ILLEGAL_STATE)?)
             }
             None => Err(actor_error!(unhandled_message; "Invalid method")),
         }

actors/init/src/lib.rs

@@ -3,11 +3,12 @@
 
 use cid::Cid;
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
-use fil_actors_runtime::{actor_error, cbor, ActorContext, ActorError, SYSTEM_ACTOR_ADDR};
+use fil_actors_runtime::{actor_error, cbor, ActorContext2, ActorError, SYSTEM_ACTOR_ADDR};
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::actor::builtin::Type;
 use fvm_shared::address::Address;
+use fvm_shared::error::ExitCode;
 use fvm_shared::{ActorID, MethodNum, METHOD_CONSTRUCTOR};
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
@@ -42,8 +43,7 @@ impl Actor {
     {
         let sys_ref: &Address = &SYSTEM_ACTOR_ADDR;
         rt.validate_immediate_caller_is(std::iter::once(sys_ref))?;
-        let state = State::new(rt.store(), params.network_name)
-            .context("failed to construct init actor state")?;
+        let state = State::new(rt.store(), params.network_name)?;
 
         rt.create(&state)?;
 
@@ -85,7 +85,7 @@ impl Actor {
         // Store mapping of pubkey or actor address to actor ID
         let id_address: ActorID = rt.transaction(|s: &mut State, rt| {
             s.map_address_to_new_id(rt.store(), &robust_address)
-                .context("failed to allocate ID address")
+                .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to allocate ID address")
         })?;
 
         // Create an empty actor
@@ -121,7 +121,7 @@ impl ActorCode for Actor {
             }
             Some(Method::Exec) => {
                 let res = Self::exec(rt, cbor::deserialize_params(params)?)?;
-                Ok(RawBytes::serialize(res)?)
+                Ok(RawBytes::serialize(res).exit_code(ExitCode::USR_ILLEGAL_STATE)?)
             }
             None => Err(actor_error!(unhandled_message; "Invalid method")),
         }

actors/init/src/state.rs

@@ -2,15 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use cid::Cid;
+use fil_actors_runtime::ActorError;
 use fil_actors_runtime::{
-    make_empty_map, make_map_with_root_and_bitwidth, FIRST_NON_SINGLETON_ADDR,
+    make_empty_map, make_map_with_root_and_bitwidth, ActorContext2, FIRST_NON_SINGLETON_ADDR,
 };
-use fil_actors_runtime::{ActorContext, ActorError};
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::tuple::*;
 use fvm_ipld_encoding::Cbor;
 use fvm_ipld_hamt::Error as HamtError;
 use fvm_shared::address::{Address, Protocol};
+use fvm_shared::error::ExitCode;
 use fvm_shared::{ActorID, HAMT_BIT_WIDTH};
 
 /// State is reponsible for creating
@@ -25,7 +26,7 @@ impl State {
     pub fn new<BS: Blockstore>(store: &BS, network_name: String) -> Result<Self, ActorError> {
         let empty_map = make_empty_map::<_, ()>(store, HAMT_BIT_WIDTH)
             .flush()
-            .context("failed to create empty map")?;
+            .context_code(ExitCode::USR_ILLEGAL_STATE, "failed to create empty map")?;
 
         Ok(Self { address_map: empty_map, next_id: FIRST_NON_SINGLETON_ADDR, network_name })
     }
@@ -66,9 +67,14 @@ impl State {
             return Ok(Some(*addr));
         }
 
-        let map = make_map_with_root_and_bitwidth(&self.address_map, store, HAMT_BIT_WIDTH)?;
+        let map = make_map_with_root_and_bitwidth(&self.address_map, store, HAMT_BIT_WIDTH)
+            .exit_code(ExitCode::USR_ILLEGAL_STATE)?;
 
-        Ok(map.get(&addr.to_bytes())?.copied().map(Address::new_id))
+        Ok(map
+            .get(&addr.to_bytes())
+            .exit_code(ExitCode::USR_ILLEGAL_STATE)?
+            .copied()
+            .map(Address::new_id))
     }
 }
 

actors/market/src/balance_table.rs

@@ -4,13 +4,13 @@
 use cid::Cid;
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_hamt::Error as HamtError;
-use fvm_shared::address::Address;
 use fvm_shared::bigint::bigint_ser::BigIntDe;
 use fvm_shared::econ::TokenAmount;
+use fvm_shared::{address::Address, error::ExitCode};
 use num_traits::{Signed, Zero};
 
 use fil_actors_runtime::{
-    actor_error, make_empty_map, make_map_with_root_and_bitwidth, ActorError, Map,
+    actor_error, make_empty_map, make_map_with_root_and_bitwidth, ActorContext2, ActorError, Map,
 };
 
 pub const BALANCE_TABLE_BITWIDTH: u32 = 6;
@@ -47,7 +47,7 @@ where
 
     /// Adds token amount to previously initialized account.
     pub fn add(&mut self, key: &Address, value: &TokenAmount) -> Result<(), ActorError> {
-        let prev = self.get(key)?;
+        let prev = self.get(key).exit_code(ExitCode::USR_SERIALIZATION)?;
         let sum = &prev + value;
         if sum.is_negative() {
             return Err(actor_error!(
@@ -57,10 +57,12 @@ where
             ));
         }
         if sum.is_zero() && !prev.is_zero() {
-            self.0.delete(&key.to_bytes())?;
+            self.0.delete(&key.to_bytes()).exit_code(ExitCode::USR_SERIALIZATION)?;
             Ok(())
         } else {
-            self.0.set(key.to_bytes().into(), BigIntDe(sum))?;
+            self.0
+                .set(key.to_bytes().into(), BigIntDe(sum))
+                .exit_code(ExitCode::USR_SERIALIZATION)?;
             Ok(())
         }
     }
@@ -74,7 +76,7 @@ where
         req: &TokenAmount,
         floor: &TokenAmount,
     ) -> Result<TokenAmount, ActorError> {
-        let prev = self.get(key)?;
+        let prev = self.get(key).exit_code(ExitCode::USR_SERIALIZATION)?;
         let available = std::cmp::max(TokenAmount::zero(), prev - floor);
         let sub: TokenAmount = std::cmp::min(&available, req).clone();
 
@@ -87,7 +89,7 @@ where
 
     /// Subtracts value from a balance, and errors if full amount was not substracted.
     pub fn must_subtract(&mut self, key: &Address, req: &TokenAmount) -> Result<(), ActorError> {
-        let prev = self.get(key)?;
+        let prev = self.get(key).exit_code(ExitCode::USR_SERIALIZATION)?;
 
         if req > &prev {
             return Err(actor_error!(illegal_argument, "couldn't subtract the requested amount"));