Signed Extensions

Anatomy

A signed extension can be either combination of the following things:

Some additional data that is attached to the transaction.
- The tip!

Some hooks that are executed before and after the transaction is executed.
- Before each transaction is executed, it must pay its fee upfront.
- Perhaps refund the fee partially 🤑.

Anatomy: Let's Peek at the Trait

 pub trait SignedExtension:
    Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
{
    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;
 
    fn validate(..) -> TransactionValidity;
    fn validate_unsigned(..) -> TransactionValidity;
 
    fn pre_dispatch() -> Result<Self::Pre, TransactionValidityError>;
    fn pre_dispatch_unsigned() -> Result<(), TransactionValidityError>;
 
    fn post_dispatch() -> Result<(), TransactionValidityError>;
} pub trait SignedExtension:
    Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
{
    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;
 
    fn validate(..) -> TransactionValidity;
    fn validate_unsigned(..) -> TransactionValidity;
 
    fn pre_dispatch() -> Result<Self::Pre, TransactionValidityError>;
    fn pre_dispatch_unsigned() -> Result<(), TransactionValidityError>;
 
    fn post_dispatch() -> Result<(), TransactionValidityError>;
} pub trait SignedExtension:
    Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
{
    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;
 
    fn validate(..) -> TransactionValidity;
    fn validate_unsigned(..) -> TransactionValidity;
 
    fn pre_dispatch() -> Result<Self::Pre, TransactionValidityError>;
    fn pre_dispatch_unsigned() -> Result<(), TransactionValidityError>;
 
    fn post_dispatch() -> Result<(), TransactionValidityError>;
} pub trait SignedExtension:
    Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
{
    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;
 
    fn validate(..) -> TransactionValidity;
    fn validate_unsigned(..) -> TransactionValidity;
 
    fn pre_dispatch() -> Result<Self::Pre, TransactionValidityError>;
    fn pre_dispatch_unsigned() -> Result<(), TransactionValidityError>;
 
    fn post_dispatch() -> Result<(), TransactionValidityError>;
} pub trait SignedExtension:
    Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
{
    fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;
 
    fn validate(..) -> TransactionValidity;
    fn validate_unsigned(..) -> TransactionValidity;
 
    fn pre_dispatch() -> Result<Self::Pre, TransactionValidityError>;
    fn pre_dispatch_unsigned() -> Result<(), TransactionValidityError>;
 
    fn post_dispatch() -> Result<(), TransactionValidityError>;
}

Encoding

struct Foo(u32, u32);
impl SignedExtension for Foo {
  type AdditionalSigned = u32;
  fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError> {
    Ok(42u32)
  }
}

pub struct UncheckedExtrinsic<Address, Call, Signature, (Foo)>
{
    pub signature: Option<(Address, Signature, Extra)>,
    pub function: Call,
}

2 u32 are decoded as, 42u32 is expected to be in the signature payload.

Here's the check function of CheckedExtrinsic extensively documented to demonstrate this:

// SignedPayload::new
pub fn new(call: Call, extra: Extra) -> Result<Self, TransactionValidityError> {
    // asks all signed extensions to give their additional signed data..
    let additional_signed = extra.additional_signed()?;
    // this essentially means: what needs to be signed in the signature of the transaction is:
    // 1. call
    // 2. signed extension data itself
    // 3. any additional signed data.
    let raw_payload = (call, extra, additional_signed);
    Ok(Self(raw_payload))
}

<p>// UncheckedExtrinsic::check
fn check(self, lookup: &Lookup) -> Result<Self::Checked, TransactionValidityError> {
    Ok(match self.signature {
        Some((signed, signature, extra)) => {
            let signed = lookup.lookup(signed)?;
            // this is the payload that we expect to be signed, as explained above.
            let raw_payload = SignedPayload::new(self.function, extra)?;
            // encode the signed payload, and check it against the signature.
            if !raw_payload.using_encoded(|payload| signature.verify(payload, &signed)) {
                return Err(InvalidTransaction::BadProof.into())
            }</p>
<pre><code class="undefined">        // the extra is passed again to `CheckedExtrinsic`, see in the next section.
        let (function, extra, _) = raw_payload.deconstruct();
        CheckedExtrinsic { signed: Some((signed, extra)), function }
    },
    // we don&#39;t care about signed extensions at all.
    None =&gt; CheckedExtrinsic { signed: None, function: self.function },
})</code></pre>}

1 . 1

Signed Extensions

Signed Extensions

History

History

Anatomy

Anatomy

Anatomy: Let's Peek at the Trait

Grouping Signed Extension

Usage In The Runtime

Encoding

Transaction Pool Validation

Transaction Pool Validation

Transaction Pool Validation

Post Dispatch

Notable Signed Extensions

`ChargeTransactionPayment`

`check_genesis`

`check_non_zero_sender`

`check_nonce`

`check_weight`

Big Picture: Pipeline of Extension

Big Picture: Pipeline of Extension

Exercises

	pub trait SignedExtension:
	Codec + Debug + Sync + Send + Clone + Eq + PartialEq + StaticTypeInfo
	{
	fn additional_signed(&self) -> Result<Self::AdditionalSigned, TransactionValidityError>;

	fn validate(..) -> TransactionValidity;
	fn validate_unsigned(..) -> TransactionValidity;

	fn pre_dispatch() -> Result<Self::Pre, TransactionValidityError>;
	fn pre_dispatch_unsigned() -> Result<(), TransactionValidityError>;

	fn post_dispatch() -> Result<(), TransactionValidityError>;
	}