maybe save the powertable

Author: ukstv

fendermint/actors/blobs/shared/src/lib.rs

@@ -36,6 +36,7 @@ pub enum Method {
     GetPendingBlobs = frc42_dispatch::method_hash!("GetPendingBlobs"),
     FinalizeBlob = frc42_dispatch::method_hash!("FinalizeBlob"),
     DeleteBlob = frc42_dispatch::method_hash!("DeleteBlob"),
+    UpdatePowerTable = frc42_dispatch::method_hash!("UpdatePowerTable"),
 }
 
 pub fn buy_credit(rt: &impl Runtime, recipient: Address) -> Result<Account, ActorError> {

fendermint/actors/blobs/shared/src/params.rs

@@ -9,13 +9,18 @@ use fvm_shared::clock::ChainEpoch;
 use fvm_shared::econ::TokenAmount;
 use serde::{Deserialize, Serialize};
 
-use crate::state::{BlobStatus, Hash, PublicKey};
+use crate::state::{BlobStatus, Hash, PowerTable, PublicKey};
 
 /// Params for buying credits.
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct BuyCreditParams(pub Address);
 
+/// Push the power table to the actor.
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct UpdatePowerTableParams(pub PowerTable);
+
 /// Params for approving credit.
 #[derive(Clone, Debug, Serialize_tuple, Deserialize_tuple)]
 pub struct ApproveCreditParams {

fendermint/actors/blobs/shared/src/state.rs

@@ -140,13 +140,10 @@ pub struct Subscription {
 pub struct Power(pub u64);
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
-pub struct PowerTable(pub Vec<Validator<Power>>);
+pub struct PowerTable(pub Vec<Validator>);
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
-pub struct ValidatorKey(pub PublicKey);
-
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
-pub struct Validator<P> {
-    pub public_key: ValidatorKey,
-    pub power: P,
+pub struct Validator {
+    pub address: Address,
+    pub power: Power,
 }

fendermint/actors/blobs/src/actor.rs

@@ -4,11 +4,7 @@
 
 use std::collections::HashSet;
 
-use fendermint_actor_blobs_shared::params::{
-    AddBlobParams, ApproveCreditParams, BuyCreditParams, DeleteBlobParams, FinalizeBlobParams,
-    GetAccountParams, GetBlobParams, GetBlobStatusParams, GetPendingBlobsParams, GetStatsReturn,
-    RevokeCreditParams,
-};
+use fendermint_actor_blobs_shared::params::{AddBlobParams, ApproveCreditParams, BuyCreditParams, DeleteBlobParams, FinalizeBlobParams, GetAccountParams, GetBlobParams, GetBlobStatusParams, GetPendingBlobsParams, GetStatsReturn, RevokeCreditParams, UpdatePowerTableParams};
 use fendermint_actor_blobs_shared::state::{
     Account, Blob, BlobStatus, CreditApproval, Hash, PublicKey, Subscription,
 };
@@ -116,6 +112,13 @@ impl BlobsActor {
         })
     }
 
+    fn update_power_table(rt: &impl Runtime, params: UpdatePowerTableParams) -> Result<(), ActorError> {
+        rt.validate_immediate_caller_is(std::iter::once(&SYSTEM_ACTOR_ADDR))?;
+        rt.transaction(|st: &mut State, _rt| {
+            st.update_power_table(params.0)
+        })
+    }
+
     fn revoke_credit(rt: &impl Runtime, params: RevokeCreditParams) -> Result<(), ActorError> {
         rt.validate_immediate_caller_accept_any()?;
         let (from, actor_type) = resolve_external(rt, params.from)?;
@@ -327,6 +330,7 @@ impl ActorCode for BlobsActor {
         GetPendingBlobs => get_pending_blobs,
         FinalizeBlob => finalize_blob,
         DeleteBlob => delete_blob,
+        UpdatePowerTable => update_power_table,
         _ => fallback,
     }
 }

fendermint/actors/blobs/src/state.rs

@@ -167,6 +167,11 @@ impl State {
         Ok(approval.clone())
     }
 
+    pub fn update_power_table(&mut self, power_table: PowerTable) -> anyhow::Result<(), ActorError> {
+        self.power_table = power_table;
+        Ok(())
+    }
+
     pub fn revoke_credit(
         &mut self,
         from: Address,

fendermint/vm/interpreter/src/chain.rs

@@ -16,9 +16,9 @@ use crate::{
 use anyhow::{anyhow, bail, Context};
 use async_stm::atomically;
 use async_trait::async_trait;
-use fendermint_actor_blobs_shared::params::{GetBlobStatusParams, GetPendingBlobsParams};
-use fendermint_actor_blobs_shared::state::BlobStatus;
-use fendermint_actor_blobs_shared::Method::DebitAccounts;
+use fendermint_actor_blobs_shared::params::{GetBlobStatusParams, GetPendingBlobsParams, UpdatePowerTableParams};
+use fendermint_actor_blobs_shared::state::{BlobStatus, Power, PowerTable, Validator};
+use fendermint_actor_blobs_shared::Method::{DebitAccounts, UpdatePowerTable};
 use fendermint_actor_blobs_shared::{
     params::FinalizeBlobParams,
     Method::{FinalizeBlob, GetBlobStatus, GetPendingBlobs},
@@ -43,7 +43,7 @@ use fendermint_vm_topdown::{
 };
 use fvm_ipld_blockstore::Blockstore;
 use fvm_ipld_encoding::RawBytes;
-use fvm_shared::address::Address;
+use fvm_shared::address::{Address, Error};
 use fvm_shared::clock::ChainEpoch;
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::message::Message;
@@ -584,6 +584,41 @@ where
                     let proposer = state.validator_id().map(|id| id.to_string());
                     let proposer_ref = proposer.as_deref();
 
+                    let (_configuration_number, powers) = self.gateway_caller.current_power_table(&mut state)?;
+                    let power_table = PowerTable(powers.iter().filter_map(|validator| {
+                        let public_key = validator.public_key.0.serialize();
+                        let address = Address::new_secp256k1(&public_key);
+                        match address {
+                            Ok(address) => {
+                                let validator = Validator {
+                                    power: Power(validator.power.0),
+                                    address,
+                                };
+                                Some(validator)
+                            }
+                            Err(_) => {
+                                tracing::debug!(
+                                    "can not construct secp256k1 address from public key"
+                                );
+                                None
+                            }
+                        }
+                    }).collect());
+                    let params = RawBytes::serialize(UpdatePowerTableParams(power_table))?;
+                    let msg = Message {
+                        version: Default::default(),
+                        from: system::SYSTEM_ACTOR_ADDR,
+                        to: blobs::BLOBS_ACTOR_ADDR,
+                        sequence: 0,
+                        value: Default::default(),
+                        method_num: UpdatePowerTable as u64,
+                        params: params,
+                        gas_limit: fvm_shared::BLOCK_GAS_LIMIT,
+                        gas_fee_cap: Default::default(),
+                        gas_premium: Default::default(),
+                    };
+                    state.execute_implicit(msg)?;
+
                     atomically(|| {
                         env.parent_finality_provider
                             .set_new_finality(finality.clone(), prev_finality.clone())?;
@@ -731,6 +766,9 @@ where
     ) -> anyhow::Result<(Self::State, Self::EndOutput)> {
         let (mut state, out) = self.inner.end(state).await?;
 
+        // TODO SU Wrong
+        let a = self.gateway_caller.current_power_table(&mut state);
+
         // Update any component that needs to know about changes in the power table.
         if !out.0.is_empty() {
             let power_updates = out