Handle polkadot forks

README.md

@@ -11,6 +11,11 @@ cargo build --release
 ```
 
 To execute the chain, run:
+error:
+Service(Client(Storage("wasm call error Other: Exported method GenesisBuilder_get_preset is not found")))
+
+need to fix with
+https://substrate.stackexchange.com/questions/10690/building-a-chain-specification-with-raw-gives-me-wasm-call-error-other-expo
 
 ```bash
 ./target/release/creditcoin3-node --dev

client/rpc/debug/Cargo.toml

@@ -8,6 +8,8 @@ version = { workspace = true }
 license = "GPL-3.0-only"
 
 [dependencies]
+parity-scale-codec = { workspace = true }
+fp-storage = { workspace = true }
 futures = { workspace = true, features = ["compat"] }
 hex-literal = { workspace = true }
 jsonrpsee = { workspace = true, features = ["macros", "server"] }

client/rpc/debug/src/lib.rs

@@ -16,6 +16,7 @@
 pub use creditcoin3_rpc_core_debug::{DebugServer, TraceParams};
 use futures::StreamExt;
 use jsonrpsee::core::{async_trait, RpcResult};
+use fc_storage::StorageOverride;
 
 use tokio::{
     self,
@@ -26,11 +27,14 @@ use creditcoin3_client_evm_tracing::{formatters::ResponseFormatter, types::singl
 use creditcoin3_rpc_core_types::{RequestBlockId, RequestBlockTag};
 use creditcoin3_rpc_primitives_debug::{DebugRuntimeApi, TracerInput};
 use ethereum_types::H256;
-use fc_rpc::{frontier_backend_client, internal_err, OverrideHandle};
+// use fc_rpc::{frontier_backend_client, internal_err, OverrideHandle};
+use fc_rpc::{frontier_backend_client, internal_err};
 use fp_rpc::EthereumRuntimeRPCApi;
 use sc_client_api::backend::{Backend, StateBackend, StorageProvider};
 use sc_utils::mpsc::TracingUnboundedSender;
-use sp_api::{ApiExt, BlockId, Core, HeaderT, ProvideRuntimeApi};
+use sp_runtime::generic::BlockId;
+use sp_runtime::traits::Header as HeaderT;
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{
     Backend as BlockchainBackend, Error as BlockChainError, HeaderBackend, HeaderMetadata,
@@ -147,7 +151,7 @@ where
         backend: Arc<BE>,
         frontier_backend: Arc<dyn fc_api::Backend<B> + Send + Sync>,
         permit_pool: Arc<Semaphore>,
-        overrides: Arc<OverrideHandle<B>>,
+        overrides: Arc<dyn StorageOverride<B>>,
         raw_max_memory_usage: usize,
     ) -> (impl Future<Output = ()>, DebugRequester) {
         let (tx, mut rx): (DebugRequester, _) =
@@ -288,7 +292,7 @@ where
         frontier_backend: Arc<dyn fc_api::Backend<B> + Send + Sync>,
         request_block_id: RequestBlockId,
         params: Option<TraceParams>,
-        overrides: Arc<OverrideHandle<B>>,
+        overrides: Arc<dyn StorageOverride<B>>,
     ) -> RpcResult<Response> {
         let (tracer_input, trace_type) = Self::handle_params(params)?;
 
@@ -332,21 +336,14 @@ where
         // Get parent blockid.
         let parent_block_hash = *header.parent_hash();
 
-        let schema = fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), hash);
+        // let schema = fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), hash);
+        // let schema = client.storage_schema::<B, C, BE>(hash);
 
         // Using storage overrides we align with `:ethereum_schema` which will result in proper
         // SCALE decoding in case of migration.
-        let statuses = match overrides.schemas.get(&schema) {
-            Some(schema) => schema
-                .current_transaction_statuses(hash)
-                .unwrap_or_default(),
-            _ => {
-                return Err(internal_err(format!(
-                    "No storage override at {:?}",
-                    reference_id
-                )))
-            }
-        };
+        let statuses = overrides
+            .current_transaction_statuses(hash)
+            .unwrap_or_default();
 
         // Known ethereum transaction hashes.
         let eth_tx_hashes: Vec<_> = statuses.iter().map(|t| t.transaction_hash).collect();
@@ -422,7 +419,7 @@ where
         frontier_backend: Arc<dyn fc_api::Backend<B> + Send + Sync>,
         transaction_hash: H256,
         params: Option<TraceParams>,
-        overrides: Arc<OverrideHandle<B>>,
+        overrides: Arc<dyn StorageOverride<B>>,
         raw_max_memory_usage: usize,
     ) -> RpcResult<Response> {
         let (tracer_input, trace_type) = Self::handle_params(params)?;
@@ -481,20 +478,19 @@ where
             ));
         };
 
-        let schema =
-            fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), reference_hash);
+        // let x = client.storage(reference_hash, &sc_client_api::StorageKey(b":ethereum_schema".to_vec()));
+        // let schema = match x {
+        //     Ok(Some(bytes)) => parity_scale_codec::Decode::decode(&mut &bytes.0[..])
+        //         .ok()
+        //         .unwrap_or(fp_storage::EthereumStorageSchema::Undefined),
+        //     _ => fp_storage::EthereumStorageSchema::Undefined,
+        // };
+        // let schema = fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), reference_hash);
+
 
         // Get the block that contains the requested transaction. Using storage overrides we align
         // with `:ethereum_schema` which will result in proper SCALE decoding in case of migration.
