Just embed the logic needed right in to wallet implementations. This will cause a little bit of code duplication but avoids the complexity of the functor

Add a new signing method to sign_transaction so that it can call out to an external functor to sign the transaction's digest. We will not always have access to the private_key so transaction signing can't expect to use that.

cleanup of transaction_context, throwing soft resource limit exceptions if limit is due to block, and preferential network billing of prunable data (#2000)

* cpu_usage limit for an action is properly tracked even through inline actions
* receipt should store net usage in words
* total billed cpu usage for a transaction should be rounded up to nearest multiple of 1024
* enforce the cpu and net usage limits set in chain configuration
* additional stateless validation on generated transactions
* clear expired input transactions (and do not touch generated transactions) on start block rather than finalize block
* fix clear expired input transactions to use pending block time rather than head block time
* update producer authority at start of block (implemention still necessary)
* move resource limit updates and updating tapos from commit_block to finalize_block
* fix to controller::last_irreversible_block_id()
* reduce default_base_per_transaction_net_usage

fixed vulnerability in previous transaction_mroot definition by now also committing to region_id, cycle_index, shard_index, and trx_index in leaf nodes of Merkle tree #1972

Enforce region id in transaction header.

Removed old calculate_transaction_merkle_root function call from
block_tests/push_invalid_block and block_tests/block_id_sig_independent
since they weren't critical to the tests anyway.

Also, bill usage (most critically network bandwidth) for accepting delayed transaction into the block.

compress context_free_data in packed_transaction and change bandwidth usage values in transaction header into upper limits

Also, disallowed redundant signatures in a tx that are signed by the
same key.

Modified block_tests/irrelevant_sig_soft_check to check for multiple
signatures by same key and to account for the fact that blocks with
transactions that have irrelevant signatures are objectively invalid.

Also added block_tests/irrelevant_sig_hard_check unit test to verify
that such objectively invalid blocks are rejected.

This is a crude but functional key recovery cache for transactions. It improves performance considerably. Today it can grow forever but the next release will contain a proper implmentation.

- todo: some of the test are broken because the tests were malformed in
the first place (missing auths)

All transactions must declare a list of permissions they utilize. The
chain now checks that the signatures are present to satisfy these
permissions, at least theoretically (only partially tested). As the
transaction is evaluated and applied, the message handlers will check
that the required permissions were declared on the transaction.

Also, define the logic to check that an authority is satisfied (only this
part is tested so far)

TODO: Test that transactions are rejected if they do not bear sufficient
signatures
TODO: Make message handlers check the declared permissions are sufficient,
and reject the transaction if they are not.

Remove chain::Transaction altogether, move its methods to
chain::SignedTransaction, which solely inherits
types::SignedTransaction, which solely inherits types::Transaction.
Aside from having no diamonds, this also eliminates vtables in the
Transaction types, which is necessary in order to store transactions in
the database.

We have a number of types defined in eos::chain like transaction,
message, etc. which parallel autogenerated types in eos::types. They are
identical in storage, but the chain types have various helper methods
which the autogenerated types, of course, lack.

I've unified these by letting the generated classes in types:: store the
data, and having the chain:: types inherit these data stores and add
functionality to them via methods.