Storage Miner Pledging

blockchain/state_manager/src/lib.rs

@@ -33,8 +33,8 @@ use futures::channel::oneshot;
 use futures::select;
 use futures::stream::StreamExt;
 use futures::FutureExt;
-use interpreter::LookbackStateGetter;
 use interpreter::{resolve_to_key_addr, ApplyRet, BlockMessages, Rand, VM};
+use interpreter::{CircSupplyCalc, LookbackStateGetter};
 use ipld_amt::Amt;
 use lazycell::AtomicLazyCell;
 use log::{debug, info, trace, warn};
@@ -1189,6 +1189,15 @@ where
         }
         Ok(())
     }
+
+    /// Retrieves total circulating supply on the network.
+    pub fn get_circulating_supply(
+        self: &Arc<Self>,
+        height: ChainEpoch,
+        state_tree: &StateTree<DB>,
+    ) -> Result<TokenAmount, Box<dyn StdError>> {
+        self.genesis_info.get_supply(height, state_tree)
+    }
 }
 
 pub struct MiningBaseInfo {

node/rpc/src/chain_api.rs

@@ -83,7 +83,7 @@ where
 pub(crate) async fn chain_read_obj<DB, KS, B>(
     data: Data<RpcState<DB, KS, B>>,
     Params(params): Params<(CidJson,)>,
-) -> Result<Vec<u8>, JsonRpcError>
+) -> Result<String, JsonRpcError>
 where
     DB: BlockStore + Send + Sync + 'static,
     KS: KeyStore + Send + Sync + 'static,
@@ -95,7 +95,7 @@ where
         .blockstore()
         .get_bytes(&obj_cid)?
         .ok_or("can't find object with that cid")?;
-    Ok(ret)
+    Ok(base64::encode(ret))
 }
 
 pub(crate) async fn chain_has_obj<DB, KS, B>(
@@ -259,24 +259,46 @@ where
     Ok(TipsetJson(ts))
 }
 
-pub(crate) async fn chain_get_randomness<DB, KS, B>(
+pub(crate) async fn chain_get_randomness_from_tickets<DB, KS, B>(
     data: Data<RpcState<DB, KS, B>>,
-    Params(params): Params<(TipsetKeys, i64, ChainEpoch, Vec<u8>)>,
+    Params(params): Params<(TipsetKeysJson, i64, ChainEpoch, String)>,
 ) -> Result<[u8; 32], JsonRpcError>
 where
     DB: BlockStore + Send + Sync + 'static,
     KS: KeyStore + Send + Sync + 'static,
     B: Beacon + Send + Sync + 'static,
 {
-    let (tsk, pers, epoch, entropy) = params;
+    let (TipsetKeysJson(tsk), pers, epoch, entropy) = params;
     Ok(data
         .state_manager
         .chain_store()
         .get_chain_randomness(
             &tsk,
             DomainSeparationTag::from_i64(pers).ok_or("invalid DomainSeparationTag")?,
             epoch,
-            &entropy,
+            &base64::decode(entropy)?,
+        )
+        .await?)
+}
+
+pub(crate) async fn chain_get_randomness_from_beacon<DB, KS, B>(
+    data: Data<RpcState<DB, KS, B>>,
+    Params(params): Params<(TipsetKeysJson, i64, ChainEpoch, String)>,
+) -> Result<[u8; 32], JsonRpcError>
+where
+    DB: BlockStore + Send + Sync + 'static,
+    KS: KeyStore + Send + Sync + 'static,
+    B: Beacon + Send + Sync + 'static,
+{
+    let (TipsetKeysJson(tsk), pers, epoch, entropy) = params;
+    Ok(data
+        .state_manager
+        .chain_store()
+        .get_beacon_randomness(
+            &tsk,
+            DomainSeparationTag::from_i64(pers).ok_or("invalid DomainSeparationTag")?,
+            epoch,
+            &base64::decode(entropy)?,
         )
         .await?)
 }

node/rpc/src/lib.rs

@@ -100,7 +100,7 @@ where
             chain_api::chain_get_message::<DB, KS, B>,
             false,
         )
-        .with_method("Filecoin.ChainGetObj", chain_read_obj::<DB, KS, B>, false)
+        .with_method("Filecoin.ChainReadObj", chain_read_obj::<DB, KS, B>, false)
         .with_method("Filecoin.ChainHasObj", chain_has_obj::<DB, KS, B>, false)
         .with_method(
             "Filecoin.ChainGetBlockMessages",
@@ -128,8 +128,13 @@ where
             false,
         )
         .with_method(
-            "Filecoin.GetRandomness",
-            chain_get_randomness::<DB, KS, B>,
+            "Filecoin.ChainGetRandomnessFromTickets",
+            chain_get_randomness_from_tickets::<DB, KS, B>,
+            false,
+        )
+        .with_method(
+            "Filecoin.ChainGetRandomnessFromBeacon",
+            chain_get_randomness_from_beacon::<DB, KS, B>,
             false,
         )
         .with_method(
@@ -243,20 +248,30 @@ where
             state_miner_partitions::<DB, KS, B>,
             false,
         )
+        .with_method(
+            "Filecoin.StateMinerPreCommitDepositForPower",
+            state_miner_pre_commit_deposit_for_power::<DB, KS, B, V>,
+            false,
+        )
+        .with_method(
+            "Filecoin.StateMinerInitialPledgeCollateral",
+            state_miner_initial_pledge_collateral::<DB, KS, B, V>,
+            false,
+        )
         .with_method("Filecoin.StateReplay", state_replay::<DB, KS, B>, false)
         .with_method(
             "Filecoin.StateGetActor",
-            state_get_actor::<DB, KS, B>,
+            state_get_actor::<DB, KS, B, V>,
             false,
         )
         .with_method(
             "Filecoin.StateAccountKey",
-            state_account_key::<DB, KS, B>,
+            state_account_key::<DB, KS, B, V>,
             false,
         )
         .with_method(
             "Filecoin.StateLookupId",
-            state_lookup_id::<DB, KS, B>,
+            state_lookup_id::<DB, KS, B, V>,
             false,
         )
         .with_method(
@@ -295,7 +310,11 @@ where
             miner_create_block::<DB, KS, B, V>,
             false,
         )
-        .with_method("Filecoin.NetworkVersion", state_get_network_version, false)
+        .with_method(
+            "Filecoin.StateNetworkVersion",
+            state_get_network_version::<DB, KS, B>,
+            false,
+        )
         // Gas API
         .with_method(
             "Filecoin.GasEstimateGasLimit",

node/rpc/src/mpool_api.rs

@@ -188,6 +188,8 @@ where
     if from.protocol() == Protocol::ID {
         umsg.from = key_addr;
     }
+    let nonce = data.mpool.get_sequence(&from).await?;
+    umsg.sequence = nonce;
     let key = wallet::find_key(&key_addr, &*keystore)?;
     let sig = wallet::sign(
         *key.key_info.key_type(),