Upgrade Polkadot SDK to stable2412-6

evm-tests/run-ci.sh

@@ -19,6 +19,13 @@ if [ "$i" -eq 1000 ]; then
     exit 1
 fi
 
+sleep 5
+
+if ! nc -z localhost 9944; then
+    echo "node subtensor exit, port not available"
+    exit 1
+fi
+
 cd evm-tests
 
 # required for papi in get-metadata.sh, but we cannot run yarn before papi as it adds the descriptors to the package.json which won't resolve

node/Cargo.toml

@@ -67,6 +67,7 @@ pallet-commitments = { path = "../pallets/commitments" }
 pallet-drand = { workspace = true }
 sp-crypto-ec-utils = { workspace = true }
 sp-keystore = { workspace = true, default-features = false }
+cumulus-primitives-proof-size-hostfunction =  { workspace = true, default-features =  false }
 
 
 # These dependencies are used for the subtensor's RPCs
@@ -136,6 +137,7 @@ runtime-benchmarks = [
 	"sp-runtime/runtime-benchmarks",
 	"pallet-commitments/runtime-benchmarks",
 	"pallet-drand/runtime-benchmarks",
+	"pallet-transaction-payment/runtime-benchmarks",
 ]
 pow-faucet = []
 

node/src/benchmarking.rs

