Rpc state implementation

Cargo.toml

@@ -17,7 +17,6 @@ members = [
     "vm/interpreter",
     "node/clock",
     "node/rpc",
-    "node/state_api",
     "crypto",
     "encoding",
     "ipld/cid",

blockchain/blocks/src/tipset.rs

@@ -285,6 +285,12 @@ pub mod tipset_json {
         }
     }
 
+    impl From<Tipset> for TipsetJson {
+        fn from(wrapper: Tipset) -> Self {
+            TipsetJson(wrapper)
+        }
+    }
+
     pub fn serialize<S>(m: &Tipset, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,

blockchain/state_manager/src/lib.rs

@@ -27,7 +27,8 @@ use interpreter::{resolve_to_key_addr, ApplyRet, ChainRand, DefaultSyscalls, VM}
 use ipld_amt::Amt;
 use log::{trace, warn};
 use message::{Message, MessageReceipt, UnsignedMessage};
-use num_bigint::BigInt;
+use num_bigint::{bigint_ser, BigInt};
+use serde::{Deserialize, Serialize};
 use state_tree::StateTree;
 use std::collections::HashMap;
 use std::error::Error as StdError;
@@ -37,22 +38,23 @@ use std::sync::Arc;
 pub type CidPair = (Cid, Cid);
 
 /// Type to represent invocation of state call results
-pub struct InvocResult<Msg>
-where
-    Msg: Message,
-{
-    pub msg: Msg,
+#[derive(Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct InvocResult {
+    pub msg: UnsignedMessage,
     pub msg_rct: Option<MessageReceipt>,
-    pub actor_error: Option<String>,
+    pub error: Option<String>,
 }
 
 // An alias Result that represents an InvocResult and an Error
-pub type StateCallResult<T> = Result<InvocResult<T>, Error>;
+pub type StateCallResult = Result<InvocResult, Error>;
 
-#[allow(dead_code)]
-#[derive(Default)]
+#[derive(Default, Serialize, Deserialize)]
+#[serde(rename_all = "PascalCase")]
 pub struct MarketBalance {
+    #[serde(with = "bigint_ser")]
     escrow: BigInt,
+    #[serde(with = "bigint_ser")]
     locked: BigInt,
 }
 
@@ -233,7 +235,7 @@ where
         bstate: &Cid,
         rand: &ChainRand,
         bheight: &ChainEpoch,
-    ) -> StateCallResult<UnsignedMessage>
+    ) -> StateCallResult
     where
         DB: BlockStore,
     {
@@ -270,17 +272,13 @@ where
             Ok(InvocResult {
                 msg: msg.clone(),
                 msg_rct: Some(apply_ret.msg_receipt.clone()),
-                actor_error: apply_ret.act_error.map(|e| e.to_string()),
+                error: apply_ret.act_error.map(|e| e.to_string()),
             })
         })
     }
 
     /// runs the given message and returns its result without any persisted changes.
-    pub fn call(
-        &self,
-        message: &mut UnsignedMessage,
-        tipset: Option<Tipset>,
-    ) -> StateCallResult<UnsignedMessage>
+    pub fn call(&self, message: &mut UnsignedMessage, tipset: Option<Tipset>) -> StateCallResult
     where
         DB: BlockStore,
     {
@@ -375,6 +373,53 @@ where
         })
     }
 
+    fn tipset_executed_message(
+        block_store: &DB,
+        tipset: &Tipset,
+        cid: &Cid,
+        (message_from_address, message_sequence): (&Address, &u64),
+    ) -> Result<Option<MessageReceipt>, Error>
+    where
+        DB: BlockStore,
+    {
+        if tipset.epoch() == 0 {
+            return Ok(None);
+        }
+        let tipset = chain::tipset_from_keys(block_store, tipset.parents())
+            .map_err(|err| Error::Other(err.to_string()))?;
+        let messages = chain::messages_for_tipset(block_store, &tipset)
+            .map_err(|err| Error::Other(err.to_string()))?;
+        messages
+            .iter()
+            .enumerate()
+            .rev()
+            .filter(|(_, s)| s.from() == message_from_address)
+            .filter_map(|(index,s)| {
+                if s.sequence() == *message_sequence {
+                    if s.cid().map(|s| &s == cid).unwrap_or_default() {
+                        return Some(
+                            chain::get_parent_reciept(
+                                block_store,
+                                tipset.blocks().first().unwrap(),
+                                index as u64,
+                            )
+                            .map_err(|err| {
+                                Error::Other(err.to_string())
+                            }),
+                        );
+                    }
+                    let error_msg = format!("found message with equal nonce as the one we are looking for (F:{:} n {:}, TS: `Error Converting message to Cid` n{:})", cid, message_sequence, s.sequence());
+                    return Some(Err(Error::Other(error_msg)))
+                }
+                if s.sequence() < *message_sequence {
+                    return Some(Ok(None));
+                }
+
+                None
+            })
+            .next()
+            .unwrap_or_else(|| Ok(None))
+    }
     fn search_back_for_message(
         block_store: Arc<DB>,
         current: &Tipset,
@@ -445,54 +490,6 @@ where
         Ok(message_receipt)
     }
 
