FRAME: Create TransactionExtension as a replacement for SignedExtension (#2280)

Closes #2160

First part of [Extrinsic
Horizon](https://github.com/paritytech/polkadot-sdk/issues/2415)

Introduces a new trait `TransactionExtension` to replace
`SignedExtension`. Introduce the idea of transactions which obey the
runtime's extensions and have according Extension data (né Extra data)
yet do not have hard-coded signatures.

Deprecate the terminology of "Unsigned" when used for
transactions/extrinsics owing to there now being "proper" unsigned
transactions which obey the extension framework and "old-style" unsigned
which do not. Instead we have __*General*__ for the former and
__*Bare*__ for the latter. (Ultimately, the latter will be phased out as
a type of transaction, and Bare will only be used for Inherents.)

Types of extrinsic are now therefore:
- Bare (no hardcoded signature, no Extra data; used to be known as
"Unsigned")
- Bare transactions (deprecated): Gossiped, validated with
`ValidateUnsigned` (deprecated) and the `_bare_compat` bits of
`TransactionExtension` (deprecated).
  - Inherents: Not gossiped, validated with `ProvideInherent`.
- Extended (Extra data): Gossiped, validated via `TransactionExtension`.
  - Signed transactions (with a hardcoded signature).
  - General transactions (without a hardcoded signature).

`TransactionExtension` differs from `SignedExtension` because:
- A signature on the underlying transaction may validly not be present.
- It may alter the origin during validation.
- `pre_dispatch` is renamed to `prepare` and need not contain the checks
present in `validate`.
- `validate` and `prepare` is passed an `Origin` rather than a
`AccountId`.
- `validate` may pass arbitrary information into `prepare` via a new
user-specifiable type `Val`.
- `AdditionalSigned`/`additional_signed` is renamed to
`Implicit`/`implicit`. It is encoded *for the entire transaction* and
passed in to each extension as a new argument to `validate`. This
facilitates the ability of extensions to acts as underlying crypto.

There is a new `DispatchTransaction` trait which contains only default
function impls and is impl'ed for any `TransactionExtension` impler. It
provides several utility functions which reduce some of the tedium from
using `TransactionExtension` (indeed, none of its regular functions
should now need to be called directly).

Three transaction version discriminator ("versions") are now
permissible:
- 0b000000100: Bare (used to be called "Unsigned"): contains Signature
or Extra (extension data). After bare transactions are no longer
supported, this will strictly identify an Inherents only.
- 0b100000100: Old-school "Signed" Transaction: contains Signature and
Extra (extension data).
- 0b010000100: New-school "General" Transaction: contains Extra
(extension data), but no Signature.

For the New-school General Transaction, it becomes trivial for authors
to publish extensions to the mechanism for authorizing an Origin, e.g.
through new kinds of key-signing schemes, ZK proofs, pallet state,
mutations over pre-authenticated origins or any combination of the
above.

## Code Migration

### NOW: Getting it to build

Wrap your `SignedExtension`s in `AsTransactionExtension`. This should be
accompanied by renaming your aggregate type in line with the new
terminology. E.g. Before:

```rust
/// The SignedExtension to the basic transaction logic.
pub type SignedExtra = (
	/* snip */
	MySpecialSignedExtension,
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic =
	generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
```

After:

```rust
/// The extension to the basic transaction logic.
pub type TxExtension = (
	/* snip */
	AsTransactionExtension<MySpecialSignedExtension>,
);
/// Unchecked extrinsic type as expected by this runtime.
pub type UncheckedExtrinsic =
	generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, TxExtension>;
```

You'll also need to alter any transaction building logic to add a
`.into()` to make the conversion happen. E.g. Before:

```rust
fn construct_extrinsic(
		/* snip */
) -> UncheckedExtrinsic {
	let extra: SignedExtra = (
		/* snip */
		MySpecialSignedExtension::new(/* snip */),
	);
	let payload = SignedPayload::new(call.clone(), extra.clone()).unwrap();
	let signature = payload.using_encoded(|e| sender.sign(e));
	UncheckedExtrinsic::new_signed(
		/* snip */
		Signature::Sr25519(signature),
		extra,
	)
}
```

After:

```rust
fn construct_extrinsic(
		/* snip */
) -> UncheckedExtrinsic {
	let tx_ext: TxExtension = (
		/* snip */
		MySpecialSignedExtension::new(/* snip */).into(),
	);
	let payload = SignedPayload::new(call.clone(), tx_ext.clone()).unwrap();
	let signature = payload.using_encoded(|e| sender.sign(e));
	UncheckedExtrinsic::new_signed(
		/* snip */
		Signature::Sr25519(signature),
		tx_ext,
	)
}
```

### SOON: Migrating to `TransactionExtension`

Most `SignedExtension`s can be trivially converted to become a
`TransactionExtension`. There are a few things to know.

- Instead of a single trait like `SignedExtension`, you should now
implement two traits individually: `TransactionExtensionBase` and
`TransactionExtension`.
- Weights are now a thing and must be provided via the new function `fn
weight`.

#### `TransactionExtensionBase`

This trait takes care of anything which is not dependent on types
specific to your runtime, most notably `Call`.

- `AdditionalSigned`/`additional_signed` is renamed to
`Implicit`/`implicit`.
- Weight must be returned by implementing the `weight` function. If your
extension is associated with a pallet, you'll probably want to do this
via the pallet's existing benchmarking infrastructure.

#### `TransactionExtension`

Generally:
- `pre_dispatch` is now `prepare` and you *should not reexecute the
`validate` functionality in there*!
- You don't get an account ID any more; you get an origin instead. If
you need to presume an account ID, then you can use the trait function
`AsSystemOriginSigner::as_system_origin_signer`.
- You get an additional ticket, similar to `Pre`, called `Val`. This
defines data which is passed from `validate` into `prepare`. This is
important since you should not be duplicating logic from `validate` to
`prepare`, you need a way of passing your working from the former into
the latter. This is it.
- This trait takes two type parameters: `Call` and `Context`. `Call` is
the runtime call type which used to be an associated type; you can just
move it to become a type parameter for your trait impl. `Context` is not
currently used and you can safely implement over it as an unbounded
type.
- There's no `AccountId` associated type any more. Just remove it.

Regarding `validate`:
- You get three new parameters in `validate`; all can be ignored when
migrating from `SignedExtension`.
- `validate` returns a tuple on success; the second item in the tuple is
the new ticket type `Self::Val` which gets passed in to `prepare`. If
you use any information extracted during `validate` (off-chain and
on-chain, non-mutating) in `prepare` (on-chain, mutating) then you can
pass it through with this. For the tuple's last item, just return the
`origin` argument.

Regarding `prepare`:
- This is renamed from `pre_dispatch`, but there is one change:
- FUNCTIONALITY TO VALIDATE THE TRANSACTION NEED NOT BE DUPLICATED FROM
`validate`!!
- (This is different to `SignedExtension` which was required to run the
same checks in `pre_dispatch` as in `validate`.)

Regarding `post_dispatch`:
- Since there are no unsigned transactions handled by
`TransactionExtension`, `Pre` is always defined, so the first parameter
is `Self::Pre` rather than `Option<Self::Pre>`.

If you make use of `SignedExtension::validate_unsigned` or
`SignedExtension::pre_dispatch_unsigned`, then:
- Just use the regular versions of these functions instead.
- Have your logic execute in the case that the `origin` is `None`.
- Ensure your transaction creation logic creates a General Transaction
rather than a Bare Transaction; this means having to include all
`TransactionExtension`s' data.
- `ValidateUnsigned` can still be used (for now) if you need to be able
to construct transactions which contain none of the extension data,
however these will be phased out in stage 2 of the Transactions Horizon,
so you should consider moving to an extension-centric design.

## TODO

- [x] Introduce `CheckSignature` impl of `TransactionExtension` to
ensure it's possible to have crypto be done wholly in a
`TransactionExtension`.
- [x] Deprecate `SignedExtension` and move all uses in codebase to
`TransactionExtension`.
  - [x] `ChargeTransactionPayment`
  - [x] `DummyExtension`
  - [x] `ChargeAssetTxPayment` (asset-tx-payment)
  - [x] `ChargeAssetTxPayment` (asset-conversion-tx-payment)
  - [x] `CheckWeight`
  - [x] `CheckTxVersion`
  - [x] `CheckSpecVersion`
  - [x] `CheckNonce`
  - [x] `CheckNonZeroSender`
  - [x] `CheckMortality`
  - [x] `CheckGenesis`
  - [x] `CheckOnlySudoAccount`
  - [x] `WatchDummy`
  - [x] `PrevalidateAttests`
  - [x] `GenericSignedExtension`
  - [x] `SignedExtension` (chain-polkadot-bulletin)
  - [x] `RefundSignedExtensionAdapter`
- [x] Implement `fn weight` across the board.
- [ ] Go through all pre-existing extensions which assume an account
signer and explicitly handle the possibility of another kind of origin.
- [x] `CheckNonce` should probably succeed in the case of a non-account
origin.
- [x] `CheckNonZeroSender` should succeed in the case of a non-account
origin.
- [x] `ChargeTransactionPayment` and family should fail in the case of a
non-account origin.
  - [ ] 
- [x] Fix any broken tests.

---------

Signed-off-by: georgepisaltu <george.pisaltu@parity.io>
Signed-off-by: Alexandru Vasile <alexandru.vasile@parity.io>
Signed-off-by: dependabot[bot] <support@github.com>
Signed-off-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>
Signed-off-by: Alexandru Gheorghe <alexandru.gheorghe@parity.io>
Signed-off-by: Andrei Sandu <andrei-mihail@parity.io>
Co-authored-by: Nikhil Gupta <17176722+gupnik@users.noreply.github.com>
Co-authored-by: georgepisaltu <52418509+georgepisaltu@users.noreply.github.com>
Co-authored-by: Chevdor <chevdor@users.noreply.github.com>
Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: Maciej <maciej.zyszkiewicz@parity.io>
Co-authored-by: Javier Viola <javier@parity.io>
Co-authored-by: Marcin S. <marcin@realemail.net>
Co-authored-by: Tsvetomir Dimitrov <tsvetomir@parity.io>
Co-authored-by: Javier Bullrich <javier@bullrich.dev>
Co-authored-by: Koute <koute@users.noreply.github.com>
Co-authored-by: Adrian Catangiu <adrian@parity.io>
Co-authored-by: Vladimir Istyufeev <vladimir@parity.io>
Co-authored-by: Ross Bulat <ross@parity.io>
Co-authored-by: Gonçalo Pestana <g6pestana@gmail.com>
Co-authored-by: Liam Aharon <liam.aharon@hotmail.com>
Co-authored-by: Svyatoslav Nikolsky <svyatonik@gmail.com>
Co-authored-by: André Silva <123550+andresilva@users.noreply.github.com>
Co-authored-by: Oliver Tale-Yazdi <oliver.tale-yazdi@parity.io>
Co-authored-by: s0me0ne-unkn0wn <48632512+s0me0ne-unkn0wn@users.noreply.github.com>
Co-authored-by: ordian <write@reusable.software>
Co-authored-by: Sebastian Kunert <skunert49@gmail.com>
Co-authored-by: Aaro Altonen <48052676+altonen@users.noreply.github.com>
Co-authored-by: Dmitry Markin <dmitry@markin.tech>
Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>
Co-authored-by: Alexander Samusev <41779041+alvicsam@users.noreply.github.com>
Co-authored-by: Julian Eager <eagr@tutanota.com>
Co-authored-by: Michal Kucharczyk <1728078+michalkucharczyk@users.noreply.github.com>
Co-authored-by: Davide Galassi <davxy@datawok.net>
Co-authored-by: Dónal Murray <donal.murray@parity.io>
Co-authored-by: yjh <yjh465402634@gmail.com>
Co-authored-by: Tom Mi <tommi@niemi.lol>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Will | Paradox | ParaNodes.io <79228812+paradox-tt@users.noreply.github.com>
Co-authored-by: Bastian Köcher <info@kchr.de>
Co-authored-by: Joshy Orndorff <JoshOrndorff@users.noreply.github.com>
Co-authored-by: Joshy Orndorff <git-user-email.h0ly5@simplelogin.com>
Co-authored-by: PG Herveou <pgherveou@gmail.com>
Co-authored-by: Alexander Theißen <alex.theissen@me.com>
Co-authored-by: Kian Paimani <5588131+kianenigma@users.noreply.github.com>
Co-authored-by: Juan Girini <juangirini@gmail.com>
Co-authored-by: bader y <ibnbassem@gmail.com>
Co-authored-by: James Wilson <james@jsdw.me>
Co-authored-by: joe petrowski <25483142+joepetrowski@users.noreply.github.com>
Co-authored-by: asynchronous rob <rphmeier@gmail.com>
Co-authored-by: Parth <desaiparth08@gmail.com>
Co-authored-by: Andrew Jones <ascjones@gmail.com>
Co-authored-by: Jonathan Udd <jonathan@dwellir.com>
Co-authored-by: Serban Iorga <serban@parity.io>
Co-authored-by: Egor_P <egor@parity.io>
Co-authored-by: Branislav Kontur <bkontur@gmail.com>
Co-authored-by: Evgeny Snitko <evgeny@parity.io>
Co-authored-by: Just van Stam <vstam1@users.noreply.github.com>
Co-authored-by: Francisco Aguirre <franciscoaguirreperez@gmail.com>
Co-authored-by: gupnik <nikhilgupta.iitk@gmail.com>
Co-authored-by: dzmitry-lahoda <dzmitry@lahoda.pro>
Co-authored-by: zhiqiangxu <652732310@qq.com>
Co-authored-by: Nazar Mokrynskyi <nazar@mokrynskyi.com>
Co-authored-by: Anwesh <anweshknayak@gmail.com>
Co-authored-by: cheme <emericchevalier.pro@gmail.com>
Co-authored-by: Sam Johnson <sam@durosoft.com>
Co-authored-by: kianenigma <kian@parity.io>
Co-authored-by: Jegor Sidorenko <5252494+jsidorenko@users.noreply.github.com>
Co-authored-by: Muharem <ismailov.m.h@gmail.com>
Co-authored-by: joepetrowski <joe@parity.io>
Co-authored-by: Alexandru Gheorghe <49718502+alexggh@users.noreply.github.com>
Co-authored-by: Gabriel Facco de Arruda <arrudagates@gmail.com>
Co-authored-by: Squirrel <gilescope@gmail.com>
Co-authored-by: Andrei Sandu <54316454+sandreim@users.noreply.github.com>
Co-authored-by: georgepisaltu <george.pisaltu@parity.io>
Co-authored-by: command-bot <>
This commit is contained in:
Gavin Wood
2024-03-04 20:12:43 +01:00
committed by GitHub
parent b0741d4f78
commit fd5f9292f5
349 changed files with 25581 additions and 17082 deletions
+1 -1
View File
@@ -95,9 +95,9 @@ std = [
"sp-staking/std",
"sp-state-machine/std",
"sp-std/std",
"sp-timestamp/std",
"sp-tracing/std",
"sp-weights/std",
"sp-timestamp/std"
]
runtime-benchmarks = [
"frame-system/runtime-benchmarks",
@@ -73,11 +73,9 @@ pub fn expand_outer_inherent(
#(
#pallet_attrs
if let Some(inherent) = #pallet_names::create_inherent(self) {
let inherent = <#unchecked_extrinsic as #scrate::sp_runtime::traits::Extrinsic>::new(
let inherent = <#unchecked_extrinsic as #scrate::sp_runtime::traits::Extrinsic>::new_inherent(
inherent.into(),
None,
).expect("Runtime UncheckedExtrinsic is not Opaque, so it has to return \
`Some`; qed");
);
inherents.push(inherent);
}
@@ -123,7 +121,7 @@ pub fn expand_outer_inherent(
for xt in block.extrinsics() {
// Inherents are before any other extrinsics.
// And signed extrinsics are not inherents.
if #scrate::sp_runtime::traits::Extrinsic::is_signed(xt).unwrap_or(false) {
if !(#scrate::sp_runtime::traits::Extrinsic::is_bare(xt)) {
break
}
@@ -161,10 +159,9 @@ pub fn expand_outer_inherent(
match #pallet_names::is_inherent_required(self) {
Ok(Some(e)) => {
let found = block.extrinsics().iter().any(|xt| {
let is_signed = #scrate::sp_runtime::traits::Extrinsic::is_signed(xt)
.unwrap_or(false);
let is_bare = #scrate::sp_runtime::traits::Extrinsic::is_bare(xt);
if !is_signed {
if is_bare {
let call = <
#unchecked_extrinsic as ExtrinsicCall
>::call(xt);
@@ -209,8 +206,9 @@ pub fn expand_outer_inherent(
use #scrate::inherent::ProvideInherent;
use #scrate::traits::{IsSubType, ExtrinsicCall};
if #scrate::sp_runtime::traits::Extrinsic::is_signed(ext).unwrap_or(false) {
// Signed extrinsics are never inherents.
let is_bare = #scrate::sp_runtime::traits::Extrinsic::is_bare(ext);
if !is_bare {
// Signed extrinsics are not inherents.
return false
}
@@ -119,13 +119,13 @@ pub fn expand_runtime_metadata(
call_ty,
signature_ty,
extra_ty,
signed_extensions: <
extensions: <
<
#extrinsic as #scrate::sp_runtime::traits::ExtrinsicMetadata
>::SignedExtensions as #scrate::sp_runtime::traits::SignedExtension
>::Extra as #scrate::sp_runtime::traits::TransactionExtensionBase
>::metadata()
.into_iter()
.map(|meta| #scrate::__private::metadata_ir::SignedExtensionMetadataIR {
.map(|meta| #scrate::__private::metadata_ir::TransactionExtensionMetadataIR {
identifier: meta.identifier,
ty: meta.ty,
additional_signed: meta.additional_signed,
@@ -153,6 +153,10 @@ pub fn expand_outer_origin(
self.filter = #scrate::__private::sp_std::rc::Rc::new(Box::new(filter));
}
fn set_caller(&mut self, caller: OriginCaller) {
self.caller = caller;
}
fn set_caller_from(&mut self, other: impl Into<Self>) {
self.caller = other.into().caller;
}
@@ -301,6 +305,16 @@ pub fn expand_outer_origin(
}
}
impl #scrate::__private::AsSystemOriginSigner<<#runtime as #system_path::Config>::AccountId> for RuntimeOrigin {
fn as_system_origin_signer(&self) -> Option<&<#runtime as #system_path::Config>::AccountId> {
if let OriginCaller::system(#system_path::Origin::<#runtime>::Signed(ref signed)) = &self.caller {
Some(signed)
} else {
None
}
}
}
#pallet_conversions
})
}
+7 -22
View File
@@ -25,7 +25,7 @@ use scale_info::TypeInfo;
use serde::{Deserialize, Serialize};
use sp_runtime::{
generic::{CheckedExtrinsic, UncheckedExtrinsic},
traits::SignedExtension,
traits::Dispatchable,
DispatchError, RuntimeDebug,
};
use sp_std::fmt;
@@ -268,7 +268,8 @@ pub fn extract_actual_weight(result: &DispatchResultWithPostInfo, info: &Dispatc
.calc_actual_weight(info)
}
/// Extract the actual pays_fee from a dispatch result if any or fall back to the default weight.
/// Extract the actual pays_fee from a dispatch result if any or fall back to the default
/// weight.
pub fn extract_actual_pays_fee(result: &DispatchResultWithPostInfo, info: &DispatchInfo) -> Pays {
match result {
Ok(post_info) => post_info,
@@ -368,11 +369,10 @@ where
}
/// Implementation for unchecked extrinsic.
impl<Address, Call, Signature, Extra> GetDispatchInfo
for UncheckedExtrinsic<Address, Call, Signature, Extra>
impl<Address, Call, Signature, Extension> GetDispatchInfo
for UncheckedExtrinsic<Address, Call, Signature, Extension>
where
Call: GetDispatchInfo,
Extra: SignedExtension,
Call: GetDispatchInfo + Dispatchable,
{
fn get_dispatch_info(&self) -> DispatchInfo {
self.function.get_dispatch_info()
@@ -380,7 +380,7 @@ where
}
/// Implementation for checked extrinsic.
impl<AccountId, Call, Extra> GetDispatchInfo for CheckedExtrinsic<AccountId, Call, Extra>
impl<AccountId, Call, Extension> GetDispatchInfo for CheckedExtrinsic<AccountId, Call, Extension>
where
Call: GetDispatchInfo,
{
@@ -389,21 +389,6 @@ where
}
}
/// Implementation for test extrinsic.
#[cfg(feature = "std")]
impl<Call: Encode + GetDispatchInfo, Extra: Encode> GetDispatchInfo
for sp_runtime::testing::TestXt<Call, Extra>
{
fn get_dispatch_info(&self) -> DispatchInfo {
// for testing: weight == size.
DispatchInfo {
weight: Weight::from_parts(self.encode().len() as _, 0),
pays_fee: Pays::Yes,
class: self.call.get_dispatch_info().class,
}
}
}
/// A struct holding value for each `DispatchClass`.
#[derive(Clone, Eq, PartialEq, Default, Debug, Encode, Decode, TypeInfo, MaxEncodedLen)]
pub struct PerDispatchClass<T> {
+5 -3
View File
@@ -54,7 +54,8 @@ pub mod __private {
#[cfg(feature = "std")]
pub use sp_runtime::{bounded_btree_map, bounded_vec};
pub use sp_runtime::{
traits::Dispatchable, DispatchError, RuntimeDebug, StateVersion, TransactionOutcome,
traits::{AsSystemOriginSigner, Dispatchable},
DispatchError, RuntimeDebug, StateVersion, TransactionOutcome,
};
#[cfg(feature = "std")]
pub use sp_state_machine::BasicExternalities;
@@ -75,6 +76,7 @@ pub mod storage;
#[cfg(test)]
mod tests;
pub mod traits;
pub mod transaction_extensions;
pub mod weights;
#[doc(hidden)]
pub mod unsigned {
@@ -1602,8 +1604,8 @@ pub mod pallet_macros {
/// [`ValidateUnsigned`](frame_support::pallet_prelude::ValidateUnsigned) for
/// type `Pallet<T>`, and some optional where clause.
///
/// NOTE: There is also the [`sp_runtime::traits::SignedExtension`] trait that can be used
/// to add some specific logic for transaction validation.
/// NOTE: There is also the [`sp_runtime::traits::TransactionExtension`] trait that can be
/// used to add some specific logic for transaction validation.
///
/// ## Macro expansion
///
+20 -1
View File
@@ -482,7 +482,7 @@ pub trait OriginTrait: Sized {
type Call;
/// The caller origin, overarching type of all pallets origins.
type PalletsOrigin: Into<Self> + CallerTrait<Self::AccountId> + MaxEncodedLen;
type PalletsOrigin: Send + Sync + Into<Self> + CallerTrait<Self::AccountId> + MaxEncodedLen;
/// The AccountId used across the system.
type AccountId;
@@ -496,6 +496,14 @@ pub trait OriginTrait: Sized {
/// Replace the caller with caller from the other origin
fn set_caller_from(&mut self, other: impl Into<Self>);
/// Replace the caller with caller from the other origin
fn set_caller(&mut self, caller: Self::PalletsOrigin);
/// Replace the caller with caller from the other origin
fn set_caller_from_signed(&mut self, caller_account: Self::AccountId) {
self.set_caller(Self::PalletsOrigin::from(RawOrigin::Signed(caller_account)))
}
/// Filter the call if caller is not root, if false is returned then the call must be filtered
/// out.
///
@@ -544,6 +552,17 @@ pub trait OriginTrait: Sized {
fn as_system_ref(&self) -> Option<&RawOrigin<Self::AccountId>> {
self.caller().as_system_ref()
}
/// Extract a reference to the sytsem signer, if that's what the caller is.
fn as_system_signer(&self) -> Option<&Self::AccountId> {
self.caller().as_system_ref().and_then(|s| {
if let RawOrigin::Signed(ref who) = s {
Some(who)
} else {
None
}
})
}
}
#[cfg(test)]
+1 -12
View File
@@ -919,24 +919,13 @@ pub trait ExtrinsicCall: sp_runtime::traits::Extrinsic {
fn call(&self) -> &Self::Call;
}
#[cfg(feature = "std")]
impl<Call, Extra> ExtrinsicCall for sp_runtime::testing::TestXt<Call, Extra>
where
Call: codec::Codec + Sync + Send + TypeInfo,
Extra: TypeInfo,
{
fn call(&self) -> &Self::Call {
&self.call
}
}
impl<Address, Call, Signature, Extra> ExtrinsicCall
for sp_runtime::generic::UncheckedExtrinsic<Address, Call, Signature, Extra>
where
Address: TypeInfo,
Call: TypeInfo,
Signature: TypeInfo,
Extra: sp_runtime::traits::SignedExtension + TypeInfo,
Extra: TypeInfo,
{
fn call(&self) -> &Self::Call {
&self.function
@@ -0,0 +1,89 @@
// This file is part of Substrate.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Transaction extensions.
use crate::{CloneNoBound, EqNoBound, PartialEqNoBound, RuntimeDebugNoBound};
use codec::{Decode, Encode};
use scale_info::TypeInfo;
use sp_io::hashing::blake2_256;
use sp_runtime::{
impl_tx_ext_default,
traits::{
transaction_extension::{TransactionExtensionBase, TransactionExtensionInterior},
DispatchInfoOf, Dispatchable, IdentifyAccount, TransactionExtension, Verify,
},
transaction_validity::{InvalidTransaction, TransactionValidityError, ValidTransaction},
};
#[derive(
CloneNoBound, EqNoBound, PartialEqNoBound, Encode, Decode, RuntimeDebugNoBound, TypeInfo,
)]
#[codec(encode_bound())]
#[codec(decode_bound())]
pub struct VerifyMultiSignature<V: Verify>
where
V: TransactionExtensionInterior,
<V::Signer as IdentifyAccount>::AccountId: TransactionExtensionInterior,
{
signature: V,
account: <V::Signer as IdentifyAccount>::AccountId,
}
impl<V: Verify> TransactionExtensionBase for VerifyMultiSignature<V>
where
V: TransactionExtensionInterior,
<V::Signer as IdentifyAccount>::AccountId: TransactionExtensionInterior,
{
const IDENTIFIER: &'static str = "VerifyMultiSignature";
type Implicit = ();
}
impl<V: Verify, Call: Dispatchable + Encode, Context> TransactionExtension<Call, Context>
for VerifyMultiSignature<V>
where
V: TransactionExtensionInterior,
<V::Signer as IdentifyAccount>::AccountId: TransactionExtensionInterior,
<Call as Dispatchable>::RuntimeOrigin: From<Option<<V::Signer as IdentifyAccount>::AccountId>>,
{
type Val = ();
type Pre = ();
impl_tx_ext_default!(Call; Context; prepare);
fn validate(
&self,
_origin: <Call as Dispatchable>::RuntimeOrigin,
_call: &Call,
_info: &DispatchInfoOf<Call>,
_len: usize,
_: &mut Context,
_: (),
inherited_implication: &impl Encode,
) -> Result<
(ValidTransaction, Self::Val, <Call as Dispatchable>::RuntimeOrigin),
TransactionValidityError,
> {
let msg = inherited_implication.using_encoded(blake2_256);
if !self.signature.verify(&msg[..], &self.account) {
Err(InvalidTransaction::BadProof)?
}
// We clobber the original origin. Maybe we shuld check that it's none?
let origin = Some(self.account.clone()).into();
Ok((ValidTransaction::default(), (), origin))
}
}
@@ -15,24 +15,23 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
//! DATE: 2023-06-16 (Y/M/D)
//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
//! DATE: 2024-03-01 (Y/M/D)
//! HOSTNAME: `runner-bn-ce5rx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//!
//! SHORT-NAME: `block`, LONG-NAME: `BlockExecution`, RUNTIME: `Development`
//! WARMUPS: `10`, REPEAT: `100`
//! WEIGHT-PATH: `./frame/support/src/weights/`
//! WEIGHT-PATH: `./substrate/frame/support/src/weights/`
//! WEIGHT-METRIC: `Average`, WEIGHT-MUL: `1.0`, WEIGHT-ADD: `0`
// Executed Command:
// ./target/production/substrate
// ./target/production/substrate-node
// benchmark
// overhead
// --chain=dev
// --execution=wasm
// --wasm-execution=compiled
// --weight-path=./frame/support/src/weights/
// --header=./HEADER-APACHE2
// --weight-path=./substrate/frame/support/src/weights/
// --header=./substrate/HEADER-APACHE2
// --warmup=10
// --repeat=100
@@ -44,17 +43,17 @@ parameter_types! {
/// Calculated by multiplying the *Average* with `1.0` and adding `0`.
///
/// Stats nanoseconds:
/// Min, Max: 376_949, 622_462
/// Average: 390_584
/// Median: 386_322
/// Std-Dev: 24792.0
/// Min, Max: 424_332, 493_017
/// Average: 437_118
/// Median: 434_920
/// Std-Dev: 8798.01
///
/// Percentiles nanoseconds:
/// 99th: 433_299
/// 95th: 402_688
/// 75th: 391_645
/// 99th: 460_074
/// 95th: 451_580
/// 75th: 440_307
pub const BlockExecutionWeight: Weight =
Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(390_584), 0);
Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(437_118), 0);
}
#[cfg(test)]
@@ -15,24 +15,23 @@
// See the License for the specific language governing permissions and
// limitations under the License.
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev
//! DATE: 2023-06-16 (Y/M/D)
//! HOSTNAME: `runner-e8ezs4ez-project-145-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 32.0.0
//! DATE: 2024-03-01 (Y/M/D)
//! HOSTNAME: `runner-bn-ce5rx-project-674-concurrent-0`, CPU: `Intel(R) Xeon(R) CPU @ 2.60GHz`
//!
//! SHORT-NAME: `extrinsic`, LONG-NAME: `ExtrinsicBase`, RUNTIME: `Development`
//! WARMUPS: `10`, REPEAT: `100`
//! WEIGHT-PATH: `./frame/support/src/weights/`
//! WEIGHT-PATH: `./substrate/frame/support/src/weights/`
//! WEIGHT-METRIC: `Average`, WEIGHT-MUL: `1.0`, WEIGHT-ADD: `0`
// Executed Command:
// ./target/production/substrate
// ./target/production/substrate-node
// benchmark
// overhead
// --chain=dev
// --execution=wasm
// --wasm-execution=compiled
// --weight-path=./frame/support/src/weights/
// --header=./HEADER-APACHE2
// --weight-path=./substrate/frame/support/src/weights/
// --header=./substrate/HEADER-APACHE2
// --warmup=10
// --repeat=100
@@ -44,17 +43,17 @@ parameter_types! {
/// Calculated by multiplying the *Average* with `1.0` and adding `0`.
///
/// Stats nanoseconds:
/// Min, Max: 123_875, 128_419
/// Average: 124_414
/// Median: 124_332
/// Std-Dev: 497.74
/// Min, Max: 106_053, 107_403
/// Average: 106_446
/// Median: 106_415
/// Std-Dev: 216.17
///
/// Percentiles nanoseconds:
/// 99th: 125_245
/// 95th: 124_989
/// 75th: 124_498
/// 99th: 107_042
/// 95th: 106_841
/// 75th: 106_544
pub const ExtrinsicBaseWeight: Weight =
Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(124_414), 0);
Weight::from_parts(WEIGHT_REF_TIME_PER_NANOS.saturating_mul(106_446), 0);
}
#[cfg(test)]
@@ -815,7 +815,7 @@ fn test_metadata() {
ty: meta_type::<UncheckedExtrinsic>(),
version: 4,
signed_extensions: vec![SignedExtensionMetadata {
identifier: "UnitSignedExtension",
identifier: "UnitTransactionExtension",
ty: meta_type::<()>(),
additional_signed: meta_type::<()>(),
}],
@@ -477,7 +477,7 @@ note: required because it appears within the type `RuntimeCall`
| ||_- in this macro invocation
... |
note: required by a bound in `frame_support::sp_runtime::traits::Dispatchable::Config`
--> $WORKSPACE/substrate/primitives/runtime/src/traits.rs
--> $WORKSPACE/substrate/primitives/runtime/src/traits/mod.rs
|
| type Config;
| ^^^^^^^^^^^^ required by this bound in `Dispatchable::Config`
@@ -510,7 +510,7 @@ note: required because it appears within the type `RuntimeCall`
| ||_- in this macro invocation
... |
note: required by a bound in `frame_support::pallet_prelude::ValidateUnsigned::Call`
--> $WORKSPACE/substrate/primitives/runtime/src/traits.rs
--> $WORKSPACE/substrate/primitives/runtime/src/traits/mod.rs
|
| type Call;
| ^^^^^^^^^^ required by this bound in `ValidateUnsigned::Call`
+80 -63
View File
@@ -743,10 +743,40 @@ impl pallet5::Config for Runtime {
type RuntimeOrigin = RuntimeOrigin;
}
#[derive(Clone, Debug, codec::Encode, codec::Decode, PartialEq, Eq, scale_info::TypeInfo)]
pub struct AccountU64(u64);
impl sp_runtime::traits::IdentifyAccount for AccountU64 {
type AccountId = u64;
fn into_account(self) -> u64 {
self.0
}
}
impl sp_runtime::traits::Verify for AccountU64 {
type Signer = AccountU64;
fn verify<L: sp_runtime::traits::Lazy<[u8]>>(
&self,
_msg: L,
_signer: &<Self::Signer as sp_runtime::traits::IdentifyAccount>::AccountId,
) -> bool {
true
}
}
impl From<u64> for AccountU64 {
fn from(value: u64) -> Self {
Self(value)
}
}
pub type Header = sp_runtime::generic::Header<u32, sp_runtime::traits::BlakeTwo256>;
pub type Block = sp_runtime::generic::Block<Header, UncheckedExtrinsic>;
pub type UncheckedExtrinsic =
sp_runtime::testing::TestXt<RuntimeCall, frame_system::CheckNonZeroSender<Runtime>>;
pub type UncheckedExtrinsic = sp_runtime::generic::UncheckedExtrinsic<
u64,
RuntimeCall,
AccountU64,
frame_system::CheckNonZeroSender<Runtime>,
>;
frame_support::construct_runtime!(
pub struct Runtime {
@@ -896,10 +926,8 @@ fn inherent_expand() {
let inherents = InherentData::new().create_extrinsics();
let expected = vec![UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
signature: None,
}];
let expected =
vec![UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_no_post_info {}))];
assert_eq!(expected, inherents);
let block = Block::new(
@@ -911,14 +939,11 @@ fn inherent_expand() {
Digest::default(),
),
vec![
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
signature: None,
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 0 }),
signature: None,
},
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_no_post_info {})),
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo {
foo: 1,
bar: 0,
})),
],
);
@@ -933,14 +958,11 @@ fn inherent_expand() {
Digest::default(),
),
vec![
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
signature: None,
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo { foo: 0, bar: 0 }),
signature: None,
},
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_no_post_info {})),
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo {
foo: 0,
bar: 0,
})),
],
);
@@ -954,10 +976,9 @@ fn inherent_expand() {
BlakeTwo256::hash(b"test"),
Digest::default(),
),
vec![UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_storage_layer { foo: 0 }),
signature: None,
}],
vec![UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_storage_layer {
foo: 0,
}))],
);
let mut inherent = InherentData::new();
@@ -972,10 +993,12 @@ fn inherent_expand() {
BlakeTwo256::hash(b"test"),
Digest::default(),
),
vec![UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
signature: Some((1, Default::default())),
}],
vec![UncheckedExtrinsic::new_signed(
RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
1,
1.into(),
Default::default(),
)],
);
let mut inherent = InherentData::new();
@@ -991,14 +1014,13 @@ fn inherent_expand() {
Digest::default(),
),
vec![
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 1 }),
signature: None,
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_storage_layer { foo: 0 }),
signature: None,
},
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo {
foo: 1,
bar: 1,
})),
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_storage_layer {
foo: 0,
})),
],
);
@@ -1013,18 +1035,14 @@ fn inherent_expand() {
Digest::default(),
),
vec![
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 1 }),
signature: None,
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_storage_layer { foo: 0 }),
signature: None,
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
signature: None,
},
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo {
foo: 1,
bar: 1,
})),
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_storage_layer {
foo: 0,
})),
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_no_post_info {})),
],
);
@@ -1039,18 +1057,17 @@ fn inherent_expand() {
Digest::default(),
),
vec![
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 1 }),
signature: None,
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 0 }),
signature: Some((1, Default::default())),
},
UncheckedExtrinsic {
call: RuntimeCall::Example(pallet::Call::foo_no_post_info {}),
signature: None,
},
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo {
foo: 1,
bar: 1,
})),
UncheckedExtrinsic::new_signed(
RuntimeCall::Example(pallet::Call::foo { foo: 1, bar: 0 }),
1,
1.into(),
Default::default(),
),
UncheckedExtrinsic::new_bare(RuntimeCall::Example(pallet::Call::foo_no_post_info {})),
],
);
@@ -1933,7 +1950,7 @@ fn extrinsic_metadata_ir_types() {
>(),
ir.signature_ty
);
assert_eq!(meta_type::<()>(), ir.signature_ty);
assert_eq!(meta_type::<AccountU64>(), ir.signature_ty);
assert_eq!(meta_type::<<<UncheckedExtrinsic as ExtrinsicT>::SignaturePayload as SignaturePayloadT>::SignatureExtra>(), ir.extra_ty);
assert_eq!(meta_type::<frame_system::CheckNonZeroSender<Runtime>>(), ir.extra_ty);
@@ -943,7 +943,7 @@ fn metadata() {
ty: scale_info::meta_type::<UncheckedExtrinsic>(),
version: 4,
signed_extensions: vec![SignedExtensionMetadata {
identifier: "UnitSignedExtension",
identifier: "UnitTransactionExtension",
ty: scale_info::meta_type::<()>(),
additional_signed: scale_info::meta_type::<()>(),
}],