weave

type Address ¶

type Address []byte

Address represents a collision-free, one-way digest of data (usually a public key) that can be used to identify a signer

It will be of size AddressLength

func MainSigner(ctx Context, fn AuthFunc) Address

func MustObjAddress(obj Marshaller) Address

func NewAddress(data []byte) Address

func ObjAddress(obj Marshaller) (Address, error)

func (a Address) MarshalJSON() ([]byte, error)

func (a *Address) UnmarshalJSON(src []byte) error

type AuthFunc ¶

type AuthFunc func(Context) []Address

AuthFunc is a function we can use to extract authentication info from the context. This should be passed into the constructor of handlers, so we can plug in another authentication system, rather than hardcoding x/auth for all extensions.

func MultiAuth(fns ...AuthFunc) AuthFunc

type Batch ¶

type Batch interface {
	SetDeleter
	Write()
}

Batch can write multiple ops atomically to an underlying KVStore

type CacheableKVStore ¶

type CacheableKVStore interface {
	KVStore
	CacheWrap() KVCacheWrap
}

CacheableKVStore is a KVStore that supports CacheWrapping

CacheWrap() should not return a Committer, since Commit() on cache-wraps make no sense.

type CheckResult ¶

type CheckResult struct {
	Data data.Bytes
	Log  string
	// GasAllocated is the maximum units of work we allow this tx to perform
	GasAllocated int64
	// GasPayment is the total fees for this tx (or other source of payment)
	GasPayment int64
}

CheckResult captures any non-error abci result to make sure people use error for error cases

func NewCheck(gasAllocated int64, log string) CheckResult

func (c CheckResult) ToABCI() abci.ResponseCheckTx

type Checker ¶

type Checker interface {
	Check(ctx Context, store KVStore, tx Tx) (CheckResult, error)
}

Checker is a subset of Handler to verify the validity of a transaction. It is its own interface to allow better type controls in the next arguments in Decorator

type CommitID ¶

type CommitID struct {
	Version int64
	Hash    []byte
}

CommitID contains the tree version number and its merkle root.

type CommitKVStore ¶

type CommitKVStore interface {
	// Get returns the value at last committed state
	// returns nil iff key doesn't exist. Panics on nil key.
	Get(key []byte) []byte

	// Get a CacheWrap to perform actions
	// TODO: add Batch to atomic writes and efficiency
	// invisibly inside this CacheWrap???
	CacheWrap() KVCacheWrap

	// Commit the next version to disk, and returns info
	Commit() CommitID

	// LoadLatestVersion loads the latest persisted version.
	// If there was a crash during the last commit, it is guaranteed
	// to return a stable state, even if older.
	LoadLatestVersion() error

	// LatestVersion returns info on the latest version saved to disk
	LatestVersion() CommitID
}

type Context ¶

type Context = context.Context

Context is just an alias for the standard implementation. We use functions to extend it to our domain

func WithChainID(ctx Context, chainID string) Context

func WithHeader(ctx Context, header abci.Header) Context

func WithHeight(ctx Context, height int64) Context

func WithLogInfo(ctx Context, keyvals ...interface{}) Context

func WithLogger(ctx Context, logger log.Logger) Context

type Decorator ¶

type Decorator interface {
	Check(ctx Context, store KVStore, tx Tx, next Checker) (CheckResult, error)
	Deliver(ctx Context, store KVStore, tx Tx, next Deliverer) (DeliverResult, error)
}

Decorator wraps a Handler to provide common functionality like authentication, or fee-handling, to many Handlers

type DeliverResult ¶

type DeliverResult struct {
	Data    data.Bytes
	Log     string
	Diff    []abci.Validator
	Tags    []common.KVPair
	GasUsed int64 // unused
}

DeliverResult captures any non-error abci result to make sure people use error for error cases

func (d DeliverResult) ToABCI() abci.ResponseDeliverTx

type Deliverer ¶

type Deliverer interface {
	Deliver(ctx Context, store KVStore, tx Tx) (DeliverResult, error)
}

Checker is a subset of Handler to execute a transaction. It is its own interface to allow better type controls in the next arguments in Decorator

type Handler ¶

type Handler interface {
	Checker
	Deliverer
}

Handler is a core engine that can process a few specific messages This could represent "coin transfer", or "bonding stake to a validator"

type Initializer ¶

type Initializer interface {
	FromGenesis(Options, KVStore) error
}

Initializer implementations are used to initialize extensions from genesis file contents

type Iterator ¶

type Iterator interface {
	// Valid returns whether the current position is valid.
	// Once invalid, an Iterator is forever invalid.
	Valid() bool

	// Next moves the iterator to the next sequential key in the database, as
	// defined by order of iteration.
	//
	// If Valid returns false, this method will panic.
	Next()

	// Key returns the key of the cursor.
	// If Valid returns false, this method will panic.
	// CONTRACT: key readonly []byte
	Key() (key []byte)

	// Value returns the value of the cursor.
	// If Valid returns false, this method will panic.
	// CONTRACT: value readonly []byte
	Value() (value []byte)

	// Close releases the Iterator.
	Close()
}

