weave

type Address ¶

type Address []byte

Address represents a collision-free, one-way digest of a Condition

It will be of size AddressLength

func NewAddress(data []byte) Address

func (a Address) Equals(b Address) bool

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

func (a Address) String() string

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

func (a Address) Validate() error

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 is a machine-parseable return value, like id of created entity
	Data []byte
	// Log is human-readable informational string
	Log string
	// RequiredFee can set an custom fee that must be paid for this transaction to be allowed to run.
	// This may enforced by a decorator, such as cash.DynamicFeeDecorator
	RequiredFee coin.Coin
	// 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)
	//TODO: Implement when tendermint implements this properly
	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
}

CommitKVStore is a root store that can make atomic commits to disk. We modify it in batch by getting a CacheWrap() and then Write(). Commit() will persist all changes to disk

This store should also be able to return merkle proofs for any committed state.

type Condition ¶ added in v0.4.0

type Condition []byte

Condition is a specially formatted array, containing information on who can authorize an action. It is of the format:

sprintf("%s/%s/%s", extension, type, data)

func NewCondition(ext, typ string, data []byte) Condition

func (c Condition) Address() Address

func (a Condition) Equals(b Condition) bool

func (c Condition) MarshalJSON() ([]byte, error)

func (c Condition) Parse() (string, string, []byte, error)

func (c Condition) String() string

func (c *Condition) UnmarshalJSON(raw []byte) error

func (c Condition) Validate() error

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 WithBlockTime(ctx Context, t time.Time) Context

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 is a machine-parseable return value, like id of created entity
	Data []byte
	// Log is human-readable informational string
	Log string
	// RequiredFee can set an custom fee that must be paid for this transaction to be allowed to run.
	// This may enforced by a decorator, such as cash.DynamicFeeDecorator
	RequiredFee coin.Coin
	// Diff, if present, will apply to the Validator set in tendermint next block
	Diff []abci.ValidatorUpdate
	// Tags, if present, will be used by tendermint to index and search the transaction history
	Tags []common.KVPair
	// GasUsed is currently unused field until effects in tendermint are clear
	GasUsed int64
}

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)
}

Deliverer 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 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 Model ¶ added in v0.2.0

type Model struct {
	Key   []byte
	Value []byte
}

Model groups together key and value to return

func Pair(key, value []byte) Model

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

	// Validate performs a sanity checks on this message. It returns an
	// error if at least one test does not pass and message is considered
	// invalid.
	// This validation performs only tests that do not require external
	// resources (ie a database).
	Validate() error
}

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.

func ExtractMsgFromSum(sum interface{}) (Msg, error)

ExtractMsgFromSum(tx.GetSum())

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 QueryHandler ¶ added in v0.2.0

type QueryHandler interface {
	Query(db ReadOnlyKVStore, mod string, data []byte) ([]Model, error)
}

QueryHandler is anything that can process ABCI queries

type QueryRegister ¶ added in v0.2.0

type QueryRegister func(QueryRouter)

QueryRegister is a function that adds some handlers to this router

type QueryRouter ¶ added in v0.2.0

type QueryRouter struct {
	// contains filtered or unexported fields
}

QueryRouter allows us to register many query handlers to different paths and then direct each query to the proper handler.

Minimal interface modeled after net/http.ServeMux

func NewQueryRouter() QueryRouter

func (r QueryRouter) Handler(path string) QueryHandler

func (r QueryRouter) Register(path string, h QueryHandler)

func (r QueryRouter) RegisterAll(qr ...QueryRegister)

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.ValidatorUpdate
}

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 {
	Persistent

	// 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 UnixTime ¶ added in v0.14.0

type UnixTime int64

UnixTime represents a point in time as POSIX time. This type comes in handy when dealing with protobuf messages. Instead of using Go's time.Time that includes nanoseconds use primitive int64 type and seconds precision. Some languages do not support nanoseconds precision anyway.

When using in protobuf declaration, use gogoproto's typecasting

int64 deadline = 1 [(gogoproto.casttype) = "github.com/iov-one/weave.UnixTime"];

func AsUnixTime(t time.Time) UnixTime

func (t UnixTime) Add(d time.Duration) UnixTime

func (t UnixTime) String() string

func (t UnixTime) Time() time.Time

func (t *UnixTime) UnmarshalJSON(raw []byte) error

func (t UnixTime) Validate() error