-        let reference_block = match overrides.schemas.get(&schema) {
-            Some(schema) => schema.current_block(reference_hash),
-            _ => {
-                return Err(internal_err(format!(
-                    "No storage override at {:?}",
-                    reference_hash
-                )))
-            }
-        };
+        let reference_block = overrides.current_block(reference_hash);
 
         // Get the actual ethereum transaction.
         if let Some(block) = reference_block {

client/rpc/trace/Cargo.toml

@@ -8,6 +8,7 @@ version = { workspace = true }
 license = "GPL-3.0-only"
 
 [dependencies]
+parity-scale-codec = { workspace = true }
 ethereum = { workspace = true, features = ["with-codec"] }
 ethereum-types = { workspace = true }
 futures = { workspace = true }
@@ -43,3 +44,4 @@ fc-rpc = { workspace = true, features = ["rpc-binary-search-estimate"] }
 fc-rpc-core = { workspace = true }
 fc-storage = { workspace = true }
 fp-rpc = { workspace = true }
+fp-storage = { workspace = true }

client/rpc/trace/src/lib.rs

@@ -30,11 +30,13 @@
     sync::{mpsc, oneshot, Semaphore},
     time::sleep,
 };
+use fc_storage::StorageOverride;
 use tracing::{instrument, Instrument};
 
-use sc_client_api::backend::{Backend, StateBackend, StorageProvider};
+use sc_client_api::{backend::{Backend, StateBackend, StorageProvider}, StorageKey};
 use sc_utils::mpsc::TracingUnboundedSender;
-use sp_api::{ApiExt, Core, HeaderT, ProvideRuntimeApi};
+use sp_runtime::traits::{Header as HeaderT};
+use sp_api::{ApiExt, Core, ProvideRuntimeApi};
 use sp_block_builder::BlockBuilder;
 use sp_blockchain::{
     Backend as BlockchainBackend, Error as BlockChainError, HeaderBackend, HeaderMetadata,
@@ -45,7 +47,7 @@
 };
 
 use ethereum_types::H256;
-use fc_rpc::OverrideHandle;
+// use fc_rpc::OverrideHandle;
 use fp_rpc::EthereumRuntimeRPCApi;
 
 use creditcoin3_client_evm_tracing::{
@@ -442,7 +444,7 @@
         backend: Arc<BE>,
         cache_duration: Duration,
         blocking_permits: Arc<Semaphore>,
-        overrides: Arc<OverrideHandle<B>>,
+        overrides: Arc<dyn StorageOverride<B>>,
         prometheus: Option<PrometheusRegistry>,
     ) -> (impl Future<Output = ()>, CacheRequester) {
         // Communication with the outside world :
@@ -535,7 +537,7 @@
         blocking_tx: &mpsc::Sender<BlockingTaskMessage>,
         sender: oneshot::Sender<CacheBatchId>,
         blocks: Vec<H256>,
-        overrides: Arc<OverrideHandle<B>>,
+        overrides: Arc<dyn StorageOverride<B>>,
     ) {
         tracing::trace!("Starting batch {}", self.next_batch_id);
         self.batches.insert(self.next_batch_id, blocks.clone());
@@ -792,7 +794,7 @@
         client: Arc<C>,
         backend: Arc<BE>,
         substrate_hash: H256,
-        overrides: Arc<OverrideHandle<B>>,
+        overrides: Arc<dyn StorageOverride<B>>,
     ) -> TxsTraceRes {
         // Get Subtrate block data.
         let api = client.runtime_api();
@@ -809,25 +811,29 @@
         let height = *block_header.number();
         let substrate_parent_hash = *block_header.parent_hash();
 
-        let schema =
-            fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), substrate_hash);
+        // let x = client.storage(substrate_hash, &StorageKey(b":ethereum_schema".to_vec()));
+        // let schema = match x {
+        //     Ok(Some(bytes)) => parity_scale_codec::Decode::decode(&mut &bytes.0[..])
+        //         .ok()
+        //         .unwrap_or(fp_storage::EthereumStorageSchema::Undefined),
+        //     _ => fp_storage::EthereumStorageSchema::Undefined,
+        // };
+        // let schema =
+        //     fc_storage::onchain_storage_schema::<B, C, BE>(client.as_ref(), substrate_hash);
 
         // Get Ethereum block data.
-        let (eth_block, eth_transactions) = match overrides.schemas.get(&schema) {
-            Some(schema) => match (
-                schema.current_block(substrate_hash),
-                schema.current_transaction_statuses(substrate_hash),
-            ) {
-                (Some(a), Some(b)) => (a, b),
-                _ => {
-                    return Err(format!(
-                        "Failed to get Ethereum block data for Substrate block {}",
-                        substrate_hash
-                    ))
-                }
-            },
-            _ => return Err(format!("No storage override at {:?}", substrate_hash)),
-        };
+        let (eth_block, eth_transactions) = match (
+			overrides.current_block(substrate_hash),
+			overrides.current_transaction_statuses(substrate_hash),
+		) {
+			(Some(a), Some(b)) => (a, b),
+			_ => {
+				return Err(format!(
+					"Failed to get Ethereum block data for Substrate block {}",
+					substrate_hash
+				))
+			}
+		};
 
         let eth_block_hash = eth_block.header.hash();
         let eth_tx_hashes = eth_transactions

node/Cargo.toml

@@ -15,6 +15,7 @@ build = "build.rs"
 targets = ["x86_64-unknown-linux-gnu"]
 
 [dependencies]
+serde_json = { workspace = true }
 async-trait = { workspace = true }
 clap = { workspace = true }
 futures = { workspace = true }