Shulou(Shulou.com)06/01 Report--

This article mainly explains "what is the development method of Tendermint Core in Go language". Interested friends may wish to have a look at it. The method introduced in this paper is simple, fast and practical. Next, let the editor take you to learn "what is the development method of Go language Tendermint Core?"

Tendermint Core is a Byzantine fault-tolerant / BFT-enabled blockchain middleware developed in the go language that is used to securely copy state machines / FSM between a set of nodes. The beauty of Tendermint Core is that it is the first blockchain consensus engine to implement BFT and always maintains this clear positioning. This guide will describe how to use the go language to develop a Tendermint Core-based blockchain application.

Tendermint Core provides a very simple development interface for blockchain applications, supports a variety of development languages, and is the preferred solution for developing its own public chain / federation chain / private chain. For example, Cosmos, Binance Chain, Hyperledger Burrow, Ethermint and so on all use Tendermint Core consensus engine.

Although Tendermint Core supports state machines developed in any language, if the state machine is written in a development language other than Go, the application needs to communicate with Tendermint Core through sockets or gRPC, which results in additional performance loss. The state machine developed in the GE language can run in the same process as Tendermint Core, so you can get the best performance.

1. Install the Go development environment

Please refer to the official documentation to install the Go development environment.

Confirm that you have installed the latest version of Go:

$go versiongo version go1.12.7 darwin/amd64

Make sure you set the GOPATH environment variable correctly:

$echo $GOPATH/Users/melekes/go2, create the Go project

First create a new Go language project:

$mkdir-p $GOPATH/src/github.com/me/kvstore$ cd $GOPATH/src/github.com/me/kvstore

Create a main.go file in the example directory as follows:

Package mainimport ("fmt") func main () {fmt.Println ("Hello, Tendermint Core")}

Run the above code and the specified string will be displayed on the standard output device:

$go run main.goHello, Tendermint Core3, writing Tendermint Core applications

Tendermint Core communicates with applications through ABCI (Application Blockchain Interface), and the message types used are defined in protobuf files, so applications developed in any language can be run based on Tendermint Core.

Create the file app.go, which is as follows:

