weave

package module
v0.4.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 8, 2018 License: Apache-2.0 Imports: 13 Imported by: 0

README

Confio Weave

Build Status circleCI codecov LoC Go Report Card API Reference ReadTheDocs license

Confio Weave is a framework for quickly building your custom ABCI application to run a blockchain on top of the best-of-class BFT Proof-of-stake Tendermint consensus engine. It provides much commonly used functionality that can quickly be imported in your custom chain, as well as a simple framework for adding the custom functionality unique to your project.

Note: Requires Go 1.9+

It is inspired by the routing and middleware model of many web application frameworks, and informed by years of wrestling with blockchain state machines. More directly, it is based on the offical cosmos-sdk, both the 0.8 release as well as the future 0.9 rewrite. Naturally, as I was the main author of 0.8.

While both of those are extremely powerful and flexible and contain advanced features, they have a steep learning curve for novice users. Thus, this library aims to favor simplicity over power when there is a choice. If you hit limitations in the design of this library (such as maintaining multiple merkle stores in one app), I highly advise you to use the official cosmos sdk.

On the other hand, if you want to try out tendermint, or have a design that doesn't require an advanced setup, you should try this library and give feedback, especially on ease-of-use. The end goal is to make blockchain development almost as productive as web development (in golang), by providing defaults and best practices for many choices, while allowing extreme flexibility in business logic and data modelling.

For more details on the design goals, see the Design Document

Prerequisites

Instructions

First, make sure you have set up the requirements. If you have a solid go and node developer setup, you may skip this, but good to go through it to be sure.

Once you are set up, you should be able to run something like the following to compile both mycoind (sample app) and tendermint (a BFT consensus engine):

go get github.com/confio/weave
cd $GOPATH/src/github.com/confio/weave
make deps
make install
# test it built properly
tendermint version
# 0.17.1-6f995699
mycoind version
# v0.2.1-21-g35d9c08

Note that this app relies on a separate tendermint process to drive it. It is helpful to first read a primer on tendermint as well as the documentation on the tendermint cli commands.

Once it compiles, I highly suggest going through the tutorials on readthedocs

Documentation

Overview

Package weave defines all common interfaces to weave together the various subpackages, as well as implementations of some of the simpler components (when interfaces would be too much overhead).

We pass context through context.Context between app, middleware, and handlers. To do so, weave defines some common keys to store info, such as block height and chain id. Each extension, such as auth, may add its own keys to enrich the context with specific data.

There should exist two functions for every XYZ of type T that we want to support in Context: 

WithXYZ(Context, T) Context
GetXYZ(Context) (val T, ok bool)

WithXYZ may error/panic if the value was previously set to avoid lower-level modules overwriting the value (eg. height, header)

Index

Constants

View Source 
const (
	// KeyQueryMod means to query for exact match (key)
	KeyQueryMod = ""
	// PrefixQueryMod means to query for anything with this prefix
	PrefixQueryMod = "prefix"
	// RangeQueryMod means to expect complex range query
	// TODO: implement
	RangeQueryMod = "range"
)
View Source 
const Fix = 1

Fix is the patch number (updated on bugfix releases)

View Source 
const Maj = 0

Maj is the major version number (updated on breaking release)

View Source 
const Min = 4

Min is the minor version number (updated on minor releases)

Variables

View Source 
var (
	// DefaultLogger is used for all context that have not
	// set anything themselves
	DefaultLogger = log.NewNopLogger()

	// IsValidChainID is the RegExp to ensure valid chain IDs
	IsValidChainID = regexp.MustCompile(`^[a-zA-Z0-9_\-]{6,20}$`).MatchString
)
View Source 
var (
	// AddressLength is the length of all addresses
	// You can modify it in init() before any addresses are calculated,
	// but it must not change during the lifetime of the kvstore
	AddressLength = 20
)
View Source 
var Version = "please set in makefile"

Version should be set by build flags: `git describe --tags`

Functions

func CheckOrError 

func CheckOrError(result CheckResult, err error) abci.ResponseCheckTx

CheckOrError returns an abci response for CheckTx, converting the error message if present, or using the successful CheckResult

func CheckTxError 

func CheckTxError(err error) abci.ResponseCheckTx

CheckTxError converts any error into a abci.ResponseCheckTx, preserving as much info as possible if it was already a TMError

func DeliverOrError 

func DeliverOrError(result DeliverResult, err error) abci.ResponseDeliverTx

DeliverOrError returns an abci response for DeliverTx, converting the error message if present, or using the successful DeliverResult

func DeliverTxError 

func DeliverTxError(err error) abci.ResponseDeliverTx

DeliverTxError converts any error into a abci.ResponseDeliverTx, preserving as much info as possible if it was already a TMError

func GetChainID 

func GetChainID(ctx Context) string

GetChainID returns the current chain id panics if chain id not already set (should never happen)

func GetHeader 

func GetHeader(ctx Context) (abci.Header, bool)