-    fn tipset_executed_message(
-        block_store: &DB,
-        tipset: &Tipset,
-        cid: &Cid,
-        (message_from_address, message_sequence): (&Address, &u64),
-    ) -> Result<Option<MessageReceipt>, Error>
-    where
-        DB: BlockStore,
-    {
-        if tipset.epoch() == 0 {
-            return Ok(None);
-        }
-        let tipset = chain::tipset_from_keys(block_store, tipset.parents())
-            .map_err(|err| Error::Other(err.to_string()))?;
-        let messages = chain::messages_for_tipset(block_store, &tipset)
-            .map_err(|err| Error::Other(err.to_string()))?;
-        messages
-            .iter()
-            .enumerate()
-            .rev()
-            .filter(|(_, s)| s.from() == message_from_address)
-            .filter_map(|(index,s)| {
-                if s.sequence() == *message_sequence {
-                    if s.cid().map(|s| &s == cid).unwrap_or_default() {
-                        return Some(
-                            chain::get_parent_reciept(
-                                block_store,
-                                tipset.blocks().first().unwrap(),
-                                index as u64,
-                            )
-                            .map_err(|err| {
-                                Error::Other(err.to_string())
-                            }),
-                        );
-                    }
-                    let error_msg = format!("found message with equal nonce as the one we are looking for (F:{:} n {:}, TS: `Error Converting message to Cid` n{:})", cid, message_sequence, s.sequence());
-                    return Some(Err(Error::Other(error_msg)))
-                }
-                if s.sequence() < *message_sequence {
-                    return Some(Ok(None));
-                }
-
-                None
-            })
-            .next()
-            .unwrap_or_else(|| Ok(None))
-    }
-
     /// WaitForMessage blocks until a message appears on chain. It looks backwards in the chain to see if this has already
     /// happened. It guarantees that the message has been on chain for at least confidence epochs without being reverted
     /// before returning.
@@ -679,7 +676,7 @@ where
         state_tree.lookup_id(addr).map_err(Error::State)
     }
 
-    pub fn market_balance(&mut self, addr: &Address, ts: &Tipset) -> Result<MarketBalance, Error> {
+    pub fn market_balance(&self, addr: &Address, ts: &Tipset) -> Result<MarketBalance, Error> {
         let market_state: market::State =
             self.load_actor_state(&*STORAGE_MARKET_ACTOR_ADDR, ts.parent_state())?;
 

forest/src/daemon.rs

@@ -13,6 +13,7 @@ use libp2p::identity::{ed25519, Keypair};
 use log::{debug, info, trace};
 use message_pool::{MessagePool, MpoolRpcProvider};
 use rpc::{start_rpc, RpcState};
+use state_manager::StateManager;
 use std::sync::Arc;
 use utils::write_to_file;
 use wallet::PersistentKeyStore;
@@ -96,14 +97,14 @@ pub(super) async fn start(config: Config) {
     });
 
     let rpc_task = if config.enable_rpc {
-        let db_rpc = Arc::clone(&db);
+        let db_rpc = StateManager::new(Arc::clone(&db));
         let keystore_rpc = Arc::clone(&keystore);
         let rpc_listen = format!("127.0.0.1:{}", &config.rpc_port);
         Some(task::spawn(async move {
             info!("JSON RPC Endpoint at {}", &rpc_listen);
             start_rpc(
                 RpcState {
-                    store: db_rpc,
+                    state_manager: db_rpc,
                     keystore: keystore_rpc,
                     mpool,
                     bad_blocks,

node/rpc/Cargo.toml

@@ -5,6 +5,7 @@ authors = ["ChainSafe Systems <info@chainsafe.io>"]
 edition = "2018"
 
 [dependencies]
+actor = { path = "../../vm/actor/" }
 async-std = { version = "1.6.0", features = ["attributes"] }
 tide = "0.9.0"
 serde = { version = "1.0.101", default-features = false, features = ["derive"] }
@@ -22,15 +23,18 @@ crypto = { package = "forest_crypto", path = "../../crypto", features = ["json"]
 num-traits = "0.2.11"
 wallet = {package = "key_management", path = "../../key_management", features = ["json"] }
 state_manager = {package = "state_manager", path = "../../blockchain/state_manager" }
-address = { package = "forest_address", path = "../../vm/address" }
+address = { package = "forest_address", path = "../../vm/address", features = ["json"] }
 encoding = { package = "forest_encoding",  path = "../../encoding/"}
 num-bigint = { path = "../../utils/bigint", package = "forest_bigint" }
 thiserror = "1.0"
 state_tree = { path = "../../vm/state_tree" }
 forest_libp2p = { path = "../forest_libp2p" }
+interpreter = { path = "../../vm/interpreter/" }
+fil_types = { path = "../../types" }
+bitfield = { path = "../../utils/bitfield",features = ["json"] }
 
 [dev-dependencies]
 db = { path = "../db" }
 futures = "0.3.5"
 test_utils = { version = "0.1.0", path = "../../utils/test_utils/", features = ["test_constructors"] }
-hex = "0.4.2"
+hex = "0.4.2"