paych and multisig actor

Author: dignifiedquire

Cargo.lock

@@ -23,7 +23,6 @@ cid = { version = "0.8.3", default-features = false, features = ["serde-codec"]
 indexmap = { version = "1.8.0", features = ["serde-1"] }
 integer-encoding = { version = "3.0.3", default-features = false }
 serde = { version = "1.0.136", features = ["derive"] }
-anyhow = "1.0.56"
 fvm_ipld_blockstore = { version = "0.1" }
 fvm_ipld_encoding = "0.1.0"
 

actors/multisig/Cargo.toml

@@ -6,8 +6,8 @@ use std::collections::BTreeSet;
 use fil_actors_runtime::cbor::serialize_vec;
 use fil_actors_runtime::runtime::{ActorCode, Runtime, Syscalls};
 use fil_actors_runtime::{
-    actor_error, cbor, make_empty_map, make_map_with_root, resolve_to_id_addr, ActorDowncast,
-    ActorError, Map, INIT_ACTOR_ADDR,
+    actor_error, cbor, make_empty_map, make_map_with_root, resolve_to_id_addr, ActorContext,
+    ActorDowncast, ActorError, Map, INIT_ACTOR_ADDR,
 };
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
@@ -73,12 +73,8 @@ impl Actor {
         let mut resolved_signers = Vec::with_capacity(params.signers.len());
         let mut dedup_signers = BTreeSet::new();
         for signer in &params.signers {
-            let resolved = resolve_to_id_addr(rt, signer).map_err(|e| {
-                e.downcast_default(
-                    ExitCode::USR_ILLEGAL_STATE,
-                    format!("failed to resolve addr {} to ID addr", signer),
-                )
-            })?;
+            let resolved = resolve_to_id_addr(rt, signer)
+                .with_context(|| format!("failed to resolve addr {} to ID addr", signer))?;
             if !dedup_signers.insert(resolved.id().expect("address should be resolved")) {
                 return Err(
                     actor_error!(illegal_argument; "duplicate signer not allowed: {}", signer),
@@ -269,11 +265,8 @@ impl Actor {
                 return Err(actor_error!(forbidden; "Cannot cancel another signers transaction"));
             }
 
-            let calculated_hash = compute_proposal_hash(&tx, rt).map_err(|e| {
-                e.downcast_default(
-                    ExitCode::USR_ILLEGAL_STATE,
-                    format!("failed to compute proposal hash for (tx: {:?})", params.id),
-                )
+            let calculated_hash = compute_proposal_hash(&tx, rt).with_context(|| {
+                format!("failed to compute proposal hash for (tx: {:?})", params.id)
             })?;
 
             if !params.proposal_hash.is_empty() && params.proposal_hash != calculated_hash {
@@ -299,12 +292,8 @@ impl Actor {
     {
         let receiver = rt.message().receiver();
         rt.validate_immediate_caller_is(std::iter::once(&receiver))?;
-        let resolved_new_signer = resolve_to_id_addr(rt, &params.signer).map_err(|e| {
-            e.downcast_default(
-                ExitCode::USR_ILLEGAL_STATE,
-                format!("failed to resolve address {}", params.signer),
-            )
-        })?;
+        let resolved_new_signer = resolve_to_id_addr(rt, &params.signer)
+            .with_context(|| format!("failed to resolve address {}", params.signer))?;
 
         rt.transaction(|st: &mut State, _| {
             if st.signers.len() >= SIGNERS_MAX {
@@ -336,12 +325,8 @@ impl Actor {
     {
         let receiver = rt.message().receiver();
         rt.validate_immediate_caller_is(std::iter::once(&receiver))?;
-        let resolved_old_signer = resolve_to_id_addr(rt, &params.signer).map_err(|e| {
-            e.downcast_default(
-                ExitCode::USR_ILLEGAL_STATE,
-                format!("failed to resolve address {}", params.signer),
-            )
-        })?;
+        let resolved_old_signer = resolve_to_id_addr(rt, &params.signer)
+            .with_context(|| format!("failed to resolve address {}", params.signer))?;
 
         rt.transaction(|st: &mut State, rt| {
             if !st.is_signer(&resolved_old_signer) {
@@ -374,12 +359,9 @@ impl Actor {
             }
 
             // Remove approvals from removed signer
-            st.purge_approvals(rt.store(), &resolved_old_signer).map_err(|e| {
-                e.downcast_default(
-                    ExitCode::USR_ILLEGAL_STATE,
-                    "failed to purge approvals of removed signer",
-                )
-            })?;
+            st.purge_approvals(rt.store(), &resolved_old_signer)
+                .context("failed to purge approvals of removed signer")?;
+
             st.signers.retain(|s| s != &resolved_old_signer);
 
             Ok(())
@@ -396,18 +378,10 @@ impl Actor {
     {
         let receiver = rt.message().receiver();
         rt.validate_immediate_caller_is(std::iter::once(&receiver))?;
-        let from_resolved = resolve_to_id_addr(rt, &params.from).map_err(|e| {
-            e.downcast_default(
-                ExitCode::USR_ILLEGAL_STATE,
-                format!("failed to resolve address {}", params.from),
-            )
-        })?;
-        let to_resolved = resolve_to_id_addr(rt, &params.to).map_err(|e| {
-            e.downcast_default(
-                ExitCode::USR_ILLEGAL_STATE,
-                format!("failed to resolve address {}", params.to),
-            )
-        })?;
+        let from_resolved = resolve_to_id_addr(rt, &params.from)
+            .with_context(|| format!("failed to resolve address {}", params.from))?;
+        let to_resolved = resolve_to_id_addr(rt, &params.to)
+            .with_context(|| format!("failed to resolve address {}", params.to))?;
 
         rt.transaction(|st: &mut State, rt| {
             if !st.is_signer(&from_resolved) {
@@ -424,12 +398,9 @@ impl Actor {
             // Add new signer
             st.signers.push(to_resolved);
 
-            st.purge_approvals(rt.store(), &from_resolved).map_err(|e| {
-                e.downcast_default(
-                    ExitCode::USR_ILLEGAL_STATE,
-                    "failed to purge approvals of removed signer",
-                )
-            })?;
+            st.purge_approvals(rt.store(), &from_resolved)
+                .context("failed to purge approvals of removed signer")?;
+
             Ok(())
         })?;
 
@@ -621,12 +592,8 @@ where
         .ok_or_else(|| actor_error!(not_found, "no such transaction {:?} for approval", txn_id))?;
 
     if !proposal_hash.is_empty() {
-        let calculated_hash = compute_proposal_hash(txn, rt).map_err(|e| {
-            e.downcast_default(
-                ExitCode::USR_ILLEGAL_STATE,
-                format!("failed to compute proposal hash for (tx: {:?})", txn_id),
-            )
-        })?;
+        let calculated_hash = compute_proposal_hash(txn, rt)
+            .with_context(|| format!("failed to compute proposal hash for (tx: {:?})", txn_id))?;
 
         if proposal_hash != calculated_hash {
             return Err(actor_error!(
@@ -641,7 +608,10 @@ where
 
 /// Computes a digest of a proposed transaction. This digest is used to confirm identity
 /// of the transaction associated with an ID, which might change under chain re-orgs.
-pub fn compute_proposal_hash(txn: &Transaction, sys: &dyn Syscalls) -> anyhow::Result<[u8; 32]> {
+pub fn compute_proposal_hash(
+    txn: &Transaction,
+    sys: &dyn Syscalls,
+) -> Result<[u8; 32], ActorError> {
     let proposal_hash = ProposalHashData {
         requester: txn.approved.get(0),
         to: &txn.to,

actors/multisig/src/lib.rs

@@ -1,8 +1,9 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use anyhow::anyhow;
 use cid::Cid;
+use fil_actors_runtime::actor_error;
+use fil_actors_runtime::ActorError;
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::tuple::*;
 use fvm_ipld_encoding::Cbor;
@@ -75,7 +76,7 @@ impl State {
         &mut self,
         store: &BS,
         addr: &Address,
-    ) -> anyhow::Result<()> {
+    ) -> Result<(), ActorError> {
         let mut txns = make_map_with_root(&self.pending_txs, store)?;
 
         // Identify transactions that need updating
@@ -86,7 +87,6 @@ impl State {
                     txn_ids_to_purge.insert(tx_id.0.clone(), txn.clone());
                 }
             }
-            Ok(())
         })?;
 
         // Update or remove those transactions.
@@ -110,12 +110,17 @@ impl State {
         balance: TokenAmount,
         amount_to_spend: &TokenAmount,
         curr_epoch: ChainEpoch,
-    ) -> anyhow::Result<()> {
+    ) -> Result<(), ActorError> {
         if amount_to_spend < &0.into() {
-            return Err(anyhow!("amount to spend {} less than zero", amount_to_spend));
+            return Err(actor_error!(
+                insufficient_funds,
+                "amount to spend {} less than zero",
+                amount_to_spend
+            ));
         }
         if &balance < amount_to_spend {
-            return Err(anyhow!(
+            return Err(actor_error!(
+                insufficient_funds,
                 "current balance {} less than amount to spend {}",
                 balance,
                 amount_to_spend
@@ -131,7 +136,8 @@ impl State {
         let remaining_balance = balance - amount_to_spend;
         let amount_locked = self.amount_locked(curr_epoch - self.start_epoch);
         if remaining_balance < amount_locked {
-            return Err(anyhow!(
+            return Err(actor_error!(
+                insufficient_funds,
                 "actor balance {} if spent {} would be less than required locked amount {}",
                 remaining_balance,
                 amount_to_spend,

actors/multisig/src/state.rs

@@ -192,8 +192,7 @@ impl ActorHarness {
         let ptx = make_map_with_root::<_, Transaction>(&st.pending_txs, &rt.store).unwrap();
         let mut actual_txns = Vec::new();
         ptx.for_each(|k, txn: &Transaction| {
-            actual_txns.push((TxnID(parse_uint_key(k)? as i64), txn.clone()));
-            Ok(())
+            actual_txns.push((TxnID(parse_uint_key(k).unwrap() as i64), txn.clone()));
         })
         .unwrap();
         expect_txns.sort_by_key(|(TxnID(id), _txn)| (*id));

actors/multisig/tests/util.rs

@@ -20,11 +20,11 @@ num-traits = "0.2.14"
 num-derive = "0.3.3"
 serde = { version = "1.0.136", features = ["derive"] }
 cid = { version = "0.8.3", default-features = false, features = ["serde-codec"] }
-anyhow = "1.0.56"
 fvm_ipld_blockstore = { version = "0.1" }
 fvm_ipld_encoding = "0.1.0"
 
 [dev-dependencies]
+anyhow = "1.0.56"
 fil_actors_runtime = { version = "8.0.0-alpha.1", path = "../runtime", features = ["test_utils", "sector-default"] }
 fvm_ipld_amt = { version = "0.4.0", features = ["go-interop"] }
 derive_builder = "0.10.2"

actors/paych/Cargo.toml

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use fil_actors_runtime::runtime::{ActorCode, Runtime};
-use fil_actors_runtime::{actor_error, cbor, resolve_to_id_addr, ActorDowncast, ActorError, Array};
+use fil_actors_runtime::{
+    actor_error, cbor, resolve_to_id_addr, ActorContext, ActorDowncast, ActorError, Array,
+};
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
 use fvm_shared::actor::builtin::Type;
@@ -72,12 +74,8 @@ impl Actor {
         BS: Blockstore,
         RT: Runtime<BS>,
     {
-        let resolved = resolve_to_id_addr(rt, raw).map_err(|e| {
-            e.downcast_default(
-                ExitCode::USR_ILLEGAL_STATE,
-                format!("failed to resolve address {}", raw),
-            )
-        })?;
+        let resolved = resolve_to_id_addr(rt, raw)
+            .with_context(|| format!("failed to resolve address {}", raw))?;
 
         let code_cid = rt
             .get_actor_code_cid(&resolved)

actors/paych/src/lib.rs

@@ -408,7 +408,7 @@ impl Actor {
                     }
                 };
 
-                if let Err(e) = mmap.for_all::<_, SealVerifyInfo, _>(|k, arr| {
+                if let Err(e) = mmap.try_for_all::<_, SealVerifyInfo, _>(|k, arr| {
                     let addr = match Address::from_bytes(&k.0) {
                         Ok(addr) => addr,
                         Err(e) => {
@@ -431,9 +431,8 @@ impl Actor {
                         .try_into()
                         .map_err(|_| "can not convert u64 to usize".to_string())?;
                     infos.reserve(num_proofs);
-                    arr.for_each::<_, ActorError>(|_, svi| {
+                    arr.for_each(|_, svi| {
                         infos.push(svi.clone());
-                        Ok(())
                     })
                     .map_err(|e| {
                         format!(

actors/power/src/lib.rs

@@ -327,9 +327,8 @@ pub(super) fn load_cron_events<BS: Blockstore>(
 ) -> Result<Vec<CronEvent>, ActorError> {
     let mut events = Vec::new();
 
-    mmap.for_each::<_, _, ActorError>(&epoch_key(epoch), |_, v: &CronEvent| {
+    mmap.for_each(&epoch_key(epoch), |_, v: &CronEvent| {
         events.push(v.clone());
-        Ok(())
     })?;
 
     Ok(events)

actors/power/src/state.rs

@@ -2,7 +2,6 @@ use cid::Cid;
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::{BytesDe, RawBytes};
 use fvm_ipld_hamt::BytesKey;
-use fvm_ipld_hamt::EitherError;
 use fvm_ipld_hamt::Error;
 use fvm_shared::address::Address;
 use fvm_shared::bigint::bigint_ser::BigIntDe;
@@ -181,13 +180,8 @@ where
     V: DeserializeOwned + Serialize,
 {
     let mut ret_keys = Vec::new();
-    m.for_each::<_, ()>(|k, _| {
+    m.for_each(|k, _| {
         ret_keys.push(k.clone());
-        Ok(())
-    })
-    .map_err(|err| match err {
-        EitherError::User(()) => unreachable!(),
-        EitherError::Hamt(e) => e,
     })?;
 
     Ok(ret_keys)
@@ -196,5 +190,5 @@ where
 pub fn verify_empty_map(rt: &MockRuntime, key: Cid) {
     let map =
         make_map_with_root_and_bitwidth::<_, BigIntDe>(&key, &rt.store, HAMT_BIT_WIDTH).unwrap();
-    map.for_each::<_, ()>(|_key, _val| panic!("expected no keys")).unwrap();
+    map.for_each(|_key, _val| panic!("expected no keys")).unwrap();
 }