GetHeader returns the current block header ok is false if no header set in this Context

func GetHeight 

func GetHeight(ctx Context) (int64, bool)

GetHeight returns the current block height ok is false if no height set in this Context

func GetLogger 

func GetLogger(ctx Context) log.Logger

GetLogger returns the currently set logger, or DefaultLogger if none was set

func GetPath 

func GetPath(tx Tx) string

GetPath returns the path of the message, or (missing) if no message

Types

type Address 

type Address []byte

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

It will be of size AddressLength

func NewAddress 

func NewAddress(data []byte) Address

NewAddress hashes and truncates into the proper size

func (Address) Equals added in v0.2.0 

func (a Address) Equals(b Address) bool

Equals checks if two addresses are the same

func (Address) MarshalJSON 

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

MarshalJSON provides a hex representation for JSON, to override the standard base64 []byte encoding

func (Address) String added in v0.2.1 

func (a Address) String() string

String returns a human readable string. Currently hex, may move to bech32

func (*Address) UnmarshalJSON 

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

UnmarshalJSON parses JSON in hex representation, to override the standard base64 []byte encoding

func (Address) Validate added in v0.2.0 

func (a Address) Validate() error

Validate returns an error if the address is not the valid size

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 []byte
	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 

func NewCheck(gasAllocated int64, log string) CheckResult

NewCheck sets the gas used and the response data but no more info these are the most common info needed to be set by the Handler

func (CheckResult) ToABCI 

func (c CheckResult) ToABCI() abci.ResponseCheckTx

ToABCI converts our internal type into an abci response

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 added in v0.4.0 

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

func (Condition) Address added in v0.4.0 

func (c Condition) Address() Address

Address will convert a Condition into an Address

func (Condition) Equals added in v0.4.0 

func (a Condition) Equals(b Condition) bool

Equals checks if two permissions are the same

func (Condition) Parse added in v0.4.0 

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

Parse will extract the sections from the Condition bytes and verify it is properly formatted

func (Condition) String added in v0.4.0 

func (c Condition) String() string

String returns a human readable string. We keep the extension and type in ascii and hex-encode the binary data

func (Condition) Validate added in v0.4.0 

func (c Condition) Validate() error

Validate returns an error if the Condition is not the proper format

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 

func WithChainID(ctx Context, chainID string) Context

WithChainID sets the chain id for the Context. panics if called with chain id already set

func WithHeader 

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

WithHeader sets the block header for the Context. panics if called with header already set

func WithHeight 

func WithHeight(ctx Context, height int64) Context

WithHeight sets the block height for the Context. panics if called with height already set

func WithLogInfo 

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

WithLogInfo accepts keyvalue pairs, and returns another context like this, after passing all the keyvals to the Logger

func WithLogger 

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

WithLogger sets the logger for this 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    []byte
	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 (DeliverResult) ToABCI 

func (d DeliverResult) ToABCI() abci.ResponseDeliverTx

ToABCI converts our internal type into an abci response

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

func Pair(key, value []byte) Model

Pair constructs a model from a key-value pair

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 (Options) ReadOptions 

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

ReadOptions reads the values stored under a given key, and parses the json into the given obj. Returns an error if it cannot parse. Noop and no error if key is missing

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

func NewQueryRouter() QueryRouter

NewQueryRouter initializes a QueryRouter with no routes

func (QueryRouter) Handler added in v0.2.0 

func (r QueryRouter) Handler(path string) QueryHandler

Handler returns the registered Handler for this path. If no path is found, returns a noSuchPath Handler Always returns a non-nil Handler

func (QueryRouter) Register added in v0.2.0 

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

Register adds a new Handler for the given path. panics if another Handler was already registered

func (QueryRouter) RegisterAll added in v0.2.0 

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

RegisterAll registers a number of QueryRegister at once

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

Source Files

View all Source files

Directories

Path Synopsis
Package app is a generated protocol buffer package.
 Package app is a generated protocol buffer package.
server
Package crypto is a generated protocol buffer package.
 Package crypto is a generated protocol buffer package.
examples
errors
package main demonstrates how we can print out our TMErrors meant for `go run .../demo.go`
 package main demonstrates how we can print out our TMErrors meant for `go run .../demo.go`
mycoind
mycoind/app
Package app contains standard implementations of a number of components.
 Package app contains standard implementations of a number of components.
mycoind/commands
Package commands has integration tests of the mycoind application.
 Package commands has integration tests of the mycoind application.
Package orm provides an easy to use db wrapper Break state space into prefixed sections called Buckets.
 Package orm provides an easy to use db wrapper Break state space into prefixed sections called Buckets.
iavl
x
Package x is a generated protocol buffer package.
 Package x is a generated protocol buffer package.
cash
Package cash is a generated protocol buffer package.
 Package cash is a generated protocol buffer package.
sigs
Package sigs is a generated protocol buffer package.
 Package sigs is a generated protocol buffer package.
utils

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.