fix: 🩹 fix merge from main

runtime/src/apis.rs

@@ -9,7 +9,8 @@ use pallet_payment_streams_runtime_api::*;
 use pallet_proofs_dealer::types::{KeyFor, ProviderIdFor, RandomnessOutputFor};
 use pallet_proofs_dealer_runtime_api::*;
 use pallet_storage_providers::types::{
-    BackupStorageProvider, BackupStorageProviderId, ProviderId, StorageDataUnit, StorageProviderId,
+    BackupStorageProvider, BackupStorageProviderId, BucketId, MainStorageProviderId, ProviderId,
+    StorageDataUnit, StorageProviderId,
 };
 use pallet_storage_providers_runtime_api::*;
 use shp_file_metadata::ChunkId;
@@ -24,13 +25,6 @@ use sp_runtime::{
 };
 use sp_std::prelude::Vec;
 use sp_version::RuntimeVersion;
-use xcm::{
-    latest::prelude::AssetId, VersionedAssetId, VersionedAssets, VersionedLocation, VersionedXcm,
-};
-use xcm_fee_payment_runtime_api::{
-    dry_run::{CallDryRunEffects, Error as XcmDryRunApiError, XcmDryRunEffects},
-    fees::Error as XcmPaymentApiError,
-};
 
 // Local module imports
 use super::{
@@ -186,45 +180,6 @@ impl_runtime_apis! {
         }
     }
 
