mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-13 10:31:04 +00:00
Bastian Köcher
8de663f105
* Adds new `check_inherents` function to the `BlockBuilder` API * Switch to `check_inherents` in `node-consensus` * Remove `CheckedBlock`, because it is not required anymore * Fixes after rebase * Fixes compilation on stable
660 lines
20 KiB
Rust
660 lines
20 KiB
Rust
// Copyright 2018 Parity Technologies (UK) Ltd.
|
|
// This file is part of Substrate.
|
|
|
|
// Substrate 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.
|
|
|
|
// Substrate 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 Substrate. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
//! API's for interfacing with the runtime via native/wasm.
|
|
|
|
#![cfg_attr(not(feature = "std"), no_std)]
|
|
|
|
extern crate sr_std as rstd;
|
|
extern crate sr_primitives as primitives;
|
|
#[doc(hidden)]
|
|
pub extern crate parity_codec as codec;
|
|
#[macro_use]
|
|
extern crate parity_codec_derive;
|
|
extern crate sr_version as runtime_version;
|
|
|
|
#[doc(hidden)]
|
|
pub use primitives::{traits::Block as BlockT, generic::BlockId, transaction_validity::TransactionValidity, ApplyResult};
|
|
use runtime_version::RuntimeVersion;
|
|
use rstd::vec::Vec;
|
|
#[doc(hidden)]
|
|
pub use rstd::slice;
|
|
#[doc(hidden)]
|
|
pub use codec::{Encode, Decode};
|
|
|
|
/// Declare the given API traits.
|
|
///
|
|
/// # Example:
|
|
///
|
|
/// ```nocompile
|
|
/// decl_apis!{
|
|
/// pub trait Test<Event> ExtraClientSide<ClientArg> {
|
|
/// fn test<AccountId>(event: Event) -> AccountId;
|
|
///
|
|
/// /// A function that will have the extra parameter `param` on the client side,
|
|
/// /// the runtime does not have any parameter.
|
|
/// fn testWithExtraParams() ExtraClientSide(param: &Self::ClientArg);
|
|
/// }
|
|
/// }
|
|
/// ```
|
|
///
|
|
/// Will result in the following declaration:
|
|
///
|
|
/// ```nocompile
|
|
/// mod runtime {
|
|
/// pub trait Test<Event, AccountId> {
|
|
/// fn test(event: Event) -> AccountId;
|
|
/// }
|
|
/// }
|
|
///
|
|
/// pub trait Test<Block: BlockT, Event> {
|
|
/// type Error;
|
|
/// type ClientArg;
|
|
/// fn test<AccountId: Encode + Decode>(&self, at: &BlockId<Block>, event: Event) -> Result<Event, Self::Error>;
|
|
/// fn testWithExtraParams(&self, at: &BlockId<Block>, param: &Client) -> Result<Event, Self::Error>;
|
|
/// }
|
|
/// ```
|
|
///
|
|
/// The declarations generated in the `runtime` module will be used by `impl_apis!` for implementing
|
|
/// the traits for a runtime. The other declarations should be used for implementing the interface
|
|
/// in the client.
|
|
#[macro_export]
|
|
macro_rules! decl_apis {
|
|
(
|
|
$(
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param:ident $( : $generic_bound:ident )* ),* >)*
|
|
$( ExtraClientSide < $( $client_generic_param:ident $( : $client_generic_bound:ident )* ),+ > )*
|
|
{
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty ),*
|
|
)
|
|
$( ExtraClientSide ( $( $client_param_name:ident : $client_param_type:ty ),+ ) )*
|
|
$( -> $return_ty:ty)*;
|
|
)*
|
|
}
|
|
)*
|
|
) => {
|
|
$(
|
|
decl_apis!(
|
|
@ADD_BLOCK_GENERIC
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param $( : $generic_bound )* ),* >)* {
|
|
$( $( type $client_generic_param $( : $client_generic_bound )*; )* )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $( $client_param_name: $client_param_type, )* )*
|
|
$( $param_name : &$param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
;
|
|
;
|
|
$( $( $generic_param $( : $generic_bound )* ),* )*
|
|
);
|
|
)*
|
|
decl_apis! {
|
|
@GENERATE_RUNTIME_TRAITS
|
|
$(
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param $( : $generic_bound )* ),* >)* {
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* ($( $param_name : $param_type )* ) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
)*
|
|
}
|
|
};
|
|
(@ADD_BLOCK_GENERIC
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty)*;
|
|
)*
|
|
};
|
|
;
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:ident )* ),*;
|
|
Block: BlockT
|
|
$(, $generic_param_rest:ident $( : $generic_bound_rest:ident )* )*
|
|
) => {
|
|
decl_apis!(
|
|
@ADD_BLOCK_GENERIC
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
Found;
|
|
$( $generic_param_parsed $( : $generic_bound_parsed )* , )* Block: $crate::BlockT;
|
|
$( $generic_param_rest $( : $generic_bound_rest )* ),*
|
|
);
|
|
};
|
|
(@ADD_BLOCK_GENERIC
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty )*;
|
|
)*
|
|
};
|
|
$( $block_found:ident )*;
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:path )* ),*;
|
|
$generic_param:ident $( : $generic_bound:ident )*
|
|
$(, $generic_param_rest:ident $( : $generic_bound_rest:ident )* )*
|
|
) => {
|
|
decl_apis!(
|
|
@ADD_BLOCK_GENERIC
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
$( $block_found )*;
|
|
$( $generic_param_parsed $( : $generic_bound_parsed )* , )* $generic_param $( : $generic_bound )*;
|
|
$( $generic_param_rest $( : $generic_bound_rest )* ),*
|
|
);
|
|
};
|
|
(@ADD_BLOCK_GENERIC
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty )*;
|
|
)*
|
|
};
|
|
Found;
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:path )* ),*;
|
|
) => {
|
|
decl_apis!(
|
|
@GENERATE_RETURN_TYPES
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed $( : $generic_bound_parsed )* ),*;
|
|
{};
|
|
$( $( $return_ty )*; )*
|
|
);
|
|
};
|
|
(@ADD_BLOCK_GENERIC
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty )*;
|
|
)*
|
|
};
|
|
;
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:ident )* ),*;
|
|
) => {
|
|
decl_apis!(
|
|
@GENERATE_RETURN_TYPES
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
// We need to add the required generic Block parameter
|
|
Block: $crate::BlockT $(, $generic_param_parsed $( : $generic_bound_parsed )* )*;
|
|
{};
|
|
$( $( $return_ty )*; )*
|
|
);
|
|
};
|
|
(@GENERATE_RETURN_TYPES
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty)*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:path )* ),*;
|
|
{ $( $result_return_ty:ty; )* };
|
|
$return_ty_current:ty;
|
|
$( $( $return_ty_rest:ty )*; )*
|
|
) => {
|
|
decl_apis!(
|
|
@GENERATE_RETURN_TYPES
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed $( : $generic_bound_parsed )* ),*;
|
|
{ $( $result_return_ty; )* Result<$return_ty_current, Self::Error>; };
|
|
$( $( $return_ty_rest )*; )*
|
|
);
|
|
};
|
|
(@GENERATE_RETURN_TYPES
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty)*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:path )* ),*;
|
|
{ $( $result_return_ty:ty; )* };
|
|
;
|
|
$( $( $return_ty_rest:ty )*; )*
|
|
) => {
|
|
decl_apis!(
|
|
@GENERATE_RETURN_TYPES
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed $( : $generic_bound_parsed )* ),*;
|
|
{ $( $result_return_ty; )* Result<(), Self::Error>; };
|
|
$( $( $return_ty_rest )*; )*
|
|
);
|
|
};
|
|
(@GENERATE_RETURN_TYPES
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty)*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:path )* ),*;
|
|
{ $( $result_return_ty:ty; )* };
|
|
) => {
|
|
decl_apis!(
|
|
@GENERATE_CLIENT_TRAITS
|
|
$( #[$attr] )*
|
|
pub trait $name $(< $( $generic_param_orig $( : $generic_bound_orig )* ),* >)* {
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic ),* > )* (
|
|
$( $param_name : $param_type, )*
|
|
) $( -> $return_ty )*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed $( : $generic_bound_parsed )* ),*;
|
|
{ $( $result_return_ty; )* };
|
|
);
|
|
};
|
|
(@GENERATE_CLIENT_TRAITS
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param_orig:ident $( : $generic_bound_orig:ident )* ),* >)* {
|
|
$( type $client_generic_param:ident $( : $client_generic_bound:ident )*; )*
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty, )*
|
|
) $( -> $return_ty:ty)*;
|
|
)*
|
|
};
|
|
$( $generic_param_parsed:ident $( : $generic_bound_parsed:path )* ),*;
|
|
{ $( $result_return_ty:ty; )* };
|
|
) => {
|
|
$( #[$attr] )*
|
|
pub trait $name < $( $generic_param_parsed $( : $generic_bound_parsed )* ),* > {
|
|
/// The Error type returned by this API.
|
|
type Error;
|
|
$( type $client_generic_param $( : $client_generic_bound )*; )*
|
|
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name $( < $( $fn_generic: $crate::Encode + $crate::Decode ),* > )* (
|
|
&self, at: &$crate::BlockId<Block> $(, $param_name: $param_type )*
|
|
) -> $result_return_ty;
|
|
)*
|
|
}
|
|
};
|
|
(@GENERATE_RUNTIME_TRAITS
|
|
$(
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident $(< $( $generic_param:ident $( : $generic_bound:ident )* ),* >)* {
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident $( < $( $fn_generic:ident ),* > )* (
|
|
$( $param_name:ident : $param_type:ty )*
|
|
) $( -> $return_ty:ty)*;
|
|
)*
|
|
};
|
|
)*
|
|
) => {
|
|
decl_apis! {
|
|
@GENERATE_RUNTIME_TRAITS_WITH_JOINED_GENERICS
|
|
$(
|
|
$( #[$attr] )*
|
|
pub trait $name < $( $( $generic_param $( : $generic_bound )*, )* )* $( $( $( $fn_generic, )* )* )* > {
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name ($( $param_name: $param_type ),*) $( -> $return_ty )*;
|
|
)*
|
|
}
|
|
)*
|
|
}
|
|
};
|
|
(@GENERATE_RUNTIME_TRAITS_WITH_JOINED_GENERICS
|
|
$(
|
|
$( #[$attr:meta] )*
|
|
pub trait $name:ident < $( $generic_param:ident $( : $generic_bound:ident )*, )* > {
|
|
$(
|
|
$( #[$fn_attr:meta] )*
|
|
fn $fn_name:ident($( $param_name:ident : $param_type:ty ),*) $( -> $return_ty:ty)*;
|
|
)*
|
|
}
|
|
)*
|
|
) => {
|
|
/// The API traits to implement on the runtime side.
|
|
pub mod runtime {
|
|
use super::*;
|
|
|
|
$(
|
|
$( #[$attr] )*
|
|
pub trait $name < $( $generic_param $( : $generic_bound )* ),* > {
|
|
$(
|
|
$( #[$fn_attr] )*
|
|
fn $fn_name ($( $param_name: $param_type ),*) $( -> $return_ty )*;
|
|
)*
|
|
}
|
|
)*
|
|
}
|
|
};
|
|
}
|
|
|
|
//TODO: Move into runtime!
|
|
#[derive(Encode)]
|
|
#[cfg_attr(feature = "std", derive(Debug, Decode))]
|
|
pub enum BlockBuilderError {
|
|
#[cfg(not(feature = "std"))]
|
|
Generic(&'static str),
|
|
#[cfg(feature = "std")]
|
|
Generic(String),
|
|
TimestampInFuture(u64),
|
|
}
|
|
|
|
decl_apis! {
|
|
/// The `Core` api trait that is mandantory for each runtime.
|
|
pub trait Core<Block: BlockT, AuthorityId> {
|
|
fn version() -> RuntimeVersion;
|
|
fn authorities() -> Vec<AuthorityId>;
|
|
fn execute_block(block: Block);
|
|
}
|
|
|
|
/// The `Metadata` api trait that returns metadata for the runtime.
|
|
pub trait Metadata {
|
|
fn metadata() -> Vec<u8>;
|
|
}
|
|
|
|
/// The `OldTxQueue` api trait for interfering with the old transaction queue.
|
|
pub trait OldTxQueue {
|
|
fn account_nonce<AccountId, Index>(account: AccountId) -> Index;
|
|
fn lookup_address<Address, LookupId>(address: Address) -> Option<LookupId>;
|
|
}
|
|
|
|
/// The `TaggedTransactionQueue` api trait for interfering with the new transaction queue.
|
|
pub trait TaggedTransactionQueue<Block: BlockT> {
|
|
fn validate_transaction<TransactionValidity>(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity;
|
|
}
|
|
|
|
/// The `Miscellaneous` api trait for getting miscellaneous information from the runtime.
|
|
pub trait Miscellaneous {
|
|
fn validator_count() -> u32;
|
|
fn validators<AccountId>() -> Vec<AccountId>;
|
|
fn timestamp<Moment>() -> Moment;
|
|
}
|
|
|
|
/// The `BlockBuilder` api trait that provides required functions for building a block for a runtime.
|
|
pub trait BlockBuilder<Block: BlockT> ExtraClientSide <OverlayedChanges> {
|
|
/// Initialise a block with the given header.
|
|
fn initialise_block(header: <Block as BlockT>::Header) ExtraClientSide(changes: &mut Self::OverlayedChanges);
|
|
/// Apply the given extrinsics.
|
|
fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) ExtraClientSide(changes: &mut Self::OverlayedChanges) -> ApplyResult;
|
|
/// Finish the current block.
|
|
fn finalise_block() ExtraClientSide(changes: &mut Self::OverlayedChanges) -> <Block as BlockT>::Header;
|
|
/// Generate inherent extrinsics.
|
|
fn inherent_extrinsics<InherentExtrinsic, UncheckedExtrinsic>(inherent: InherentExtrinsic) -> Vec<UncheckedExtrinsic>;
|
|
/// Check that the inherents are valid.
|
|
fn check_inherents<InherentData>(block: Block, data: InherentData) -> Result<(), BlockBuilderError>;
|
|
/// Generate a random seed.
|
|
fn random_seed() -> <Block as BlockT>::Hash;
|
|
}
|
|
}
|
|
|
|
/// Implement the given API's for the given runtime.
|
|
/// All desired API's need to be implemented in one `impl_apis!` call.
|
|
/// Besides generating the implementation for the runtime, there will be also generated an
|
|
/// auxiliary module named `api` that contains function for inferring with the API in native/wasm.
|
|
/// It is important to use the traits from the `runtime` module with this macro.
|
|
///
|
|
/// # Example:
|
|
///
|
|
/// ```nocompile
|
|
/// #[macro_use]
|
|
/// extern crate sr_api as runtime_api;
|
|
///
|
|
/// use runtime_api::runtime::{Core, TaggedTransactionQueue};
|
|
///
|
|
/// impl_apis! {
|
|
/// impl Core<Block, AccountId> for Runtime {
|
|
/// fn version() -> RuntimeVersion { 1 }
|
|
/// fn authorities() -> Vec<AuthorityId> { vec![1] }
|
|
/// fn execute_block(block: Block) {
|
|
/// //comment
|
|
/// let block = call_arbitrary_code(block);
|
|
/// execute(block);
|
|
/// }
|
|
/// }
|
|
///
|
|
/// impl TaggedTransactionQueue<Block> for Runtime {
|
|
/// fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity {
|
|
/// unimplemented!()
|
|
/// }
|
|
/// }
|
|
/// }
|
|
///
|
|
/// fn main() {}
|
|
/// ```
|
|
#[macro_export]
|
|
macro_rules! impl_apis {
|
|
(
|
|
impl $trait_name:ident $( < $( $generic:ident ),* > )* for $runtime:ident {
|
|
$(
|
|
fn $fn_name:ident ( $( $arg_name:ident : $arg_ty:ty ),* ) $( -> $return_ty:ty )* {
|
|
$( $impl:tt )*
|
|
}
|
|
)*
|
|
}
|
|
$( $rest:tt )*
|
|
) => {
|
|
impl $trait_name $( < $( $generic ),* > )* for $runtime {
|
|
$(
|
|
fn $fn_name ( $( $arg_name : $arg_ty ),* ) $( -> $return_ty )* {
|
|
$( $impl )*
|
|
}
|
|
)*
|
|
}
|
|
impl_apis! {
|
|
$runtime;
|
|
$( $fn_name ( $( $arg_name: $arg_ty ),* ); )*;
|
|
$( $rest )*
|
|
}
|
|
};
|
|
(
|
|
$runtime:ident;
|
|
$( $fn_name_parsed:ident ( $( $arg_name_parsed:ident : $arg_ty_parsed:ty ),* ); )*;
|
|
impl $trait_name:ident $( < $( $generic:ident ),* > )* for $runtime_ignore:ident {
|
|
$(
|
|
fn $fn_name:ident ( $( $arg_name:ident : $arg_ty:ty ),* ) $( -> $return_ty:ty )* {
|
|
$( $impl:tt )*
|
|
}
|
|
)*
|
|
}
|
|
$( $rest:tt )*
|
|
) => {
|
|
impl $trait_name $( < $( $generic ),* > )* for $runtime {
|
|
$(
|
|
fn $fn_name ( $( $arg_name : $arg_ty ),* ) $( -> $return_ty )* {
|
|
$( $impl )*
|
|
}
|
|
)*
|
|
}
|
|
impl_apis! {
|
|
$runtime;
|
|
$( $fn_name_parsed ( $( $arg_name_parsed: $arg_ty_parsed ),* ); )*
|
|
$( $fn_name ( $( $arg_name: $arg_ty ),* ); )*;
|
|
$( $rest )*
|
|
}
|
|
};
|
|
(
|
|
$runtime:ident;
|
|
$( $fn_name:ident ( $( $arg_name:ident : $arg_ty:ty ),* ); )*;
|
|
) => {
|
|
pub mod api {
|
|
use super::*;
|
|
|
|
#[cfg(feature = "std")]
|
|
pub fn dispatch(method: &str, mut data: &[u8]) -> Option<Vec<u8>> {
|
|
match method {
|
|
$(
|
|
stringify!($fn_name) => {
|
|
Some({impl_apis! {
|
|
@GENERATE_IMPL_CALL
|
|
$runtime;
|
|
$fn_name;
|
|
$( $arg_name : $arg_ty ),*;
|
|
data;
|
|
}})
|
|
}
|
|
)*
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
$(
|
|
#[cfg(not(feature = "std"))]
|
|
#[no_mangle]
|
|
pub fn $fn_name(input_data: *mut u8, input_len: usize) -> u64 {
|
|
let mut input = if input_len == 0 {
|
|
&[0u8; 0]
|
|
} else {
|
|
unsafe {
|
|
$crate::slice::from_raw_parts(input_data, input_len)
|
|
}
|
|
};
|
|
|
|
let output = { impl_apis! {
|
|
@GENERATE_IMPL_CALL
|
|
$runtime;
|
|
$fn_name;
|
|
$( $arg_name : $arg_ty ),*;
|
|
input;
|
|
} };
|
|
let res = output.as_ptr() as u64 + ((output.len() as u64) << 32);
|
|
|
|
// Leak the output vector to avoid it being freed.
|
|
// This is fine in a WASM context since the heap
|
|
// will be discarded after the call.
|
|
::core::mem::forget(output);
|
|
res
|
|
}
|
|
)*
|
|
}
|
|
};
|
|
(@GENERATE_IMPL_CALL
|
|
$runtime:ident;
|
|
$fn_name:ident;
|
|
$arg_name:ident : $arg_ty:ty;
|
|
$input:ident;
|
|
) => {
|
|
let $arg_name : $arg_ty = match $crate::codec::Decode::decode(&mut $input) {
|
|
Some(input) => input,
|
|
None => panic!("Bad input data provided to {}", stringify!($fn_name)),
|
|
};
|
|
|
|
let output = $runtime::$fn_name($arg_name);
|
|
$crate::codec::Encode::encode(&output)
|
|
};
|
|
(@GENERATE_IMPL_CALL
|
|
$runtime:ident;
|
|
$fn_name:ident;
|
|
$( $arg_name:ident : $arg_ty:ty ),*;
|
|
$input:ident;
|
|
) => {
|
|
let ( $( $arg_name ),* ) : ($( $arg_ty ),*) = match $crate::codec::Decode::decode(&mut $input) {
|
|
Some(input) => input,
|
|
None => panic!("Bad input data provided to {}", stringify!($fn_name)),
|
|
};
|
|
|
|
let output = $runtime::$fn_name($( $arg_name ),*);
|
|
$crate::codec::Encode::encode(&output)
|
|
};
|
|
}
|