hyperledger/burrow

Name: burrow

Owner: Hyperledger

Description: Hyperledger Burrow

Created: 2015-06-08 21:14:27.0

Updated: 2018-05-24 14:54:43.0

Pushed: 2018-05-24 12:39:24.0

Homepage: https://www.hyperledger.org/projects/hyperledger-burrow

Size: 34339

Language: Go

GitHub Committers

User	Most Recent Commit	# Commits

Other Committers

User	Email	Most Recent Commit	# Commits

README

Hyperledger Burrow

| | Linux | |—|——-| | Master | | | Develop | |

Hyperledger Burrow is a permissioned Ethereum smart-contract blockchain node built with <3 by Monax. It executes Ethereum EVM smart contract code (usually written in Solidity) on a permissioned virtual machine. Burrow provides transaction finality and high transaction throughput on a proof-of-stake Tendermint consensus engine.

What is Burrow

Hyperledger Burrow is a permissioned blockchain node that executes smart contract code following the Ethereum specification. Burrow is built for a multi-chain universe with application specific optimization in mind. Burrow as a node is constructed out of three main components: the consensus engine, the permissioned Ethereum virtual machine and the rpc gateway. More specifically Burrow consists of the following:

• Consensus Engine: Transactions are ordered and finalised with the Byzantine fault-tolerant Tendermint protocol. The Tendermint protocol provides high transaction throughput over a set of known validators and prevents the blockchain from forking.
• Application Blockchain Interface (ABCI): The smart contract application interfaces with the consensus engine over the ABCI. The ABCI allows for the consensus engine to remain agnostic from the smart contract application.
• Smart Contract Application: Transactions are validated and applied to the application state in the order that the consensus engine has finalised them. The application state consists of all accounts, the validator set and the name registry. Accounts in Burrow have permissions and either contain smart contract code or correspond to a public-private key pair. A transaction that calls on the smart contract code in a given account will activate the execution of that account?s code in a permissioned virtual machine.
• Permissioned Ethereum Virtual Machine: This virtual machine is built to observe the Ethereum operation code specification and additionally asserts the correct permissions have been granted. Permissioning is enforced through secure native functions and underlies all smart contract code. An arbitrary but finite amount of gas is handed out for every execution to ensure a finite execution duration - ?You don?t need money to play, when you have permission to play?.
• Application Binary Interface (ABI): Transactions need to be formulated in a binary format that can be processed by the blockchain node. Current tooling provides functionality to compile, deploy and link solidity smart contracts and formulate transactions to call smart contracts on the chain.
• API Gateway: Burrow exposes REST and JSON-RPC endpoints to interact with the blockchain network and the application state through broadcasting transactions, or querying the current state of the application. Websockets allow subscribing to events, which is particularly valuable as the consensus engine and smart contract application can give unambiguously finalised results to transactions within one blocktime of about one second.

Project documentation and Roadmap

Project information generally updated on a quarterly basis can be found on the Hyperledger Burrow Wiki.

Installation

• Install go version 1.10 or above and have $GOPATH set

et github.com/hyperledger/burrow
ithub.com/hyperledger/burrow
 build

This will build the burrow and burrow-client binaries and put them in the bin/ directory. They can be executed from there or put wherever is convenient.

You can also install burrow into $GOPATH/bin with make install_db,

Usage

The end result will be a burrow.toml that will be read in from your current working directory when starting burrow.

Configuration

Install monax-keys

Monax-keys is our key-signing daemon. In a future release this will be merged with Burrow and will support a GPG backend in addition to the development mode that monax-keys currently supplies.

We need to run monax-keys so that burrow configure can generate keys for us in the following step.

stall monax-keys
et -u github.com/monax/bosmarmot/keys/cmd/monax-keys
n monax-keys server in background
x-keys server &

Configure Burrow

The quick-and-dirty one-liner looks like:

ad spec on stdin
ow spec -p1 -f1 | burrow configure -s- > burrow.toml

which translates into:

is is a place we can store config files and burrow's working directory '.burrow'
r chain_dir && cd chain_dir
ow spec --participant-accounts=1 --full-accounts=1 > genesis-spec.json
ow configure --genesis-spec=genesis-spec.json > burrow.toml

Run Burrow

Once the burrow.toml has been created, we run:

 select our validator address by index in the GenesisDoc
ow serve --validator-index=0 
 to select based on address directly (substituting the example address below with your validator's):
ow serve --validator-address=BE584820DC904A55449D7EB0C97607B40224B96E

and the logs will start streaming through.

If you would like to reset your node, you can just delete its working directory with rm -rf .burrow. In the context of a multi-node chain it will resync with peers, otherwise it will restart from height 0.

Logging

Logging is highly configurable through the burrow.toml [logging] section. Each log line is a list of key-value pairs that flows from the root sink through possible child sinks. Each sink can have an output, a transform, and sinks that it outputs to. Below is a more involved example than the one appearing in the default generated config of what you can configure:

is is a top level config section within the main Burrow config
ging]
All log lines are sent to the root sink from all sources
ogging.root_sink]
# We define two child sinks that each receive all log lines
[[logging.root_sink.sinks]]
  # We send all output to stderr
  [logging.root_sink.sinks.output]
    output_type = "stderr"

[[logging.root_sink.sinks]]
  # But for the second sink we define a transform that filters log lines from Tendermint's p2p module
  [logging.root_sink.sinks.transform]
    transform_type = "filter"
    filter_mode = "exclude_when_all_match"

    [[logging.root_sink.sinks.transform.predicates]]
      key_regex = "module"
      value_regex = "p2p"

    [[logging.root_sink.sinks.transform.predicates]]
      key_regex = "captured_logging_source"
      value_regex = "tendermint_log15"

  # The child sinks of this filter transform sink are syslog and file and will omit log lines originating from p2p
  [[logging.root_sink.sinks.sinks]]
    [logging.root_sink.sinks.sinks.output]
      output_type = "syslog"
      url = ""
      tag = "Burrow-network"

  [[logging.root_sink.sinks.sinks]]
    [logging.root_sink.sinks.sinks.output]
      output_type = "file"
      path = "/var/log/burrow-network.log"

Contribute

We welcome any and all contributions. Read the contributing file for more information on making your first Pull Request to Burrow!

You can find us on:

• Hyperledger Chat
• Hyperledger Mailing List
• here on Github

Future work

For some (slightly outdated) ideas on future work, see the proposals document.

License

Apache 2.0