@@ -123,7 +123,7 @@ pub fn create_benchmark_extrinsic(
         .checked_next_power_of_two()
         .map(|c| c / 2)
         .unwrap_or(2) as u64;
-    let extra: runtime::SignedExtra = (
+    let extra: runtime::TransactionExtensions = (
         frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
         frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
         frame_system::CheckTxVersion::<runtime::Runtime>::new(),
@@ -135,8 +135,7 @@ pub fn create_benchmark_extrinsic(
         check_nonce::CheckNonce::<runtime::Runtime>::from(nonce),
         frame_system::CheckWeight::<runtime::Runtime>::new(),
         pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
-        pallet_subtensor::SubtensorSignedExtension::<runtime::Runtime>::new(),
-        pallet_commitments::CommitmentsSignedExtension::<runtime::Runtime>::new(),
+        pallet_subtensor::SubtensorTransactionExtension::<runtime::Runtime>::new(),
         frame_metadata_hash_extension::CheckMetadataHash::<runtime::Runtime>::new(true),
     );
 
@@ -153,7 +152,6 @@ pub fn create_benchmark_extrinsic(
             (),
             (),
             (),
-            (),
             None,
         ),
     );

node/src/client.rs

@@ -1,3 +1,4 @@
+use cumulus_primitives_proof_size_hostfunction::storage_proof_size::HostFunctions as ProofSize;
 use node_subtensor_runtime::{RuntimeApi, opaque::Block};
 use sc_executor::WasmExecutor;
 
@@ -14,5 +15,6 @@ pub type HostFunctions = (
     sp_io::SubstrateHostFunctions,
     frame_benchmarking::benchmarking::HostFunctions,
     sp_crypto_ec_utils::bls12_381::host_calls::HostFunctions,
+    ProofSize,
 );
 pub type RuntimeExecutor = WasmExecutor<HostFunctions>;

node/src/command.rs

@@ -196,11 +196,12 @@ pub fn run() -> sc_cli::Result<()> {
                         let ext_builder = RemarkBuilder::new(client.clone());
 
                         cmd.run(
-                            config,
+                            config.chain_spec.name().into(),
                             client,
                             inherent_benchmark_data()?,
                             Vec::new(),
                             &ext_builder,
+                            false,
                         )
                     }
                     BenchmarkCmd::Extrinsic(cmd) => {

node/src/ethereum.rs

@@ -17,10 +17,9 @@ use sc_client_api::client::BlockchainEvents;
 use sc_network_sync::SyncingService;
 use sc_rpc::SubscriptionTaskExecutor;
 use sc_service::{Configuration, TaskManager, error::Error as ServiceError};
-use sc_transaction_pool::ChainApi;
 use sc_transaction_pool_api::TransactionPool;
 use sp_inherents::CreateInherentDataProviders;
-use sp_runtime::traits::Block as BlockT;
+use sp_runtime::{OpaqueExtrinsic, traits::BlakeTwo256, traits::Block as BlockT};
 use std::path::PathBuf;
 use std::time::Duration;
 use std::{
@@ -196,13 +195,18 @@ pub async fn spawn_frontier_tasks(
     );
 }
 
-fn extend_rpc_aet_api<P, A, CT, CIDP, EC>(
+fn extend_rpc_aet_api<P, CT, CIDP, EC>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     EC: EthConfig<Block, FullClient>,
@@ -213,7 +217,7 @@ where
     }
 
     io.merge(
-        Eth::<Block, FullClient, P, CT, FullBackend, A, CIDP, EC>::new(
+        Eth::<Block, FullClient, P, CT, FullBackend, CIDP, EC>::new(
             deps.client.clone(),
             deps.pool.clone(),
             deps.graph.clone(),
@@ -239,13 +243,18 @@ where
     Ok(())
 }
 
-fn extend_rpc_eth_filter<P, A, CT, CIDP>(
+fn extend_rpc_eth_filter<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
 {
@@ -267,9 +276,9 @@ where
 }
 
 // Function for EthPubSub merge
-fn extend_rpc_eth_pubsub<P, A, CT, CIDP>(
+fn extend_rpc_eth_pubsub<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
     subscription_task_executor: SubscriptionTaskExecutor,
     pubsub_notification_sinks: Arc<
         fc_mapping_sync::EthereumBlockNotificationSinks<
@@ -278,8 +287,13 @@ fn extend_rpc_eth_pubsub<P, A, CT, CIDP>(
     >,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -297,13 +311,18 @@ where
     Ok(())
 }
 
-fn extend_rpc_net<P, A, CT, CIDP>(
+fn extend_rpc_net<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -318,27 +337,37 @@ where
     Ok(())
 }
 
-fn extend_rpc_web3<P, A, CT, CIDP>(
+fn extend_rpc_web3<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
     io.merge(Web3::new(deps.client.clone()).into_rpc())?;
     Ok(())
 }
 
-fn extend_rpc_debug<P, A, CT, CIDP>(
+fn extend_rpc_debug<P, CT, CIDP>(
     io: &mut RpcModule<()>,
-    deps: &EthDeps<P, A, CT, CIDP>,
+    deps: &EthDeps<P, CT, CIDP>,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + 'static,
 {
@@ -355,9 +384,9 @@ where
 }
 
 /// Extend RpcModule with Eth RPCs
-pub fn create_eth<P, A, CT, CIDP, EC>(
+pub fn create_eth<P, CT, CIDP, EC>(
     mut io: RpcModule<()>,
-    deps: EthDeps<P, A, CT, CIDP>,
+    deps: EthDeps<P, CT, CIDP>,
     subscription_task_executor: SubscriptionTaskExecutor,
     pubsub_notification_sinks: Arc<
         fc_mapping_sync::EthereumBlockNotificationSinks<
@@ -366,23 +395,28 @@ pub fn create_eth<P, A, CT, CIDP, EC>(
     >,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     EC: EthConfig<Block, FullClient>,
 {
-    extend_rpc_aet_api::<P, A, CT, CIDP, EC>(&mut io, &deps)?;
-    extend_rpc_eth_filter::<P, A, CT, CIDP>(&mut io, &deps)?;
-    extend_rpc_eth_pubsub::<P, A, CT, CIDP>(
+    extend_rpc_aet_api::<P, CT, CIDP, EC>(&mut io, &deps)?;
+    extend_rpc_eth_filter::<P, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_eth_pubsub::<P, CT, CIDP>(
         &mut io,
         &deps,
         subscription_task_executor,
         pubsub_notification_sinks,
     )?;
-    extend_rpc_net::<P, A, CT, CIDP>(&mut io, &deps)?;
-    extend_rpc_web3::<P, A, CT, CIDP>(&mut io, &deps)?;
-    extend_rpc_debug::<P, A, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_net::<P, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_web3::<P, CT, CIDP>(&mut io, &deps)?;
+    extend_rpc_debug::<P, CT, CIDP>(&mut io, &deps)?;
 
     Ok(io)
 }

node/src/rpc.rs

@@ -18,11 +18,10 @@ use sc_consensus_manual_seal::EngineCommand;
 use sc_network::service::traits::NetworkService;
 use sc_network_sync::SyncingService;
 use sc_rpc::SubscriptionTaskExecutor;
-use sc_transaction_pool::{ChainApi, Pool};
 use sc_transaction_pool_api::TransactionPool;
 use sp_core::H256;
 use sp_inherents::CreateInherentDataProviders;
-use sp_runtime::traits::Block as BlockT;
+use sp_runtime::{OpaqueExtrinsic, traits::BlakeTwo256, traits::Block as BlockT};
 use subtensor_runtime_common::Hash;
 
 use crate::{
@@ -31,13 +30,13 @@ use crate::{
 };
 
 /// Extra dependencies for Ethereum compatibility.
-pub struct EthDeps<P, A: ChainApi, CT, CIDP> {
+pub struct EthDeps<P, CT, CIDP> {
     /// The client instance to use.
     pub client: Arc<FullClient>,
     /// Transaction pool instance.
     pub pool: Arc<P>,
     /// Graph pool instance.
-    pub graph: Arc<Pool<A>>,
+    pub graph: Arc<P>,
     /// Ethereum transaction converter.
     pub converter: Option<CT>,
     /// The Node authority flag
@@ -84,20 +83,20 @@ impl fc_rpc::EthConfig<Block, FullClient> for DefaultEthConfig {
 }
 
 /// Full client dependencies.
-pub struct FullDeps<P, A: ChainApi, CT, CIDP> {
+pub struct FullDeps<P, CT, CIDP> {
     /// The client instance to use.
     pub client: Arc<FullClient>,
     /// Transaction pool instance.
     pub pool: Arc<P>,
     /// Manual seal command sink
     pub command_sink: Option<mpsc::Sender<EngineCommand<Hash>>>,
     /// Ethereum-compatibility specific dependencies.
-    pub eth: EthDeps<P, A, CT, CIDP>,
+    pub eth: EthDeps<P, CT, CIDP>,
 }
 
 /// Instantiate all full RPC extensions.
-pub fn create_full<P, A, CT, CIDP>(
-    deps: FullDeps<P, A, CT, CIDP>,
+pub fn create_full<P, CT, CIDP>(
+    deps: FullDeps<P, CT, CIDP>,
     subscription_task_executor: SubscriptionTaskExecutor,
     pubsub_notification_sinks: Arc<
         fc_mapping_sync::EthereumBlockNotificationSinks<
@@ -106,8 +105,13 @@ pub fn create_full<P, A, CT, CIDP>(
     >,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
-    P: TransactionPool<Block = Block> + 'static,
-    A: ChainApi<Block = Block> + 'static,
+    P: TransactionPool<
+            Block = Block,
+            Hash = <sp_runtime::generic::Block<
+                sp_runtime::generic::Header<u32, BlakeTwo256>,
+                OpaqueExtrinsic,
+            > as BlockT>::Hash,
+        > + 'static,
     CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
     CT: fp_rpc::ConvertTransaction<<Block as BlockT>::Extrinsic> + Send + Sync + Clone + 'static,
 {
@@ -144,7 +148,7 @@ where
     }
 
     // Ethereum compatibility RPCs
-    let module = create_eth::<_, _, _, _, DefaultEthConfig>(
+    let module = create_eth::<_, _, _, DefaultEthConfig>(
         module,
         eth,
         subscription_task_executor,