-    impl xcm_fee_payment_runtime_api::fees::XcmPaymentApi<Block> for Runtime {
-        fn query_acceptable_payment_assets(xcm_version: xcm::Version) -> Result<Vec<VersionedAssetId>, XcmPaymentApiError> {
-
-            let acceptable_assets = vec![AssetId(configs::xcm_config::RelayLocation::get())];
-            PolkadotXcm::query_acceptable_payment_assets(xcm_version, acceptable_assets)
-        }
-        fn query_weight_to_asset_fee(weight: Weight, asset: VersionedAssetId) -> Result<u128, XcmPaymentApiError> {
-            match asset.try_as::<AssetId>() {
-                Ok(asset_id) if asset_id.0 == configs::xcm_config::RelayLocation::get() => {
-                    // for native token
-                    Ok(<WeightToFee as sp_weights::WeightToFee>::weight_to_fee(&weight))
-                },
-                Ok(asset_id) => {
-                    log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - unhandled asset_id: {asset_id:?}!");
-                    Err(XcmPaymentApiError::AssetNotFound)
-                },
-                Err(_) => {
-                    log::trace!(target: "xcm::xcm_fee_payment_runtime_api", "query_weight_to_asset_fee - failed to convert asset: {asset:?}!");
-                    Err(XcmPaymentApiError::VersionedConversionFailed)
-                }
-            }
-        }
-        fn query_xcm_weight(message: VersionedXcm<()>) -> Result<Weight, XcmPaymentApiError> {
-            PolkadotXcm::query_xcm_weight(message)
-        }
-        fn query_delivery_fees(destination: VersionedLocation, message: VersionedXcm<()>) -> Result<VersionedAssets, XcmPaymentApiError> {
-            PolkadotXcm::query_delivery_fees(destination, message)
-        }
-    }
-
-    impl xcm_fee_payment_runtime_api::dry_run::DryRunApi<Block, RuntimeCall, RuntimeEvent, OriginCaller> for Runtime {
-        fn dry_run_call(origin: OriginCaller, call: RuntimeCall) -> Result<CallDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-            PolkadotXcm::dry_run_call::<Runtime, configs::xcm_config::XcmRouter, OriginCaller, RuntimeCall>(origin, call)
-        }
-        fn dry_run_xcm(origin_location: VersionedLocation, xcm: VersionedXcm<RuntimeCall>) -> Result<XcmDryRunEffects<RuntimeEvent>, XcmDryRunApiError> {
-            PolkadotXcm::dry_run_xcm::<Runtime, configs::xcm_config::XcmRouter, RuntimeCall, configs::xcm_config::XcmConfig>(origin_location, xcm)
-        }
-    }
-
     impl cumulus_primitives_core::CollectCollationInfo<Block> for Runtime {
         fn collect_collation_info(header: &<Block as BlockT>::Header) -> cumulus_primitives_core::CollationInfo {
             ParachainSystem::collect_collation_info(header)
@@ -314,14 +269,18 @@ impl_runtime_apis! {
         }
     }
 
-    impl pallet_file_system_runtime_api::FileSystemApi<Block, BackupStorageProviderId<Runtime>, H256, BlockNumber, ChunkId> for Runtime {
+    impl pallet_file_system_runtime_api::FileSystemApi<Block, BackupStorageProviderId<Runtime>, MainStorageProviderId<Runtime>, H256, BlockNumber, ChunkId> for Runtime {
         fn query_earliest_file_volunteer_tick(bsp_id: BackupStorageProviderId<Runtime>, file_key: H256) -> Result<BlockNumber, QueryFileEarliestVolunteerTickError> {
             FileSystem::query_earliest_file_volunteer_tick(bsp_id, file_key)
         }
 
         fn query_bsp_confirm_chunks_to_prove_for_file(bsp_id: BackupStorageProviderId<Runtime>, file_key: H256) -> Result<Vec<ChunkId>, QueryBspConfirmChunksToProveForFileError> {
             FileSystem::query_bsp_confirm_chunks_to_prove_for_file(bsp_id, file_key)
         }
+
+        fn query_msp_confirm_chunks_to_prove_for_file(msp_id: MainStorageProviderId<Runtime>, file_key: H256) -> Result<Vec<ChunkId>, QueryMspConfirmChunksToProveForFileError> {
+            FileSystem::query_msp_confirm_chunks_to_prove_for_file(msp_id, file_key)
+        }
     }
 
     impl pallet_payment_streams_runtime_api::PaymentStreamsApi<Block, ProviderIdFor<Runtime>, Balance, AccountId> for Runtime {
@@ -377,7 +336,7 @@ impl_runtime_apis! {
         }
     }
 
-    impl pallet_storage_providers_runtime_api::StorageProvidersApi<Block, BlockNumber, BackupStorageProviderId<Runtime>, BackupStorageProvider<Runtime>, AccountId, ProviderId<Runtime>, StorageProviderId<Runtime>, StorageDataUnit<Runtime>, Balance> for Runtime {
+    impl pallet_storage_providers_runtime_api::StorageProvidersApi<Block, BlockNumber, BackupStorageProviderId<Runtime>, BackupStorageProvider<Runtime>, AccountId, ProviderId<Runtime>, StorageProviderId<Runtime>, StorageDataUnit<Runtime>, Balance, BucketId<Runtime>> for Runtime {
         fn get_bsp_info(bsp_id: &BackupStorageProviderId<Runtime>) -> Result<BackupStorageProvider<Runtime>, GetBspInfoError> {
             Providers::get_bsp_info(bsp_id)
         }
@@ -386,6 +345,10 @@ impl_runtime_apis! {
             Providers::get_storage_provider_id(who)
         }
 
+        fn query_msp_id_of_bucket_id(bucket_id: &BucketId<Runtime>) -> Result<ProviderId<Runtime>, QueryMspIdOfBucketIdError> {
+            Providers::query_msp_id_of_bucket_id(bucket_id)
+        }
+
         fn query_storage_provider_capacity(provider_id: &ProviderId<Runtime>) -> Result<StorageDataUnit<Runtime>, QueryStorageProviderCapacityError> {
             Providers::query_storage_provider_capacity(provider_id)
         }
@@ -401,5 +364,9 @@ impl_runtime_apis! {
         fn get_worst_case_scenario_slashable_amount(provider_id: ProviderId<Runtime>) -> Option<Balance> {
             Providers::get_worst_case_scenario_slashable_amount(&provider_id).ok()
         }
+
+        fn get_slash_amount_per_max_file_size() -> Balance {
+            Providers::get_slash_amount_per_max_file_size()
+        }
     }
 }

runtime/src/configs/mod.rs

@@ -28,8 +28,8 @@ pub mod xcm_config;
 
 // Substrate and Polkadot dependencies
 use core::marker::PhantomData;
-use cumulus_pallet_parachain_system::RelayNumberMonotonicallyIncreases;
-use cumulus_primitives_core::{AggregateMessageOrigin, ParaId};
+use cumulus_pallet_parachain_system::{RelayChainStateProof, RelayNumberMonotonicallyIncreases};
+use cumulus_primitives_core::{relay_chain::well_known_keys, AggregateMessageOrigin, ParaId};
 use frame_support::{
     derive_impl,
     dispatch::DispatchClass,
@@ -58,7 +58,7 @@ use shp_file_metadata::{ChunkId, FileMetadata};
 use shp_forest_verifier::ForestVerifier;
 use shp_traits::{CommitmentVerifier, MaybeDebug};
 use sp_consensus_aura::sr25519::AuthorityId as AuraId;
-use sp_core::{blake2_256, ConstU128, Get, Hasher, H256};
+use sp_core::{ConstU128, Get, Hasher, H256};
 use sp_runtime::{
     traits::{BlakeTwo256, Convert, ConvertBack, Verify},
     AccountId32, DispatchError, Perbill, SaturatedConversion,
@@ -73,8 +73,8 @@ use xcm::latest::prelude::BodyId;
 use crate::{
     weights::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight},
     AccountId, Aura, Balance, Balances, Block, BlockNumber, BucketNfts, CollatorSelection, Hash,
-    MessageQueue, Nfts, Nonce, PalletInfo, ParachainSystem, PaymentStreams, PolkadotXcm,
-    ProofsDealer, Providers, Runtime, RuntimeCall, RuntimeEvent, RuntimeFreezeReason,
+    MessageQueue, Nfts, Nonce, PalletInfo, ParachainInfo, ParachainSystem, PaymentStreams,
+    PolkadotXcm, ProofsDealer, Providers, Runtime, RuntimeCall, RuntimeEvent, RuntimeFreezeReason,
     RuntimeHoldReason, RuntimeOrigin, RuntimeTask, Session, SessionKeys, Signature, System,
     WeightToFee, XcmpQueue, AVERAGE_ON_INITIALIZE_RATIO, BLOCK_PROCESSING_VELOCITY, DAYS,
     EXISTENTIAL_DEPOSIT, HOURS, MAXIMUM_BLOCK_WEIGHT, MICROUNIT, MINUTES, NORMAL_DISPATCH_RATIO,
@@ -393,7 +393,7 @@ fn relay_chain_state_proof() -> RelayChainStateProof {
         .expect("set in `set_validation_data`");
     RelayChainStateProof::new(ParachainInfo::get(), relay_storage_root, relay_chain_state)
         .expect("Invalid relay chain state proof, already constructed in `set_validation_data`")
-} */
+}
 
 pub struct BabeDataGetter;
 impl pallet_randomness::GetBabeData<u64, Hash> for BabeDataGetter {
@@ -408,13 +408,11 @@ impl pallet_randomness::GetBabeData<u64, Hash> for BabeDataGetter {
             const BENCHMARKING_NEW_EPOCH: u64 = 10u64;
             return BENCHMARKING_NEW_EPOCH;
         }
-        // CRITICAL TODO: Uncomment this after upgrading to polkadot-sdk v1.13.0 and remove frame_system::Pallet::<Runtime>::block_number().into()
-        /* relay_chain_state_proof()
-        .read_optional_entry(well_known_keys::EPOCH_INDEX)
-        .ok()
-        .flatten()
-        .expect("expected to be able to read epoch index from relay chain state proof") */
-        frame_system::Pallet::<Runtime>::block_number().into()
+        relay_chain_state_proof()
+            .read_optional_entry(well_known_keys::EPOCH_INDEX)
+            .ok()
+            .flatten()
+            .expect("expected to be able to read epoch index from relay chain state proof")
     }
     fn get_epoch_randomness() -> Hash {
         if cfg!(feature = "runtime-benchmarks") {
@@ -426,13 +424,11 @@ impl pallet_randomness::GetBabeData<u64, Hash> for BabeDataGetter {
             let benchmarking_babe_output = Hash::default();
             return benchmarking_babe_output;
         }
-        // CRITICAL TODO: Uncomment this after upgrading to polkadot-sdk v1.13.0 and remove H256::from_slice(&blake2_256(&Self::get_epoch_index().to_le_bytes()))
-        /* relay_chain_state_proof()
-        .read_optional_entry(well_known_keys::ONE_EPOCH_AGO_RANDOMNESS)
-        .ok()
-        .flatten()
-        .expect("expected to be able to read epoch randomness from relay chain state proof") */
-        H256::from_slice(&blake2_256(&Self::get_epoch_index().to_le_bytes()))
+        relay_chain_state_proof()
+            .read_optional_entry(well_known_keys::ONE_EPOCH_AGO_RANDOMNESS)
+            .ok()
+            .flatten()
+            .expect("expected to be able to read epoch randomness from relay chain state proof")
     }
     fn get_parent_randomness() -> Hash {
         if cfg!(feature = "runtime-benchmarks") {
@@ -446,15 +442,11 @@ impl pallet_randomness::GetBabeData<u64, Hash> for BabeDataGetter {
         }
         // Note: we use the `CURRENT_BLOCK_RANDOMNESS` key here as it also represents the parent randomness, the only difference
         // is the block since this randomness is valid, but we don't care about that because we are setting that directly in the `randomness` pallet.
-        /* relay_chain_state_proof()
-        .read_optional_entry(well_known_keys::CURRENT_BLOCK_RANDOMNESS)
-        .ok()
-        .flatten()
-        .expect("expected to be able to read parent randomness from relay chain state proof") */
-        // CRITICAL TODO: Uncomment this after upgrading to polkadot-sdk v1.13.0 and remove H256::from_slice(&blake2_256(&Self::get_epoch_index().saturating_sub(1).to_le_bytes()))
-        H256::from_slice(&blake2_256(
-            &Self::get_epoch_index().saturating_sub(1).to_le_bytes(),
-        ))
+        relay_chain_state_proof()
+            .read_optional_entry(well_known_keys::CURRENT_BLOCK_RANDOMNESS)
+            .ok()
+            .flatten()
+            .expect("expected to be able to read parent randomness from relay chain state proof")
     }
 }