update to latest polkadot-sdk

.github/scripts/matrices.py

@@ -130,6 +130,8 @@ def main():
 
                 if profile == "isolate":
                     flags += " --features=isolate-by-default"
+                if target == t_windows:
+                    flags += " --no-default-features"
                 name += os_str
 
                 obj = Expanded(

crates/anvil-polkadot/src/substrate_node/service/consensus.rs

@@ -2,6 +2,7 @@ use polkadot_sdk::{
     sc_consensus::BlockImportParams,
     sc_consensus_aura::CompatibleDigestItem,
     sc_consensus_manual_seal::{ConsensusDataProvider, Error},
+    sp_api::StorageProof,
     sp_consensus_aura::ed25519::AuthoritySignature,
     sp_consensus_babe::Slot,
     sp_inherents::InherentData,
@@ -16,23 +17,20 @@ use std::marker::PhantomData;
 /// forking from an assethub chain, we expect an assethub runtime based on AURA,
 /// which will pick the author based on the slot given through the digest, which will
 /// also result in picking the AURA authority from index 0.
-pub struct SameSlotConsensusDataProvider<B, P> {
-    _phantom: PhantomData<(B, P)>,
+pub struct SameSlotConsensusDataProvider<B> {
+    _phantom: PhantomData<B>,
 }
 
-impl<B, P> SameSlotConsensusDataProvider<B, P> {
+impl<B> SameSlotConsensusDataProvider<B> {
     pub fn new() -> Self {
         Self { _phantom: PhantomData }
     }
 }
 
-impl<B, P> ConsensusDataProvider<B> for SameSlotConsensusDataProvider<B, P>
+impl<B> ConsensusDataProvider<B> for SameSlotConsensusDataProvider<B>
 where
     B: BlockT,
-    P: Send + Sync,
 {
-    type Proof = P;
-
     fn create_digest(
         &self,
         _parent: &B::Header,
@@ -50,7 +48,7 @@ where
         _parent: &B::Header,
         _params: &mut BlockImportParams<B>,
         _inherents: &InherentData,
-        _proof: Self::Proof,
+        _proof: StorageProof,
     ) -> Result<(), Error> {
         Ok(())
     }

crates/anvil-polkadot/tests/it/gas.rs

@@ -95,7 +95,7 @@ async fn test_set_next_fee_multiplier(#[case] rpc_driven: bool) {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_next_fee_multiplier_minimum() {
     // 1e18 denomination.
-    let new_base_fee = U256::from(50_123);
+    let new_base_fee = U256::from(50_1230);
     let anvil_node_config =
         AnvilNodeConfig::test_config().with_base_fee(Some(new_base_fee.to::<u64>()));
     let substrate_node_config = SubstrateNodeConfig::new(&anvil_node_config);

crates/anvil-polkadot/tests/it/standard_rpc.rs

@@ -174,7 +174,7 @@ async fn test_gas_price() {
 
     let gas_price =
         unwrap_response::<U256>(node.eth_rpc(EthRequest::EthGasPrice(())).await.unwrap()).unwrap();
-    assert_eq!(gas_price, U256::from(1000000));
+    assert_eq!(gas_price, U256::from(10000000));
 }
 
 #[tokio::test(flavor = "multi_thread")]

crates/revive-env/src/lib.rs

@@ -18,7 +18,7 @@ use polkadot_sdk::{
     sp_tracing,
 };
 
-pub use crate::runtime::{AccountId, Balance, BlockAuthor, Runtime, System, Timestamp};
+pub use crate::runtime::{AccountId, Balance, BlockAuthor, GasScale, Runtime, System, Timestamp};
 
 mod runtime;
 

crates/revive-env/src/runtime.rs

@@ -61,9 +61,10 @@ impl pallet_timestamp::Config for Runtime {}
 parameter_types! {
     pub const UnstableInterface: bool = true;
     pub const DepositPerByte: Balance = 1;
-    pub const DepositPerItem: Balance = 2;
+    pub const DepositPerItem: Balance = 1;
     pub const CodeHashLockupDepositPercent: Perbill = Perbill::from_percent(0);
     pub const NativeToEthRatio: u32 = 1_000_000;
+    pub const GasScale : u32 = u32::MAX;
     pub BlockWeights: frame_system::limits::BlockWeights =
         frame_system::limits::BlockWeights::simple_max(
             Weight::from_parts(2u64 * WEIGHT_REF_TIME_PER_SECOND, u64::MAX),
@@ -88,6 +89,7 @@ impl pallet_revive::Config for Runtime {
     type NativeToEthRatio = NativeToEthRatio;
     type FindAuthor = Self;
     type DebugEnabled = ConstBool<true>;
+    type GasScale = GasScale;
 }
 
 parameter_types! {

crates/revive-strategy/src/cheatcodes/mod.rs

@@ -28,12 +28,11 @@ use tracing::warn;
 use alloy_eips::eip7702::SignedAuthorization;
 use polkadot_sdk::{
     pallet_revive::{
-        AccountInfo, AddressMapper, BalanceOf, BytecodeType, Code, ContractInfo, DebugSettings,
-        ExecConfig, Pallet, evm::CallTrace,
+        self, AccountInfo, AddressMapper, BalanceOf, BytecodeType, Code, ContractInfo,
+        DebugSettings, ExecConfig, Executable, Pallet, ResourceMeter, evm::CallTrace,
     },
     polkadot_sdk_frame::prelude::OriginFor,
-    sp_core::{self, H160, H256},
-    sp_io,
+    sp_core::{self, H160},
     sp_weights::Weight,
 };
 
@@ -704,12 +703,16 @@ fn select_revive(ctx: &mut PvmCheatcodeInspectorStrategyContext, data: Ecx<'_, '
                                     Pallet::<Runtime>::account_id(),
                                     code_bytes.clone(),
                                     code_type,
-                                    u64::MAX.into(),
+                                    &mut ResourceMeter::new(pallet_revive::TransactionLimits::WeightAndDeposit {
+                                        weight_limit: Weight::MAX,
+                                        deposit_limit: BalanceOf::<Runtime>::MAX,
+                                    })
+                                    .unwrap(),
                                     &ExecConfig::new_substrate_tx(),
                                 );
                                 match upload_result {
-                                    Ok(_) => {
-                                        let code_hash = H256(sp_io::hashing::keccak_256(&code_bytes));
+                                    Ok(upload_res) => {
+                                        let code_hash = upload_res.code_hash().to_owned();
                                         let contract_info = ContractInfo::<Runtime>::new(&account_h160, nonce as u32, code_hash)
                                             .expect("Failed to create contract info");
                                         AccountInfo::<Runtime>::insert_contract(&account_h160, contract_info);
@@ -742,13 +745,17 @@ fn select_revive(ctx: &mut PvmCheatcodeInspectorStrategyContext, data: Ecx<'_, '
                                 Pallet::<Runtime>::account_id(),
                                 code_bytes.clone(),
                                 BytecodeType::Evm,
-                                u64::MAX.into(),
+                                &mut ResourceMeter::new(pallet_revive::TransactionLimits::WeightAndDeposit {
+                                    weight_limit: Weight::MAX,
+                                    deposit_limit: BalanceOf::<Runtime>::MAX,
+                                })
+                                .unwrap(),
                                 &ExecConfig::new_substrate_tx_without_bump(),
                             );
                             match upload_result {
-                                Ok(_) => {
-                                    let code_hash = H256(sp_io::hashing::keccak_256(&code_bytes));
-                                    let contract_info = ContractInfo::<Runtime>::new(&account_h160, nonce as u32, code_hash)
+                                Ok(upload_res) => {
+                                    let code_hash = upload_res.code_hash();
+                                    let contract_info = ContractInfo::<Runtime>::new(&account_h160, nonce as u32, code_hash.to_owned())
                                         .expect("Failed to create contract info");
                                     AccountInfo::<Runtime>::insert_contract(&account_h160, contract_info);
                                 }
@@ -949,6 +956,7 @@ impl foundry_cheatcodes::CheatcodeInspectorStrategyExt for PvmCheatcodeInspector
                 let origin = OriginFor::<Runtime>::signed(origin_account_id.clone());
                 let evm_value = sp_core::U256::from_little_endian(&input.value().as_le_bytes());
                 mock_handler.fund_pranked_accounts(input.caller());
+
                 System::inc_account_nonce(&origin_account_id);
                 let code = Code::Upload(code_bytes.clone());
                 let data = constructor_args;
@@ -982,9 +990,10 @@ impl foundry_cheatcodes::CheatcodeInspectorStrategyExt for PvmCheatcodeInspector
                 Pallet::<Runtime>::bare_instantiate(
                     origin,
                     evm_value,
-                    Weight::MAX,
-                    // TODO: fixing.
-                    BalanceOf::<Runtime>::MAX,
+                    pallet_revive::TransactionLimits::WeightAndDeposit {
+                        weight_limit: Weight::MAX,
+                        deposit_limit: BalanceOf::<Runtime>::MAX,
+                    },
                     code,
                     data,
                     salt,
@@ -993,18 +1002,22 @@ impl foundry_cheatcodes::CheatcodeInspectorStrategyExt for PvmCheatcodeInspector
             })
         });
         let mut gas = Gas::new(input.gas_limit());
-        if res.result.as_ref().is_ok_and(|r| !r.result.did_revert()) {
-            self.append_recorded_accesses(state, ecx, tracer.get_recorded_accesses());
-        }
         post_exec(state, ecx, executor, &mut tracer, false);
+        self.append_recorded_accesses(state, ecx, tracer.get_recorded_accesses());
         mock_handler.update_state_mocks(state);
 
         match &res.result {
             Ok(result) => {
                 // Only record gas cost if gas metering is not paused.
                 // When paused, the gas counter should remain frozen.
                 if !state.gas_metering.paused {
-                    let _ = gas.record_cost(res.gas_required.ref_time());
+                    let _ = gas.record_cost(
+                        res.gas_consumed
+                            .div_euclid(<Runtime as pallet_revive::Config>::GasScale::get().into())
+                            .min(u64::MAX.into())
+                            .try_into()
+                            .unwrap(),
+                    );
                 }
 
                 let outcome = if result.result.did_revert() {
@@ -1131,27 +1144,32 @@ impl foundry_cheatcodes::CheatcodeInspectorStrategyExt for PvmCheatcodeInspector
                     origin,
                     target,
                     evm_value,
-                    Weight::MAX,
-                    // TODO: fixing.
-                    BalanceOf::<Runtime>::MAX,
+                    pallet_revive::TransactionLimits::WeightAndDeposit {
+                        weight_limit: Weight::MAX,
+                        deposit_limit: if call.is_static { 0 } else { BalanceOf::<Runtime>::MAX },
+                    },
                     call.input.bytes(ecx).to_vec(),
                     exec_config,
                 )
             })
         });
         mock_handler.update_state_mocks(state);
         let mut gas = Gas::new(call.gas_limit);
-        if res.result.as_ref().is_ok_and(|r| !r.did_revert()) {
-            self.append_recorded_accesses(state, ecx, tracer.get_recorded_accesses());
-        }
         post_exec(state, ecx, executor, &mut tracer, call.is_static);
+        self.append_recorded_accesses(state, ecx, tracer.get_recorded_accesses());
 
         match res.result {
             Ok(result) => {
                 // Only record gas cost if gas metering is not paused.
                 // When paused, the gas counter should remain frozen.
                 if !state.gas_metering.paused {
-                    let _ = gas.record_cost(res.gas_required.ref_time());
+                    let _ = gas.record_cost(
+                        res.gas_consumed
+                            .div_euclid(<Runtime as pallet_revive::Config>::GasScale::get().into())
+                            .min(u64::MAX.into())
+                            .try_into()
+                            .unwrap(),
+                    );
                 }
 
                 let outcome = if result.did_revert() {

crates/revive-strategy/src/state.rs

@@ -3,7 +3,7 @@ use foundry_cheatcodes::{Ecx, Error, Result};
 use polkadot_sdk::{
     pallet_revive::{
         self, AccountInfo, AddressMapper, BalanceOf, BytecodeType, ContractInfo, ExecConfig,
-        Executable, Pallet,
+        Executable, Pallet, ResourceMeter,
     },
     sp_core::{self, H160},
     sp_externalities::Externalities,
@@ -27,7 +27,10 @@ impl Default for Inner {
     fn default() -> Self {
         Self {
             externalities: ExtBuilder::default()
-                .balance_genesis_config(vec![(H160::from_low_u64_be(1), 1000)])
+                .balance_genesis_config(vec![(
+                    H160::from_low_u64_be(1),
+                    1_000_000_000_000_000_000_000_000_000_u128,
+                )])
                 .build(),
             depth: 0,
         }
@@ -142,11 +145,14 @@ impl TestEnv {
                 origin_account,
                 code,
                 code_type,
-                BalanceOf::<Runtime>::MAX,
+                &mut ResourceMeter::new(pallet_revive::TransactionLimits::WeightAndDeposit {
+                    weight_limit: Default::default(),
+                    deposit_limit: BalanceOf::<Runtime>::MAX,
+                })
+                .unwrap(),
                 &ExecConfig::new_substrate_tx(),
             )
-            .map_err(|_| <&str as Into<Error>>::into("Could not upload PVM code"))?
-            .0;
+            .map_err(|_| <&str as Into<Error>>::into("Could not upload PVM code"))?;
 
             let mut contract_info = if let Some(contract_info) =
                 AccountInfo::<Runtime>::load_contract(&target_address)

crates/revive-strategy/src/tracing/call_tracer.rs

@@ -4,7 +4,6 @@ use polkadot_sdk::{
     pallet_revive,
     pallet_revive::tracing::Tracing,
     sp_core::{H160, U256},
-    sp_weights::Weight,
 };
 
 #[derive(Debug)]
@@ -24,14 +23,16 @@ impl Tracing for ExpectedCallTracer {
         &mut self,
         _from: H160,
         to: H160,
-        _is_delegate_call: bool,
+        is_delegate_call: Option<H160>,
         _is_read_only: bool,
         value: U256,
         input: &[u8],
-        _gas: Weight,
+        _gas: U256,
     ) {
+        let addr =
+            is_delegate_call.map(|x| Address::from(x.0)).unwrap_or_else(|| Address::from(to.0));
         if !self.is_create
-            && let Some(expected_calls_for_target) = self.data.get_mut(&Address::from(to.0))
+            && let Some(expected_calls_for_target) = self.data.get_mut(&addr)
         {
             // Match every partial/full calldata
             for (calldata, (expected, actual_count)) in expected_calls_for_target {
@@ -53,9 +54,10 @@ impl Tracing for ExpectedCallTracer {
             }
         }
     }
-    fn exit_child_span(&mut self, _output: &pallet_revive::ExecReturnValue, _gas_left: Weight) {
+    fn exit_child_span(&mut self, _output: &pallet_revive::ExecReturnValue, _gas_left: U256) {
         self.is_create = false;
     }
+
     fn instantiate_code(
         &mut self,
         _code: &polkadot_sdk::pallet_revive::Code,