Package mainimport (abcitypes "github.com/tendermint/tendermint/abci/types") type KVStoreApplication struct {} var _ abcitypes.Application = (* KVStoreApplication) (nil) func NewKVStoreApplication () * KVStoreApplication {return & KVStoreApplication {} func (KVStoreApplication) Info (req abcitypes.RequestInfo) abcitypes.ResponseInfo {return abcitypes.ResponseInfo {} func (KVStoreApplication) SetOption (req abcitypes.RequestSetOption) abcitypes.ResponseSetOption {return abcitypes.ResponseSetOption {} func (KVStoreApplication) DeliverTx (req abcitypes.RequestDeliverTx ) abcitypes.ResponseDeliverTx {return abcitypes.ResponseDeliverTx {Code: 0} func (KVStoreApplication) CheckTx (req abcitypes.RequestCheckTx) abcitypes.ResponseCheckTx {return abcitypes.ResponseCheckTx {Code: 0}} func (KVStoreApplication) Commit () abcitypes.ResponseCommit {return abcitypes.ResponseCommit {} func (KVStoreApplication) Query (req abcitypes.RequestQuery) abcitypes.ResponseQuery {return abcitypes.ResponseQuery {Code: 0}} func (KVStoreApplication) InitChain (req abcitypes.RequestInitChain) abcitypes.ResponseInitChain {return abcitypes ResponseInitChain {} func (KVStoreApplication) BeginBlock (req abcitypes.RequestBeginBlock) abcitypes.ResponseBeginBlock {return abcitypes.ResponseBeginBlock {} func (KVStoreApplication) EndBlock (req abcitypes.RequestEndBlock) abcitypes.ResponseEndBlock {return abcitypes.ResponseEndBlock {}}

Next, let's interpret the above methods one by one and add the necessary implementation logic.

3 、 CheckTx

When a new transaction enters the Tendermint Core, it requires the application to check first, such as verifying the format, signature, and so on.

Func (app * KVStoreApplication) isValid (tx [] byte) (code uint32) {/ / check format parts: = bytes.Split (tx, [] byte ("=") if len (parts)! = 2 {return 1} key, value: = parts [0] Parts [1] / / check if the same key=value already exists err: = app.db.View (func (txn * badger.Txn) error {item Err: = txn.Get (key) if err! = nil & & err! = badger.ErrKeyNotFound {return err} if err = = nil {return item.Value (func (val [] byte) error {if bytes.Equal (val) Value) {code = 2} return nil})} return nil}) if err! = nil { Panic (err)} return code} func (app * KVStoreApplication) CheckTx (req abcitypes.RequestCheckTx) abcitypes.ResponseCheckTx {code: = app.isValid (req.Tx) return abcitypes.ResponseCheckTx {Code: code GasWanted: 1}}

If the incoming transaction format is not {bytes} = {bytes}, we will return code 1. If the specified key and value already exist, we return code 2. In other cases, we return the code 0 to indicate that the transaction is valid-- note that Tendermint Core will treat any transaction that returns a non-zero code as invalid.

Valid transactions will eventually be submitted, and we use badger as the underlying key / value library. Badger is an embedded fast KV database.

Import "github.com/dgraph-io/badger" type KVStoreApplication struct {db * badger.DB currentBatch * badger.Txn} func NewKVStoreApplication (db * badger.DB) * KVStoreApplication {return & KVStoreApplication {db: db,}} 4, BeginBlock-> DeliverTx-> EndBlock-> Commit

When Tendermint Core determines the new block, it invokes the application three times:

BeginBlock: called at the beginning of the block

DeliverTx: called on each transaction

EndBlock: called at the end of the block

Note that the DeliverTx is invoked asynchronously, but the response is orderly.

Func (app * KVStoreApplication) BeginBlock (req abcitypes.RequestBeginBlock) abcitypes.ResponseBeginBlock {app.currentBatch = app.db.NewTransaction (true) return abcitypes.ResponseBeginBlock {}}

The following code creates a data operation batch to store block transactions:

Func (app * KVStoreApplication) DeliverTx (req abcitypes.RequestDeliverTx) abcitypes.ResponseDeliverTx {code: = app.isValid (req.Tx) if code! = 0 {return abcitypes.ResponseDeliverTx {Code: code}} parts: = bytes.Split (req.Tx, [] byte ("=") key, value: = parts [0], parts [1] err: = app.currentBatch.Set (key) Value) if err! = nil {panic (err)} return abcitypes.ResponseDeliverTx {Code: 0}}

If the transaction is in the wrong format, or the same key / value pair already exists, then we still return a non-zero code, otherwise, we add the transaction to the operation batch.

In the current design, blocks can contain incorrect transactions-those that pass the CheckTx check but fail the DeliverTx, for performance reasons.

Note that we cannot submit the transaction in DeliverTx, because in this case Query may return inconsistent data as a result of concurrent calls, for example, Query prompts that the specified value already exists and that the actual chunk has not been actually committed.

Commit is used to notify the application to persist the new state.

Func (app * KVStoreApplication) Commit () abcitypes.ResponseCommit {app.currentBatch.Commit () return abcitypes.ResponseCommit {Data: [] byte {} 5, query-Query

When the client application wants to know whether the specified key / value pair exists, it will call Tendermint Core's RPC interface / abci_query to query, which will call the application's Query method.

Tendermint Core-based applications are free to provide their own API. However, using Tendermint Core as a proxy, client applications take advantage of Tendermint Core's unified API. In addition, the client does not need to call other additional Tendermint Core API to obtain further proof.

Note that we do not include proof data in the following code.

Func (app * KVStoreApplication) Query (reqQuery abcitypes.RequestQuery) (resQuery abcitypes.ResponseQuery) {resQuery.Key = reqQuery.Data err: = app.db.View (func (txn * badger.Txn) error {item Err: = txn.Get (reqQuery.Data) if err! = nil & & err! = badger.ErrKeyNotFound {return err} if err = = badger.ErrKeyNotFound {resQuery.Log = "does not exist"} else {return item.Value ( Func (val [] byte) error {resQuery.Log = "exists" resQuery.Value = val return nil})} return nil}) if err! = nil { Panic (err)} return} 6. Start Tendermint Core and application instance in the same process

Add the following code to the main.go file:

Package mainimport ("flag"fmt"os", "os/signal", "path/filepath", "syscall", "github.com/dgraph-io/badger", "github.com/pkg/errors", "github.com/spf13/viper" abci "github.com/tendermint/tendermint/abci/types" cfg "github.com/tendermint/" Tendermint/config "tmflags" github.com/tendermint/tendermint/libs/cli/flags "github.com/tendermint/tendermint/libs/log" nm "github.com/tendermint/tendermint/node"github.com/tendermint/tendermint/p2p"github.com/tendermint/tendermint/privval"github.com/tendermint/tendermint/proxy") var configFile stringfunc init () {flag.StringVar (& configFile) "config", "$HOME/.tendermint/config/config.toml", "Path to config.toml"} func main () {db, err: = badger.Open (badger.DefaultOptions ("/ tmp/badger")) if err! = nil {fmt.Fprintf (os.Stderr, "failed to open badger db:% v" Err) os.Exit (1)} defer db.Close () app: = NewKVStoreApplication (db) flag.Parse () node, err: = newTendermint (app, configFile) if err! = nil {fmt.Fprintf (os.Stderr, "% v" Err) os.Exit (2)} node.Start () defer func () {node.Stop () node.Wait () `} () c: = make (chan os.Signal, 1) signal.Notify (c, os.Interrupt, syscall.SIGTERM)

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.