Allow nested pallet error, and encode pallet error in 2 bytes.

[gui1117]

Currently pallet error is encoded in one byte, and declare in the metadata some documentation associated to each byte.

But we could encode the error on 2 bytes and allow some nested error. As long as the nested error encode in 1 byte and declare its metadata in some way.

We could implement something like this:

#[pallet::error]
enum Error<C: Config> {
    /// Some error
    Foo(Bar),
}

And require Bar to implement a trait.

trait PalletNestedError: Into<u8> {
    fn metadata() -> &[&'static str];
}

The nested error could make use of regular derive macro.

#[derive(PalletNestedError)]
pub enum Bar {
    /// Some doc
    M,
}

This require also some changes in the metadata, (and we probably want to keep the old metadata format available for off-chain libraries, but this is another issue #8083).

[gui1117]

once we have metadata with scale-info i think error is just a regular type with its scale-info.
So we should only make sure that the type is not too big so that it is not a footgun, but otherwise any type should easily accepted.

[stale]

Hey, is anyone still working on this? Due to the inactivity this issue has been automatically marked as stale. It will be closed if no further activity occurs. Thank you for your contributions.

[gui1117]

still relevant to me, also with #8615 which should be able to improve it easily

[KiChjang]

Okay, so I would ideally want to use a static assertion here to ensure that the encoded size is less than or equal to 2 bytes. Problem is, there isn't really a method to call the encoded_size() in a const context, since Rust does not support const fns in traits yet.

[KiChjang]

The other issue is, the pallet Error type may be parametric, so we can't know the encoded size of the type until we construct the runtime.

[gui1117]

We can still make a new trait which definition is: encoded size is at most 2 bytes. Like:

trait PalletNestedError {
    fn metadata() -> &[&'static str];
    fn encode() -> u16;
}

I mean we can create a new set of trait and derive macro to declare those errors and they would ensure the constraint we want.

We could also just have some test to ensure the max encoded size is less than some value. It might be enough I'm not sure

[xlc]

We already have assert to ensure size of Call. Similar thing can be done to ensure size of Error

[gui1117]

yes we can also assert this in the integrity test of frame_system pallet