Previously, validate_referenced_accounts was called during transaction
application; however, account creation is one of those changes that
doesn't really take effect until the end of the block, so we want to
validate the referenced accounts for all transactions at the beginning
of the block so that if trx A creates account joe, then trx B references
joe, that reference will fail if A and B are in the same block. We also
call it during push_transaction, as we do want to check it for pending
transactions that aren't in a block yet.

Implement automatic signing of transactions in the test framework.
Currently disabled, as it's not yet working

I want two things from AuthorityChecker that it wasn't doing yet:
1. I want it to track which of the provided keys were used, so I can
reject transactions which bear more signatures than are necessary
2. To sign a transaction with no unnecessary keys, I want it to support
taking a list of available public keys and an authority, then telling me
which of those keys I should use to fully satisfy the authority, without
having any unnecessary keys

As an added bonus, having both of these operations handled by
AuthorityChecker means that determining the set of keys needed to sign a
transaction, and determining whether a transaction is properly signed,
use the same code. :D

Move logic from apply_context::unused_authorizations out to a header so
other code can use it.

The logic in question takes an array of data, and a parallel array of
"markers" (booleans, in this instance), and returns a range containing
only the data elements whose corresponding marker matches a provided
value (i.e. the boolean was true).

Stay tuned to see how else I use this code! ;)

Allow scoped_exit objects to be canceled so they do not call their
callbacks when destroyed.

When rejecting a transaction due to excessive authorizations on a
message, include the authorizations which were not necessary in the
reported error

Add macros for Link_Authority and Unlink_Authority, write some initial
tests of these operations, and fix a bug (unlinkauth didn't require any
authority)

Initial Transaction API

Otherwise the build fails on my system

The behavior change is that I am forbidding changing a
permission_object's parent until we come up with a safe way to support
it. The issue is that it's possible to create loops by creating an
object A with an existing parent B, then setting B's parent to A. The
obvious solution is to ensure with every parent change that there is a
path back to the owner authority by following parents, but to do this we
need a tree depth limit. I haven't explored the implications of that, so
I'm just disabling parent changes for the time being. The user can
simply delete the old subtree and create a new one if he wants to move a
subtree from one parent to another.

Create and smoke test Add_Authority and Delete_Authority test helper
macros

Add a new testing helper macro, Complex_Authority, to create an
arbitrary Authority inline with a slightly less confusing syntax

Though not strictly part of issue 123, this is a necessary step in order
to complete #123. Rename UpdatePermission->updateauth and
DeletePermission->deleteauth, and implement them.

At this point, I think #123 is fully implemented and ready for testing.

Add a check to the validate function on authority which checks that the
authority can be satisfied, which is to say, that the total of all the
weights meets or exceeds the threshold.

Add an unlinkauth message type which removes a link from a message type
to a required authority

Implement the linkauth handler in the system contract

The name requirepermission was too long, so I renamed it linkauth

Add docs on some of the types, register the index, and implement
chain_controller::lookup_minimum_permission.

Define the types documented in the issue.

TODO: Implement logic

Require_authorization is now implemented so as the contract executes and
asserts that a particular account approved the transaction, the chain
asserts that this is so and throws if not.

Also, update the tests, since the auth checks now bring to bear the rule
that an account cannot be used in the same block that creates it. The
tests now comply with this rule.

TODO:
 - Check that all declared authorizations get required by the contract
 - Implement the mapping from user permissions to message types
 - Use mapping of permission to message type in
lookup_minimum_permission

We now check authorization of transactions when they come in as pending,
and again when we apply them in some block (either when generating the
block or when applying it). When applying the transactions in a block,
we check auth for all transactions in the block prior to processing any.

To check auth, we first scan all of the declared authorizations, and
check that the authorization is sufficient to grant permission for the
given account to execute the given message type (TODO: look up the
actual required permission level rather than just assuming it's
'active'); then, check that the transaction bears signatures to confer
the declared authorization.

1) add default command - help
2) prevent segfault

Implement and test remaining db functions

Eosc ext 125