convert shared

Author: dignifiedquire

ipld/blockstore/src/lib.rs

@@ -13,7 +13,7 @@ pub use block::*;
 /// An IPLD blockstore suitable for injection into the FVM.
 ///
 /// The cgo blockstore adapter implements this trait.
-pub trait Blockstore {
+pub trait Blockstore: std::fmt::Debug {
     type Error: std::error::Error + std::fmt::Debug;
 
     /// Gets the block from the blockstore.

shared/Cargo.toml

@@ -23,7 +23,6 @@ log = "0.4.8"
 cid = { version = "0.8.2", default-features = false, features = ["serde-codec", "std"] }
 multihash = { version = "0.16.1", default-features = false, features = ["blake2b", "multihash-impl"] }
 unsigned-varint = "0.7.1"
-anyhow = "1.0.51"
 bimap = { version = "0.6.2", features = ["serde"] }
 fvm_ipld_blockstore = { version = "0.1", path = "../ipld/blockstore" }
 fvm_ipld_encoding = { version = "0.1", path = "../ipld/encoding" }

shared/src/actor/builtin.rs

@@ -1,10 +1,9 @@
 use std::fmt::{Debug, Display, Formatter};
 
-use anyhow::anyhow;
 use bimap::BiBTreeMap;
 use cid::Cid;
 use fvm_ipld_blockstore::Blockstore;
-use fvm_ipld_encoding::CborStore;
+use fvm_ipld_encoding::{CborStore, CborStoreError};
 use num_derive::FromPrimitive;
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
@@ -115,26 +114,36 @@ impl Display for Type {
 /// A mapping of builtin actor CIDs to their respective types.
 pub type Manifest = BiBTreeMap<Cid, Type>;
 
-pub fn load_manifest<B: Blockstore>(bs: &B, root_cid: &Cid, ver: u32) -> anyhow::Result<Manifest> {
+pub fn load_manifest<B: Blockstore>(
+    bs: &B,
+    root_cid: &Cid,
+    ver: u32,
+) -> Result<Manifest, ManifestError<B>> {
     match ver {
         0 => load_manifest_v0(bs, root_cid),
         1 => load_manifest_v1(bs, root_cid),
-        _ => Err(anyhow!("unknown manifest version {}", ver)),
+        _ => Err(ManifestError::UnknownVersion(ver)),
     }
 }
 
-pub fn load_manifest_v0<B: Blockstore>(bs: &B, root_cid: &Cid) -> anyhow::Result<Manifest> {
+pub fn load_manifest_v0<B: Blockstore>(
+    bs: &B,
+    root_cid: &Cid,
+) -> Result<Manifest, ManifestError<B>> {
     match bs.get_cbor::<Manifest>(root_cid)? {
         Some(mf) => Ok(mf),
-        None => Err(anyhow!("cannot find manifest root cid {}", root_cid)),
+        None => Err(ManifestError::MissingRootCid(*root_cid)),
     }
 }
 
-pub fn load_manifest_v1<B: Blockstore>(bs: &B, root_cid: &Cid) -> anyhow::Result<Manifest> {
+pub fn load_manifest_v1<B: Blockstore>(
+    bs: &B,
+    root_cid: &Cid,
+) -> Result<Manifest, ManifestError<B>> {
     let vec: Vec<(String, Cid)> = match bs.get_cbor(root_cid)? {
         Some(vec) => vec,
         None => {
-            return Err(anyhow!("cannot find manifest root cid {}", root_cid));
+            return Err(ManifestError::MissingRootCid(*root_cid));
         }
     };
     let mut manifest = Manifest::new();
@@ -145,9 +154,21 @@ pub fn load_manifest_v1<B: Blockstore>(bs: &B, root_cid: &Cid) -> anyhow::Result
                 manifest.insert(code_cid, t);
             }
             Err(what) => {
-                return Err(anyhow!("bad builtin actor name: {}: {} ", name, what));
+                return Err(ManifestError::BadBuiltinActor(name, what));
             }
         }
     }
     Ok(manifest)
 }
+
+#[derive(thiserror::Error, Debug)]
+pub enum ManifestError<BS: Blockstore> {
+    #[error("unknown manifest version {0}")]
+    UnknownVersion(u32),
+    #[error("cannot find manifest root cid {0}")]
+    MissingRootCid(Cid),
+    #[error("bad builtin actor name: {0}: {1}")]
+    BadBuiltinActor(String, String),
+    #[error("encoding {0}")]
+    Encoding(#[from] CborStoreError<BS>),
+}

shared/src/message.rs

@@ -1,7 +1,6 @@
 // Copyright 2019-2022 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
-use anyhow::anyhow;
 use fvm_ipld_encoding::de::{Deserialize, Deserializer};
 use fvm_ipld_encoding::ser::{Serialize, Serializer};
 use fvm_ipld_encoding::{Cbor, RawBytes};
@@ -38,17 +37,25 @@ impl Message {
     }
 
     /// Does some basic checks on the Message to see if the fields are valid.
-    pub fn check(self: &Message) -> anyhow::Result<()> {
+    pub fn check(self: &Message) -> Result<(), MessageError> {
         if self.gas_limit == 0 {
-            return Err(anyhow!("Message has no gas limit set"));
+            return Err(MessageError::MissingGasLimit);
         }
         if self.gas_limit < 0 {
-            return Err(anyhow!("Message has negative gas limit"));
+            return Err(MessageError::NegativeGasLimit);
         }
         Ok(())
     }
 }
 
+#[derive(thiserror::Error, Debug)]
+pub enum MessageError {
+    #[error("Message has no gas limit set")]
+    MissingGasLimit,
+    #[error("Message has negative gas limit")]
+    NegativeGasLimit,
+}
+
 impl Serialize for Message {
     fn serialize<S>(&self, s: S) -> std::result::Result<S::Ok, S::Error>
     where