Iterator allows us to access a set of items within a range of keys. These may all be preloaded, or loaded on demand.

Usage:

var itr Iterator = ...
defer itr.Close()

for ; itr.Valid(); itr.Next() {
  k, v := itr.Key(); itr.Value()
  // ...
}

type KVCacheWrap ¶

type KVCacheWrap interface {
	// CacheableKVStore allows us to use this Cache recursively
	CacheableKVStore

	// Write syncs with the underlying store.
	Write()

	// Discard invalidates this CacheWrap and releases all data
	Discard()
}

KVCacheWrap allows us to maintain a scratch-pad of uncommitted data that we can view with all queries.

At the end, call Write to use the cached data, or Discard to drop it.

type KVStore ¶

type KVStore interface {
	ReadOnlyKVStore
	SetDeleter
	// NewBatch returns a batch that can write multiple ops atomically
	NewBatch() Batch
}

KVStore is a simple interface to get/set data

For simplicity, we require all backing stores to implement this interface. They *may* implement other methods as well, but at least these are required.

type MarshalValidater ¶

type MarshalValidater interface {
	Marshaller
	Validater
}

type Marshaller ¶

type Marshaller interface {
	Marshal() ([]byte, error)
}

Marshaller is anything that can be represented in binary

Marshall may validate the data before serializing it and unless you previously validated the struct, errors should be expected.

type Msg ¶

type Msg interface {
	Persistent

	// Return the message path.
	// This is used by the Router to locate the proper Handler.
	// Msg should be created alongside the Handler that corresponds to them.
	//
	// Multiple types may have the same value, and will end up at the
	// same Handler.
	//
	// Must be alphanumeric [0-9A-Za-z_\-]+
	Path() string
}

Msg is message for the blockchain to take an action (Make a state transition). It is just the request, and must be validated by the Handlers. All authentication information is in the wrapping Tx.

type Options ¶

type Options map[string]json.RawMessage

Options are the app options Each extension can look up it's key and parse the json as desired

func (o Options) ReadOptions(key string, obj interface{}) error

type Persistent ¶

type Persistent interface {
	Marshaller
	Unmarshal([]byte) error
}

Persistent supports Marshal and Unmarshal

This is separated from Marshal, as this almost always requires a pointer, and functions that only need to marshal bytes can use the Marshaller interface to access non-pointers.

As with Marshaller, this may do internal validation on the data and errors should be expected.

type ReadOnlyKVStore ¶

type ReadOnlyKVStore interface {
	// Get returns nil iff key doesn't exist. Panics on nil key.
	Get(key []byte) []byte

	// Has checks if a key exists. Panics on nil key.
	Has(key []byte) bool

	// Iterator over a domain of keys in ascending order. End is exclusive.
	// Start must be less than end, or the Iterator is invalid.
	// CONTRACT: No writes may happen within a domain while an iterator exists over it.
	Iterator(start, end []byte) Iterator

	// ReverseIterator over a domain of keys in descending order. End is exclusive.
	// Start must be greater than end, or the Iterator is invalid.
	// CONTRACT: No writes may happen within a domain while an iterator exists over it.
	ReverseIterator(start, end []byte) Iterator
}

ReadOnlyKVStore is a simple interface to query data.

type Registry ¶

type Registry interface {
	Handle(path string, h Handler)
}

Registry is an interface to register your handler, the setup side of a Router

type SetDeleter ¶

type SetDeleter interface {
	Set(key, value []byte) // CONTRACT: key, value readonly []byte
	Delete(key []byte)     // CONTRACT: key readonly []byte
}

SetDeleter is a minimal interface for writing, Unifying KVStore and Batch

type TickResult ¶

type TickResult struct {
	Diff []abci.Validator
}

TickResult allows the Ticker to modify the validator set

type Ticker ¶

type Ticker interface {
	Tick(ctx Context, store KVStore) (TickResult, error)
}

Ticker is a method that is called the beginning of every block, which can be used to perform periodic or delayed tasks

type Tx ¶

type Tx interface {
	// GetMsg returns the action we wish to communicate
	GetMsg() (Msg, error)
}

Tx represent the data sent from the user to the chain. It includes the actual message, along with information needed to authenticate the sender (cryptographic signatures), and anything else needed to pass through middleware.

Each Application must define their own tx type, which embeds all the middlewares that we wish to use. auth.SignedTx and token.FeeTx are common interfaces that many apps will wish to support.

type TxDecoder ¶

type TxDecoder func(txBytes []byte) (Tx, error)

TxDecoder can parse bytes into a Tx

type Validater ¶

type Validater interface {
	Validate() error
}

Validater is any struct that can be validated. Not the same as a Validator, which votes on the blocks.