Auto-generate hooks based on Runtime

[preston-evans98]

Currently, users have to manually define their TxHooks implementation based on the modules they use. In principle, though, it seems like it should be possible (and much less error-prone) to automatically generate the hooks based on the runtime.

cc @bkolad

[bkolad]

What about this:

1. We introduce ModuleHook trait with pre_dispatch_tx_hook, post_dispatch_tx_hook etc methods
2. Every module that introduces hooks needs to implement this trait.
3. Runtime gets an additional macro and [hooks] attribute:

#[derive(Genesis, DispatchCall, MessageCodec, Hooks)]
pub struct Runtime<C: Context> {
   #[hook]
    pub sequencer: sequencer::Sequencer<C>,

    pub bank: bank::Bank<C>,

    pub election: election::Election<C>,

    pub value_setter: value_setter::ValueSetter<C>,

   #[hook]
    pub accounts: accounts::Accounts<C>,
}

And the implementation of the Hook trait is automatically derived.

[preston-evans98]

This looks great overall. Do we have a motivating a use case where users would want a module without its hooks though? If not, can we just derive a no-op Hook trait implementation for all Modules and then get rid of the #[hook] annotation here? I'm worried that forgetting to add the annotation will be a very subtle way to completely break security guarantees

[bkolad]

Yeah we can automatically derive implementations with noop.

[bkolad]

After incorporating #361, the hooks implementation has a well-defined structure, allowing us to implement the macro. However, there is a small remaining issue.

impl<C: Context> TxHooks for Runtime<C> {
    type Context = C;

    fn pre_dispatch_tx_hook(
        &self,
        tx: Transaction<Self::Context>,
        working_set: &mut WorkingSet<<Self::Context as Spec>::Storage>,
    ) -> anyhow::Result<<Self::Context as Spec>::Address> {
        self.accounts.pre_dispatch_tx_hook(tx, working_set)
    }

    fn post_dispatch_tx_hook(
        &self,
        tx: &Transaction<Self::Context>,
        working_set: &mut WorkingSet<<Self::Context as Spec>::Storage>,
    ) -> anyhow::Result<()> {
        self.accounts.post_dispatch_tx_hook(tx, working_set)
    }
}

The issue with the pre_dispatch_tx_hook method is that it returns an Address type, which is not ideal for macros. As we add more modules, we will need to handle the return types for pre_dispatch_tx_hook of each module. One possible solution is to generate a type that holds all the types, but it is unclear how the user would interact with this generated type.

To address this, we can modify the pre_dispatch_tx_hook method to return Result<()>. However, we still need to obtain the Account from the PublicKey. There are two ways to solve this:

1.Remove the functionality that updates the Address corresponding to a given PublicKey and use PublicKey::default_address() everywhere.
2. Send both the Address and PublicKey together in a Transaction. In this case, the sov-accounts module would validate if they match and return Result<()>.