metatx

type Transactable interface {
	// transactable types need to be able to marshal and unmarshal themselves
	msgp.Marshaler
	msgp.Unmarshaler

	// Validate returns nil if the Transactable is valid, or an error otherwise.
	//
	// `app` will always be an instance of your app; it is expected that the
	// first line of most implementations will be
	//
	// “`go
	// app := appInt.(*MyApp)
	// ““
	Validate(app interface{}) error

	// Apply applies this transaction to the supplied application, updating its
	// internal state as required.
	//
	// If anything but nil is returned, the internal state of the input App
	// must be unchanged.
	//
	// `app` will always be an instance of your app; it is expected that the
	// first line of most implementations will be
	//
	// “`go
	// app := appInt.(*MyApp)
	// “`
	Apply(app interface{}) error

	// SignableBytes must return a representation of all the data in the
	// transactable, except the signature. No particular ordering or schema
	// is required, only that the bytes are computed deterministically and
	// contain a complete representation of the transactable.
	//
	// For transactables with a signature field, this must _not_ include the
	// signature.
	//
	// For transactables without a signature field, this must include all data.
	// In that case, it is probably simplest to delegate this function
	// to `.MarshalMsg(nil)`.
	//
	// Unfortunately, we can't enforce the above two restrictions in code; just
	// trust that if you don't write your implementation with those semantics,
	// you will encounter weird, hard-to-debug errors eventually.
	//
	// This is designed to support two use cases:
	//
	//   1.  Most transactables must be signed. Using this method simplifies
	//       the problem of generating and validating signatures.
	//   2.  For error tracing, we desire a short and unique-ish string which
	//       can be computed for every transaction. We can get there from here.
	SignableBytes() []byte
}

type Transaction struct {
	Nonce          []byte
	TransactableID TxID
	Transactable   msgp.Raw
}

type TxID uint8

type TxIDMap map[TxID]Transactable