mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-28 17:57:56 +00:00
Bastian Köcher
0c934a9352
* ed25519_verify: Support using dalek for historical blocks The switch from `ed25519-dalek` to `ed25519-zebra` was actually a breaking change. `ed25519-zebra` is more permissive. To support historical blocks when syncing a chain this pull request introduces an externalities extension `UseDalekExt`. This extension is just used as a signaling mechanism to `ed25519_verify` to use `ed25519-dalek` when it is present. Together with `ExtensionBeforeBlock` it can be used to setup a node in way to sync historical blocks that require `ed25519-dalek`, because they included a transaction that verified differently as when using `ed25519-zebra`. This feature can be enabled in the following way. In the chain service file, directly after the client is created, the following code should be added: ``` use sc_client_api::ExecutorProvider; client.execution_extensions().set_extensions_factory( sc_client_api::execution_extensions::ExtensionBeforeBlock::<Block, sp_io::UseDalekExt>::new(BLOCK_NUMBER_UNTIL_DALEK_SHOULD_BE_USED) ); ``` * Fix doc * More fixes * Update client/api/src/execution_extensions.rs Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com> * Fix merge and warning * Fix docs Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>
98 lines
3.0 KiB
Rust
98 lines
3.0 KiB
Rust
// This file is part of Substrate.
|
|
|
|
// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd.
|
|
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
//! A method call executor interface.
|
|
|
|
use sc_executor::{RuntimeVersion, RuntimeVersionOf};
|
|
use sp_runtime::{generic::BlockId, traits::Block as BlockT};
|
|
use sp_state_machine::{ExecutionStrategy, OverlayedChanges, StorageProof};
|
|
use std::cell::RefCell;
|
|
|
|
use crate::execution_extensions::ExecutionExtensions;
|
|
use sp_api::{ExecutionContext, ProofRecorder, StorageTransactionCache};
|
|
|
|
/// Executor Provider
|
|
pub trait ExecutorProvider<Block: BlockT> {
|
|
/// executor instance
|
|
type Executor: CallExecutor<Block>;
|
|
|
|
/// Get call executor reference.
|
|
fn executor(&self) -> &Self::Executor;
|
|
|
|
/// Get a reference to the execution extensions.
|
|
fn execution_extensions(&self) -> &ExecutionExtensions<Block>;
|
|
}
|
|
|
|
/// Method call executor.
|
|
pub trait CallExecutor<B: BlockT>: RuntimeVersionOf {
|
|
/// Externalities error type.
|
|
type Error: sp_state_machine::Error;
|
|
|
|
/// The backend used by the node.
|
|
type Backend: crate::backend::Backend<B>;
|
|
|
|
/// Returns the [`ExecutionExtensions`].
|
|
fn execution_extensions(&self) -> &ExecutionExtensions<B>;
|
|
|
|
/// Execute a call to a contract on top of state in a block of given hash.
|
|
///
|
|
/// No changes are made.
|
|
fn call(
|
|
&self,
|
|
id: &BlockId<B>,
|
|
method: &str,
|
|
call_data: &[u8],
|
|
strategy: ExecutionStrategy,
|
|
) -> Result<Vec<u8>, sp_blockchain::Error>;
|
|
|
|
/// Execute a contextual call on top of state in a block of a given hash.
|
|
///
|
|
/// No changes are made.
|
|
/// Before executing the method, passed header is installed as the current header
|
|
/// of the execution context.
|
|
fn contextual_call(
|
|
&self,
|
|
at: &BlockId<B>,
|
|
method: &str,
|
|
call_data: &[u8],
|
|
changes: &RefCell<OverlayedChanges>,
|
|
storage_transaction_cache: Option<
|
|
&RefCell<
|
|
StorageTransactionCache<B, <Self::Backend as crate::backend::Backend<B>>::State>,
|
|
>,
|
|
>,
|
|
proof_recorder: &Option<ProofRecorder<B>>,
|
|
context: ExecutionContext,
|
|
) -> sp_blockchain::Result<Vec<u8>>;
|
|
|
|
/// Extract RuntimeVersion of given block
|
|
///
|
|
/// No changes are made.
|
|
fn runtime_version(&self, id: &BlockId<B>) -> Result<RuntimeVersion, sp_blockchain::Error>;
|
|
|
|
/// Prove the execution of the given `method`.
|
|
///
|
|
/// No changes are made.
|
|
fn prove_execution(
|
|
&self,
|
|
at: &BlockId<B>,
|
|
method: &str,
|
|
call_data: &[u8],
|
|
) -> Result<(Vec<u8>, StorageProof), sp_blockchain::Error>;
|
|
}
|