feat(rpc): implement Filecoin.StateMarketParticipants

src/rpc/methods/state.rs

@@ -8,6 +8,7 @@ pub use types::*;
 use crate::blocks::Tipset;
 use crate::cid_collections::CidHashSet;
 use crate::libp2p::NetworkMessage;
+use crate::shim::actors::market::BalanceTableExt as _;
 use crate::shim::message::Message;
 use crate::shim::piece::PaddedPieceSize;
 use crate::shim::state_tree::StateTree;
@@ -88,6 +89,7 @@ macro_rules! for_each_method {
  $callback!(crate::rpc::state::StateListMiners);
  $callback!(crate::rpc::state::StateNetworkVersion);
  $callback!(crate::rpc::state::StateMarketBalance);
+ $callback!(crate::rpc::state::StateMarketParticipants);
  $callback!(crate::rpc::state::StateMarketDeals);
  $callback!(crate::rpc::state::StateDealProviderCollateralBounds);
  $callback!(crate::rpc::state::StateMarketStorageDeal);
@@ -1423,6 +1425,41 @@ impl RpcMethod<2> for StateMarketStorageDeal {
  }
 }
 
+pub enum StateMarketParticipants {}
+
+impl RpcMethod<1> for StateMarketParticipants {
+ const NAME: &'static str = "Filecoin.StateMarketParticipants";
+ const PARAM_NAMES: [&'static str; 1] = ["tipset_key"];
+ const API_VERSION: ApiVersion = ApiVersion::V0;
+ const PERMISSION: Permission = Permission::Read;
+
+ type Params = (ApiTipsetKey,);
+ type Ok = HashMap<String, MarketBalance>;
+
+ async fn handle(
+ ctx: Ctx<impl Blockstore + Send + Sync + 'static>,
+ (ApiTipsetKey(tsk),): Self::Params,
+ ) -> Result<Self::Ok, ServerError> {
+ let ts = ctx.chain_store.load_required_tipset_or_heaviest(&tsk)?;
+ let market_state = ctx.state_manager.market_state(&ts)?;
+ let escrow_table = market_state.escrow_table(ctx.store())?;
+ let locked_table = market_state.locked_table(ctx.store())?;
+ let mut result = HashMap::new();
+ escrow_table.for_each(|address, escrow| {
+ let locked = locked_table.get(&address.into())?;
+ result.insert(
+ address.to_string(),
+ MarketBalance {
+ escrow: escrow.clone(),
+ locked: locked.into(),
+ },
+ );
+ Ok(())
+ })?;
+ Ok(result)
+ }
+}
+
 pub enum StateDealProviderCollateralBounds {}
 
 impl RpcMethod<3> for StateDealProviderCollateralBounds {

src/shim/actors/market.rs

@@ -0,0 +1,13 @@
+// Copyright 2019-2024 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+mod balance_table;
+
+use crate::shim::address::Address;
+use crate::shim::econ::TokenAmount;
+
+pub trait BalanceTableExt {
+ fn for_each<F>(&self, f: F) -> anyhow::Result<()>
+ where
+ F: FnMut(&Address, &TokenAmount) -> anyhow::Result<()>;
+}

src/shim/actors/market/balance_table.rs

@@ -0,0 +1,37 @@
+// Copyright 2019-2024 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+use super::*;
+use fil_actor_interface::market::BalanceTable;
+use fvm_ipld_blockstore::Blockstore;
+
+impl<'bs, BS: Blockstore> BalanceTableExt for BalanceTable<'bs, BS> {
+ fn for_each<F>(&self, mut f: F) -> anyhow::Result<()>
+ where
+ F: FnMut(&Address, &TokenAmount) -> anyhow::Result<()>,
+ {
+ match self {
+ Self::V8(t) => {
+ t.0.for_each(|key, escrow| f(&Address::from_bytes(&key.0)?, &escrow.into()))?
+ }
+ Self::V9(t) => {
+ t.0.for_each(|key, escrow| f(&Address::from_bytes(&key.0)?, &escrow.into()))?
+ }
+ Self::V10(t) => {
+ t.0.for_each(|key, escrow| f(&Address::from_bytes(&key.0)?, &escrow.into()))?
+ }
+ Self::V11(t) => {
+ t.0.for_each(|key, escrow| f(&Address::from_bytes(&key.0)?, &escrow.into()))?
+ }
+ Self::V12(t) => t.0.for_each(|address, escrow| {
+ f(&address.into(), &escrow.into())
+ .map_err(|e| fil_actors_shared::v12::ActorError::unspecified(e.to_string()))
+ })?,
+ Self::V13(t) => t.0.for_each(|address, escrow| {
+ f(&address.into(), &escrow.into())
+ .map_err(|e| fil_actors_shared::v13::ActorError::unspecified(e.to_string()))
+ })?,
+ };
+ Ok(())
+ }
+}

src/shim/actors/mod.rs

@@ -0,0 +1,4 @@
+// Copyright 2019-2024 ChainSafe Systems
+// SPDX-License-Identifier: Apache-2.0, MIT
+
+pub mod market;

src/shim/mod.rs

@@ -1,6 +1,7 @@
 // Copyright 2019-2024 ChainSafe Systems
 // SPDX-License-Identifier: Apache-2.0, MIT
 
+pub mod actors;
 pub mod address;
 pub mod bigint;
 pub mod clock;

src/state_manager/mod.rs

@@ -193,10 +193,10 @@ impl TipsetStateCache {
 pub struct MarketBalance {
  #[schemars(with = "LotusJson<TokenAmount>")]
  #[serde(with = "crate::lotus_json")]
- escrow: TokenAmount,
+ pub escrow: TokenAmount,
  #[schemars(with = "LotusJson<TokenAmount>")]
  #[serde(with = "crate::lotus_json")]
- locked: TokenAmount,
+ pub locked: TokenAmount,
 }
 lotus_json_with_self!(MarketBalance);
 
@@ -1019,19 +1019,16 @@ where
  .ok_or_else(|| Error::Other(format!("Failed to lookup the id address {addr}")))
  }
 
- /// Retrieves market balance in escrow and locked tables.
- pub fn market_balance(
- &self,
- addr: &Address,
- ts: &Tipset,
- ) -> anyhow::Result<MarketBalance, Error> {
- let actor = self
- .get_actor(&Address::MARKET_ACTOR, *ts.parent_state())?
- .ok_or_else(|| {
- Error::State("Market actor address could not be resolved".to_string())
- })?;
-
+ /// Retrieves market state
+ pub fn market_state(&self, ts: &Tipset) -> Result<market::State, Error> {
+ let actor = self.get_required_actor(&Address::MARKET_ACTOR, *ts.parent_state())?;
  let market_state = market::State::load(self.blockstore(), actor.code, actor.state)?;
+ Ok(market_state)
+ }
+
+ /// Retrieves market balance in escrow and locked tables.
+ pub fn market_balance(&self, addr: &Address, ts: &Tipset) -> Result<MarketBalance, Error> {
+ let market_state = self.market_state(ts)?;
 
  let new_addr = self
  .lookup_id(addr, ts)?

src/tool/subcommands/api_cmd.rs

@@ -729,6 +729,7 @@ fn state_tests_with_tipset<DB: Blockstore>(
  RpcTest::identity(StateVMCirculatingSupplyInternal::request((tipset
  .key()
  .into(),))?),
+ RpcTest::identity(StateMarketParticipants::request((tipset.key().into(),))?),
  ];
 
  // Get deals