stub object store actor

Signed-off-by: Sander Pick <sanderpick@gmail.com>

Author: sanderpick

Cargo.lock

@@ -28,6 +28,7 @@ members = [
   "fendermint/vm/*",
   "fendermint/actors",
   "fendermint/actors/chainmetadata",
+  "fendermint/actors/objectstore",
 ]
 
 [workspace.package]
@@ -169,6 +170,7 @@ fvm_ipld_car = "0.7.1"
 fvm_ipld_encoding = "0.4.0"
 fvm_ipld_hamt = "0.9.0"
 fvm_ipld_amt = "0.6.2"
+fvm_ipld_kamt = "0.3.0"
 
 # Local FVM debugging
 # fvm = { path = "../ref-fvm/fvm", default-features = false }

Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "fendermint_actor_objectstore"
+description = "Actor for object storage"
+license.workspace = true
+edition.workspace = true
+authors.workspace = true
+version = "0.1.0"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+cid = { workspace = true, default-features = false }
+fil_actors_runtime = { workspace = true, optional = true, features = [
+    "fil-actor",
+] }
+fvm_shared = { workspace = true }
+fvm_ipld_encoding = { workspace = true }
+fvm_ipld_blockstore = { workspace = true }
+fvm_ipld_kamt = { workspace = true }
+num-derive = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_tuple = { workspace = true }
+num-traits = { workspace = true }
+frc42_dispatch = { workspace = true }
+anyhow = { workspace = true }
+
+[features]
+default = []
+fil-actor = ["fil_actors_runtime"]

fendermint/actors/objectstore/Cargo.toml

@@ -0,0 +1,87 @@
+// Copyright 2021-2023 Protocol Labs
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use fil_actors_runtime::actor_dispatch;
+use fil_actors_runtime::actor_error;
+use fil_actors_runtime::builtin::singletons::SYSTEM_ACTOR_ADDR;
+use fil_actors_runtime::runtime::{ActorCode, Runtime};
+use fil_actors_runtime::ActorDowncast;
+use fil_actors_runtime::ActorError;
+use fvm_shared::error::ExitCode;
+
+use crate::{ConstructorParams, Method, State, OBJECTSTORE_ACTOR_NAME};
+
+fil_actors_runtime::wasm_trampoline!(Actor);
+
+pub struct Actor;
+
+impl Actor {
+    fn constructor(rt: &impl Runtime, params: ConstructorParams) -> Result<(), ActorError> {
+        // Note(sander): We're setting this up to be a subnet-wide actor for a single repo.
+        // Note(sander): In the future, this could be deployed dynamically for multi repo subnets.
+        rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
+
+        let state = State::new(rt.store()).map_err(|e| {
+            e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to create empty KAMT")
+        })?;
+
+        rt.create(&state)?;
+
+        Ok(())
+    }
+
+    // Note(sander): Probably obvious, but example actor method that mutates state
+    // fn push_block_hash(rt: &impl Runtime, params: PushBlockParams) -> Result<(), ActorError> {
+    //     rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
+    //
+    //     rt.transaction(|st: &mut State, rt| {
+    //         // load the blockhashes AMT
+    //         let mut blockhashes = Array::load(&st.blockhashes, rt.store()).map_err(|e| {
+    //             e.downcast_default(
+    //                 ExitCode::USR_ILLEGAL_STATE,
+    //                 "failed to load blockhashes states",
+    //             )
+    //         })?;
+    //
+    //         // push the block to the AMT
+    //         blockhashes.set(params.epoch as u64, params.block).unwrap();
+    //
+    //         // remove the oldest block if the AMT is full (note that this assume the
+    //         // for_each_while iterates in order, which it seems to do)
+    //         if blockhashes.count() > st.lookback_len {
+    //             let mut first_idx = 0;
+    //             blockhashes
+    //                 .for_each_while(|i, _: &BlockHash| {
+    //                     first_idx = i;
+    //                     Ok(false)
+    //                 })
+    //                 .unwrap();
+    //             blockhashes.delete(first_idx).unwrap();
+    //         }
+    //
+    //         // save the new blockhashes AMT cid root
+    //         st.blockhashes = blockhashes.flush().map_err(|e| {
+    //             e.downcast_default(ExitCode::USR_ILLEGAL_STATE, "failed to save blockhashes")
+    //         })?;
+    //
+    //         Ok(())
+    //     })?;
+    //
+    //     Ok(())
+    // }
+}
+
+impl ActorCode for Actor {
+    type Methods = Method;
+
+    fn name() -> &'static str {
+        OBJECTSTORE_ACTOR_NAME
+    }
+
+    actor_dispatch! {
+        Constructor => constructor,
+        // PushBlockHash => push_block_hash,
+        // LookbackLen => lookback_len,
+        // GetBlockHash => get_block_hash,
+    }
+}

fendermint/actors/objectstore/src/actor.rs

@@ -0,0 +1,7 @@
+// Copyright 2021-2023 Protocol Labs
+// SPDX-License-Identifier: Apache-2.0, MIT
+#[cfg(feature = "fil-actor")]
+mod actor;
+mod shared;
+
+pub use shared::*;

fendermint/actors/objectstore/src/lib.rs

@@ -0,0 +1,57 @@
+// Copyright 2021-2023 Protocol Labs
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use cid::Cid;
+use fvm_ipld_blockstore::Blockstore;
+use fvm_ipld_encoding::tuple::{Deserialize_tuple, Serialize_tuple};
+use fvm_ipld_kamt::{id::Identity, Kamt};
+use fvm_shared::METHOD_CONSTRUCTOR;
+use num_derive::FromPrimitive;
+
+// The state stores the blockhashes of the last `lookback_len` epochs
+#[derive(Serialize_tuple, Deserialize_tuple)]
+pub struct State {
+    // the KAMT root cid of keys
+    pub keys: Cid,
+}
+
+impl State {
+    pub fn new<BS: Blockstore>(store: &BS) -> anyhow::Result<Self> {
+        // Note(sander): I don't know if these generics are correct... maybe K should be Cid?
+        let empty_keys_cid = match Kamt::<_, String, Vec<u8>, Identity, 32>::new(store).flush() {
+            Ok(cid) => cid,
+            Err(e) => {
+                return Err(anyhow::anyhow!(
+                    "objectstore actor failed to create empty Kamt: {}",
+                    e
+                ))
+            }
+        };
+
+        Ok(Self {
+            keys: empty_keys_cid,
+        })
+    }
+}
+
+pub const OBJECTSTORE_ACTOR_NAME: &str = "objectstore";
+
+#[derive(Default, Debug, Serialize_tuple, Deserialize_tuple)]
+pub struct ConstructorParams {
+    pub foo: u64,
+}
+
+// Note(sander): Example of method params
+// #[derive(Default, Debug, Serialize_tuple, Deserialize_tuple)]
+// pub struct PushBlockParams {
+//
+// }
+
+#[derive(FromPrimitive)]
+#[repr(u64)]
+pub enum Method {
+    Constructor = METHOD_CONSTRUCTOR,
+    // PushBlockHash = frc42_dispatch::method_hash!("PushBlockHash"),
+    // LookbackLen = frc42_dispatch::method_hash!("LookbackLen"),
+    // GetBlockHash = frc42_dispatch::method_hash!("GetBlockHash"),
+}