mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-06-12 14:41:11 +00:00
[contracts] define_env! re-write as a proc macro (#11888)
* define_env proc macro basics + can_satisfy part ready * expand_impls part done * fix of the &FunctionType bug * pallet is compiled * updated host fn definition syntax * docs comments allowed to host fn definitions * all 53 host funcs re-defined by the new macro * unstable feat fix * cleanup * legacy mbe macros cleaned up * Added Env ident to macro attribute; all tests pass! * \#[v(..)] -> \#[version(..)] * some tiny corrections * save * builds with non-magic rt; tests fail * tests pass * refactored errors + added docs * merge err fixed * fixes on @ascjones review, all except moving away from `pub mod env` syntax * debug printing cleared * clippy fix
This commit is contained in:
Sasha Gryaznov
@@ -15,16 +15,23 @@
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
//! Proc macros used in the contracts module.
|
||||
//! Procedural macroses used in the contracts module.
|
||||
//!
|
||||
//! Most likely you should use the [`#[define_env]`][`macro@define_env`] attribute macro which hides
|
||||
//! boilerplate of defining external environment for a wasm module.
|
||||
|
||||
#![no_std]
|
||||
|
||||
extern crate alloc;
|
||||
|
||||
use alloc::string::ToString;
|
||||
use alloc::{
|
||||
format,
|
||||
string::{String, ToString},
|
||||
vec::Vec,
|
||||
};
|
||||
use proc_macro2::TokenStream;
|
||||
use quote::{quote, quote_spanned};
|
||||
use syn::{parse_macro_input, Data, DeriveInput, Ident};
|
||||
use quote::{quote, quote_spanned, ToTokens};
|
||||
use syn::{parse_macro_input, spanned::Spanned, Data, DeriveInput, Ident};
|
||||
|
||||
/// This derives `Debug` for a struct where each field must be of some numeric type.
|
||||
/// It interprets each field as its represents some weight and formats it as times so that
|
||||
@@ -85,7 +92,7 @@ fn derive_debug(
|
||||
/// This is only used then the `full` feature is activated.
|
||||
#[cfg(feature = "full")]
|
||||
fn iterate_fields(data: &syn::DataStruct, fmt: impl Fn(&Ident) -> TokenStream) -> TokenStream {
|
||||
use syn::{spanned::Spanned, Fields};
|
||||
use syn::Fields;
|
||||
|
||||
match &data.fields {
|
||||
Fields::Named(fields) => {
|
||||
@@ -140,3 +147,392 @@ fn format_default(field: &Ident) -> TokenStream {
|
||||
&self.#field
|
||||
}
|
||||
}
|
||||
|
||||
/// Parsed environment definition.
|
||||
struct EnvDef {
|
||||
host_funcs: Vec<HostFn>,
|
||||
}
|
||||
|
||||
/// Parsed host function definition.
|
||||
struct HostFn {
|
||||
item: syn::ItemFn,
|
||||
module: String,
|
||||
name: String,
|
||||
returns: HostFnReturn,
|
||||
}
|
||||
|
||||
enum HostFnReturn {
|
||||
Unit,
|
||||
U32,
|
||||
ReturnCode,
|
||||
}
|
||||
|
||||
impl ToTokens for HostFn {
|
||||
fn to_tokens(&self, tokens: &mut TokenStream) {
|
||||
self.item.to_tokens(tokens);
|
||||
}
|
||||
}
|
||||
|
||||
impl HostFn {
|
||||
pub fn try_from(item: syn::Item) -> syn::Result<Self> {
|
||||
let err = |span, msg| {
|
||||
let msg = format!("Invalid host function definition. {}", msg);
|
||||
syn::Error::new(span, msg)
|
||||
};
|
||||
let msg = "only #[version(<u8>)] or #[unstable] attribute is allowed.";
|
||||
let span = item.span();
|
||||
let item = match item {
|
||||
syn::Item::Fn(i_fn) => Ok(i_fn),
|
||||
_ => Err(err(span, msg)),
|
||||
}?;
|
||||
|
||||
let name = item.sig.ident.to_string();
|
||||
let attrs: Vec<&syn::Attribute> =
|
||||
item.attrs.iter().filter(|m| !m.path.is_ident("doc")).collect();
|
||||
|
||||
let module = match attrs.len() {
|
||||
0 => Ok("seal0".to_string()),
|
||||
1 => {
|
||||
let attr = &attrs[0];
|
||||
let ident = attr.path.get_ident().ok_or(err(span, msg))?.to_string();
|
||||
match ident.as_str() {
|
||||
"version" => {
|
||||
let ver: syn::LitInt = attr.parse_args()?;
|
||||
Ok(format!("seal{}", ver.base10_parse::<u8>().map_err(|_| err(span, msg))?))
|
||||
},
|
||||
"unstable" => Ok("__unstable__".to_string()),
|
||||
_ => Err(err(span, msg)),
|
||||
}
|
||||
},
|
||||
_ => Err(err(span, msg)),
|
||||
}?;
|
||||
|
||||
let msg = r#"Should return one of the following:
|
||||
- Result<(), TrapReason>,
|
||||
- Result<ReturnCode, TrapReason>,
|
||||
- Result<u32, TrapReason>"#;
|
||||
|
||||
let ret_ty = match item.clone().sig.output {
|
||||
syn::ReturnType::Type(_, ty) => Ok(ty.clone()),
|
||||
_ => Err(err(span, &msg)),
|
||||
}?;
|
||||
|
||||
match *ret_ty {
|
||||
syn::Type::Path(tp) => {
|
||||
let result = &tp.path.segments.last().ok_or(err(span, &msg))?;
|
||||
let (id, span) = (result.ident.to_string(), result.ident.span());
|
||||
id.eq(&"Result".to_string()).then_some(()).ok_or(err(span, &msg))?;
|
||||
|
||||
match &result.arguments {
|
||||
syn::PathArguments::AngleBracketed(group) => {
|
||||
if group.args.len() != 2 {
|
||||
return Err(err(span, &msg))
|
||||
};
|
||||
|
||||
let arg2 = group.args.last().ok_or(err(span, &msg))?;
|
||||
|
||||
let err_ty = match arg2 {
|
||||
syn::GenericArgument::Type(ty) => Ok(ty.clone()),
|
||||
_ => Err(err(arg2.span(), &msg)),
|
||||
}?;
|
||||
|
||||
match err_ty {
|
||||
syn::Type::Path(tp) => Ok(tp
|
||||
.path
|
||||
.segments
|
||||
.first()
|
||||
.ok_or(err(arg2.span(), &msg))?
|
||||
.ident
|
||||
.to_string()),
|
||||
_ => Err(err(tp.span(), &msg)),
|
||||
}?
|
||||
.eq("TrapReason")
|
||||
.then_some(())
|
||||
.ok_or(err(span, &msg))?;
|
||||
|
||||
let arg1 = group.args.first().ok_or(err(span, &msg))?;
|
||||
let ok_ty = match arg1 {
|
||||
syn::GenericArgument::Type(ty) => Ok(ty.clone()),
|
||||
_ => Err(err(arg1.span(), &msg)),
|
||||
}?;
|
||||
let ok_ty_str = match ok_ty {
|
||||
syn::Type::Path(tp) => Ok(tp
|
||||
.path
|
||||
.segments
|
||||
.first()
|
||||
.ok_or(err(arg1.span(), &msg))?
|
||||
.ident
|
||||
.to_string()),
|
||||
syn::Type::Tuple(tt) => {
|
||||
if !tt.elems.is_empty() {
|
||||
return Err(err(arg1.span(), &msg))
|
||||
};
|
||||
Ok("()".to_string())
|
||||
},
|
||||
_ => Err(err(ok_ty.span(), &msg)),
|
||||
}?;
|
||||
|
||||
let returns = match ok_ty_str.as_str() {
|
||||
"()" => Ok(HostFnReturn::Unit),
|
||||
"u32" => Ok(HostFnReturn::U32),
|
||||
"ReturnCode" => Ok(HostFnReturn::ReturnCode),
|
||||
_ => Err(err(arg1.span(), &msg)),
|
||||
}?;
|
||||
Ok(Self { item, module, name, returns })
|
||||
},
|
||||
_ => Err(err(span, &msg)),
|
||||
}
|
||||
},
|
||||
_ => Err(err(span, &msg)),
|
||||
}
|
||||
}
|
||||
|
||||
fn to_wasm_sig(&self) -> TokenStream {
|
||||
let args = self.item.sig.inputs.iter().skip(1).filter_map(|a| match a {
|
||||
syn::FnArg::Typed(pt) => Some(&pt.ty),
|
||||
_ => None,
|
||||
});
|
||||
let returns = match &self.returns {
|
||||
HostFnReturn::U32 => quote! { vec![ <u32>::VALUE_TYPE ] },
|
||||
HostFnReturn::ReturnCode => quote! { vec![ <ReturnCode>::VALUE_TYPE ] },
|
||||
HostFnReturn::Unit => quote! { vec![] },
|
||||
};
|
||||
|
||||
quote! {
|
||||
wasm_instrument::parity_wasm::elements::FunctionType::new(
|
||||
vec! [ #(<#args>::VALUE_TYPE),* ],
|
||||
#returns,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
impl EnvDef {
|
||||
pub fn try_from(item: syn::ItemMod) -> syn::Result<Self> {
|
||||
let span = item.span();
|
||||
let err = |msg| syn::Error::new(span, msg);
|
||||
let items = &item
|
||||
.content
|
||||
.as_ref()
|
||||
.ok_or(err("Invalid environment definition, expected `mod` to be inlined."))?
|
||||
.1;
|
||||
|
||||
let host_funcs = items
|
||||
.iter()
|
||||
.map(|i| HostFn::try_from(i.clone()))
|
||||
.collect::<Result<Vec<_>, _>>()?;
|
||||
|
||||
Ok(Self { host_funcs })
|
||||
}
|
||||
}
|
||||
|
||||
/// Expands environment definiton.
|
||||
/// Should generate source code for:
|
||||
/// - wasm import satisfy checks (see `expand_can_satisfy()`);
|
||||
/// - implementations of the host functions to be added to the wasm runtime environment (see
|
||||
/// `expand_impls()`).
|
||||
fn expand_env(def: &mut EnvDef) -> proc_macro2::TokenStream {
|
||||
let can_satisfy = expand_can_satisfy(def);
|
||||
let impls = expand_impls(def);
|
||||
|
||||
quote! {
|
||||
pub struct Env;
|
||||
#can_satisfy
|
||||
#impls
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates `can_satisfy()` method for every host function, to be used to check
|
||||
/// these functions versus expected module, name and signatures when imporing them from a wasm
|
||||
/// module.
|
||||
fn expand_can_satisfy(def: &mut EnvDef) -> proc_macro2::TokenStream {
|
||||
let checks = def.host_funcs.iter().map(|f| {
|
||||
let (module, name, signature) = (&f.module, &f.name, &f.to_wasm_sig());
|
||||
quote! {
|
||||
if module == #module.as_bytes()
|
||||
&& name == #name.as_bytes()
|
||||
&& signature == &#signature
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
});
|
||||
let satisfy_checks = quote! {
|
||||
#( #checks )*
|
||||
};
|
||||
|
||||
quote! {
|
||||
impl crate::wasm::env_def::ImportSatisfyCheck for Env {
|
||||
fn can_satisfy(
|
||||
module: &[u8],
|
||||
name: &[u8],
|
||||
signature: &wasm_instrument::parity_wasm::elements::FunctionType,
|
||||
) -> bool {
|
||||
use crate::wasm::env_def::ConvertibleToWasm;
|
||||
#[cfg(not(feature = "unstable-interface"))]
|
||||
if module == b"__unstable__" {
|
||||
return false;
|
||||
}
|
||||
#satisfy_checks
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Generates implementation for every host function, to register it in the contract execution
|
||||
/// environment.
|
||||
fn expand_impls(def: &mut EnvDef) -> proc_macro2::TokenStream {
|
||||
let impls = def.host_funcs.iter().map(|f| {
|
||||
let params = &f.item.sig.inputs.iter().skip(1).map(|arg| {
|
||||
match arg {
|
||||
syn::FnArg::Typed(pt) => {
|
||||
if let syn::Pat::Ident(ident) = &*pt.pat {
|
||||
let p_type = &pt.ty;
|
||||
let p_name = ident.ident.clone();
|
||||
quote! {
|
||||
let #p_name : <#p_type as crate::wasm::env_def::ConvertibleToWasm>::NativeType =
|
||||
args.next()
|
||||
.and_then(|v| <#p_type as crate::wasm::env_def::ConvertibleToWasm>::from_typed_value(v.clone()))
|
||||
.expect(
|
||||
"precondition: all imports should be checked against the signatures of corresponding
|
||||
functions defined by `#[define_env]` proc macro by the user of the macro;
|
||||
thus this can never be `None`;
|
||||
qed;"
|
||||
);
|
||||
}
|
||||
} else { quote! { } }
|
||||
},
|
||||
_ => quote! { },
|
||||
}
|
||||
});
|
||||
|
||||
let outline = match &f.returns {
|
||||
HostFnReturn::Unit => quote! {
|
||||
body().map_err(|reason| {
|
||||
ctx.set_trap_reason(reason);
|
||||
sp_sandbox::HostError
|
||||
})?;
|
||||
return Ok(sp_sandbox::ReturnValue::Unit);
|
||||
},
|
||||
_ => quote! {
|
||||
let r = body().map_err(|reason| {
|
||||
ctx.set_trap_reason(reason);
|
||||
sp_sandbox::HostError
|
||||
})?;
|
||||
return Ok(sp_sandbox::ReturnValue::Value({
|
||||
r.to_typed_value()
|
||||
}));
|
||||
},
|
||||
};
|
||||
let params = params.clone();
|
||||
let (module, name, ident, body) = (&f.module, &f.name, &f.item.sig.ident, &f.item.block);
|
||||
let unstable_feat = match module.as_str() {
|
||||
"__unstable__" => quote! { #[cfg(feature = "unstable-interface")] },
|
||||
_ => quote! { },
|
||||
};
|
||||
quote! {
|
||||
#unstable_feat
|
||||
f(#module.as_bytes(), #name.as_bytes(), {
|
||||
fn #ident<E: Ext>(
|
||||
ctx: &mut crate::wasm::Runtime<E>,
|
||||
args: &[sp_sandbox::Value],
|
||||
) -> Result<sp_sandbox::ReturnValue, sp_sandbox::HostError>
|
||||
where
|
||||
<E::T as frame_system::Config>::AccountId: sp_core::crypto::UncheckedFrom<<E::T as frame_system::Config>::Hash>
|
||||
+ AsRef<[u8]>,
|
||||
{
|
||||
#[allow(unused)]
|
||||
let mut args = args.iter();
|
||||
let mut body = || {
|
||||
#( #params )*
|
||||
#body
|
||||
};
|
||||
#outline
|
||||
}
|
||||
#ident::<E>
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
let packed_impls = quote! {
|
||||
#( #impls )*
|
||||
};
|
||||
|
||||
quote! {
|
||||
impl<E: Ext> crate::wasm::env_def::FunctionImplProvider<E> for Env
|
||||
where
|
||||
<E::T as frame_system::Config>::AccountId:
|
||||
sp_core::crypto::UncheckedFrom<<E::T as frame_system::Config>::Hash> + AsRef<[u8]>,
|
||||
{
|
||||
fn impls<F: FnMut(&[u8], &[u8], crate::wasm::env_def::HostFunc<E>)>(f: &mut F) {
|
||||
#packed_impls
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Defines a host functions set that can be imported by contract wasm code.
|
||||
///
|
||||
/// **NB**: Be advised that all functions defined by this macro
|
||||
/// will panic if called with unexpected arguments.
|
||||
///
|
||||
/// It's up to you as the user of this macro to check signatures of wasm code to be executed
|
||||
/// and reject the code if any imported function has a mismatched signature.
|
||||
///
|
||||
/// ## Example
|
||||
///
|
||||
/// ```nocompile
|
||||
/// #[define_env]
|
||||
/// pub mod some_env {
|
||||
/// fn some_host_fn(ctx: Runtime<E: Ext>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<(), TrapReason> {
|
||||
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
/// This example will expand to the `some_host_fn()` defined in the wasm module named `seal0`.
|
||||
/// To define a host function in `seal1` and `__unstable__` modules, it should be annotated with the
|
||||
/// appropriate attribute as follows:
|
||||
///
|
||||
/// ## Example
|
||||
///
|
||||
/// ```nocompile
|
||||
/// #[define_env]
|
||||
/// pub mod some_env {
|
||||
/// #[version(1)]
|
||||
/// fn some_host_fn(ctx: Runtime<E: Ext>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<ReturnCode, TrapReason> {
|
||||
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
|
||||
/// }
|
||||
///
|
||||
/// #[unstable]
|
||||
/// fn some_host_fn(ctx: Runtime<E: Ext>, key_ptr: u32, value_ptr: u32, value_len: u32) -> Result<u32, TrapReason> {
|
||||
/// ctx.some_host_fn(KeyType::Fix, key_ptr, value_ptr, value_len).map(|_| ())
|
||||
/// }
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// Only following return types are allowed for the host functions defined with the macro:
|
||||
/// - `Result<(), TrapReason>`,
|
||||
/// - `Result<ReturnCode, TrapReason>`,
|
||||
/// - `Result<u32, TrapReason>`.
|
||||
///
|
||||
/// The macro expands to `pub struct Env` declaration, with the following traits implementations:
|
||||
/// - `pallet_contracts::wasm::env_def::ImportSatisfyCheck`
|
||||
/// - `pallet_contracts::wasm::env_def::FunctionImplProvider`
|
||||
#[proc_macro_attribute]
|
||||
pub fn define_env(
|
||||
attr: proc_macro::TokenStream,
|
||||
item: proc_macro::TokenStream,
|
||||
) -> proc_macro::TokenStream {
|
||||
if !attr.is_empty() {
|
||||
let msg = "Invalid `define_env` attribute macro: expected no attributes: `#[define_env]`.";
|
||||
let span = proc_macro2::TokenStream::from(attr).span();
|
||||
return syn::Error::new(span, msg).to_compile_error().into()
|
||||
}
|
||||
|
||||
let item = syn::parse_macro_input!(item as syn::ItemMod);
|
||||
|
||||
match EnvDef::try_from(item) {
|
||||
Ok(mut def) => expand_env(&mut def).into(),
|
||||
Err(e) => e.to_compile_error().into(),
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user