Cron actor implementation

vm/actor/src/builtin/cron/mod.rs

@@ -4,13 +4,14 @@
 mod state;
 
 pub use self::state::{Entry, State};
-use crate::{assert_empty_params, empty_return};
+use crate::{assert_empty_params, empty_return, SYSTEM_ACTOR_ADDR};
+use address::Address;
 use ipld_blockstore::BlockStore;
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
 use runtime::{ActorCode, Runtime};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use vm::{ExitCode, MethodNum, Serialized, METHOD_CONSTRUCTOR};
+use vm::{ExitCode, MethodNum, Serialized, TokenAmount, METHOD_CONSTRUCTOR};
 
 /// Cron actor methods available
 #[derive(FromPrimitive)]
@@ -57,37 +58,37 @@ impl<'de> Deserialize<'de> for ConstructorParams {
 pub struct Actor;
 impl Actor {
     /// Constructor for Cron actor
-    fn constructor<BS, RT>(_rt: &RT, _params: ConstructorParams)
+    fn constructor<BS, RT>(rt: &RT, params: ConstructorParams)
     where
         BS: BlockStore,
         RT: Runtime<BS>,
     {
-        // TODO now finished spec
-        todo!()
+        let sys_ref: &Address = &SYSTEM_ACTOR_ADDR;
+        rt.validate_immediate_caller_is(std::iter::once(sys_ref));
+        rt.create(&State {
+            entries: params.entries,
+        })
     }
-    /// epoch_tick executes built-in periodic actions, run at every Epoch.
+    /// Executes built-in periodic actions, run at every Epoch.
     /// epoch_tick(r) is called after all other messages in the epoch have been applied.
     /// This can be seen as an implicit last message.
-    fn epoch_tick<BS, RT>(_rt: &RT)
+    fn epoch_tick<BS, RT>(rt: &RT)
     where
         BS: BlockStore,
         RT: Runtime<BS>,
     {
-        // self.entries is basically a static registry for now, loaded
-        // in the interpreter static registry.
-        // TODO update to new spec
-        todo!()
-        // for entry in &self.entries {
-        //     let res = rt.send_catching_errors(InvocInput {
-        //         to: entry.to_addr.clone(),
-        //         method: entry.method_num,
-        //         params: Serialized::default(),
-        //         value: TokenAmount::new(0),
-        //     });
-        //     if let Err(e) = res {
-        //         return e.into();
-        //     }
-        // }
+        let sys_ref: &Address = &SYSTEM_ACTOR_ADDR;
+        rt.validate_immediate_caller_is(std::iter::once(sys_ref));
+
+        let st: State = rt.state();
+        for entry in st.entries {
+            rt.send::<Serialized>(
+                &entry.receiver,
+                entry.method_num,
+                &Serialized::default(),
+                &TokenAmount::new(0),
+            );
+        }
     }
 }
 

vm/actor/src/builtin/cron/state.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0, MIT
 
 use address::Address;
+use encoding::Cbor;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use vm::MethodNum;
 
@@ -13,8 +14,8 @@ pub struct State {
 }
 
 pub struct Entry {
-    receiver: Address,
-    method_num: MethodNum,
+    pub receiver: Address,
+    pub method_num: MethodNum,
 }
 
 impl Serialize for State {
@@ -26,6 +27,8 @@ impl Serialize for State {
     }
 }
 
+impl Cbor for State {}
+
 impl<'de> Deserialize<'de> for State {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where