diff --git a/Gopkg.lock b/Gopkg.lock
index 8dc60b9351f9b552f450ce676e7040bc992788db..30aac009bff7ad6ee8e95f5eaca65486dd86aeb1 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -110,6 +110,7 @@
name = "github.com/golang/protobuf"
packages = [
"proto",
+ "protoc-gen-go/descriptor",
"ptypes",
"ptypes/any",
"ptypes/duration",
@@ -497,6 +498,8 @@
"metadata",
"naming",
"peer",
+ "reflection",
+ "reflection/grpc_reflection_v1alpha",
"resolver",
"resolver/dns",
"resolver/passthrough",
@@ -529,6 +532,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
- inputs-digest = "e967fbd5455762e55b443957abeda0cdd7a1c368d170b18909351d4a2ff7b75b"
+ inputs-digest = "ef2abf85870ab16c7ec56ad383638fe151996472e942921b51e6190a1f454013"
solver-name = "gps-cdcl"
solver-version = 1
diff --git a/Gopkg.toml b/Gopkg.toml
index d326efb02d3f5cbf7dc397cf39178723ec812017..34827290fc3d655bd8ee4f2aff044fbc97108ea0 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -26,11 +26,11 @@
[[constraint]]
name = "github.com/tendermint/iavl"
- branch = "develop"
+ version = "=0.8.0-rc0"
[[constraint]]
-name = "github.com/prometheus/client_golang"
-branch = "master"
+ name = "github.com/prometheus/client_golang"
+ branch = "master"
[[override]]
name = "github.com/tendermint/tmlibs"
diff --git a/Makefile b/Makefile
index 1aa6d3689fb2abbdd2c90639bfb5a61281856fb5..bf0faf067363dd560377595746510bfeeafbfe74 100644
--- a/Makefile
+++ b/Makefile
@@ -16,7 +16,8 @@ BOSMARMOT_PROJECT := github.com/monax/bosmarmot
BOSMARMOT_GOPATH := ${REPO}/.gopath_bos
BOSMARMOT_CHECKOUT := ${BOSMARMOT_GOPATH}/src/${BOSMARMOT_PROJECT}
-DOCKER_NAMESPACE := quay.io/monax
+PROTO_FILES = $(shell find . -type f -name '*.proto')
+PROTO_GO_FILES = $(patsubst %.proto, %.pb.go, $(PROTO_FILES))
### Formatting, linting and vetting
@@ -67,13 +68,18 @@ megacheck:
protobuf_deps:
@go get -u github.com/golang/protobuf/protoc-gen-go
-keys/pbkeys/keys.pb.go: keys/pbkeys/keys.proto
- @protoc -I ./keys/pbkeys keys/pbkeys/keys.proto --go_out=plugins=grpc:keys/pbkeys
+# Implicit compile rule for GRPC/proto files
+%.pb.go: %.proto
+ protoc -I ${GOPATH}/src ${REPO}/$< --go_out=plugins=grpc:${GOPATH}/src
-rpc/burrow/burrow.pb.go: rpc/burrow
- @protoc -I ./rpc/burrow rpc/burrow/burrow.proto --go_out=plugins=grpc:rpc/burrow
-### Dependency management for github.com/hyperledger/burrow
+.PHONY: protobuf
+protobuf: $(PROTO_GO_FILES)
+
+.PHONY: clean_protobuf
+clean_protobuf:
+ @rm -f $(PROTO_GO_FILES)
+### Dependency management for github.com/hyperledger/burrow
# erase vendor wipes the full vendor directory
.PHONY: erase_vendor
erase_vendor:
@@ -114,7 +120,7 @@ build_race: check build_race_db build_race_client
# build burrow
.PHONY: build_db
-build_db: commit_hash
+build_db: commit_hash protobuf
go build -ldflags "-extldflags '-static' \
-X github.com/hyperledger/burrow/project.commit=$(shell cat commit_hash.txt)" \
-o ${REPO}/bin/burrow ./cmd/burrow
@@ -125,7 +131,7 @@ install_db: build_db
# build burrow-client
.PHONY: build_client
-build_client: commit_hash
+build_client: commit_hash protobuf
go build -ldflags "-extldflags '-static' \
-X github.com/hyperledger/burrow/project.commit=$(shell cat commit_hash.txt)" \
-o ${REPO}/bin/burrow-client ./client/cmd/burrow-client
@@ -169,7 +175,7 @@ test_keys: build_db
.PHONY: test_integration
test_integration: test_keys
- @go test -tags integration ./rpc/burrow/integration
+ @go test -tags integration ./rpc/rpctransactor/integration
@go test -tags integration ./rpc/v0/integration
@go test -tags integration ./rpc/tm/integration
diff --git a/account/state/memory_state.go b/account/state/memory_state.go
index 368c4fa3bf849a0c4d5eaf13f7ac3ea73d0a2719..605ecd05e79425927bca321266d9227b4d28b534 100644
--- a/account/state/memory_state.go
+++ b/account/state/memory_state.go
@@ -13,9 +13,9 @@ type MemoryState struct {
Storage map[crypto.Address]map[binary.Word256]binary.Word256
}
-var _ IterableWriter = &MemoryState{}
+var _ IterableReaderWriter = &MemoryState{}
-// Get an in-memory state Iterable
+// Get an in-memory state IterableReader
func NewMemoryState() *MemoryState {
return &MemoryState{
Accounts: make(map[crypto.Address]acm.Account),
diff --git a/account/state/state.go b/account/state/state.go
index 645462abde6c325fdf9fe7c547683eb258d34dd5..95389ad3d0a42cbd97618c7fe518a629850caf4d 100644
--- a/account/state/state.go
+++ b/account/state/state.go
@@ -53,26 +53,32 @@ type Reader interface {
StorageGetter
}
-// Read and list account and storage state
type Iterable interface {
- Reader
AccountIterable
StorageIterable
}
-// Read and write account and storage state
-type Writer interface {
+// Read and list account and storage state
+type IterableReader interface {
+ Iterable
Reader
+}
+
+type Writer interface {
AccountUpdater
StorageSetter
}
-type IterableWriter interface {
+// Read and write account and storage state
+type ReaderWriter interface {
Reader
- AccountUpdater
- StorageSetter
- AccountIterable
- StorageIterable
+ Writer
+}
+
+type IterableReaderWriter interface {
+ Iterable
+ Reader
+ Writer
}
func GetMutableAccount(getter AccountGetter, address crypto.Address) (acm.MutableAccount, error) {
diff --git a/account/state/state_cache.go b/account/state/state_cache.go
index 869842431bc3213eda869d65103ddf384d13738f..4daf768746e81a9c060358893c39114b7124a08e 100644
--- a/account/state/state_cache.go
+++ b/account/state/state_cache.go
@@ -24,14 +24,7 @@ import (
"github.com/hyperledger/burrow/crypto"
)
-type Cache interface {
- Writer
- Sync(state Writer) error
- Reset(backend Iterable)
- Flush(state IterableWriter) error
-}
-
-type stateCache struct {
+type Cache struct {
sync.RWMutex
name string
backend Reader
@@ -46,12 +39,12 @@ type accountInfo struct {
updated bool
}
-type CacheOption func(*stateCache)
+type CacheOption func(*Cache)
// Returns a Cache that wraps an underlying Reader to use on a cache miss, can write to an output Writer
// via Sync. Goroutine safe for concurrent access.
-func NewCache(backend Reader, options ...CacheOption) Cache {
- cache := &stateCache{
+func NewCache(backend Reader, options ...CacheOption) *Cache {
+ cache := &Cache{
backend: backend,
accounts: make(map[crypto.Address]*accountInfo),
}
@@ -62,12 +55,12 @@ func NewCache(backend Reader, options ...CacheOption) Cache {
}
func Name(name string) CacheOption {
- return func(cache *stateCache) {
+ return func(cache *Cache) {
cache.name = name
}
}
-func (cache *stateCache) GetAccount(address crypto.Address) (acm.Account, error) {
+func (cache *Cache) GetAccount(address crypto.Address) (acm.Account, error) {
accInfo, err := cache.get(address)
if err != nil {
return nil, err
@@ -80,7 +73,7 @@ func (cache *stateCache) GetAccount(address crypto.Address) (acm.Account, error)
return accInfo.account, nil
}
-func (cache *stateCache) UpdateAccount(account acm.Account) error {
+func (cache *Cache) UpdateAccount(account acm.Account) error {
accInfo, err := cache.get(account.Address())
if err != nil {
return err
@@ -95,7 +88,7 @@ func (cache *stateCache) UpdateAccount(account acm.Account) error {
return nil
}
-func (cache *stateCache) RemoveAccount(address crypto.Address) error {
+func (cache *Cache) RemoveAccount(address crypto.Address) error {
accInfo, err := cache.get(address)
if err != nil {
return err
@@ -110,7 +103,7 @@ func (cache *stateCache) RemoveAccount(address crypto.Address) error {
}
// Iterates over all cached accounts first in cache and then in backend until consumer returns true for 'stop'
-func (cache *stateCache) IterateCachedAccount(consumer func(acm.Account) (stop bool)) (stopped bool, err error) {
+func (cache *Cache) IterateCachedAccount(consumer func(acm.Account) (stop bool)) (stopped bool, err error) {
// Try cache first for early exit
cache.RLock()
for _, info := range cache.accounts {
@@ -123,7 +116,7 @@ func (cache *stateCache) IterateCachedAccount(consumer func(acm.Account) (stop b
return false, nil
}
-func (cache *stateCache) GetStorage(address crypto.Address, key binary.Word256) (binary.Word256, error) {
+func (cache *Cache) GetStorage(address crypto.Address, key binary.Word256) (binary.Word256, error) {
accInfo, err := cache.get(address)
if err != nil {
return binary.Zero256, err
@@ -149,7 +142,7 @@ func (cache *stateCache) GetStorage(address crypto.Address, key binary.Word256)
}
// NOTE: Set value to zero to remove.
-func (cache *stateCache) SetStorage(address crypto.Address, key binary.Word256, value binary.Word256) error {
+func (cache *Cache) SetStorage(address crypto.Address, key binary.Word256, value binary.Word256) error {
accInfo, err := cache.get(address)
accInfo.Lock()
defer accInfo.Unlock()
@@ -165,7 +158,7 @@ func (cache *stateCache) SetStorage(address crypto.Address, key binary.Word256,
}
// Iterates over all cached storage items first in cache and then in backend until consumer returns true for 'stop'
-func (cache *stateCache) IterateCachedStorage(address crypto.Address,
+func (cache *Cache) IterateCachedStorage(address crypto.Address,
consumer func(key, value binary.Word256) (stop bool)) (stopped bool, err error) {
accInfo, err := cache.get(address)
if err != nil {
@@ -185,7 +178,7 @@ func (cache *stateCache) IterateCachedStorage(address crypto.Address,
// Syncs changes to the backend in deterministic order. Sends storage updates before updating
// the account they belong so that storage values can be taken account of in the update.
-func (cache *stateCache) Sync(state Writer) error {
+func (cache *Cache) Sync(state Writer) error {
cache.Lock()
defer cache.Unlock()
var addresses crypto.Addresses
@@ -229,24 +222,24 @@ func (cache *stateCache) Sync(state Writer) error {
}
// Resets the cache to empty initialising the backing map to the same size as the previous iteration.
-func (cache *stateCache) Reset(backend Iterable) {
+func (cache *Cache) Reset(backend Reader) {
cache.Lock()
defer cache.Unlock()
cache.backend = backend
cache.accounts = make(map[crypto.Address]*accountInfo, len(cache.accounts))
}
-// Syncs the Cache and Resets it to use as the backend Reader
-func (cache *stateCache) Flush(state IterableWriter) error {
- err := cache.Sync(state)
+// Syncs the Cache to output and Resets it to use backend as Reader
+func (cache *Cache) Flush(output Writer, backend Reader) error {
+ err := cache.Sync(output)
if err != nil {
return err
}
- cache.Reset(state)
+ cache.Reset(backend)
return nil
}
-func (cache *stateCache) String() string {
+func (cache *Cache) String() string {
if cache.name == "" {
return fmt.Sprintf("StateCache{Length: %v}", len(cache.accounts))
}
@@ -254,7 +247,7 @@ func (cache *stateCache) String() string {
}
// Get the cache accountInfo item creating it if necessary
-func (cache *stateCache) get(address crypto.Address) (*accountInfo, error) {
+func (cache *Cache) get(address crypto.Address) (*accountInfo, error) {
cache.RLock()
accInfo := cache.accounts[address]
cache.RUnlock()
diff --git a/binary/bytes.go b/binary/bytes.go
index 236ef6d402ff3585e19e9ae6b4c2531f4b61fdaa..03a736c45df1e1ebddb7b2535051899a97194138 100644
--- a/binary/bytes.go
+++ b/binary/bytes.go
@@ -4,15 +4,19 @@ import "github.com/tmthrgd/go-hex"
type HexBytes []byte
-func (bs *HexBytes) UnmarshalText(hexBytes []byte) error {
- bs2, err := hex.DecodeString(string(hexBytes))
+func (hb *HexBytes) UnmarshalText(hexBytes []byte) error {
+ bs, err := hex.DecodeString(string(hexBytes))
if err != nil {
return err
}
- *bs = bs2
+ *hb = bs
return nil
}
-func (bs HexBytes) MarshalText() ([]byte, error) {
- return []byte(hex.EncodeUpperToString(bs)), nil
+func (hb HexBytes) MarshalText() ([]byte, error) {
+ return []byte(hb.String()), nil
+}
+
+func (hb HexBytes) String() string {
+ return hex.EncodeUpperToString(hb)
}
diff --git a/binary/integer_test.go b/binary/integer_test.go
index c0c1533fecac2e81eb73a754eab919e6c505af04..3e30e2163d511f9b40c0a4adbe5af26f90e72302 100644
--- a/binary/integer_test.go
+++ b/binary/integer_test.go
@@ -97,6 +97,12 @@ func TestS256(t *testing.T) {
assertBigIntEqual(t, expected, signed, "Out of twos complement bounds")
}
+func TestPutUint64BE(t *testing.T) {
+ bs := make([]byte, 8)
+ PutUint64BE(bs, 245343)
+ assert.Equal(t, "000000000003BE5F", fmt.Sprintf("%X", bs))
+}
+
func TestSignExtend(t *testing.T) {
assertSignExtend(t, 16, 0,
"0000 0000 1001 0000",
diff --git a/blockchain/blockchain.go b/blockchain/blockchain.go
index af8e43e413f415f74a319641e667d22c10c9d555..2d1f3553f7bd3568897f5b578622ec71e30cca32 100644
--- a/blockchain/blockchain.go
+++ b/blockchain/blockchain.go
@@ -39,6 +39,8 @@ type TipInfo interface {
LastBlockTime() time.Time
LastBlockHash() []byte
AppHashAfterLastBlock() []byte
+ IterateValidators(iter func(publicKey crypto.PublicKey, power uint64) (stop bool)) (stopped bool)
+ NumValidators() int
}
type BlockchainInfo interface {
diff --git a/client/websocket_client.go b/client/websocket_client.go
index ffc67d2c609ac3046b465f726bf4a48a0822a5fb..2580dc4bb0096e4241814fe806590727cd7aa342 100644
--- a/client/websocket_client.go
+++ b/client/websocket_client.go
@@ -152,7 +152,7 @@ func (burrowNodeWebsocketClient *burrowNodeWebsocketClient) WaitForConfirmation(
continue
}
- eventDataTx := resultEvent.EventDataTx
+ eventDataTx := resultEvent.Execution.GetTx()
if eventDataTx == nil {
// We are on the lookout for EventDataTx
confirmationChannel <- Confirmation{
@@ -171,7 +171,7 @@ func (burrowNodeWebsocketClient *burrowNodeWebsocketClient) WaitForConfirmation(
continue
}
- if eventDataTx.Exception != nil && eventDataTx.Exception.Code != errors.ErrorCodeExecutionReverted {
+ if eventDataTx.Exception != nil && eventDataTx.Exception.ErrorCode() != errors.ErrorCodeExecutionReverted {
confirmationChannel <- Confirmation{
BlockHash: latestBlockHash,
EventDataTx: eventDataTx,
diff --git a/cmd/burrow/commands/keys.go b/cmd/burrow/commands/keys.go
index 815167d14ac64f255b8d24bc842e7910d787cc44..e8ba5d4b09221a4e741137aeccdba97baf57897d 100644
--- a/cmd/burrow/commands/keys.go
+++ b/cmd/burrow/commands/keys.go
@@ -69,9 +69,8 @@ func Keys(output Output) func(cmd *cli.Cmd) {
output.Fatalf("could not generate logger from logging config: %v", err)
}
- if *badPerm != false {
- conf.Keys.AllowBadFilePermissions = *badPerm
- }
+ conf.Keys.AllowBadFilePermissions = *badPerm
+
if *keysDir != "" {
conf.Keys.KeysDirectory = *keysDir
}
@@ -331,7 +330,7 @@ func Keys(output Output) func(cmd *cli.Cmd) {
c := grpcKeysClient(output)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
- resp, err := c.List(ctx, &pbkeys.Name{*name})
+ resp, err := c.List(ctx, &pbkeys.ListRequest{})
if err != nil {
output.Fatalf("failed to list key names: %v", err)
}
@@ -356,7 +355,7 @@ func Keys(output Output) func(cmd *cli.Cmd) {
c := grpcKeysClient(output)
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
- _, err := c.RemoveName(ctx, &pbkeys.Name{*name})
+ _, err := c.RemoveName(ctx, &pbkeys.RemoveNameRequest{Keyname: *name})
if err != nil {
output.Fatalf("failed to remove key: %v", err)
}
diff --git a/config/config.go b/config/config.go
index 747dc208285911e028c4f9da10ca2cf6e6801444..c9958d56df2cccc1ddcbfc233db4f81bef7681fd 100644
--- a/config/config.go
+++ b/config/config.go
@@ -56,7 +56,7 @@ func (conf *BurrowConfig) Kernel(ctx context.Context) (*core.Kernel, error) {
return nil, fmt.Errorf("could not generate logger from logging config: %v", err)
}
var keyClient keys.KeyClient
- var keyStore keys.KeyStore
+ var keyStore *keys.KeyStore
if conf.Keys.RemoteAddress != "" {
keyClient, err = keys.NewRemoteKeyClient(conf.Keys.RemoteAddress, logger)
if err != nil {
@@ -86,7 +86,7 @@ func (conf *BurrowConfig) Kernel(ctx context.Context) (*core.Kernel, error) {
}
return core.NewKernel(ctx, keyClient, privValidator, conf.GenesisDoc, conf.Tendermint.TendermintConfig(), conf.RPC, conf.Keys,
- &keyStore, exeOptions, logger)
+ keyStore, exeOptions, logger)
}
func (conf *BurrowConfig) JSONString() string {
diff --git a/consensus/tendermint/events.go b/consensus/tendermint/events.go
index db069d683404f3fe763b6c17e0a63802af70bad4..c85f976c0d20cad99722976c4393e9d0d261df41 100644
--- a/consensus/tendermint/events.go
+++ b/consensus/tendermint/events.go
@@ -4,6 +4,7 @@ import (
"context"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/logging/structure"
"github.com/tendermint/tendermint/libs/pubsub"
tm_types "github.com/tendermint/tendermint/types"
@@ -55,7 +56,7 @@ func PublishEvent(ctx context.Context, fromSubscribable event.Subscribable, subs
tm_types.EventTypeKey: eventType,
event.EventIDKey: eventType,
}
- return event.PublishAll(ctx, fromSubscribable, subscriber, event.WrapQuery(tm_types.QueryForEvent(eventType)),
+ return event.PublishAll(ctx, fromSubscribable, subscriber, query.WrapQuery(tm_types.QueryForEvent(eventType)),
toPublisher, tags)
}
@@ -67,17 +68,17 @@ func EventBusAsSubscribable(eventBus tm_types.EventBusSubscriber) event.Subscrib
return eventBusSubscriber{eventBus}
}
-func (ebs eventBusSubscriber) Subscribe(ctx context.Context, subscriber string, query event.Queryable,
+func (ebs eventBusSubscriber) Subscribe(ctx context.Context, subscriber string, queryable query.Queryable,
out chan<- interface{}) error {
- qry, err := query.Query()
+ qry, err := queryable.Query()
if err != nil {
return err
}
return ebs.EventBusSubscriber.Subscribe(ctx, subscriber, qry, out)
}
-func (ebs eventBusSubscriber) Unsubscribe(ctx context.Context, subscriber string, query event.Queryable) error {
- qry, err := query.Query()
+func (ebs eventBusSubscriber) Unsubscribe(ctx context.Context, subscriber string, queryable query.Queryable) error {
+ qry, err := queryable.Query()
if err != nil {
return err
}
@@ -92,11 +93,11 @@ func SubscribableAsEventBus(subscribable event.Subscribable) tm_types.EventBusSu
return subscribableEventBus{subscribable}
}
-func (seb subscribableEventBus) Subscribe(ctx context.Context, subscriber string, query pubsub.Query,
+func (seb subscribableEventBus) Subscribe(ctx context.Context, subscriber string, qry pubsub.Query,
out chan<- interface{}) error {
- return seb.Subscribable.Subscribe(ctx, subscriber, event.WrapQuery(query), out)
+ return seb.Subscribable.Subscribe(ctx, subscriber, query.WrapQuery(qry), out)
}
-func (seb subscribableEventBus) Unsubscribe(ctx context.Context, subscriber string, query pubsub.Query) error {
- return seb.Subscribable.Unsubscribe(ctx, subscriber, event.WrapQuery(query))
+func (seb subscribableEventBus) Unsubscribe(ctx context.Context, subscriber string, qry pubsub.Query) error {
+ return seb.Subscribable.Unsubscribe(ctx, subscriber, query.WrapQuery(qry))
}
diff --git a/consensus/tendermint/tendermint.go b/consensus/tendermint/tendermint.go
index 8e9813f48a7a22fd35338708efc211c0138ea55a..e7ddf260b6622e13cdf1e30d0e9a2ec739963c59 100644
--- a/consensus/tendermint/tendermint.go
+++ b/consensus/tendermint/tendermint.go
@@ -9,6 +9,7 @@ import (
bcm "github.com/hyperledger/burrow/blockchain"
"github.com/hyperledger/burrow/consensus/tendermint/abci"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/execution"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging"
@@ -30,6 +31,8 @@ type Node struct {
}
}
+var NewBlockQuery = query.Must(event.QueryForEventID(tm_types.EventNewBlock).Query())
+
func DBProvider(ID string, backendType dbm.DBBackendType, dbDir string) dbm.DB {
return dbm.NewDB(ID, backendType, dbDir)
}
@@ -98,18 +101,36 @@ func DeriveGenesisDoc(burrowGenesisDoc *genesis.GenesisDoc) *tm_types.GenesisDoc
}
}
-func SubscribeNewBlock(ctx context.Context, subscribable event.Subscribable, subscriber string,
- ch chan<- *tm_types.EventDataNewBlock) error {
- query := event.QueryForEventID(tm_types.EventNewBlock)
-
- return event.SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) bool {
- tmEventData, ok := message.(tm_types.TMEventData)
+func NewBlockEvent(message interface{}) *tm_types.EventDataNewBlock {
+ tmEventData, ok := message.(tm_types.TMEventData)
+ if ok {
+ eventDataNewBlock, ok := tmEventData.(tm_types.EventDataNewBlock)
if ok {
- eventDataNewBlock, ok := tmEventData.(tm_types.EventDataNewBlock)
- if ok {
- ch <- &eventDataNewBlock
+ return &eventDataNewBlock
+ }
+ }
+ return nil
+}
+
+// Subscribe to NewBlock event safely that ensures progress by a non-blocking receive as well as handling unsubscribe
+func SubscribeNewBlock(ctx context.Context, subscribable event.Subscribable) (<-chan *tm_types.EventDataNewBlock, error) {
+ subID, err := event.GenerateSubscriptionID()
+ if err != nil {
+ return nil, err
+ }
+ const unconsumedBlocksBeforeUnsubscribe = 3
+ ch := make(chan *tm_types.EventDataNewBlock, unconsumedBlocksBeforeUnsubscribe)
+ return ch, event.SubscribeCallback(ctx, subscribable, subID, NewBlockQuery, func(message interface{}) (stop bool) {
+ eventDataNewBlock := NewBlockEvent(message)
+ if eventDataNewBlock != nil {
+ select {
+ case ch <- eventDataNewBlock:
+ return false
+ default:
+ // If we can't send shut down the channel
+ return true
}
}
- return true
+ return
})
}
diff --git a/core/kernel.go b/core/kernel.go
index c796fdea6dfab9c9e52a181ab4d838ffa1cc7605..1ea5f95b9791405126d2659c4bb5ce3e27084613 100644
--- a/core/kernel.go
+++ b/core/kernel.go
@@ -32,6 +32,8 @@ import (
"github.com/hyperledger/burrow/consensus/tendermint/query"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/hyperledger/burrow/execution/pbtransactor"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/keys"
"github.com/hyperledger/burrow/keys/pbkeys"
@@ -39,8 +41,9 @@ import (
"github.com/hyperledger/burrow/logging/structure"
"github.com/hyperledger/burrow/process"
"github.com/hyperledger/burrow/rpc"
- "github.com/hyperledger/burrow/rpc/burrow"
"github.com/hyperledger/burrow/rpc/metrics"
+ "github.com/hyperledger/burrow/rpc/rpcevents"
+ "github.com/hyperledger/burrow/rpc/rpctransactor"
"github.com/hyperledger/burrow/rpc/tm"
"github.com/hyperledger/burrow/rpc/v0"
v0_server "github.com/hyperledger/burrow/rpc/v0/server"
@@ -48,6 +51,7 @@ import (
tm_config "github.com/tendermint/tendermint/config"
tm_types "github.com/tendermint/tendermint/types"
dbm "github.com/tendermint/tmlibs/db"
+ "google.golang.org/grpc/reflection"
)
const (
@@ -62,6 +66,8 @@ type Kernel struct {
Emitter event.Emitter
Service *rpc.Service
Launchers []process.Launcher
+ State *execution.State
+ Blockchain bcm.BlockchainInfo
Logger *logging.Logger
processes map[string]process.Process
shutdownNotify chan struct{}
@@ -108,8 +114,9 @@ func NewKernel(ctx context.Context, keyClient keys.KeyClient, privValidator tm_t
transactor := execution.NewTransactor(blockchain.Tip, emitter, tmNode.MempoolReactor().BroadcastTx, txCodec,
logger)
- nameReg := state
- service := rpc.NewService(ctx, state, nameReg, checker, emitter, blockchain, keyClient, transactor,
+ nameRegState := state
+ accountState := state
+ service := rpc.NewService(ctx, accountState, nameRegState, checker, emitter, blockchain, keyClient, transactor,
query.NewNodeView(tmNode, txCodec), logger)
launchers := []process.Launcher{
@@ -217,7 +224,7 @@ func NewKernel(ctx context.Context, keyClient keys.KeyClient, privValidator tm_t
},
},
{
- Name: "GRPC",
+ Name: "RPC/GRPC",
Enabled: rpcConfig.GRPC.Enabled,
Launch: func() (process.Process, error) {
listen, err := net.Listen("tcp", rpcConfig.GRPC.ListenAddress)
@@ -226,19 +233,28 @@ func NewKernel(ctx context.Context, keyClient keys.KeyClient, privValidator tm_t
}
grpcServer := rpc.NewGRPCServer(logger)
- var ks keys.KeyStore
+ var ks *keys.KeyStore
if keyStore != nil {
- ks = *keyStore
+ ks = keyStore
}
if keyConfig.GRPCServiceEnabled {
if keyStore == nil {
ks = keys.NewKeyStore(keyConfig.KeysDirectory, keyConfig.AllowBadFilePermissions, logger)
}
- pbkeys.RegisterKeysServer(grpcServer, &ks)
+ pbkeys.RegisterKeysServer(grpcServer, ks)
}
- burrow.RegisterTransactionServer(grpcServer, burrow.NewTransactionServer(service, state, txCodec))
+ pbtransactor.RegisterTransactorServer(grpcServer, rpctransactor.NewTransactorServer(service.Transactor(),
+ service.MempoolAccounts(), state, txCodec))
+
+ pbevents.RegisterEventsServer(grpcServer, rpcevents.NewEventsServer(rpc.NewSubscriptions(service)))
+
+ pbevents.RegisterExecutionEventsServer(grpcServer, rpcevents.NewExecutionEventsServer(state, emitter,
+ blockchain.Tip))
+
+ // Provides metadata about services registered
+ reflection.Register(grpcServer)
go grpcServer.Serve(listen)
@@ -255,8 +271,10 @@ func NewKernel(ctx context.Context, keyClient keys.KeyClient, privValidator tm_t
Emitter: emitter,
Service: service,
Launchers: launchers,
- processes: make(map[string]process.Process),
+ State: state,
+ Blockchain: blockchain,
Logger: logger,
+ processes: make(map[string]process.Process),
shutdownNotify: make(chan struct{}),
}, nil
}
diff --git a/core/kernel_test.go b/core/kernel_test.go
index fae573639b9ce3c39eb379e187447bac2fd9e47b..be0c5106875518518a4c53cf95c4f04d465c7f35 100644
--- a/core/kernel_test.go
+++ b/core/kernel_test.go
@@ -67,7 +67,7 @@ func bootWaitBlocksShutdown(privValidator tmTypes.PrivValidator, genesisDoc *gen
keyStore := keys.NewKeyStore(keys.DefaultKeysDir, false, logger)
keyClient := keys.NewLocalKeyClient(keyStore, logging.NewNoopLogger())
kern, err := NewKernel(context.Background(), keyClient, privValidator, genesisDoc, tmConf,
- rpc.DefaultRPCConfig(), keys.DefaultKeysConfig(), &keyStore, nil, logger)
+ rpc.DefaultRPCConfig(), keys.DefaultKeysConfig(), keyStore, nil, logger)
if err != nil {
return err
}
@@ -77,8 +77,10 @@ func bootWaitBlocksShutdown(privValidator tmTypes.PrivValidator, genesisDoc *gen
return err
}
- ch := make(chan *tmTypes.EventDataNewBlock)
- tendermint.SubscribeNewBlock(context.Background(), kern.Emitter, "TestBootShutdownResume", ch)
+ ch, err := tendermint.SubscribeNewBlock(context.Background(), kern.Emitter)
+ if err != nil {
+ return err
+ }
cont := true
for cont {
select {
diff --git a/docs/PROPOSALS.md b/docs/PROPOSALS.md
deleted file mode 100644
index fc2b5371123098c75f779e9066abea7fd6d8dd8d..0000000000000000000000000000000000000000
--- a/docs/PROPOSALS.md
+++ /dev/null
@@ -1,17 +0,0 @@
-# burrow proposals for future work
-
-The following list is extra-ordinarily uncommitted to and deliberately incomplete, but we thought it may be worthwhile sharing with you for soliciting your input and collaboration going forward:
-
-#### Security, Identity and Privacy
-
-- **Advanced security framework:** Functionality preceding Monax’s Nightsky (see multi-chain universe continuation below) to enable global encryption of transactions, genesis files and account storage at rest.
-- **Identity Management and Whitelisting:** write protection is inherent to the permissioning scheme but read protection will be enabled by integrating certificates for restricting connectivity access to the peer-to-peer network for validators, verifiers or light clients. This is in addition to normal VPN and firewall solutions and a precursor of Monax’s Nightsky, which restricts read-access through selective decryption.
-- **Multi-chain Universe (Step 2 of 3):** The second step towards enabling the multi-chain universe is well-underway with the Tendermint Cosmos proposal for interblockchain communication.
-- **Multi-chain Universe (Step 3 of 3):** The third and final step is the Monax’s Nightsky proposal for inherent encryption of transactions and allowing only partial reconstruction of the smart contract application state for verifiers or light clients (for mobile or IoT devices). Together Cosmos and Nightsky allow smart contracts to orchestrate where information flows and who has the ability to decypher what part of the data.
-
-#### Scalability and Governance
-
-- **Read-cache Optimisation and Queryability:** subjectively pipe the application state and event logs to a data warehousing solution. Building upon the read-cache the SQLsol prototype can be integrated as an SQL-opinionated transformation layer of smart contract events and data into a relational database.
-- **Chain life-cycle management:** the tooling is the starting point for chain life-cycle management and will be extended with exporting snapshots of chain state. These snapshots can be used to administratively start a new network with an updated version of burrow software as cold upgrade. In a second phase the Cosmos proposal is ideally suited to run a new version of the node software in parallel to existing chain and the validators of the network can atomically cast their vote of approval through the Cosmos hub to dynamically move the voting power over to the updated chain (hot upgrade) until a full vote of confidence is achieved. It is important to note that chain life-cycle management is complementary to and will support smart contract life-cycle management, known to some as DOUG, our marmot mascot.
-- **Sharding and scalability framework:** interblockchain communication through the exchange of proofs leverages the peer-to-peer network - rather than oracles - to distribute the load across parallel chains and removes oracle-bridges as potential bottlenecks and security risks.
-- **Light-client and ABI integration:** a significant usability upgrade of smart contract chains will be achieved through the ability for the ABI definition of the deployed smart contracts to be verifiably linked to the smart contract accounts. The introduction of the EIP-141 will enable the injection of an ABI fingerprint into smart contract code such that a light client, burrow-worker can dynamically expose the smart contract functionality through API calls. As an aside it is worth noting that the tendermint consensus protocol provides a distinctive advantage for light-clients as the last block signed by a majority of validators is unambiguously the current state;
diff --git a/event/cache.go b/event/cache.go
index 5be39c53ed81e2ec2c4e4e307ed5b47114945e9d..75f676cfc1333daaabd7520f5a69b68e43b68cea 100644
--- a/event/cache.go
+++ b/event/cache.go
@@ -10,17 +10,19 @@ const maximumBufferCapacityToLengthRatio = 2
// A Cache buffers events for a Publisher.
type Cache struct {
- publisher Publisher
- events []messageInfo
+ events []messageInfo
+}
+
+// If message implement this interface we will provide them with an index in the cache
+type Indexable interface {
+ ProvideIndex(index uint64)
}
var _ Publisher = &Cache{}
// Create a new Cache with an EventSwitch as backend
-func NewEventCache(publisher Publisher) *Cache {
- return &Cache{
- publisher: publisher,
- }
+func NewCache() *Cache {
+ return &Cache{}
}
// a cached event
@@ -29,30 +31,43 @@ type messageInfo struct {
// empty context
ctx context.Context
message interface{}
- tags map[string]interface{}
+ tags Tags
}
// Cache an event to be fired upon finality.
-func (evc *Cache) Publish(ctx context.Context, message interface{}, tags map[string]interface{}) error {
+func (evc *Cache) Publish(ctx context.Context, message interface{}, tags Tags) error {
// append to list (go will grow our backing array exponentially)
evc.events = append(evc.events, messageInfo{
ctx: ctx,
- message: message,
+ message: evc.provideIndex(message),
tags: tags,
})
return nil
}
+func (evc *Cache) Flush(publisher Publisher) error {
+ err := evc.Sync(publisher)
+ if err != nil {
+ return err
+ }
+ evc.Reset()
+ return nil
+}
+
// Clears cached events by flushing them to Publisher
-func (evc *Cache) Flush() error {
+func (evc *Cache) Sync(publisher Publisher) error {
var err error
for _, mi := range evc.events {
- publishErr := evc.publisher.Publish(mi.ctx, mi.message, mi.tags)
- // Capture first by try to flush the rest
+ publishErr := publisher.Publish(mi.ctx, mi.message, mi.tags)
+ // Capture first by try to sync the rest
if publishErr != nil && err == nil {
err = publishErr
}
}
+ return err
+}
+
+func (evc *Cache) Reset() {
// Clear the buffer by re-slicing its length to zero
if cap(evc.events) > len(evc.events)*maximumBufferCapacityToLengthRatio {
// Trim the backing array capacity when it is more than double the length of the slice to avoid tying up memory
@@ -63,5 +78,11 @@ func (evc *Cache) Flush() error {
// in previous cache round
evc.events = evc.events[:0]
}
- return err
+}
+
+func (evc *Cache) provideIndex(message interface{}) interface{} {
+ if im, ok := message.(Indexable); ok {
+ im.ProvideIndex(uint64(len(evc.events)))
+ }
+ return message
}
diff --git a/event/cache_test.go b/event/cache_test.go
index 276d323c47ce444a505bfec63ef4d131fb0f2ef0..52bcbd6640a0f7008caf061cc504eb6cdfec00d6 100644
--- a/event/cache_test.go
+++ b/event/cache_test.go
@@ -6,6 +6,7 @@ import (
"testing"
"time"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/logging"
"github.com/stretchr/testify/assert"
)
@@ -18,35 +19,35 @@ func TestEventCache_Flush(t *testing.T) {
flushed := false
em := NewEmitter(logging.NewNoopLogger())
- SubscribeCallback(ctx, em, "nothingness", NewQueryBuilder(), func(message interface{}) bool {
+ SubscribeCallback(ctx, em, "nothingness", query.NewBuilder(), func(message interface{}) (stop bool) {
// Check against sending a buffer of zeroed messages
if message == nil {
errCh <- fmt.Errorf("recevied empty message but none sent")
}
- return false
+ return true
})
- evc := NewEventCache(em)
- evc.Flush()
+ evc := NewCache()
+ evc.Flush(em)
// Check after reset
- evc.Flush()
- SubscribeCallback(ctx, em, "somethingness", NewQueryBuilder().AndEquals("foo", "bar"),
- func(interface{}) bool {
+ evc.Flush(em)
+ SubscribeCallback(ctx, em, "somethingness", query.NewBuilder().AndEquals("foo", "bar"),
+ func(interface{}) (stop bool) {
if flushed {
errCh <- nil
- return true
+ return false
} else {
errCh <- fmt.Errorf("callback was run before messages were flushed")
- return false
+ return true
}
})
numMessages := 3
- tags := map[string]interface{}{"foo": "bar"}
+ tags := TagMap{"foo": "bar"}
for i := 0; i < numMessages; i++ {
evc.Publish(ctx, fmt.Sprintf("something_%v", i), tags)
}
flushed = true
- evc.Flush()
+ evc.Flush(em)
for i := 0; i < numMessages; i++ {
select {
case <-time.After(2 * time.Second):
@@ -60,30 +61,31 @@ func TestEventCache_Flush(t *testing.T) {
}
func TestEventCacheGrowth(t *testing.T) {
- evc := NewEventCache(NewEmitter(logging.NewNoopLogger()))
+ em := NewEmitter(logging.NewNoopLogger())
+ evc := NewCache()
fireNEvents(evc, 100)
c := cap(evc.events)
- evc.Flush()
+ evc.Flush(em)
assert.Equal(t, c, cap(evc.events), "cache cap should remain the same after flushing events")
fireNEvents(evc, c/maximumBufferCapacityToLengthRatio+1)
- evc.Flush()
+ evc.Flush(em)
assert.Equal(t, c, cap(evc.events), "cache cap should remain the same after flushing more than half "+
"the number of events as last time")
fireNEvents(evc, c/maximumBufferCapacityToLengthRatio-1)
- evc.Flush()
+ evc.Flush(em)
assert.True(t, c > cap(evc.events), "cache cap should drop after flushing fewer than half "+
"the number of events as last time")
fireNEvents(evc, c*2*maximumBufferCapacityToLengthRatio)
- evc.Flush()
+ evc.Flush(em)
assert.True(t, c < cap(evc.events), "cache cap should grow after flushing more events than seen before")
for numEvents := 100; numEvents >= 0; numEvents-- {
fireNEvents(evc, numEvents)
- evc.Flush()
+ evc.Flush(em)
assert.True(t, cap(evc.events) <= maximumBufferCapacityToLengthRatio*numEvents,
"cap (%v) should be at most twice numEvents (%v)", cap(evc.events), numEvents)
}
diff --git a/event/convention.go b/event/convention.go
index 33a66a501f7e686898ecbaf86654ce8eb601ee52..dede8493bbc98eba5ada4947d3e0816d857f8714 100644
--- a/event/convention.go
+++ b/event/convention.go
@@ -2,52 +2,75 @@ package event
import (
"context"
+
+ "time"
+
"fmt"
- "reflect"
+
+ "github.com/hyperledger/burrow/event/query"
)
const (
+ EventTypeKey = "EventType"
EventIDKey = "EventID"
MessageTypeKey = "MessageType"
TxTypeKey = "TxType"
TxHashKey = "TxHash"
+ HeightKey = "Height"
+ IndexKey = "Index"
+ NameKey = "Name"
+ PermissionKey = "Permission"
StackDepthKey = "StackDepth"
+ AddressKey = "Address"
+ OriginKey = "Origin"
+ CalleeKey = "Callee"
+ CallerKey = "Caller"
+ ValueKey = "Value"
+ GasKey = "Gas"
+ ExceptionKey = "Exception"
+ LogNKeyPrefix = "Log"
)
-// Get a query that matches events with a specific eventID
-func QueryForEventID(eventID string) *QueryBuilder {
- // Since we're accepting external output here there is a chance it won't parse...
- return NewQueryBuilder().AndEquals(EventIDKey, eventID)
+func LogNKey(topic int) string {
+ return fmt.Sprintf("%s%d", LogNKeyPrefix, topic)
}
-func PublishWithEventID(publisher Publisher, eventID string, eventData interface{},
- extraTags map[string]interface{}) error {
+func LogNTextKey(topic int) string {
+ return fmt.Sprintf("%s%dText", LogNKeyPrefix, topic)
+}
- if extraTags[EventIDKey] != nil {
- return fmt.Errorf("PublishWithEventID was passed the extraTags with %s already set: %s = '%s'",
- EventIDKey, EventIDKey, eventID)
- }
- tags := map[string]interface{}{
- EventIDKey: eventID,
- MessageTypeKey: reflect.TypeOf(eventData).String(),
- }
- for k, v := range extraTags {
- tags[k] = v
- }
- return publisher.Publish(context.Background(), eventData, tags)
+const SubscribeCallbackTimeout = 2 * time.Second
+
+// Get a query that matches events with a specific eventID
+func QueryForEventID(eventID string) *query.Builder {
+ // Since we're accepting external output here there is a chance it won't parse...
+ return query.NewBuilder().AndEquals(EventIDKey, eventID)
}
// Subscribe to messages matching query and launch a goroutine to run a callback for each one. The goroutine will exit
-// when the context is done or the subscription is removed.
-func SubscribeCallback(ctx context.Context, subscribable Subscribable, subscriber string, query Queryable,
- callback func(message interface{}) bool) error {
+// if the callback returns true for 'stop' and clean up the subscription and channel.
+func SubscribeCallback(ctx context.Context, subscribable Subscribable, subscriber string, queryable query.Queryable,
+ callback func(message interface{}) (stop bool)) error {
+
+ out := make(chan interface{}, 1)
+ stopCh := make(chan bool)
- out := make(chan interface{})
go func() {
for msg := range out {
- if !callback(msg) {
+ go func() {
+ stopCh <- callback(msg)
+ }()
+
+ // Stop unless the callback returns
+ stop := true
+ select {
+ case stop = <-stopCh:
+ case <-time.After(SubscribeCallbackTimeout):
+ }
+
+ if stop {
// Callback is requesting stop so unsubscribe and drain channel
- subscribable.Unsubscribe(context.Background(), subscriber, query)
+ subscribable.Unsubscribe(context.Background(), subscriber, queryable)
// Not draining channel can starve other subscribers
for range out {
}
@@ -55,7 +78,7 @@ func SubscribeCallback(ctx context.Context, subscribable Subscribable, subscribe
}
}
}()
- err := subscribable.Subscribe(ctx, subscriber, query, out)
+ err := subscribable.Subscribe(ctx, subscriber, queryable, out)
if err != nil {
// To clean up goroutine - otherwise subscribable should close channel for us
close(out)
@@ -63,16 +86,16 @@ func SubscribeCallback(ctx context.Context, subscribable Subscribable, subscribe
return err
}
-func PublishAll(ctx context.Context, subscribable Subscribable, subscriber string, query Queryable,
+func PublishAll(ctx context.Context, subscribable Subscribable, subscriber string, queryable query.Queryable,
publisher Publisher, extraTags map[string]interface{}) error {
- return SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) bool {
+ return SubscribeCallback(ctx, subscribable, subscriber, queryable, func(message interface{}) (stop bool) {
tags := make(map[string]interface{})
for k, v := range extraTags {
tags[k] = v
}
// Help! I can't tell which tags the original publisher used - so I can't forward them on
- publisher.Publish(ctx, message, tags)
- return true
+ publisher.Publish(ctx, message, TagMap(tags))
+ return
})
}
diff --git a/event/convention_test.go b/event/convention_test.go
index 35c8f7d675cc2ddb870893b5545955e4d1b3d451..2fd0202dee11da929840814755b45e4f87e57842 100644
--- a/event/convention_test.go
+++ b/event/convention_test.go
@@ -5,6 +5,7 @@ import (
"testing"
"time"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/logging"
"github.com/stretchr/testify/assert"
)
@@ -13,10 +14,11 @@ func TestSubscribeCallback(t *testing.T) {
ctx := context.Background()
em := NewEmitter(logging.NewNoopLogger())
ch := make(chan interface{})
- SubscribeCallback(ctx, em, "TestSubscribeCallback", MatchAllQueryable(), func(msg interface{}) bool {
- ch <- msg
- return true
- })
+ SubscribeCallback(ctx, em, "TestSubscribeCallback", query.MatchAllQueryable(),
+ func(msg interface{}) (stop bool) {
+ ch <- msg
+ return
+ })
sent := "FROTHY"
diff --git a/event/emitter.go b/event/emitter.go
index 738104fdea49cdd1b1f15e8709257fa887862e60..1fd09e81a4a0fb5afb61bbc33b57410f4c82ddf4 100644
--- a/event/emitter.go
+++ b/event/emitter.go
@@ -21,6 +21,7 @@ import (
"fmt"
"strings"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
"github.com/hyperledger/burrow/process"
@@ -30,21 +31,26 @@ import (
const DefaultEventBufferCapacity = 2 << 10
+// TODO: manage the creation, closing, and draining of channels behind the interface rather than only closing.
+// stop one subscriber from blocking everything!
type Subscribable interface {
- // Subscribe to all events matching query, which is a valid tmlibs Query
- Subscribe(ctx context.Context, subscriber string, query Queryable, out chan<- interface{}) error
- // Unsubscribe subscriber from a specific query string
- Unsubscribe(ctx context.Context, subscriber string, query Queryable) error
+ // Subscribe to all events matching query, which is a valid tmlibs Query. Blocking the out channel blocks the entire
+ // pubsub.
+ Subscribe(ctx context.Context, subscriber string, queryable query.Queryable, out chan<- interface{}) error
+ // Unsubscribe subscriber from a specific query string. Note the subscribe channel must be drained.
+ Unsubscribe(ctx context.Context, subscriber string, queryable query.Queryable) error
UnsubscribeAll(ctx context.Context, subscriber string) error
}
type Publisher interface {
- Publish(ctx context.Context, message interface{}, tags map[string]interface{}) error
+ Publish(ctx context.Context, message interface{}, tag Tags) error
}
-type PublisherFunc func(ctx context.Context, message interface{}, tags map[string]interface{}) error
+var _ Publisher = PublisherFunc(nil)
-func (pf PublisherFunc) Publish(ctx context.Context, message interface{}, tags map[string]interface{}) error {
+type PublisherFunc func(ctx context.Context, message interface{}, tags Tags) error
+
+func (pf PublisherFunc) Publish(ctx context.Context, message interface{}, tags Tags) error {
return pf(ctx, message, tags)
}
@@ -77,21 +83,21 @@ func (em *emitter) Shutdown(ctx context.Context) error {
}
// Publisher
-func (em *emitter) Publish(ctx context.Context, message interface{}, tags map[string]interface{}) error {
- return em.pubsubServer.PublishWithTags(ctx, message, tagMap(tags))
+func (em *emitter) Publish(ctx context.Context, message interface{}, tags Tags) error {
+ return em.pubsubServer.PublishWithTags(ctx, message, tags)
}
// Subscribable
-func (em *emitter) Subscribe(ctx context.Context, subscriber string, query Queryable, out chan<- interface{}) error {
- pubsubQuery, err := query.Query()
+func (em *emitter) Subscribe(ctx context.Context, subscriber string, queryable query.Queryable, out chan<- interface{}) error {
+ pubsubQuery, err := queryable.Query()
if err != nil {
return nil
}
return em.pubsubServer.Subscribe(ctx, subscriber, pubsubQuery, out)
}
-func (em *emitter) Unsubscribe(ctx context.Context, subscriber string, query Queryable) error {
- pubsubQuery, err := query.Query()
+func (em *emitter) Unsubscribe(ctx context.Context, subscriber string, queryable query.Queryable) error {
+ pubsubQuery, err := queryable.Query()
if err != nil {
return nil
}
@@ -110,7 +116,7 @@ func NewNoOpPublisher() Publisher {
type noOpPublisher struct {
}
-func (nop *noOpPublisher) Publish(ctx context.Context, message interface{}, tags map[string]interface{}) error {
+func (nop *noOpPublisher) Publish(ctx context.Context, message interface{}, tags Tags) error {
return nil
}
@@ -127,11 +133,3 @@ func GenerateSubscriptionID() (string, error) {
rStr := hex.EncodeToString(b)
return strings.ToUpper(rStr), nil
}
-
-func tagMap(tags map[string]interface{}) pubsub.TagMap {
- mp := make(map[string]string, len(tags))
- for k, v := range tags {
- mp[k] = structure.StringifyKey(v)
- }
- return pubsub.NewTagMap(mp)
-}
diff --git a/event/emitter_test.go b/event/emitter_test.go
index d9709d6d62bf432f8b2161564d9ffd0e7663e1e0..8325456db81515e406e6705e962ce362b1b110d1 100644
--- a/event/emitter_test.go
+++ b/event/emitter_test.go
@@ -5,6 +5,7 @@ import (
"testing"
"time"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/logging"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
@@ -15,15 +16,15 @@ func TestEmitter(t *testing.T) {
ctx := context.Background()
out := make(chan interface{})
- err := em.Subscribe(ctx, "TestEmitter", NewQueryBuilder().AndStrictlyGreaterThan("foo", 10), out)
+ err := em.Subscribe(ctx, "TestEmitter", query.NewBuilder().AndStrictlyGreaterThan("foo", 10), out)
require.NoError(t, err)
msgMiss := struct{ flob string }{"flib"}
- err = em.Publish(ctx, msgMiss, map[string]interface{}{"foo": 10})
+ err = em.Publish(ctx, msgMiss, TagMap(map[string]interface{}{"foo": 10}))
assert.NoError(t, err)
msgHit := struct{ blib string }{"blab"}
- err = em.Publish(ctx, msgHit, map[string]interface{}{"foo": 11})
+ err = em.Publish(ctx, msgHit, TagMap(map[string]interface{}{"foo": 11}))
assert.NoError(t, err)
select {
@@ -39,14 +40,14 @@ func TestOrdering(t *testing.T) {
ctx := context.Background()
out := make(chan interface{})
- err := em.Subscribe(ctx, "TestOrdering1", NewQueryBuilder().AndEquals("foo", "bar"), out)
+ err := em.Subscribe(ctx, "TestOrdering1", query.NewBuilder().AndEquals("foo", "bar"), out)
require.NoError(t, err)
- err = em.Subscribe(ctx, "TestOrdering2", NewQueryBuilder().AndEquals("foo", "baz"), out)
+ err = em.Subscribe(ctx, "TestOrdering2", query.NewBuilder().AndEquals("foo", "baz"), out)
require.NoError(t, err)
- barTag := map[string]interface{}{"foo": "bar"}
- bazTag := map[string]interface{}{"foo": "baz"}
+ barTag := TagMap{"foo": "bar"}
+ bazTag := TagMap{"foo": "baz"}
msgs := [][]interface{}{
{"baz1", bazTag},
@@ -60,7 +61,7 @@ func TestOrdering(t *testing.T) {
go func() {
for _, msg := range msgs {
- em.Publish(ctx, msg[0], msg[1].(map[string]interface{}))
+ em.Publish(ctx, msg[0], msg[1].(TagMap))
}
em.Publish(ctx, "stop", bazTag)
}()
diff --git a/event/query/empty.go b/event/query/empty.go
new file mode 100644
index 0000000000000000000000000000000000000000..c83169e18b5224a178d6812439393bac69231dd2
--- /dev/null
+++ b/event/query/empty.go
@@ -0,0 +1,13 @@
+package query
+
+import (
+ "github.com/tendermint/tendermint/libs/pubsub"
+ "github.com/tendermint/tendermint/libs/pubsub/query"
+)
+
+// Matches everything
+type Empty query.Empty
+
+func (Empty) Query() (pubsub.Query, error) {
+ return query.Empty{}, nil
+}
diff --git a/event/query.go b/event/query/query.go
similarity index 52%
rename from event/query.go
rename to event/query/query.go
index 41f4ca712753e7f0d8fbf5ae852ce4e47984658f..fc107968b1541927f0c1a9f7e9edb1f9f9f9a4ae 100644
--- a/event/query.go
+++ b/event/query/query.go
@@ -1,4 +1,4 @@
-package event
+package query
import (
"bytes"
@@ -34,9 +34,16 @@ type Queryable interface {
}
// A yet-to-parsed query
-type QueryString string
+type String string
-func (qs QueryString) Query() (pubsub.Query, error) {
+func Must(qry pubsub.Query, err error) Query {
+ if err != nil {
+ panic(fmt.Errorf("could not compile: %v", qry))
+ }
+ return WrapQuery(qry)
+}
+
+func (qs String) Query() (pubsub.Query, error) {
if isEmpty(string(qs)) {
return query.Empty{}, nil
}
@@ -61,7 +68,7 @@ func (q Query) Query() (pubsub.Query, error) {
}
// A fluent query builder
-type QueryBuilder struct {
+type Builder struct {
queryString string
condition
// reusable buffer for building queryString
@@ -79,17 +86,17 @@ type condition struct {
var conditionTemplate = template.Must(template.New("condition").Parse("{{.Tag}} {{.Op}} {{.Operand}}"))
// Creates a new query builder with a base query that is the conjunction of all queries passed
-func NewQueryBuilder(queries ...string) *QueryBuilder {
- qb := new(QueryBuilder)
+func NewBuilder(queries ...string) *Builder {
+ qb := new(Builder)
qb.queryString = qb.and(stringIterator(queries...))
return qb
}
-func (qb *QueryBuilder) String() string {
+func (qb *Builder) String() string {
return qb.queryString
}
-func (qb *QueryBuilder) Query() (pubsub.Query, error) {
+func (qb *Builder) Query() (pubsub.Query, error) {
if qb.error != nil {
return nil, qb.error
}
@@ -99,55 +106,55 @@ func (qb *QueryBuilder) Query() (pubsub.Query, error) {
return query.New(qb.String())
}
-// Creates the conjunction of QueryBuilder and rightQuery
-func (qb *QueryBuilder) And(queryBuilders ...*QueryBuilder) *QueryBuilder {
- return NewQueryBuilder(qb.and(queryBuilderIterator(queryBuilders...)))
+// Creates the conjunction of Builder and rightQuery
+func (qb *Builder) And(queryBuilders ...*Builder) *Builder {
+ return NewBuilder(qb.and(queryBuilderIterator(queryBuilders...)))
}
-// Creates the conjunction of QueryBuilder and tag = operand
-func (qb *QueryBuilder) AndEquals(tag string, operand interface{}) *QueryBuilder {
+// Creates the conjunction of Builder and tag = operand
+func (qb *Builder) AndEquals(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = equalString
- qb.condition.Operand = qb.operand(operand)
- return NewQueryBuilder(qb.and(stringIterator(qb.conditionString())))
+ qb.condition.Operand = operandString(operand)
+ return NewBuilder(qb.and(stringIterator(qb.conditionString())))
}
-func (qb *QueryBuilder) AndGreaterThanOrEqual(tag string, operand interface{}) *QueryBuilder {
+func (qb *Builder) AndGreaterThanOrEqual(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = greaterOrEqualString
- qb.condition.Operand = qb.operand(operand)
- return NewQueryBuilder(qb.and(stringIterator(qb.conditionString())))
+ qb.condition.Operand = operandString(operand)
+ return NewBuilder(qb.and(stringIterator(qb.conditionString())))
}
-func (qb *QueryBuilder) AndLessThanOrEqual(tag string, operand interface{}) *QueryBuilder {
+func (qb *Builder) AndLessThanOrEqual(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = lessOrEqualString
- qb.condition.Operand = qb.operand(operand)
- return NewQueryBuilder(qb.and(stringIterator(qb.conditionString())))
+ qb.condition.Operand = operandString(operand)
+ return NewBuilder(qb.and(stringIterator(qb.conditionString())))
}
-func (qb *QueryBuilder) AndStrictlyGreaterThan(tag string, operand interface{}) *QueryBuilder {
+func (qb *Builder) AndStrictlyGreaterThan(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = greaterThanString
- qb.condition.Operand = qb.operand(operand)
- return NewQueryBuilder(qb.and(stringIterator(qb.conditionString())))
+ qb.condition.Operand = operandString(operand)
+ return NewBuilder(qb.and(stringIterator(qb.conditionString())))
}
-func (qb *QueryBuilder) AndStrictlyLessThan(tag string, operand interface{}) *QueryBuilder {
+func (qb *Builder) AndStrictlyLessThan(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = lessThanString
- qb.condition.Operand = qb.operand(operand)
- return NewQueryBuilder(qb.and(stringIterator(qb.conditionString())))
+ qb.condition.Operand = operandString(operand)
+ return NewBuilder(qb.and(stringIterator(qb.conditionString())))
}
-func (qb *QueryBuilder) AndContains(tag string, operand interface{}) *QueryBuilder {
+func (qb *Builder) AndContains(tag string, operand interface{}) *Builder {
qb.condition.Tag = tag
qb.condition.Op = containsString
- qb.condition.Operand = qb.operand(operand)
- return NewQueryBuilder(qb.and(stringIterator(qb.conditionString())))
+ qb.condition.Operand = operandString(operand)
+ return NewBuilder(qb.and(stringIterator(qb.conditionString())))
}
-func (qb *QueryBuilder) and(queryIterator func(func(string))) string {
+func (qb *Builder) and(queryIterator func(func(string))) string {
defer qb.Buffer.Reset()
qb.Buffer.WriteString(qb.queryString)
queryIterator(func(q string) {
@@ -163,44 +170,56 @@ func (qb *QueryBuilder) and(queryIterator func(func(string))) string {
return qb.Buffer.String()
}
-func (qb *QueryBuilder) operand(operand interface{}) string {
- defer qb.Buffer.Reset()
- switch oper := operand.(type) {
+func operandString(value interface{}) string {
+ buf := new(bytes.Buffer)
+ switch v := value.(type) {
+ case string:
+ buf.WriteByte('\'')
+ buf.WriteString(v)
+ buf.WriteByte('\'')
+ return buf.String()
+ case fmt.Stringer:
+ return operandString(v.String())
+ default:
+ return StringFromValue(v)
+ }
+}
+
+func StringFromValue(value interface{}) string {
+ switch v := value.(type) {
case string:
- qb.Buffer.WriteByte('\'')
- qb.Buffer.WriteString(oper)
- qb.Buffer.WriteByte('\'')
- return qb.Buffer.String()
+ return v
case fmt.Stringer:
- return qb.operand(oper.String())
+ return v.String()
case bool:
- if oper {
+ if v {
return trueString
}
return falseString
case int:
- return strconv.FormatInt(int64(oper), 10)
+ return strconv.FormatInt(int64(v), 10)
+ case int32:
+ return strconv.FormatInt(int64(v), 10)
case int64:
- return strconv.FormatInt(oper, 10)
+ return strconv.FormatInt(v, 10)
case uint:
- return strconv.FormatUint(uint64(oper), 10)
+ return strconv.FormatUint(uint64(v), 10)
+ case uint32:
+ return strconv.FormatUint(uint64(v), 10)
case uint64:
- return strconv.FormatUint(oper, 10)
+ return strconv.FormatUint(v, 10)
case float32:
- return strconv.FormatFloat(float64(oper), 'f', -1, 32)
+ return strconv.FormatFloat(float64(v), 'f', -1, 32)
case float64:
- return strconv.FormatFloat(float64(oper), 'f', -1, 64)
+ return strconv.FormatFloat(float64(v), 'f', -1, 64)
case time.Time:
- qb.Buffer.WriteString(timeString)
- qb.Buffer.WriteByte(' ')
- qb.Buffer.WriteString(oper.Format(time.RFC3339))
- return qb.Buffer.String()
+ return timeString + " " + v.Format(time.RFC3339)
default:
- return fmt.Sprintf("%v", oper)
+ return fmt.Sprintf("%v", v)
}
}
-func (qb *QueryBuilder) conditionString() string {
+func (qb *Builder) conditionString() string {
defer qb.Buffer.Reset()
err := conditionTemplate.Execute(&qb.Buffer, qb.condition)
if err != nil && qb.error == nil {
@@ -222,7 +241,7 @@ func stringIterator(strs ...string) func(func(string)) {
}
}
-func queryBuilderIterator(qbs ...*QueryBuilder) func(func(string)) {
+func queryBuilderIterator(qbs ...*Builder) func(func(string)) {
return func(callback func(string)) {
for _, qb := range qbs {
callback(qb.String())
diff --git a/event/query_test.go b/event/query/query_test.go
similarity index 91%
rename from event/query_test.go
rename to event/query/query_test.go
index 35e9b36a791785e52ebeebd869d9809cc9e21a1a..a7116b0a8b43c50e2099f82b6ede2178fa22bcdc 100644
--- a/event/query_test.go
+++ b/event/query/query_test.go
@@ -1,4 +1,4 @@
-package event
+package query
import (
"testing"
@@ -10,7 +10,7 @@ import (
)
func TestQueryBuilder(t *testing.T) {
- qb := NewQueryBuilder()
+ qb := NewBuilder()
qry, err := qb.Query()
require.NoError(t, err)
assert.Equal(t, emptyString, qry.String())
@@ -37,8 +37,8 @@ func TestQueryBuilder(t *testing.T) {
assert.True(t, qry.Matches(makeTagMap("foo.size", 80, "bar.name", "marmot", "bar.desc", "lives in a burrow")))
assert.False(t, qry.Matches(makeTagMap("foo.size", 80, "bar.name", "marmot", "bar.desc", "lives in a shoe")))
- qb = NewQueryBuilder().AndEquals("foo", "bar")
- qb = qb.And(NewQueryBuilder().AndGreaterThanOrEqual("frogs", 4))
+ qb = NewBuilder().AndEquals("foo", "bar")
+ qb = qb.And(NewBuilder().AndGreaterThanOrEqual("frogs", 4))
qry, err = qb.Query()
require.NoError(t, err)
assert.Equal(t, "foo = 'bar' AND frogs >= 4", qry.String())
diff --git a/event/tags.go b/event/tags.go
new file mode 100644
index 0000000000000000000000000000000000000000..759d035d734b6ee4987cd1952c3b63da47373f39
--- /dev/null
+++ b/event/tags.go
@@ -0,0 +1,87 @@
+package event
+
+import (
+ "fmt"
+
+ "github.com/tendermint/tendermint/libs/pubsub"
+)
+
+type Tags interface {
+ pubsub.TagMap
+ Keys() []string
+}
+
+type TagMap map[string]interface{}
+
+func (ts TagMap) Get(key string) (value string, ok bool) {
+ var vint interface{}
+ vint, ok = ts[key]
+ if !ok {
+ return
+ }
+ switch v := vint.(type) {
+ case string:
+ value = v
+ case fmt.Stringer:
+ value = v.String()
+ default:
+ value = fmt.Sprintf("%v", v)
+ }
+ return
+}
+
+func (ts TagMap) Len() int {
+ return len(ts)
+}
+
+func (ts TagMap) Map() map[string]interface{} {
+ return ts
+}
+
+func (ts TagMap) Keys() []string {
+ keys := make([]string, 0, len(ts))
+ for k := range ts {
+ keys = append(keys, k)
+ }
+ return keys
+}
+
+type CombinedTags []Tags
+
+func (ct CombinedTags) Get(key string) (value string, ok bool) {
+ for _, t := range ct {
+ value, ok = t.Get(key)
+ if ok {
+ return
+ }
+ }
+ return
+}
+
+func (ct CombinedTags) Len() (length int) {
+ for _, t := range ct {
+ length += t.Len()
+ }
+ return length
+}
+
+func (ct CombinedTags) Map() map[string]interface{} {
+ tags := make(map[string]interface{})
+ for _, t := range ct {
+ for _, k := range t.Keys() {
+ v, ok := t.Get(k)
+ if ok {
+ tags[k] = v
+ }
+ }
+ }
+ return tags
+}
+
+func (ct CombinedTags) Keys() []string {
+ var keys []string
+ for _, t := range ct {
+ keys = append(keys, t.Keys()...)
+ }
+ return keys
+}
diff --git a/execution/accounts.go b/execution/accounts.go
index 1a9fe3aa53cb1f53217ffc1a65ecf1032cd85007..8125ef0a10d9546c8165b9c98d65b04881e7f717 100644
--- a/execution/accounts.go
+++ b/execution/accounts.go
@@ -88,6 +88,22 @@ func (accs *Accounts) SequentialSigningAccountFromPrivateKey(privateKeyBytes []b
}, nil
}
+// Gets signing account from onr of private key or address - failing if both are provided
+func (accs *Accounts) GetSequentialSigningAccount(address, privateKey []byte) (*SequentialSigningAccount, error) {
+ if len(address) > 0 {
+ if len(privateKey) > 0 {
+ return nil, fmt.Errorf("address and private key provided but only one or the other should be given")
+ }
+ address, err := crypto.AddressFromBytes(address)
+ if err != nil {
+ return nil, err
+ }
+ return accs.SequentialSigningAccount(address)
+ }
+
+ return accs.SequentialSigningAccountFromPrivateKey(privateKey)
+}
+
type UnlockFunc func()
func (ssa *SequentialSigningAccount) Lock() (*SigningAccount, UnlockFunc, error) {
diff --git a/execution/errors/errors.go b/execution/errors/errors.go
index 7c576566c06f2233a43bcfbbfd5d047b9a2a39d2..ba15497f0212b37909f772f9b2f321a89ef08567 100644
--- a/execution/errors/errors.go
+++ b/execution/errors/errors.go
@@ -1,18 +1,19 @@
package errors
import (
+ "encoding/json"
"fmt"
)
type CodedError interface {
error
- ErrorCode() ErrorCode
+ ErrorCode() Code
}
-type ErrorCode int8
+type Code uint32
const (
- ErrorCodeGeneric ErrorCode = iota
+ ErrorCodeGeneric Code = iota
ErrorCodeUnknownAddress
ErrorCodeInsufficientBalance
ErrorCodeInvalidJumpDest
@@ -31,14 +32,15 @@ const (
ErrorCodeExecutionReverted
ErrorCodePermissionDenied
ErrorCodeNativeFunction
+ ErrorCodeEventPublish
)
-func (ec ErrorCode) ErrorCode() ErrorCode {
- return ec
+func (c Code) ErrorCode() Code {
+ return c
}
-func (ec ErrorCode) Error() string {
- switch ec {
+func (c Code) Error() string {
+ switch c {
case ErrorCodeUnknownAddress:
return "Unknown address"
case ErrorCodeInsufficientBalance:
@@ -73,23 +75,23 @@ func (ec ErrorCode) Error() string {
return "Execution reverted"
case ErrorCodeNativeFunction:
return "Native function error"
- default:
+ case ErrorCodeEventPublish:
+ return "Event publish error"
+ case ErrorCodeGeneric:
return "Generic error"
+ default:
+ return "Unknown error"
}
}
-// Exception provides a serialisable coded error for the VM
-type Exception struct {
- Code ErrorCode
- Exception string
-}
-
-func NewCodedError(errorCode ErrorCode, exception string) *Exception {
+func NewCodedError(errorCode Code, exception string) *Exception {
if exception == "" {
return nil
}
return &Exception{
- Code: errorCode,
+ Code: &ErrorCode{
+ Code: uint32(errorCode),
+ },
Exception: exception,
}
}
@@ -117,29 +119,39 @@ func Errorf(format string, a ...interface{}) CodedError {
return ErrorCodef(ErrorCodeGeneric, format, a...)
}
-func ErrorCodef(errorCode ErrorCode, format string, a ...interface{}) CodedError {
+func ErrorCodef(errorCode Code, format string, a ...interface{}) CodedError {
return NewCodedError(errorCode, fmt.Sprintf(format, a...))
}
func (e *Exception) AsError() error {
- // thanks go, you dick
+ // We need to return a bare untyped error here so that err == nil downstream
if e == nil {
return nil
}
return e
}
-func (e *Exception) ErrorCode() ErrorCode {
- return e.Code
-}
-
-func (e *Exception) String() string {
- return e.Error()
+func (e *Exception) ErrorCode() Code {
+ return Code(e.GetCode().Code)
}
func (e *Exception) Error() string {
if e == nil {
return ""
}
- return fmt.Sprintf("VM Error %v: %s", e.Code, e.Exception)
+ return fmt.Sprintf("Error %v: %s", e.Code.Code, e.Exception)
+}
+
+func NewErrorCode(code Code) *ErrorCode {
+ return &ErrorCode{
+ Code: uint32(code),
+ }
+}
+
+func (e ErrorCode) MarshalJSON() ([]byte, error) {
+ return json.Marshal(e.Code)
+}
+
+func (e *ErrorCode) UnmarshalJSON(bs []byte) error {
+ return json.Unmarshal(bs, &(e.Code))
}
diff --git a/execution/errors/errors.pb.go b/execution/errors/errors.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..14d297a6c41cda1f905353a1f056f72b5fab3895
--- /dev/null
+++ b/execution/errors/errors.pb.go
@@ -0,0 +1,135 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/hyperledger/burrow/execution/errors/errors.proto
+
+package errors
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Exception struct {
+ Code *ErrorCode `protobuf:"bytes,1,opt,name=Code,proto3" json:"Code,omitempty"`
+ Exception string `protobuf:"bytes,2,opt,name=Exception,proto3" json:"Exception,omitempty"`
+ BS []byte `protobuf:"bytes,3,opt,name=BS,proto3" json:"BS,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Exception) Reset() { *m = Exception{} }
+func (m *Exception) String() string { return proto.CompactTextString(m) }
+func (*Exception) ProtoMessage() {}
+func (*Exception) Descriptor() ([]byte, []int) {
+ return fileDescriptor_errors_e7e9443965b28d5d, []int{0}
+}
+func (m *Exception) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Exception.Unmarshal(m, b)
+}
+func (m *Exception) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Exception.Marshal(b, m, deterministic)
+}
+func (dst *Exception) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Exception.Merge(dst, src)
+}
+func (m *Exception) XXX_Size() int {
+ return xxx_messageInfo_Exception.Size(m)
+}
+func (m *Exception) XXX_DiscardUnknown() {
+ xxx_messageInfo_Exception.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Exception proto.InternalMessageInfo
+
+func (m *Exception) GetCode() *ErrorCode {
+ if m != nil {
+ return m.Code
+ }
+ return nil
+}
+
+func (m *Exception) GetException() string {
+ if m != nil {
+ return m.Exception
+ }
+ return ""
+}
+
+func (m *Exception) GetBS() []byte {
+ if m != nil {
+ return m.BS
+ }
+ return nil
+}
+
+type ErrorCode struct {
+ Code uint32 `protobuf:"varint,1,opt,name=Code,proto3" json:"Code,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ErrorCode) Reset() { *m = ErrorCode{} }
+func (m *ErrorCode) String() string { return proto.CompactTextString(m) }
+func (*ErrorCode) ProtoMessage() {}
+func (*ErrorCode) Descriptor() ([]byte, []int) {
+ return fileDescriptor_errors_e7e9443965b28d5d, []int{1}
+}
+func (m *ErrorCode) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ErrorCode.Unmarshal(m, b)
+}
+func (m *ErrorCode) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ErrorCode.Marshal(b, m, deterministic)
+}
+func (dst *ErrorCode) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ErrorCode.Merge(dst, src)
+}
+func (m *ErrorCode) XXX_Size() int {
+ return xxx_messageInfo_ErrorCode.Size(m)
+}
+func (m *ErrorCode) XXX_DiscardUnknown() {
+ xxx_messageInfo_ErrorCode.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ErrorCode proto.InternalMessageInfo
+
+func (m *ErrorCode) GetCode() uint32 {
+ if m != nil {
+ return m.Code
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*Exception)(nil), "errors.Exception")
+ proto.RegisterType((*ErrorCode)(nil), "errors.ErrorCode")
+}
+
+func init() {
+ proto.RegisterFile("github.com/hyperledger/burrow/execution/errors/errors.proto", fileDescriptor_errors_e7e9443965b28d5d)
+}
+
+var fileDescriptor_errors_e7e9443965b28d5d = []byte{
+ // 168 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xb2, 0x4e, 0xcf, 0x2c, 0xc9,
+ 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0xcf, 0xa8, 0x2c, 0x48, 0x2d, 0xca, 0x49, 0x4d, 0x49,
+ 0x4f, 0x2d, 0xd2, 0x4f, 0x2a, 0x2d, 0x2a, 0xca, 0x2f, 0xd7, 0x4f, 0xad, 0x48, 0x4d, 0x2e, 0x2d,
+ 0xc9, 0xcc, 0xcf, 0xd3, 0x4f, 0x2d, 0x2a, 0xca, 0x2f, 0x2a, 0x86, 0x52, 0x7a, 0x05, 0x45, 0xf9,
+ 0x25, 0xf9, 0x42, 0x6c, 0x10, 0x9e, 0x52, 0x02, 0x17, 0xa7, 0x6b, 0x45, 0x72, 0x6a, 0x01, 0x48,
+ 0xa1, 0x90, 0x2a, 0x17, 0x8b, 0x73, 0x7e, 0x4a, 0xaa, 0x04, 0xa3, 0x02, 0xa3, 0x06, 0xb7, 0x91,
+ 0xa0, 0x1e, 0x54, 0x87, 0x2b, 0x88, 0x02, 0x49, 0x04, 0x81, 0xa5, 0x85, 0x64, 0x90, 0xf4, 0x48,
+ 0x30, 0x29, 0x30, 0x6a, 0x70, 0x06, 0x21, 0x19, 0xc2, 0xc7, 0xc5, 0xe4, 0x14, 0x2c, 0xc1, 0xac,
+ 0xc0, 0xa8, 0xc1, 0x13, 0xc4, 0xe4, 0x14, 0xac, 0x24, 0xcf, 0xc5, 0x09, 0x37, 0x40, 0x48, 0x08,
+ 0xc9, 0x06, 0x5e, 0x88, 0x71, 0x49, 0x6c, 0x60, 0x17, 0x19, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff,
+ 0x20, 0x37, 0xb1, 0xd9, 0xd0, 0x00, 0x00, 0x00,
+}
diff --git a/execution/errors/errors.proto b/execution/errors/errors.proto
new file mode 100644
index 0000000000000000000000000000000000000000..2620fdd403e97fd1d7037ab49be92bfbb4e94bac
--- /dev/null
+++ b/execution/errors/errors.proto
@@ -0,0 +1,13 @@
+syntax = "proto3";
+
+package errors;
+
+message Exception {
+ ErrorCode Code = 1;
+ string Exception = 2;
+ bytes BS = 3;
+}
+
+message ErrorCode {
+ uint32 Code = 1;
+}
diff --git a/execution/errors/errors_test.go b/execution/errors/errors_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..3b85c4adbd71f64b1c1fcd82460dc3e428c41ed9
--- /dev/null
+++ b/execution/errors/errors_test.go
@@ -0,0 +1,42 @@
+package errors
+
+import (
+ "encoding/json"
+ "testing"
+
+ "fmt"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "github.com/tendermint/abci/types"
+)
+
+func TestErrorCode_MarshalJSON(t *testing.T) {
+ ec := NewErrorCode(ErrorCodeDataStackOverflow)
+ bs, err := json.Marshal(ec)
+ require.NoError(t, err)
+
+ ecOut := new(ErrorCode)
+ err = json.Unmarshal(bs, ecOut)
+ require.NoError(t, err)
+
+ assert.Equal(t, ec, ecOut)
+}
+
+func TestException_MarshalJSON(t *testing.T) {
+ ex := NewCodedError(ErrorCodeExecutionReverted, "Oh noes we reverted")
+ ex.BS = []byte{2, 3, 4, 5}
+ bs, err := json.Marshal(ex)
+ require.NoError(t, err)
+ fmt.Println(string(bs))
+ exOut := new(Exception)
+ err = json.Unmarshal(bs, exOut)
+ require.NoError(t, err)
+
+ bb := types.RequestBeginBlock{
+ Hash: []byte{2, 3, 4},
+ }
+ bs, err = json.Marshal(bb)
+ require.NoError(t, err)
+ fmt.Println(string(bs))
+}
diff --git a/execution/errors/native.go b/execution/errors/native.go
index df35e9a4f1379b37c6368764156e214ed0a70087..bd64b6f75a796dc645a49d5e7337cea69dd14f74 100644
--- a/execution/errors/native.go
+++ b/execution/errors/native.go
@@ -15,6 +15,6 @@ func (e LacksSNativePermission) Error() string {
return fmt.Sprintf("account %s does not have SNative function call permission: %s", e.Address, e.SNative)
}
-func (e LacksSNativePermission) ErrorCode() ErrorCode {
+func (e LacksSNativePermission) ErrorCode() Code {
return ErrorCodeNativeFunction
}
diff --git a/execution/errors/vm.go b/execution/errors/vm.go
index d8b164c230fd94e490dd4bd91154fad93a68f9fb..f2d40983fd03377db7064a8716c3c2cc1bff0c6c 100644
--- a/execution/errors/vm.go
+++ b/execution/errors/vm.go
@@ -12,7 +12,7 @@ type PermissionDenied struct {
Perm types.PermFlag
}
-func (err PermissionDenied) ErrorCode() ErrorCode {
+func (err PermissionDenied) ErrorCode() Code {
return ErrorCodePermissionDenied
}
@@ -24,10 +24,10 @@ type NestedCall struct {
NestedError CodedError
Caller crypto.Address
Callee crypto.Address
- StackDepth int
+ StackDepth uint64
}
-func (err NestedCall) ErrorCode() ErrorCode {
+func (err NestedCall) ErrorCode() Code {
return err.NestedError.ErrorCode()
}
@@ -41,7 +41,7 @@ type Call struct {
NestedErrors []NestedCall
}
-func (err Call) ErrorCode() ErrorCode {
+func (err Call) ErrorCode() Code {
return err.CallError.ErrorCode()
}
diff --git a/execution/evm/events/events.go b/execution/events/call.go
similarity index 52%
rename from execution/evm/events/events.go
rename to execution/events/call.go
index 3dcb4461060297ec4fd44f9dc57bbe4a8815b697..23e047248756c6f4a8362af08b5dbf8bce36cb0b 100644
--- a/execution/evm/events/events.go
+++ b/execution/events/call.go
@@ -19,17 +19,17 @@ import (
"fmt"
"github.com/hyperledger/burrow/binary"
- . "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
"github.com/hyperledger/burrow/execution/errors"
- "github.com/tmthrgd/go-hex"
+ "github.com/hyperledger/burrow/txs"
+ hex "github.com/tmthrgd/go-hex"
)
// Functions to generate eventId strings
func EventStringAccountCall(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Call", addr) }
-func EventStringLogEvent(addr crypto.Address) string { return fmt.Sprintf("Log/%s", addr) }
//----------------------------------------
@@ -37,8 +37,7 @@ func EventStringLogEvent(addr crypto.Address) string { return fmt.Sprintf("Lo
type EventDataCall struct {
CallData *CallData
Origin crypto.Address
- TxHash binary.HexBytes
- StackDepth int
+ StackDepth uint64
Return binary.HexBytes
Exception *errors.Exception
}
@@ -51,15 +50,21 @@ type CallData struct {
Gas uint64
}
-// EventDataLog fires when a contract executes the LOG opcode
-type EventDataLog struct {
- Address crypto.Address
- Topics []Word256
- Data binary.HexBytes
- Height uint64
-}
-
// Publish/Subscribe
+func PublishAccountCall(publisher event.Publisher, tx *txs.Tx, height uint64, call *EventDataCall) error {
+ eventID := EventStringAccountCall(call.CallData.Callee)
+ ev := &Event{
+ Header: &Header{
+ TxType: tx.Type(),
+ TxHash: tx.Hash(),
+ EventType: TypeCall,
+ EventID: eventID,
+ Height: height,
+ },
+ Call: call,
+ }
+ return publisher.Publish(context.Background(), ev, ev.Tags())
+}
// Subscribe to account call event - if TxHash is provided listens for a specifc Tx otherwise captures all, if
// stackDepth is greater than or equal to 0 captures calls at a specific stack depth (useful for capturing the return
@@ -77,39 +82,68 @@ func SubscribeAccountCall(ctx context.Context, subscribable event.Subscribable,
query = query.AndEquals(event.StackDepthKey, stackDepth)
}
- return event.SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) bool {
- eventDataCall, ok := message.(*EventDataCall)
- if ok {
- ch <- eventDataCall
+ return event.SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) (stop bool) {
+ ev, ok := message.(*Event)
+ if ok && ev.Call != nil {
+ ch <- ev.Call
}
- return true
+ return
})
}
-func SubscribeLogEvent(ctx context.Context, subscribable event.Subscribable, subscriber string, address crypto.Address,
- ch chan<- *EventDataLog) error {
+// Tags
- query := event.QueryForEventID(EventStringLogEvent(address))
+var callTagKeys = []string{
+ event.CalleeKey,
+ event.CallerKey,
+ event.ValueKey,
+ event.GasKey,
+ event.StackDepthKey,
+ event.OriginKey,
+ event.ExceptionKey,
+}
- return event.SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) bool {
- eventDataLog, ok := message.(*EventDataLog)
- if ok {
- ch <- eventDataLog
- }
- return true
- })
+// Implements Tags for events
+func (call *EventDataCall) Get(key string) (string, bool) {
+ var value interface{}
+ switch key {
+ case event.CalleeKey:
+ value = call.CallData.Callee
+ case event.CallerKey:
+ value = call.CallData.Caller
+ case event.ValueKey:
+ value = call.CallData.Value
+ case event.GasKey:
+ value = call.CallData.Gas
+ case event.StackDepthKey:
+ value = call.StackDepth
+ case event.OriginKey:
+ value = call.Origin
+ case event.ExceptionKey:
+ value = call.Exception
+ default:
+ return "", false
+ }
+ return query.StringFromValue(value), true
}
-func PublishAccountCall(publisher event.Publisher, address crypto.Address, eventDataCall *EventDataCall) error {
- return event.PublishWithEventID(publisher, EventStringAccountCall(address), eventDataCall,
- map[string]interface{}{
- "address": address,
- event.TxHashKey: hex.EncodeUpperToString(eventDataCall.TxHash),
- event.StackDepthKey: eventDataCall.StackDepth,
- })
+func (call *EventDataCall) Len() int {
+ return len(callTagKeys)
}
-func PublishLogEvent(publisher event.Publisher, address crypto.Address, eventDataLog *EventDataLog) error {
- return event.PublishWithEventID(publisher, EventStringLogEvent(address), eventDataLog,
- map[string]interface{}{"address": address})
+func (call *EventDataCall) Keys() []string {
+ return callTagKeys
+}
+
+func (call *EventDataCall) Tags(tags map[string]interface{}) map[string]interface{} {
+ tags[event.CalleeKey] = call.CallData.Callee
+ tags[event.CallerKey] = call.CallData.Caller
+ tags[event.ValueKey] = call.CallData.Value
+ tags[event.GasKey] = call.CallData.Gas
+ tags[event.StackDepthKey] = call.StackDepth
+ tags[event.OriginKey] = call.Origin
+ if call.Exception != nil {
+ tags[event.ExceptionKey] = call.Exception
+ }
+ return tags
}
diff --git a/execution/events/event.go b/execution/events/event.go
new file mode 100644
index 0000000000000000000000000000000000000000..e5f7f5edb3773ba0608164d216bd1ebda9b8d93f
--- /dev/null
+++ b/execution/events/event.go
@@ -0,0 +1,99 @@
+package events
+
+import (
+ "fmt"
+
+ "reflect"
+
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/txs"
+)
+
+var cdc = txs.NewAminoCodec()
+
+var eventMessageTag = event.TagMap{event.MessageTypeKey: reflect.TypeOf(&Event{}).String()}
+
+type Provider interface {
+ GetEvents(startKey, endKey Key, consumer func(*Event) (stop bool)) (stopped bool, err error)
+ LatestEventKey() Key
+}
+
+type Event struct {
+ Header *Header
+ Call *EventDataCall `json:",omitempty"`
+ Log *EventDataLog `json:",omitempty"`
+ Tx *EventDataTx `json:",omitempty"`
+ tags event.Tags
+}
+
+func DecodeEvent(bs []byte) (*Event, error) {
+ ev := new(Event)
+ err := cdc.UnmarshalBinary(bs, ev)
+ if err != nil {
+ return nil, err
+ }
+ return ev, nil
+}
+
+func (ev *Event) Key() Key {
+ return ev.Header.Key()
+}
+
+func (ev *Event) Encode() ([]byte, error) {
+ return cdc.MarshalBinary(ev)
+}
+
+func (ev *Event) Tags() event.Tags {
+ if ev.tags == nil {
+ ev.tags = event.CombinedTags{
+ ev.Header,
+ eventMessageTag,
+ ev.Tx,
+ ev.Call,
+ ev.Log,
+ }
+ }
+ return ev.tags
+}
+
+func (ev *Event) Get(key string) (value string, ok bool) {
+ return ev.Tags().Get(key)
+}
+
+func (ev *Event) Keys() []string {
+ return ev.Tags().Keys()
+}
+
+func (ev *Event) Len() int {
+ return ev.Tags().Len()
+}
+
+// event.Cache will provide an index through this methods of Indexable
+func (ev *Event) ProvideIndex(index uint64) {
+ ev.Header.Index = index
+}
+
+func (ev *Event) String() string {
+ return fmt.Sprintf("%v", ev.Header)
+}
+
+func (ev *Event) GetTx() *EventDataTx {
+ if ev == nil {
+ return nil
+ }
+ return ev.Tx
+}
+
+func (ev *Event) GetCall() *EventDataCall {
+ if ev == nil {
+ return nil
+ }
+ return ev.Call
+}
+
+func (ev *Event) GetLog() *EventDataLog {
+ if ev == nil {
+ return nil
+ }
+ return ev.Log
+}
diff --git a/execution/events/event_test.go b/execution/events/event_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..4831edfe2760a4fcc5d2d97b2471ddfbf5bf6987
--- /dev/null
+++ b/execution/events/event_test.go
@@ -0,0 +1,92 @@
+package events
+
+import (
+ "testing"
+
+ "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+ "github.com/tmthrgd/go-hex"
+)
+
+func TestHeader_Key(t *testing.T) {
+ h := &Header{
+ EventID: "Foos",
+ Height: 2345345232,
+ Index: 34,
+ }
+ key := h.Key()
+ keyString := hex.EncodeUpperToString(key)
+ assert.Equal(t, "000000008BCB20D00000000000000022", keyString)
+ assert.Len(t, keyString, 32, "should be 16 bytes")
+ assert.Equal(t, h.Height, key.Height())
+ assert.Equal(t, h.Index, key.Index())
+}
+
+func TestKey_IsSuccessorOf(t *testing.T) {
+ assert.True(t, NewKey(1, 0).IsSuccessorOf(NewKey(0, 1)))
+ assert.True(t, NewKey(100, 24).IsSuccessorOf(NewKey(100, 23)))
+ assert.False(t, NewKey(100, 23).IsSuccessorOf(NewKey(100, 25)))
+ assert.False(t, NewKey(1, 1).IsSuccessorOf(NewKey(0, 25)))
+ assert.True(t, NewKey(3, 0).IsSuccessorOf(NewKey(2, 0)))
+}
+
+func TestEventTagQueries(t *testing.T) {
+ addressHex := "DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF"
+ address, err := crypto.AddressFromHexString(addressHex)
+ require.NoError(t, err)
+ ev := &Event{
+ Header: &Header{
+ EventType: TypeLog,
+ EventID: "foo/bar",
+ TxHash: []byte{2, 3, 4},
+ Height: 34,
+ Index: 2,
+ },
+ Log: &EventDataLog{
+ Address: address,
+ Topics: []binary.Word256{binary.RightPadWord256([]byte("marmot"))},
+ },
+ }
+
+ qb := query.NewBuilder().AndEquals(event.EventTypeKey, TypeLog.String())
+ qry, err := qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ qb = qb.AndContains(event.EventIDKey, "bar")
+ qry, err = qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ qb = qb.AndEquals(event.TxHashKey, hex.EncodeUpperToString(ev.Header.TxHash))
+ qry, err = qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ qb = qb.AndGreaterThanOrEqual(event.HeightKey, ev.Header.Height)
+ qry, err = qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ qb = qb.AndStrictlyLessThan(event.IndexKey, ev.Header.Index+1)
+ qry, err = qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ qb = qb.AndEquals(event.AddressKey, addressHex)
+ qry, err = qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ qb = qb.AndEquals(event.LogNTextKey(0), "marmot")
+ qry, err = qb.Query()
+ require.NoError(t, err)
+ assert.True(t, qry.Matches(ev))
+
+ t.Logf("Query: %v", qry)
+ t.Logf("Keys: %v", ev.Keys())
+}
diff --git a/execution/events/events.go b/execution/events/events.go
deleted file mode 100644
index 1efdda9f26f528de4a93deb445499ab97e88b1b7..0000000000000000000000000000000000000000
--- a/execution/events/events.go
+++ /dev/null
@@ -1,115 +0,0 @@
-package events
-
-import (
- "context"
- "fmt"
- "reflect"
-
- "github.com/hyperledger/burrow/binary"
- "github.com/hyperledger/burrow/crypto"
- "github.com/hyperledger/burrow/event"
- "github.com/hyperledger/burrow/execution/errors"
- ptypes "github.com/hyperledger/burrow/permission/types"
- "github.com/hyperledger/burrow/txs"
- "github.com/hyperledger/burrow/txs/payload"
- "github.com/tmthrgd/go-hex"
-)
-
-func EventStringAccountInput(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Input", addr) }
-func EventStringAccountOutput(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Output", addr) }
-func EventStringNameReg(name string) string { return fmt.Sprintf("NameReg/%s", name) }
-func EventStringPermissions(perm ptypes.PermFlag) string { return fmt.Sprintf("Permissions/%v", perm) }
-func EventStringBond() string { return "Bond" }
-func EventStringUnbond() string { return "Unbond" }
-func EventStringRebond() string { return "Rebond" }
-
-// All txs fire EventDataTx, but only CallTx might have Return or Exception
-type EventDataTx struct {
- Tx *txs.Tx
- Return binary.HexBytes
- Exception *errors.Exception
-}
-
-// For re-use
-var sendTxQuery = event.NewQueryBuilder().
- AndEquals(event.MessageTypeKey, reflect.TypeOf(&EventDataTx{}).String()).
- AndEquals(event.TxTypeKey, payload.TypeSend.String())
-
-var callTxQuery = event.NewQueryBuilder().
- AndEquals(event.MessageTypeKey, reflect.TypeOf(&EventDataTx{}).String()).
- AndEquals(event.TxTypeKey, payload.TypeCall.String())
-
-// Publish/Subscribe
-func SubscribeAccountOutputSendTx(ctx context.Context, subscribable event.Subscribable, subscriber string,
- address crypto.Address, txHash []byte, ch chan<- *payload.SendTx) error {
-
- query := sendTxQuery.And(event.QueryForEventID(EventStringAccountOutput(address))).
- AndEquals(event.TxHashKey, hex.EncodeUpperToString(txHash))
-
- return event.SubscribeCallback(ctx, subscribable, subscriber, query, func(message interface{}) bool {
- if edt, ok := message.(*EventDataTx); ok {
- if sendTx, ok := edt.Tx.Payload.(*payload.SendTx); ok {
- ch <- sendTx
- }
- }
- return true
- })
-}
-
-func PublishAccountOutput(publisher event.Publisher, address crypto.Address, tx *txs.Tx, ret []byte,
- exception *errors.Exception) error {
-
- return event.PublishWithEventID(publisher, EventStringAccountOutput(address),
- &EventDataTx{
- Tx: tx,
- Return: ret,
- Exception: exception,
- },
- map[string]interface{}{
- "address": address,
- event.TxTypeKey: tx.Type().String(),
- event.TxHashKey: hex.EncodeUpperToString(tx.Hash()),
- })
-}
-
-func PublishAccountInput(publisher event.Publisher, address crypto.Address, tx *txs.Tx, ret []byte,
- exception *errors.Exception) error {
-
- return event.PublishWithEventID(publisher, EventStringAccountInput(address),
- &EventDataTx{
- Tx: tx,
- Return: ret,
- Exception: exception,
- },
- map[string]interface{}{
- "address": address,
- event.TxTypeKey: tx.Type().String(),
- event.TxHashKey: hex.EncodeUpperToString(tx.Hash()),
- })
-}
-
-func PublishNameReg(publisher event.Publisher, tx *txs.Tx) error {
- nameTx, ok := tx.Payload.(*payload.NameTx)
- if !ok {
- return fmt.Errorf("Tx payload must be NameTx to PublishNameReg")
- }
- return event.PublishWithEventID(publisher, EventStringNameReg(nameTx.Name), &EventDataTx{Tx: tx},
- map[string]interface{}{
- "name": nameTx.Name,
- event.TxTypeKey: tx.Type().String(),
- event.TxHashKey: hex.EncodeUpperToString(tx.Hash()),
- })
-}
-
-func PublishPermissions(publisher event.Publisher, perm ptypes.PermFlag, tx *txs.Tx) error {
- _, ok := tx.Payload.(*payload.PermissionsTx)
- if !ok {
- return fmt.Errorf("Tx payload must be PermissionsTx to PublishPermissions")
- }
- return event.PublishWithEventID(publisher, EventStringPermissions(perm), &EventDataTx{Tx: tx},
- map[string]interface{}{
- "name": perm.String(),
- event.TxTypeKey: tx.Type().String(),
- event.TxHashKey: hex.EncodeUpperToString(tx.Hash()),
- })
-}
diff --git a/execution/events/header.go b/execution/events/header.go
new file mode 100644
index 0000000000000000000000000000000000000000..d5b09749b3c3bbbe3d57b1e6ea3f8800c81d0b5b
--- /dev/null
+++ b/execution/events/header.go
@@ -0,0 +1,76 @@
+package events
+
+import (
+ "fmt"
+
+ "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
+ "github.com/hyperledger/burrow/txs/payload"
+)
+
+type Header struct {
+ TxType payload.Type
+ TxHash binary.HexBytes
+ EventType Type
+ EventID string
+ Height uint64
+ Index uint64
+}
+
+var headerTagKeys = []string{
+ event.TxTypeKey,
+ event.TxHashKey,
+ event.EventTypeKey,
+ event.EventIDKey,
+ event.HeightKey,
+ event.IndexKey,
+}
+
+// Implements Tags for events
+func (h *Header) Get(key string) (value string, ok bool) {
+ var v interface{}
+ switch key {
+ case event.TxTypeKey:
+ v = h.TxType
+ case event.TxHashKey:
+ v = h.TxHash
+ case event.EventTypeKey:
+ v = h.EventType
+ case event.EventIDKey:
+ v = h.EventID
+ case event.HeightKey:
+ v = h.Height
+ case event.IndexKey:
+ v = h.Index
+ default:
+ return "", false
+ }
+ return query.StringFromValue(v), true
+}
+
+func (h *Header) Len() int {
+ return len(headerTagKeys)
+}
+
+func (h *Header) Map() map[string]interface{} {
+ tags := make(map[string]interface{})
+ for _, key := range headerTagKeys {
+ tags[key], _ = h.Get(key)
+ }
+ return tags
+}
+
+func (h *Header) Keys() []string {
+ return headerTagKeys
+}
+
+// Returns a lexicographically sortable key encoding the height and index of this event
+func (h *Header) Key() Key {
+ return NewKey(h.Height, h.Index)
+}
+
+func (h *Header) String() string {
+ return fmt.Sprintf("Header{Tx{%v}: %v; Event{%v}: %v; Height: %v; Index: %v}",
+ h.TxType, h.TxHash, h.EventType, h.EventID, h.Height, h.Index)
+}
diff --git a/execution/events/key.go b/execution/events/key.go
new file mode 100644
index 0000000000000000000000000000000000000000..f78463e16d8f521ee4fdbf9dc3389b05b0443121
--- /dev/null
+++ b/execution/events/key.go
@@ -0,0 +1,53 @@
+package events
+
+import (
+ "bytes"
+ "fmt"
+
+ "github.com/hyperledger/burrow/binary"
+)
+
+type Key []byte
+
+func NewKey(height, index uint64) Key {
+ k := make(Key, 16)
+ // Will order first by height then by index so events from the same block will be consecutive
+ binary.PutUint64BE(k[:8], height)
+ binary.PutUint64BE(k[8:], index)
+ return k
+}
+
+// -1 if k < k2
+// 0 if k == k2
+// 1 if k > k2
+func (k Key) Compare(k2 Key) int {
+ return bytes.Compare(k, k2)
+}
+
+// Returns true iff k is a valid successor key to p;
+// iff (the height is the same and the index is one greater) or (the height is greater and the index is zero) or (p
+// is uninitialised)
+func (k Key) IsSuccessorOf(p Key) bool {
+ if len(p) == 0 {
+ return true
+ }
+ ph, kh := p.Height(), k.Height()
+ pi, ki := p.Index(), k.Index()
+ return ph == kh && pi+1 == ki || ph < kh && ki == 0
+}
+
+func (k Key) Bytes() []byte {
+ return k
+}
+
+func (k Key) Height() uint64 {
+ return binary.GetUint64BE(k[:8])
+}
+
+func (k Key) Index() uint64 {
+ return binary.GetUint64BE(k[8:])
+}
+
+func (k Key) String() string {
+ return fmt.Sprintf("Key{Height: %v; Index: %v}", k.Height(), k.Index())
+}
diff --git a/execution/events/log.go b/execution/events/log.go
new file mode 100644
index 0000000000000000000000000000000000000000..b41fad89fcc24db4a431e64fdf4dd8013bd8b30a
--- /dev/null
+++ b/execution/events/log.go
@@ -0,0 +1,124 @@
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package events
+
+import (
+ "context"
+ "fmt"
+
+ "strings"
+
+ "github.com/hyperledger/burrow/binary"
+ . "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
+ "github.com/hyperledger/burrow/txs"
+ "github.com/tmthrgd/go-hex"
+)
+
+// Functions to generate eventId strings
+
+func EventStringLogEvent(addr crypto.Address) string { return fmt.Sprintf("Log/%s", addr) }
+
+//----------------------------------------
+
+// EventDataLog fires when a contract executes the LOG opcode
+type EventDataLog struct {
+ Height uint64
+ Address crypto.Address
+ Topics []Word256
+ Data binary.HexBytes
+}
+
+// Publish/Subscribe
+func PublishLogEvent(publisher event.Publisher, tx *txs.Tx, log *EventDataLog) error {
+ ev := &Event{
+ Header: &Header{
+ TxType: tx.Type(),
+ TxHash: tx.Hash(),
+ EventType: TypeLog,
+ EventID: EventStringLogEvent(log.Address),
+ Height: log.Height,
+ },
+ Log: log,
+ }
+ return publisher.Publish(context.Background(), ev, ev.Tags())
+}
+
+func SubscribeLogEvent(ctx context.Context, subscribable event.Subscribable, subscriber string, address crypto.Address,
+ ch chan<- *EventDataLog) error {
+
+ qry := event.QueryForEventID(EventStringLogEvent(address))
+
+ return event.SubscribeCallback(ctx, subscribable, subscriber, qry, func(message interface{}) (stop bool) {
+ ev, ok := message.(*Event)
+ if ok && ev.Log != nil {
+ ch <- ev.Log
+ }
+ return
+ })
+}
+
+// Tags
+const logNTextTopicCutset = "\x00"
+
+var logTagKeys []string
+var logNTopicIndex = make(map[string]int, 5)
+var logNTextTopicIndex = make(map[string]int, 5)
+
+func init() {
+ for i := 0; i <= 4; i++ {
+ logN := event.LogNKey(i)
+ logTagKeys = append(logTagKeys, event.LogNKey(i))
+ logNText := event.LogNTextKey(i)
+ logTagKeys = append(logTagKeys, logNText)
+ logNTopicIndex[logN] = i
+ logNTextTopicIndex[logNText] = i
+ }
+ logTagKeys = append(logTagKeys, event.AddressKey)
+}
+
+func (log *EventDataLog) Get(key string) (string, bool) {
+ var value interface{}
+ switch key {
+ case event.AddressKey:
+ value = log.Address
+ default:
+ if i, ok := logNTopicIndex[key]; ok {
+ return hex.EncodeUpperToString(log.GetTopic(i).Bytes()), true
+ }
+ if i, ok := logNTextTopicIndex[key]; ok {
+ return strings.Trim(string(log.GetTopic(i).Bytes()), logNTextTopicCutset), true
+ }
+ return "", false
+ }
+ return query.StringFromValue(value), true
+}
+
+func (log *EventDataLog) GetTopic(i int) Word256 {
+ if i < len(log.Topics) {
+ return log.Topics[i]
+ }
+ return Word256{}
+}
+
+func (log *EventDataLog) Len() int {
+ return len(logTagKeys)
+}
+
+func (log *EventDataLog) Keys() []string {
+ return logTagKeys
+}
diff --git a/execution/events/pbevents/blocks.go b/execution/events/pbevents/blocks.go
new file mode 100644
index 0000000000000000000000000000000000000000..5856e64b90a7e12c849da2f060400179aa70ea95
--- /dev/null
+++ b/execution/events/pbevents/blocks.go
@@ -0,0 +1,63 @@
+package pbevents
+
+import "github.com/hyperledger/burrow/execution/events"
+
+func (br *BlockRange) Bounds(latestBlockHeight uint64) (startKey, endKey events.Key, streaming bool) {
+ return br.GetStart().Key(latestBlockHeight), br.GetEnd().Key(latestBlockHeight),
+ br.GetEnd().GetType() == Bound_STREAM
+}
+
+func (b *Bound) Key(latestBlockHeight uint64) events.Key {
+ return events.NewKey(b.Bound(latestBlockHeight), 0)
+}
+
+func (b *Bound) Bound(latestBlockHeight uint64) uint64 {
+ switch b.Type {
+ case Bound_ABSOLUTE:
+ return b.GetIndex()
+ case Bound_RELATIVE:
+ if b.Index < latestBlockHeight {
+ return latestBlockHeight - b.Index
+ }
+ return 0
+ case Bound_FIRST:
+ return 0
+ case Bound_LATEST, Bound_STREAM:
+ return latestBlockHeight
+ default:
+ return latestBlockHeight
+ }
+}
+
+func AbsoluteBound(index uint64) *Bound {
+ return &Bound{
+ Index: index,
+ Type: Bound_ABSOLUTE,
+ }
+}
+
+func RelativeBound(index uint64) *Bound {
+ return &Bound{
+ Index: index,
+ Type: Bound_RELATIVE,
+ }
+}
+
+func LatestBound() *Bound {
+ return &Bound{
+ Type: Bound_LATEST,
+ }
+}
+
+func StreamBound() *Bound {
+ return &Bound{
+ Type: Bound_STREAM,
+ }
+}
+
+func NewBlockRange(start, end *Bound) *BlockRange {
+ return &BlockRange{
+ Start: start,
+ End: end,
+ }
+}
diff --git a/execution/events/pbevents/events.go b/execution/events/pbevents/events.go
new file mode 100644
index 0000000000000000000000000000000000000000..99bc841b766b8df191a7c8fe881e0431a81d5be2
--- /dev/null
+++ b/execution/events/pbevents/events.go
@@ -0,0 +1,168 @@
+package pbevents
+
+import (
+ "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution/events"
+ "github.com/hyperledger/burrow/txs/payload"
+)
+
+// this mostly contains tedious mapping between protobuf and our domain objects, but it may be worth
+// the pain to avoid complexity and edge cases using gogoproto or other techniques.
+
+func GetEventDataCall(edt *events.EventDataCall) *EventDataCall {
+ return &EventDataCall{
+ Origin: edt.Origin.Bytes(),
+ CallData: GetCallData(edt.CallData),
+ StackDepth: edt.StackDepth,
+ Return: edt.Return,
+ Exception: edt.Exception,
+ }
+}
+
+func GetCallData(cd *events.CallData) *CallData {
+ return &CallData{
+ Caller: cd.Caller.Bytes(),
+ Callee: cd.Callee.Bytes(),
+ Data: cd.Data,
+ Gas: cd.Gas,
+ }
+}
+
+func GetExecutionEvent(event *events.Event) *ExecutionEvent {
+ return &ExecutionEvent{
+ Header: GetEventHeader(event.Header),
+ EventData: GetEventData(event),
+ }
+}
+
+func GetEventHeader(header *events.Header) *EventHeader {
+ return &EventHeader{
+ TxType: header.TxType.String(),
+ TxHash: header.TxHash,
+ EventType: header.EventType.String(),
+ EventID: header.EventID,
+ Height: header.Height,
+ Index: header.Index,
+ }
+}
+
+func GetEventData(ev *events.Event) isExecutionEvent_EventData {
+ if ev.Call != nil {
+ return &ExecutionEvent_EventDataCall{
+ EventDataCall: &EventDataCall{
+ CallData: GetCallData(ev.Call.CallData),
+ Origin: ev.Call.Origin.Bytes(),
+ StackDepth: ev.Call.StackDepth,
+ Return: ev.Call.Return,
+ Exception: ev.Call.Exception,
+ },
+ }
+ }
+
+ if ev.Log != nil {
+ return &ExecutionEvent_EventDataLog{
+ EventDataLog: &EventDataLog{
+ Address: ev.Log.Address.Bytes(),
+ Data: ev.Log.Data,
+ Topics: GetTopic(ev.Log.Topics),
+ },
+ }
+ }
+
+ if ev.Tx != nil {
+ return &ExecutionEvent_EventDataTx{
+ EventDataTx: &EventDataTx{
+ Return: ev.Tx.Return,
+ Exception: ev.Tx.Exception,
+ },
+ }
+ }
+
+ return nil
+}
+
+func GetTopic(topics []binary.Word256) [][]byte {
+ topicBytes := make([][]byte, len(topics))
+ for i, t := range topics {
+ topicBytes[i] = t.Bytes()
+ }
+ return topicBytes
+}
+
+func (ee *ExecutionEvent) Event() *events.Event {
+ return &events.Event{
+ Header: ee.GetHeader().Header(),
+ Tx: ee.GetEventDataTx().Tx(),
+ Log: ee.GetEventDataLog().Log(ee.Header.Height),
+ Call: ee.GetEventDataCall().Call(ee.Header.TxHash),
+ }
+}
+
+func (ee *ExecutionEvent) Key() events.Key {
+ return ee.Header.Key()
+}
+
+func (h *EventHeader) Key() events.Key {
+ return events.NewKey(h.Height, h.Index)
+}
+
+func (h *EventHeader) Header() *events.Header {
+ return &events.Header{
+ TxType: payload.TxTypeFromString(h.TxType),
+ TxHash: h.TxHash,
+ EventType: events.EventTypeFromString(h.EventType),
+ EventID: h.EventID,
+ Height: h.Height,
+ Index: h.Index,
+ }
+}
+
+func (tx *EventDataTx) Tx() *events.EventDataTx {
+ if tx == nil {
+ return nil
+ }
+ return &events.EventDataTx{
+ Return: tx.Return,
+ Exception: tx.Exception,
+ }
+}
+
+func (log *EventDataLog) Log(height uint64) *events.EventDataLog {
+ if log == nil {
+ return nil
+ }
+ topicWords := make([]binary.Word256, len(log.Topics))
+ for i, bs := range log.Topics {
+ topicWords[i] = binary.LeftPadWord256(bs)
+ }
+ return &events.EventDataLog{
+ Height: height,
+ Topics: topicWords,
+ Address: crypto.MustAddressFromBytes(log.Address),
+ Data: log.Data,
+ }
+}
+
+func (call *EventDataCall) Call(txHash []byte) *events.EventDataCall {
+ if call == nil {
+ return nil
+ }
+ return &events.EventDataCall{
+ Return: call.Return,
+ CallData: call.CallData.CallData(),
+ Origin: crypto.MustAddressFromBytes(call.Origin),
+ StackDepth: call.StackDepth,
+ Exception: call.Exception,
+ }
+}
+
+func (cd *CallData) CallData() *events.CallData {
+ return &events.CallData{
+ Caller: crypto.MustAddressFromBytes(cd.Caller),
+ Callee: crypto.MustAddressFromBytes(cd.Callee),
+ Value: cd.Value,
+ Gas: cd.Gas,
+ Data: cd.Data,
+ }
+}
diff --git a/execution/events/pbevents/events.pb.go b/execution/events/pbevents/events.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..132817582cfcda6667e5e75c5fc750bf1b565a4a
--- /dev/null
+++ b/execution/events/pbevents/events.pb.go
@@ -0,0 +1,1403 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/hyperledger/burrow/execution/events/pbevents/events.proto
+
+package pbevents // import "github.com/hyperledger/burrow/execution/events/pbevents"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import errors "github.com/hyperledger/burrow/execution/errors"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Bound_BoundType int32
+
+const (
+ // Index is absolute index of object in collection
+ Bound_ABSOLUTE Bound_BoundType = 0
+ // Index is an offset relative to another bound determined by context
+ Bound_RELATIVE Bound_BoundType = 1
+ // The first block
+ Bound_FIRST Bound_BoundType = 2
+ // Ignore provided index and evaluate to latest index
+ Bound_LATEST Bound_BoundType = 3
+ // Ignore provided index and stream new objects as they are generated
+ Bound_STREAM Bound_BoundType = 4
+)
+
+var Bound_BoundType_name = map[int32]string{
+ 0: "ABSOLUTE",
+ 1: "RELATIVE",
+ 2: "FIRST",
+ 3: "LATEST",
+ 4: "STREAM",
+}
+var Bound_BoundType_value = map[string]int32{
+ "ABSOLUTE": 0,
+ "RELATIVE": 1,
+ "FIRST": 2,
+ "LATEST": 3,
+ "STREAM": 4,
+}
+
+func (x Bound_BoundType) String() string {
+ return proto.EnumName(Bound_BoundType_name, int32(x))
+}
+func (Bound_BoundType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{7, 0}
+}
+
+// Params
+type EventIdParam struct {
+ EventId string `protobuf:"bytes,1,opt,name=eventId,proto3" json:"eventId,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EventIdParam) Reset() { *m = EventIdParam{} }
+func (m *EventIdParam) String() string { return proto.CompactTextString(m) }
+func (*EventIdParam) ProtoMessage() {}
+func (*EventIdParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{0}
+}
+func (m *EventIdParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EventIdParam.Unmarshal(m, b)
+}
+func (m *EventIdParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EventIdParam.Marshal(b, m, deterministic)
+}
+func (dst *EventIdParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventIdParam.Merge(dst, src)
+}
+func (m *EventIdParam) XXX_Size() int {
+ return xxx_messageInfo_EventIdParam.Size(m)
+}
+func (m *EventIdParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventIdParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventIdParam proto.InternalMessageInfo
+
+func (m *EventIdParam) GetEventId() string {
+ if m != nil {
+ return m.EventId
+ }
+ return ""
+}
+
+type SubIdParam struct {
+ SubId string `protobuf:"bytes,1,opt,name=subId,proto3" json:"subId,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SubIdParam) Reset() { *m = SubIdParam{} }
+func (m *SubIdParam) String() string { return proto.CompactTextString(m) }
+func (*SubIdParam) ProtoMessage() {}
+func (*SubIdParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{1}
+}
+func (m *SubIdParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SubIdParam.Unmarshal(m, b)
+}
+func (m *SubIdParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SubIdParam.Marshal(b, m, deterministic)
+}
+func (dst *SubIdParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SubIdParam.Merge(dst, src)
+}
+func (m *SubIdParam) XXX_Size() int {
+ return xxx_messageInfo_SubIdParam.Size(m)
+}
+func (m *SubIdParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_SubIdParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SubIdParam proto.InternalMessageInfo
+
+func (m *SubIdParam) GetSubId() string {
+ if m != nil {
+ return m.SubId
+ }
+ return ""
+}
+
+// Results
+type EventUnSub struct {
+ Result bool `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EventUnSub) Reset() { *m = EventUnSub{} }
+func (m *EventUnSub) String() string { return proto.CompactTextString(m) }
+func (*EventUnSub) ProtoMessage() {}
+func (*EventUnSub) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{2}
+}
+func (m *EventUnSub) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EventUnSub.Unmarshal(m, b)
+}
+func (m *EventUnSub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EventUnSub.Marshal(b, m, deterministic)
+}
+func (dst *EventUnSub) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventUnSub.Merge(dst, src)
+}
+func (m *EventUnSub) XXX_Size() int {
+ return xxx_messageInfo_EventUnSub.Size(m)
+}
+func (m *EventUnSub) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventUnSub.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventUnSub proto.InternalMessageInfo
+
+func (m *EventUnSub) GetResult() bool {
+ if m != nil {
+ return m.Result
+ }
+ return false
+}
+
+type PollResponse struct {
+ Events []*Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *PollResponse) Reset() { *m = PollResponse{} }
+func (m *PollResponse) String() string { return proto.CompactTextString(m) }
+func (*PollResponse) ProtoMessage() {}
+func (*PollResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{3}
+}
+func (m *PollResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_PollResponse.Unmarshal(m, b)
+}
+func (m *PollResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_PollResponse.Marshal(b, m, deterministic)
+}
+func (dst *PollResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PollResponse.Merge(dst, src)
+}
+func (m *PollResponse) XXX_Size() int {
+ return xxx_messageInfo_PollResponse.Size(m)
+}
+func (m *PollResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_PollResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PollResponse proto.InternalMessageInfo
+
+func (m *PollResponse) GetEvents() []*Event {
+ if m != nil {
+ return m.Events
+ }
+ return nil
+}
+
+type Event struct {
+ Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
+ // Types that are valid to be assigned to Event:
+ // *Event_ExecutionEvent
+ // *Event_TendermintEventJSON
+ Event isEvent_Event `protobuf_oneof:"Event"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Event) Reset() { *m = Event{} }
+func (m *Event) String() string { return proto.CompactTextString(m) }
+func (*Event) ProtoMessage() {}
+func (*Event) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{4}
+}
+func (m *Event) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Event.Unmarshal(m, b)
+}
+func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Event.Marshal(b, m, deterministic)
+}
+func (dst *Event) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Event.Merge(dst, src)
+}
+func (m *Event) XXX_Size() int {
+ return xxx_messageInfo_Event.Size(m)
+}
+func (m *Event) XXX_DiscardUnknown() {
+ xxx_messageInfo_Event.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Event proto.InternalMessageInfo
+
+type isEvent_Event interface {
+ isEvent_Event()
+}
+
+type Event_ExecutionEvent struct {
+ ExecutionEvent *ExecutionEvent `protobuf:"bytes,2,opt,name=ExecutionEvent,proto3,oneof"`
+}
+type Event_TendermintEventJSON struct {
+ TendermintEventJSON string `protobuf:"bytes,3,opt,name=TendermintEventJSON,proto3,oneof"`
+}
+
+func (*Event_ExecutionEvent) isEvent_Event() {}
+func (*Event_TendermintEventJSON) isEvent_Event() {}
+
+func (m *Event) GetEvent() isEvent_Event {
+ if m != nil {
+ return m.Event
+ }
+ return nil
+}
+
+func (m *Event) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+func (m *Event) GetExecutionEvent() *ExecutionEvent {
+ if x, ok := m.GetEvent().(*Event_ExecutionEvent); ok {
+ return x.ExecutionEvent
+ }
+ return nil
+}
+
+func (m *Event) GetTendermintEventJSON() string {
+ if x, ok := m.GetEvent().(*Event_TendermintEventJSON); ok {
+ return x.TendermintEventJSON
+ }
+ return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Event) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _Event_OneofMarshaler, _Event_OneofUnmarshaler, _Event_OneofSizer, []interface{}{
+ (*Event_ExecutionEvent)(nil),
+ (*Event_TendermintEventJSON)(nil),
+ }
+}
+
+func _Event_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*Event)
+ // Event
+ switch x := m.Event.(type) {
+ case *Event_ExecutionEvent:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.ExecutionEvent); err != nil {
+ return err
+ }
+ case *Event_TendermintEventJSON:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.TendermintEventJSON)
+ case nil:
+ default:
+ return fmt.Errorf("Event.Event has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _Event_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*Event)
+ switch tag {
+ case 2: // Event.ExecutionEvent
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ExecutionEvent)
+ err := b.DecodeMessage(msg)
+ m.Event = &Event_ExecutionEvent{msg}
+ return true, err
+ case 3: // Event.TendermintEventJSON
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.Event = &Event_TendermintEventJSON{x}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _Event_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*Event)
+ // Event
+ switch x := m.Event.(type) {
+ case *Event_ExecutionEvent:
+ s := proto.Size(x.ExecutionEvent)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *Event_TendermintEventJSON:
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(len(x.TendermintEventJSON)))
+ n += len(x.TendermintEventJSON)
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+type GetEventsRequest struct {
+ BlockRange *BlockRange `protobuf:"bytes,1,opt,name=BlockRange,proto3" json:"BlockRange,omitempty"`
+ // Specify a query on which to match the tags of events.
+ // Tag | Match type | Values
+ // -----------------------------------------
+ // All events
+ // -----------------------------------------
+ // TxType | String | "UnknownTx", "SendTx", "CallTx", "NameTx", "BondTx", "UnbondTx", "PermissionsTx", "GovernanceTx"
+ // TxHash | String | bytes
+ // EventType | String | "CallEvent", "LogEvent", "AccountInputEvent", "AccountOutputEvent"
+ // EventID | String | string
+ // Height | Integer | uint64
+ // Index | Integer | uint64
+ // MessageType | String | Go type name
+ // -----------------------------------------
+ // Log event
+ // -----------------------------------------
+ // Address | String | Address (hex)
+ // Log<0-4> | String | Word256 (hex)
+ // Log<0-4>Text | String | string (trimmed)
+ // -----------------------------------------
+ // Call event
+ // -----------------------------------------
+ // Origin | String | Address (hex)
+ // Callee | String | Address (hex)
+ // Caller | String | Address (hex)
+ // Value | Integer | uint64
+ // Gas | Integer | uint64
+ // StackDepth | Integer | uint64
+ // Exception | String | string
+ // -----------------------------------------
+ // Tx event (input/output)
+ // -----------------------------------------
+ // Exception | String | string
+ //
+ // For example:
+ // EventType = 'LogEvent' AND EventID CONTAINS 'bar' AND TxHash = '020304' AND Height >= 34 AND Index < 3 AND Address = 'DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF'
+ Query string `protobuf:"bytes,2,opt,name=Query,proto3" json:"Query,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GetEventsRequest) Reset() { *m = GetEventsRequest{} }
+func (m *GetEventsRequest) String() string { return proto.CompactTextString(m) }
+func (*GetEventsRequest) ProtoMessage() {}
+func (*GetEventsRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{5}
+}
+func (m *GetEventsRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GetEventsRequest.Unmarshal(m, b)
+}
+func (m *GetEventsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GetEventsRequest.Marshal(b, m, deterministic)
+}
+func (dst *GetEventsRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GetEventsRequest.Merge(dst, src)
+}
+func (m *GetEventsRequest) XXX_Size() int {
+ return xxx_messageInfo_GetEventsRequest.Size(m)
+}
+func (m *GetEventsRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_GetEventsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetEventsRequest proto.InternalMessageInfo
+
+func (m *GetEventsRequest) GetBlockRange() *BlockRange {
+ if m != nil {
+ return m.BlockRange
+ }
+ return nil
+}
+
+func (m *GetEventsRequest) GetQuery() string {
+ if m != nil {
+ return m.Query
+ }
+ return ""
+}
+
+type GetEventsResponse struct {
+ Events []*ExecutionEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GetEventsResponse) Reset() { *m = GetEventsResponse{} }
+func (m *GetEventsResponse) String() string { return proto.CompactTextString(m) }
+func (*GetEventsResponse) ProtoMessage() {}
+func (*GetEventsResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{6}
+}
+func (m *GetEventsResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GetEventsResponse.Unmarshal(m, b)
+}
+func (m *GetEventsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GetEventsResponse.Marshal(b, m, deterministic)
+}
+func (dst *GetEventsResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GetEventsResponse.Merge(dst, src)
+}
+func (m *GetEventsResponse) XXX_Size() int {
+ return xxx_messageInfo_GetEventsResponse.Size(m)
+}
+func (m *GetEventsResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_GetEventsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GetEventsResponse proto.InternalMessageInfo
+
+func (m *GetEventsResponse) GetEvents() []*ExecutionEvent {
+ if m != nil {
+ return m.Events
+ }
+ return nil
+}
+
+type Bound struct {
+ Type Bound_BoundType `protobuf:"varint,1,opt,name=Type,proto3,enum=pbevents.Bound_BoundType" json:"Type,omitempty"`
+ Index uint64 `protobuf:"varint,2,opt,name=Index,proto3" json:"Index,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *Bound) Reset() { *m = Bound{} }
+func (m *Bound) String() string { return proto.CompactTextString(m) }
+func (*Bound) ProtoMessage() {}
+func (*Bound) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{7}
+}
+func (m *Bound) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Bound.Unmarshal(m, b)
+}
+func (m *Bound) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Bound.Marshal(b, m, deterministic)
+}
+func (dst *Bound) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Bound.Merge(dst, src)
+}
+func (m *Bound) XXX_Size() int {
+ return xxx_messageInfo_Bound.Size(m)
+}
+func (m *Bound) XXX_DiscardUnknown() {
+ xxx_messageInfo_Bound.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Bound proto.InternalMessageInfo
+
+func (m *Bound) GetType() Bound_BoundType {
+ if m != nil {
+ return m.Type
+ }
+ return Bound_ABSOLUTE
+}
+
+func (m *Bound) GetIndex() uint64 {
+ if m != nil {
+ return m.Index
+ }
+ return 0
+}
+
+// An inclusive range of blocks to include in output
+type BlockRange struct {
+ // Bounds can be set to:
+ // absolute: block height
+ // relative: block height counting back from latest
+ // latest: latest block when call is processed
+ // stream: for End keep sending new blocks, for start same as latest
+ Start *Bound `protobuf:"bytes,1,opt,name=Start,proto3" json:"Start,omitempty"`
+ End *Bound `protobuf:"bytes,2,opt,name=End,proto3" json:"End,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *BlockRange) Reset() { *m = BlockRange{} }
+func (m *BlockRange) String() string { return proto.CompactTextString(m) }
+func (*BlockRange) ProtoMessage() {}
+func (*BlockRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{8}
+}
+func (m *BlockRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_BlockRange.Unmarshal(m, b)
+}
+func (m *BlockRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_BlockRange.Marshal(b, m, deterministic)
+}
+func (dst *BlockRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_BlockRange.Merge(dst, src)
+}
+func (m *BlockRange) XXX_Size() int {
+ return xxx_messageInfo_BlockRange.Size(m)
+}
+func (m *BlockRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_BlockRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BlockRange proto.InternalMessageInfo
+
+func (m *BlockRange) GetStart() *Bound {
+ if m != nil {
+ return m.Start
+ }
+ return nil
+}
+
+func (m *BlockRange) GetEnd() *Bound {
+ if m != nil {
+ return m.End
+ }
+ return nil
+}
+
+type EventHeader struct {
+ // Transaction type
+ TxType string `protobuf:"bytes,1,opt,name=TxType,proto3" json:"TxType,omitempty"`
+ // The hash of the transaction that caused this event to be generated
+ TxHash []byte `protobuf:"bytes,2,opt,name=TxHash,proto3" json:"TxHash,omitempty"`
+ // The type of event
+ EventType string `protobuf:"bytes,3,opt,name=EventType,proto3" json:"EventType,omitempty"`
+ // EventID published with event
+ EventID string `protobuf:"bytes,4,opt,name=EventID,proto3" json:"EventID,omitempty"`
+ // The block height at which this event was emitted
+ Height uint64 `protobuf:"varint,5,opt,name=Height,proto3" json:"Height,omitempty"`
+ // The index amongst all other events in the block of this event
+ Index uint64 `protobuf:"varint,6,opt,name=Index,proto3" json:"Index,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EventHeader) Reset() { *m = EventHeader{} }
+func (m *EventHeader) String() string { return proto.CompactTextString(m) }
+func (*EventHeader) ProtoMessage() {}
+func (*EventHeader) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{9}
+}
+func (m *EventHeader) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EventHeader.Unmarshal(m, b)
+}
+func (m *EventHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EventHeader.Marshal(b, m, deterministic)
+}
+func (dst *EventHeader) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventHeader.Merge(dst, src)
+}
+func (m *EventHeader) XXX_Size() int {
+ return xxx_messageInfo_EventHeader.Size(m)
+}
+func (m *EventHeader) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventHeader.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventHeader proto.InternalMessageInfo
+
+func (m *EventHeader) GetTxType() string {
+ if m != nil {
+ return m.TxType
+ }
+ return ""
+}
+
+func (m *EventHeader) GetTxHash() []byte {
+ if m != nil {
+ return m.TxHash
+ }
+ return nil
+}
+
+func (m *EventHeader) GetEventType() string {
+ if m != nil {
+ return m.EventType
+ }
+ return ""
+}
+
+func (m *EventHeader) GetEventID() string {
+ if m != nil {
+ return m.EventID
+ }
+ return ""
+}
+
+func (m *EventHeader) GetHeight() uint64 {
+ if m != nil {
+ return m.Height
+ }
+ return 0
+}
+
+func (m *EventHeader) GetIndex() uint64 {
+ if m != nil {
+ return m.Index
+ }
+ return 0
+}
+
+type ExecutionEvent struct {
+ Header *EventHeader `protobuf:"bytes,1,opt,name=Header,proto3" json:"Header,omitempty"`
+ // Types that are valid to be assigned to EventData:
+ // *ExecutionEvent_EventDataTx
+ // *ExecutionEvent_EventDataCall
+ // *ExecutionEvent_EventDataLog
+ EventData isExecutionEvent_EventData `protobuf_oneof:"EventData"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExecutionEvent) Reset() { *m = ExecutionEvent{} }
+func (m *ExecutionEvent) String() string { return proto.CompactTextString(m) }
+func (*ExecutionEvent) ProtoMessage() {}
+func (*ExecutionEvent) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{10}
+}
+func (m *ExecutionEvent) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExecutionEvent.Unmarshal(m, b)
+}
+func (m *ExecutionEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExecutionEvent.Marshal(b, m, deterministic)
+}
+func (dst *ExecutionEvent) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExecutionEvent.Merge(dst, src)
+}
+func (m *ExecutionEvent) XXX_Size() int {
+ return xxx_messageInfo_ExecutionEvent.Size(m)
+}
+func (m *ExecutionEvent) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExecutionEvent.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExecutionEvent proto.InternalMessageInfo
+
+type isExecutionEvent_EventData interface {
+ isExecutionEvent_EventData()
+}
+
+type ExecutionEvent_EventDataTx struct {
+ EventDataTx *EventDataTx `protobuf:"bytes,2,opt,name=EventDataTx,proto3,oneof"`
+}
+type ExecutionEvent_EventDataCall struct {
+ EventDataCall *EventDataCall `protobuf:"bytes,3,opt,name=EventDataCall,proto3,oneof"`
+}
+type ExecutionEvent_EventDataLog struct {
+ EventDataLog *EventDataLog `protobuf:"bytes,4,opt,name=EventDataLog,proto3,oneof"`
+}
+
+func (*ExecutionEvent_EventDataTx) isExecutionEvent_EventData() {}
+func (*ExecutionEvent_EventDataCall) isExecutionEvent_EventData() {}
+func (*ExecutionEvent_EventDataLog) isExecutionEvent_EventData() {}
+
+func (m *ExecutionEvent) GetEventData() isExecutionEvent_EventData {
+ if m != nil {
+ return m.EventData
+ }
+ return nil
+}
+
+func (m *ExecutionEvent) GetHeader() *EventHeader {
+ if m != nil {
+ return m.Header
+ }
+ return nil
+}
+
+func (m *ExecutionEvent) GetEventDataTx() *EventDataTx {
+ if x, ok := m.GetEventData().(*ExecutionEvent_EventDataTx); ok {
+ return x.EventDataTx
+ }
+ return nil
+}
+
+func (m *ExecutionEvent) GetEventDataCall() *EventDataCall {
+ if x, ok := m.GetEventData().(*ExecutionEvent_EventDataCall); ok {
+ return x.EventDataCall
+ }
+ return nil
+}
+
+func (m *ExecutionEvent) GetEventDataLog() *EventDataLog {
+ if x, ok := m.GetEventData().(*ExecutionEvent_EventDataLog); ok {
+ return x.EventDataLog
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ExecutionEvent) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _ExecutionEvent_OneofMarshaler, _ExecutionEvent_OneofUnmarshaler, _ExecutionEvent_OneofSizer, []interface{}{
+ (*ExecutionEvent_EventDataTx)(nil),
+ (*ExecutionEvent_EventDataCall)(nil),
+ (*ExecutionEvent_EventDataLog)(nil),
+ }
+}
+
+func _ExecutionEvent_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*ExecutionEvent)
+ // EventData
+ switch x := m.EventData.(type) {
+ case *ExecutionEvent_EventDataTx:
+ b.EncodeVarint(2<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.EventDataTx); err != nil {
+ return err
+ }
+ case *ExecutionEvent_EventDataCall:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.EventDataCall); err != nil {
+ return err
+ }
+ case *ExecutionEvent_EventDataLog:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.EventDataLog); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("ExecutionEvent.EventData has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _ExecutionEvent_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*ExecutionEvent)
+ switch tag {
+ case 2: // EventData.EventDataTx
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(EventDataTx)
+ err := b.DecodeMessage(msg)
+ m.EventData = &ExecutionEvent_EventDataTx{msg}
+ return true, err
+ case 3: // EventData.EventDataCall
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(EventDataCall)
+ err := b.DecodeMessage(msg)
+ m.EventData = &ExecutionEvent_EventDataCall{msg}
+ return true, err
+ case 4: // EventData.EventDataLog
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(EventDataLog)
+ err := b.DecodeMessage(msg)
+ m.EventData = &ExecutionEvent_EventDataLog{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _ExecutionEvent_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*ExecutionEvent)
+ // EventData
+ switch x := m.EventData.(type) {
+ case *ExecutionEvent_EventDataTx:
+ s := proto.Size(x.EventDataTx)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *ExecutionEvent_EventDataCall:
+ s := proto.Size(x.EventDataCall)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *ExecutionEvent_EventDataLog:
+ s := proto.Size(x.EventDataLog)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+type EventDataLog struct {
+ Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
+ Data []byte `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
+ Topics [][]byte `protobuf:"bytes,3,rep,name=Topics,proto3" json:"Topics,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EventDataLog) Reset() { *m = EventDataLog{} }
+func (m *EventDataLog) String() string { return proto.CompactTextString(m) }
+func (*EventDataLog) ProtoMessage() {}
+func (*EventDataLog) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{11}
+}
+func (m *EventDataLog) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EventDataLog.Unmarshal(m, b)
+}
+func (m *EventDataLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EventDataLog.Marshal(b, m, deterministic)
+}
+func (dst *EventDataLog) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventDataLog.Merge(dst, src)
+}
+func (m *EventDataLog) XXX_Size() int {
+ return xxx_messageInfo_EventDataLog.Size(m)
+}
+func (m *EventDataLog) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventDataLog.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventDataLog proto.InternalMessageInfo
+
+func (m *EventDataLog) GetAddress() []byte {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+func (m *EventDataLog) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+func (m *EventDataLog) GetTopics() [][]byte {
+ if m != nil {
+ return m.Topics
+ }
+ return nil
+}
+
+type EventDataTx struct {
+ Return []byte `protobuf:"bytes,1,opt,name=Return,proto3" json:"Return,omitempty"`
+ Exception *errors.Exception `protobuf:"bytes,2,opt,name=Exception,proto3" json:"Exception,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EventDataTx) Reset() { *m = EventDataTx{} }
+func (m *EventDataTx) String() string { return proto.CompactTextString(m) }
+func (*EventDataTx) ProtoMessage() {}
+func (*EventDataTx) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{12}
+}
+func (m *EventDataTx) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EventDataTx.Unmarshal(m, b)
+}
+func (m *EventDataTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EventDataTx.Marshal(b, m, deterministic)
+}
+func (dst *EventDataTx) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventDataTx.Merge(dst, src)
+}
+func (m *EventDataTx) XXX_Size() int {
+ return xxx_messageInfo_EventDataTx.Size(m)
+}
+func (m *EventDataTx) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventDataTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventDataTx proto.InternalMessageInfo
+
+func (m *EventDataTx) GetReturn() []byte {
+ if m != nil {
+ return m.Return
+ }
+ return nil
+}
+
+func (m *EventDataTx) GetException() *errors.Exception {
+ if m != nil {
+ return m.Exception
+ }
+ return nil
+}
+
+type EventDataCall struct {
+ CallData *CallData `protobuf:"bytes,1,opt,name=CallData,proto3" json:"CallData,omitempty"`
+ Origin []byte `protobuf:"bytes,2,opt,name=Origin,proto3" json:"Origin,omitempty"`
+ StackDepth uint64 `protobuf:"varint,3,opt,name=StackDepth,proto3" json:"StackDepth,omitempty"`
+ Return []byte `protobuf:"bytes,4,opt,name=Return,proto3" json:"Return,omitempty"`
+ Exception *errors.Exception `protobuf:"bytes,5,opt,name=Exception,proto3" json:"Exception,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EventDataCall) Reset() { *m = EventDataCall{} }
+func (m *EventDataCall) String() string { return proto.CompactTextString(m) }
+func (*EventDataCall) ProtoMessage() {}
+func (*EventDataCall) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{13}
+}
+func (m *EventDataCall) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EventDataCall.Unmarshal(m, b)
+}
+func (m *EventDataCall) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EventDataCall.Marshal(b, m, deterministic)
+}
+func (dst *EventDataCall) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EventDataCall.Merge(dst, src)
+}
+func (m *EventDataCall) XXX_Size() int {
+ return xxx_messageInfo_EventDataCall.Size(m)
+}
+func (m *EventDataCall) XXX_DiscardUnknown() {
+ xxx_messageInfo_EventDataCall.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EventDataCall proto.InternalMessageInfo
+
+func (m *EventDataCall) GetCallData() *CallData {
+ if m != nil {
+ return m.CallData
+ }
+ return nil
+}
+
+func (m *EventDataCall) GetOrigin() []byte {
+ if m != nil {
+ return m.Origin
+ }
+ return nil
+}
+
+func (m *EventDataCall) GetStackDepth() uint64 {
+ if m != nil {
+ return m.StackDepth
+ }
+ return 0
+}
+
+func (m *EventDataCall) GetReturn() []byte {
+ if m != nil {
+ return m.Return
+ }
+ return nil
+}
+
+func (m *EventDataCall) GetException() *errors.Exception {
+ if m != nil {
+ return m.Exception
+ }
+ return nil
+}
+
+type CallData struct {
+ Caller []byte `protobuf:"bytes,1,opt,name=Caller,proto3" json:"Caller,omitempty"`
+ Callee []byte `protobuf:"bytes,2,opt,name=Callee,proto3" json:"Callee,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
+ Value uint64 `protobuf:"varint,4,opt,name=Value,proto3" json:"Value,omitempty"`
+ Gas uint64 `protobuf:"varint,5,opt,name=Gas,proto3" json:"Gas,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *CallData) Reset() { *m = CallData{} }
+func (m *CallData) String() string { return proto.CompactTextString(m) }
+func (*CallData) ProtoMessage() {}
+func (*CallData) Descriptor() ([]byte, []int) {
+ return fileDescriptor_events_a0e2b84614955cff, []int{14}
+}
+func (m *CallData) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_CallData.Unmarshal(m, b)
+}
+func (m *CallData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_CallData.Marshal(b, m, deterministic)
+}
+func (dst *CallData) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CallData.Merge(dst, src)
+}
+func (m *CallData) XXX_Size() int {
+ return xxx_messageInfo_CallData.Size(m)
+}
+func (m *CallData) XXX_DiscardUnknown() {
+ xxx_messageInfo_CallData.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CallData proto.InternalMessageInfo
+
+func (m *CallData) GetCaller() []byte {
+ if m != nil {
+ return m.Caller
+ }
+ return nil
+}
+
+func (m *CallData) GetCallee() []byte {
+ if m != nil {
+ return m.Callee
+ }
+ return nil
+}
+
+func (m *CallData) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+func (m *CallData) GetValue() uint64 {
+ if m != nil {
+ return m.Value
+ }
+ return 0
+}
+
+func (m *CallData) GetGas() uint64 {
+ if m != nil {
+ return m.Gas
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*EventIdParam)(nil), "pbevents.EventIdParam")
+ proto.RegisterType((*SubIdParam)(nil), "pbevents.SubIdParam")
+ proto.RegisterType((*EventUnSub)(nil), "pbevents.EventUnSub")
+ proto.RegisterType((*PollResponse)(nil), "pbevents.PollResponse")
+ proto.RegisterType((*Event)(nil), "pbevents.Event")
+ proto.RegisterType((*GetEventsRequest)(nil), "pbevents.GetEventsRequest")
+ proto.RegisterType((*GetEventsResponse)(nil), "pbevents.GetEventsResponse")
+ proto.RegisterType((*Bound)(nil), "pbevents.Bound")
+ proto.RegisterType((*BlockRange)(nil), "pbevents.BlockRange")
+ proto.RegisterType((*EventHeader)(nil), "pbevents.EventHeader")
+ proto.RegisterType((*ExecutionEvent)(nil), "pbevents.ExecutionEvent")
+ proto.RegisterType((*EventDataLog)(nil), "pbevents.EventDataLog")
+ proto.RegisterType((*EventDataTx)(nil), "pbevents.EventDataTx")
+ proto.RegisterType((*EventDataCall)(nil), "pbevents.EventDataCall")
+ proto.RegisterType((*CallData)(nil), "pbevents.CallData")
+ proto.RegisterEnum("pbevents.Bound_BoundType", Bound_BoundType_name, Bound_BoundType_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// EventsClient is the client API for Events service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type EventsClient interface {
+ EventPoll(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*PollResponse, error)
+ EventSubscribe(ctx context.Context, in *EventIdParam, opts ...grpc.CallOption) (*SubIdParam, error)
+ EventUnsubscribe(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*EventUnSub, error)
+}
+
+type eventsClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewEventsClient(cc *grpc.ClientConn) EventsClient {
+ return &eventsClient{cc}
+}
+
+func (c *eventsClient) EventPoll(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*PollResponse, error) {
+ out := new(PollResponse)
+ err := c.cc.Invoke(ctx, "/pbevents.Events/EventPoll", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *eventsClient) EventSubscribe(ctx context.Context, in *EventIdParam, opts ...grpc.CallOption) (*SubIdParam, error) {
+ out := new(SubIdParam)
+ err := c.cc.Invoke(ctx, "/pbevents.Events/EventSubscribe", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *eventsClient) EventUnsubscribe(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*EventUnSub, error) {
+ out := new(EventUnSub)
+ err := c.cc.Invoke(ctx, "/pbevents.Events/EventUnsubscribe", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// EventsServer is the server API for Events service.
+type EventsServer interface {
+ EventPoll(context.Context, *SubIdParam) (*PollResponse, error)
+ EventSubscribe(context.Context, *EventIdParam) (*SubIdParam, error)
+ EventUnsubscribe(context.Context, *SubIdParam) (*EventUnSub, error)
+}
+
+func RegisterEventsServer(s *grpc.Server, srv EventsServer) {
+ s.RegisterService(&_Events_serviceDesc, srv)
+}
+
+func _Events_EventPoll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SubIdParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(EventsServer).EventPoll(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbevents.Events/EventPoll",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(EventsServer).EventPoll(ctx, req.(*SubIdParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Events_EventSubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(EventIdParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(EventsServer).EventSubscribe(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbevents.Events/EventSubscribe",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(EventsServer).EventSubscribe(ctx, req.(*EventIdParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Events_EventUnsubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SubIdParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(EventsServer).EventUnsubscribe(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbevents.Events/EventUnsubscribe",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(EventsServer).EventUnsubscribe(ctx, req.(*SubIdParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _Events_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "pbevents.Events",
+ HandlerType: (*EventsServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "EventPoll",
+ Handler: _Events_EventPoll_Handler,
+ },
+ {
+ MethodName: "EventSubscribe",
+ Handler: _Events_EventSubscribe_Handler,
+ },
+ {
+ MethodName: "EventUnsubscribe",
+ Handler: _Events_EventUnsubscribe_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "github.com/hyperledger/burrow/execution/events/pbevents/events.proto",
+}
+
+// ExecutionEventsClient is the client API for ExecutionEvents service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type ExecutionEventsClient interface {
+ // GetEvents provides events streaming one block at a time - that is all events emitted in a particular block
+ // are guaranteed to be delivered in each GetEventsResponse
+ GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (ExecutionEvents_GetEventsClient, error)
+}
+
+type executionEventsClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewExecutionEventsClient(cc *grpc.ClientConn) ExecutionEventsClient {
+ return &executionEventsClient{cc}
+}
+
+func (c *executionEventsClient) GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (ExecutionEvents_GetEventsClient, error) {
+ stream, err := c.cc.NewStream(ctx, &_ExecutionEvents_serviceDesc.Streams[0], "/pbevents.ExecutionEvents/GetEvents", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &executionEventsGetEventsClient{stream}
+ if err := x.ClientStream.SendMsg(in); err != nil {
+ return nil, err
+ }
+ if err := x.ClientStream.CloseSend(); err != nil {
+ return nil, err
+ }
+ return x, nil
+}
+
+type ExecutionEvents_GetEventsClient interface {
+ Recv() (*GetEventsResponse, error)
+ grpc.ClientStream
+}
+
+type executionEventsGetEventsClient struct {
+ grpc.ClientStream
+}
+
+func (x *executionEventsGetEventsClient) Recv() (*GetEventsResponse, error) {
+ m := new(GetEventsResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+// ExecutionEventsServer is the server API for ExecutionEvents service.
+type ExecutionEventsServer interface {
+ // GetEvents provides events streaming one block at a time - that is all events emitted in a particular block
+ // are guaranteed to be delivered in each GetEventsResponse
+ GetEvents(*GetEventsRequest, ExecutionEvents_GetEventsServer) error
+}
+
+func RegisterExecutionEventsServer(s *grpc.Server, srv ExecutionEventsServer) {
+ s.RegisterService(&_ExecutionEvents_serviceDesc, srv)
+}
+
+func _ExecutionEvents_GetEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
+ m := new(GetEventsRequest)
+ if err := stream.RecvMsg(m); err != nil {
+ return err
+ }
+ return srv.(ExecutionEventsServer).GetEvents(m, &executionEventsGetEventsServer{stream})
+}
+
+type ExecutionEvents_GetEventsServer interface {
+ Send(*GetEventsResponse) error
+ grpc.ServerStream
+}
+
+type executionEventsGetEventsServer struct {
+ grpc.ServerStream
+}
+
+func (x *executionEventsGetEventsServer) Send(m *GetEventsResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+var _ExecutionEvents_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "pbevents.ExecutionEvents",
+ HandlerType: (*ExecutionEventsServer)(nil),
+ Methods: []grpc.MethodDesc{},
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "GetEvents",
+ Handler: _ExecutionEvents_GetEvents_Handler,
+ ServerStreams: true,
+ },
+ },
+ Metadata: "github.com/hyperledger/burrow/execution/events/pbevents/events.proto",
+}
+
+func init() {
+ proto.RegisterFile("github.com/hyperledger/burrow/execution/events/pbevents/events.proto", fileDescriptor_events_a0e2b84614955cff)
+}
+
+var fileDescriptor_events_a0e2b84614955cff = []byte{
+ // 907 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x6e, 0xdc, 0x44,
+ 0x14, 0x5e, 0x67, 0x7f, 0x1a, 0x9f, 0x5d, 0x12, 0x77, 0x08, 0xc5, 0x04, 0x84, 0x82, 0x05, 0x22,
+ 0x37, 0xdd, 0xad, 0x0c, 0x52, 0x15, 0x81, 0x8a, 0x76, 0x89, 0xdb, 0x4d, 0xb5, 0x34, 0x65, 0xec,
+ 0x46, 0x82, 0x0b, 0x24, 0x7b, 0x3d, 0xda, 0xb5, 0xea, 0xd8, 0x66, 0xc6, 0x2e, 0x9b, 0x17, 0xe0,
+ 0x19, 0xb8, 0xe0, 0x8e, 0x17, 0x41, 0xe2, 0xc5, 0xd0, 0xfc, 0xf8, 0x97, 0xad, 0x54, 0x71, 0x13,
+ 0xcf, 0x37, 0xe7, 0x9b, 0x6f, 0xcf, 0xf9, 0xce, 0xfc, 0x04, 0x2e, 0x37, 0x51, 0xbe, 0x2d, 0x82,
+ 0xe9, 0x3a, 0xbd, 0x9d, 0x6d, 0xef, 0x32, 0x42, 0x63, 0x12, 0x6e, 0x08, 0x9d, 0x05, 0x05, 0xa5,
+ 0xe9, 0x6f, 0x33, 0xb2, 0x23, 0xeb, 0x22, 0x8f, 0xd2, 0x64, 0x46, 0xde, 0x90, 0x24, 0x67, 0xb3,
+ 0x2c, 0x50, 0x03, 0xf9, 0x99, 0x66, 0x34, 0xcd, 0x53, 0x74, 0x58, 0x4e, 0x9f, 0x7e, 0xf3, 0xce,
+ 0x7a, 0x94, 0xa6, 0x94, 0xa9, 0x8f, 0x94, 0xb1, 0xce, 0x61, 0xe2, 0x70, 0x99, 0xab, 0xf0, 0xa5,
+ 0x4f, 0xfd, 0x5b, 0x64, 0xc2, 0x3d, 0x22, 0xb1, 0xa9, 0x9d, 0x69, 0xe7, 0x3a, 0x2e, 0xa1, 0x65,
+ 0x01, 0xb8, 0x45, 0x50, 0xf2, 0x4e, 0x60, 0xc8, 0x38, 0x52, 0x2c, 0x09, 0xac, 0xcf, 0x01, 0x84,
+ 0xda, 0xab, 0xc4, 0x2d, 0x02, 0xf4, 0x00, 0x46, 0x94, 0xb0, 0x22, 0xce, 0x05, 0xe9, 0x10, 0x2b,
+ 0x64, 0x3d, 0x86, 0xc9, 0xcb, 0x34, 0x8e, 0x31, 0x61, 0x59, 0x9a, 0x30, 0x82, 0xbe, 0x84, 0x91,
+ 0x2c, 0xc5, 0xd4, 0xce, 0xfa, 0xe7, 0x63, 0xfb, 0x78, 0x5a, 0xd6, 0x36, 0x15, 0x6a, 0x58, 0x85,
+ 0xad, 0x3f, 0x35, 0x18, 0x8a, 0x19, 0x84, 0x60, 0xf0, 0xc2, 0xbf, 0x25, 0xea, 0xd7, 0xc5, 0x18,
+ 0x2d, 0xe0, 0xc8, 0x29, 0x6b, 0x15, 0x2c, 0xf3, 0xe0, 0x4c, 0x3b, 0x1f, 0xdb, 0x66, 0x43, 0xae,
+ 0x15, 0x5f, 0xf6, 0x70, 0x67, 0x05, 0xb2, 0xe1, 0x7d, 0x8f, 0x24, 0x21, 0xa1, 0xb7, 0x51, 0x92,
+ 0x8b, 0xa9, 0xe7, 0xee, 0xf5, 0x0b, 0xb3, 0xcf, 0x7f, 0x66, 0xd9, 0xc3, 0xfb, 0x82, 0x8b, 0x7b,
+ 0x2a, 0x29, 0xeb, 0x17, 0x30, 0x9e, 0x11, 0x19, 0x60, 0x98, 0xfc, 0x5a, 0x10, 0x96, 0xa3, 0xaf,
+ 0x01, 0x16, 0x71, 0xba, 0x7e, 0x8d, 0xfd, 0x64, 0x23, 0xd3, 0x1d, 0xdb, 0x27, 0x75, 0x42, 0x75,
+ 0x0c, 0x37, 0x78, 0xdc, 0xdd, 0x1f, 0x0b, 0x42, 0xef, 0x44, 0x05, 0x3a, 0x96, 0xc0, 0x72, 0xe0,
+ 0x7e, 0x43, 0x5f, 0x99, 0xf7, 0xa8, 0x63, 0xde, 0x5b, 0xab, 0xad, 0x5c, 0xfc, 0x43, 0x83, 0xe1,
+ 0x22, 0x2d, 0x92, 0x10, 0x3d, 0x84, 0x81, 0x77, 0x97, 0xc9, 0xb4, 0x8e, 0xec, 0x8f, 0x1a, 0x69,
+ 0xf1, 0xb0, 0xfc, 0xcb, 0x09, 0x58, 0xd0, 0x78, 0x56, 0x57, 0x49, 0x48, 0x76, 0x22, 0xab, 0x01,
+ 0x96, 0xc0, 0x7a, 0x0e, 0x7a, 0x45, 0x44, 0x13, 0x38, 0x9c, 0x2f, 0xdc, 0xeb, 0xd5, 0x2b, 0xcf,
+ 0x31, 0x7a, 0x1c, 0x61, 0x67, 0x35, 0xf7, 0xae, 0x6e, 0x1c, 0x43, 0x43, 0x3a, 0x0c, 0x9f, 0x5e,
+ 0x61, 0xd7, 0x33, 0x0e, 0x10, 0xc0, 0x68, 0x35, 0xf7, 0x1c, 0xd7, 0x33, 0xfa, 0x7c, 0xec, 0x7a,
+ 0xd8, 0x99, 0xff, 0x60, 0x0c, 0xac, 0x9b, 0xa6, 0x5b, 0xe8, 0x0b, 0x18, 0xba, 0xb9, 0x4f, 0x73,
+ 0x65, 0xdb, 0x71, 0x27, 0x3f, 0x2c, 0xa3, 0xe8, 0x33, 0xe8, 0x3b, 0x49, 0xa8, 0x9a, 0xfd, 0x1f,
+ 0x12, 0x8f, 0x59, 0x7f, 0x69, 0x30, 0x96, 0x2d, 0x27, 0x7e, 0x48, 0x28, 0xdf, 0x99, 0xde, 0xae,
+ 0x2a, 0x5d, 0xc7, 0x0a, 0xc9, 0xf9, 0xa5, 0xcf, 0xb6, 0x42, 0x6d, 0x82, 0x15, 0x42, 0x9f, 0x80,
+ 0x2e, 0x96, 0x8b, 0x25, 0x62, 0x33, 0xe0, 0x7a, 0x82, 0x9f, 0x19, 0x79, 0x86, 0x2e, 0xcd, 0x81,
+ 0x3c, 0x33, 0x0a, 0x72, 0xbd, 0x25, 0x89, 0x36, 0xdb, 0xdc, 0x1c, 0x0a, 0xcb, 0x14, 0xaa, 0x9d,
+ 0x1c, 0x35, 0x9d, 0xfc, 0xfd, 0xa0, 0xbb, 0x83, 0xd1, 0x43, 0x2e, 0xc0, 0x53, 0x56, 0x1e, 0x7c,
+ 0xd0, 0x39, 0x1a, 0x32, 0x88, 0x15, 0x09, 0x5d, 0xa8, 0x32, 0x2f, 0xfd, 0xdc, 0xf7, 0x76, 0xca,
+ 0x92, 0xee, 0x1a, 0x19, 0x5c, 0xf6, 0x70, 0x93, 0x8b, 0xbe, 0x83, 0xf7, 0x2a, 0xf8, 0xbd, 0x1f,
+ 0xc7, 0xa2, 0xcc, 0xb1, 0xfd, 0xe1, 0x9e, 0xc5, 0x3c, 0xbc, 0xec, 0xe1, 0x36, 0x1f, 0x7d, 0xab,
+ 0x6e, 0x12, 0x3e, 0xb1, 0x4a, 0x37, 0xc2, 0x8a, 0xb1, 0xfd, 0x60, 0xcf, 0xfa, 0x55, 0xba, 0x59,
+ 0xf6, 0x70, 0x8b, 0xbd, 0x18, 0x2b, 0x87, 0x39, 0xb6, 0xbc, 0xb6, 0x14, 0x37, 0x78, 0x1e, 0x86,
+ 0x94, 0x30, 0x26, 0x6c, 0x98, 0xe0, 0x12, 0xf2, 0x7b, 0x80, 0x93, 0x54, 0xbb, 0xc4, 0x58, 0x34,
+ 0x31, 0xcd, 0xa2, 0x35, 0x33, 0xfb, 0x67, 0x7d, 0xd1, 0x44, 0x81, 0xac, 0x9b, 0x96, 0x39, 0x9c,
+ 0x86, 0x49, 0x5e, 0xd0, 0x44, 0x69, 0x2a, 0x84, 0x66, 0xa0, 0x3b, 0xbb, 0x35, 0xc9, 0x78, 0x13,
+ 0x94, 0x83, 0xf7, 0xa7, 0xea, 0xce, 0xac, 0x02, 0xb8, 0xe6, 0x58, 0x7f, 0x6b, 0x1d, 0xeb, 0xd0,
+ 0x14, 0x0e, 0xf9, 0x57, 0x64, 0x26, 0xfb, 0x86, 0x6a, 0x1b, 0xca, 0x08, 0xae, 0x38, 0x3c, 0x95,
+ 0x6b, 0x1a, 0x6d, 0xa2, 0xa4, 0xdc, 0x76, 0x12, 0xa1, 0x4f, 0x01, 0xdc, 0xdc, 0x5f, 0xbf, 0xbe,
+ 0x24, 0x59, 0xbe, 0x15, 0x0d, 0x19, 0xe0, 0xc6, 0x4c, 0xa3, 0x84, 0xc1, 0xdb, 0x4b, 0x18, 0xbe,
+ 0x43, 0x09, 0x6f, 0xa0, 0x95, 0x0c, 0x1f, 0xab, 0x2d, 0x37, 0xc1, 0x0a, 0x55, 0xf3, 0xa4, 0x4c,
+ 0x52, 0xa2, 0xaa, 0x05, 0xfd, 0x46, 0x0b, 0x4e, 0x60, 0x78, 0xe3, 0xc7, 0x05, 0x11, 0x79, 0x0d,
+ 0xb0, 0x04, 0xc8, 0x80, 0xfe, 0x33, 0x9f, 0xa9, 0xa3, 0xc0, 0x87, 0xf6, 0x3f, 0x1a, 0x8c, 0xe4,
+ 0x7d, 0x86, 0x2e, 0xd4, 0x06, 0xe0, 0x2f, 0x03, 0x6a, 0xdc, 0x90, 0xf5, 0x9b, 0x73, 0xda, 0xd8,
+ 0x4b, 0xad, 0xf7, 0xe3, 0x09, 0x1c, 0x89, 0xa5, 0x6e, 0x11, 0xb0, 0x35, 0x8d, 0x02, 0x82, 0xba,
+ 0xbb, 0xae, 0x54, 0xd8, 0xab, 0x8b, 0x9e, 0x80, 0xa1, 0x5e, 0x2d, 0x56, 0x29, 0xec, 0xcf, 0xe0,
+ 0xa4, 0xa3, 0x2b, 0xde, 0x39, 0xfb, 0x27, 0x38, 0x6e, 0x1f, 0x5b, 0x86, 0x9e, 0x82, 0x5e, 0x5d,
+ 0xd5, 0xe8, 0xb4, 0x5e, 0xd5, 0x7d, 0x1f, 0x4e, 0x3f, 0xde, 0x1b, 0x93, 0x85, 0x3d, 0xd2, 0x16,
+ 0x17, 0x3f, 0x3f, 0xfe, 0x9f, 0xff, 0x2d, 0x04, 0x23, 0xf1, 0xc0, 0x7f, 0xf5, 0x6f, 0x00, 0x00,
+ 0x00, 0xff, 0xff, 0x6f, 0x28, 0x40, 0xd9, 0x6f, 0x08, 0x00, 0x00,
+}
diff --git a/execution/events/pbevents/events.proto b/execution/events/pbevents/events.proto
new file mode 100644
index 0000000000000000000000000000000000000000..67cb46c39152e9ba95ab05d4539c55b80cbf803e
--- /dev/null
+++ b/execution/events/pbevents/events.proto
@@ -0,0 +1,177 @@
+syntax = 'proto3';
+
+option go_package = "github.com/hyperledger/burrow/execution/events/pbevents";
+
+import "github.com/hyperledger/burrow/execution/errors/errors.proto";
+
+package pbevents;
+
+//--------------------------------------------------
+// Event Service Definition
+service Events {
+ rpc EventPoll (SubIdParam) returns (PollResponse);
+ rpc EventSubscribe (EventIdParam) returns (SubIdParam);
+ rpc EventUnsubscribe (SubIdParam) returns (EventUnSub);
+}
+
+// Params
+message EventIdParam {
+ string eventId = 1;
+}
+
+message SubIdParam {
+ string subId = 1;
+}
+
+// Results
+message EventUnSub {
+ bool result = 1;
+}
+
+message PollResponse {
+ repeated Event events = 1;
+}
+
+message Event {
+ string Name = 1;
+ oneof Event {
+ // Burrow's execution domain events generated deterministically from transactions
+ ExecutionEvent ExecutionEvent = 2;
+ // Operational events from tendermint serialised into their standard JSON representation
+ string TendermintEventJSON = 3;
+ }
+}
+
+//--------------------------------------------------
+// Execution events
+service ExecutionEvents {
+ // GetEvents provides events streaming one block at a time - that is all events emitted in a particular block
+ // are guaranteed to be delivered in each GetEventsResponse
+ rpc GetEvents (GetEventsRequest) returns (stream GetEventsResponse);
+}
+
+message GetEventsRequest {
+ BlockRange BlockRange = 1;
+ // Specify a query on which to match the tags of events.
+ // Tag | Match type | Values
+ // -----------------------------------------
+ // All events
+ // -----------------------------------------
+ // TxType | String | "UnknownTx", "SendTx", "CallTx", "NameTx", "BondTx", "UnbondTx", "PermissionsTx", "GovernanceTx"
+ // TxHash | String | bytes
+ // EventType | String | "CallEvent", "LogEvent", "AccountInputEvent", "AccountOutputEvent"
+ // EventID | String | string
+ // Height | Integer | uint64
+ // Index | Integer | uint64
+ // MessageType | String | Go type name
+ // -----------------------------------------
+ // Log event
+ // -----------------------------------------
+ // Address | String | Address (hex)
+ // Log<0-4> | String | Word256 (hex)
+ // Log<0-4>Text | String | string (trimmed)
+ // -----------------------------------------
+ // Call event
+ // -----------------------------------------
+ // Origin | String | Address (hex)
+ // Callee | String | Address (hex)
+ // Caller | String | Address (hex)
+ // Value | Integer | uint64
+ // Gas | Integer | uint64
+ // StackDepth | Integer | uint64
+ // Exception | String | string
+ // -----------------------------------------
+ // Tx event (input/output)
+ // -----------------------------------------
+ // Exception | String | string
+ //
+ // For example:
+ // EventType = 'LogEvent' AND EventID CONTAINS 'bar' AND TxHash = '020304' AND Height >= 34 AND Index < 3 AND Address = 'DEADBEEFDEADBEEFDEADBEEFDEADBEEFDEADBEEF'
+ string Query = 2;
+}
+
+message GetEventsResponse {
+ repeated ExecutionEvent events = 1;
+}
+
+message Bound {
+ BoundType Type = 1;
+ uint64 Index = 2;
+ enum BoundType {
+ // Index is absolute index of object in collection
+ ABSOLUTE = 0;
+ // Index is an offset relative to another bound determined by context
+ RELATIVE = 1;
+ // The first block
+ FIRST = 2;
+ // Ignore provided index and evaluate to latest index
+ LATEST = 3;
+ // Ignore provided index and stream new objects as they are generated
+ STREAM = 4;
+ }
+}
+
+// An inclusive range of blocks to include in output
+message BlockRange {
+ // Bounds can be set to:
+ // absolute: block height
+ // relative: block height counting back from latest
+ // latest: latest block when call is processed
+ // stream: for End keep sending new blocks, for start same as latest
+ Bound Start = 1;
+ Bound End = 2;
+}
+
+//--------------------------------------------------
+// Event types
+
+message EventHeader {
+ // Transaction type
+ string TxType = 1;
+ // The hash of the transaction that caused this event to be generated
+ bytes TxHash = 2;
+ // The type of event
+ string EventType = 3;
+ // EventID published with event
+ string EventID = 4;
+ // The block height at which this event was emitted
+ uint64 Height = 5;
+ // The index amongst all other events in the block of this event
+ uint64 Index = 6;
+}
+
+message ExecutionEvent {
+ EventHeader Header = 1;
+ oneof EventData {
+ EventDataTx EventDataTx = 2;
+ EventDataCall EventDataCall = 3;
+ EventDataLog EventDataLog = 4;
+ }
+}
+
+message EventDataLog {
+ bytes Address = 1;
+ bytes Data = 2;
+ repeated bytes Topics = 3;
+}
+
+message EventDataTx {
+ bytes Return = 1;
+ errors.Exception Exception = 2;
+}
+
+message EventDataCall {
+ CallData CallData = 1;
+ bytes Origin = 2;
+ uint64 StackDepth = 3;
+ bytes Return = 4;
+ errors.Exception Exception = 5;
+}
+
+message CallData {
+ bytes Caller = 1;
+ bytes Callee = 2;
+ bytes Data = 3;
+ uint64 Value = 4;
+ uint64 Gas = 5;
+}
diff --git a/execution/events/tx.go b/execution/events/tx.go
new file mode 100644
index 0000000000000000000000000000000000000000..c1da5c62d4856d96e6d6fbdd5c1feff9d58dbc67
--- /dev/null
+++ b/execution/events/tx.go
@@ -0,0 +1,134 @@
+package events
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
+ "github.com/hyperledger/burrow/execution/errors"
+ ptypes "github.com/hyperledger/burrow/permission/types"
+ "github.com/hyperledger/burrow/txs"
+ "github.com/hyperledger/burrow/txs/payload"
+ "github.com/tmthrgd/go-hex"
+)
+
+func EventStringAccountInput(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Input", addr) }
+func EventStringAccountOutput(addr crypto.Address) string { return fmt.Sprintf("Acc/%s/Output", addr) }
+func EventStringNameReg(name string) string { return fmt.Sprintf("NameReg/%s", name) }
+func EventStringPermissions(perm ptypes.PermFlag) string { return fmt.Sprintf("Permissions/%v", perm) }
+func EventStringBond() string { return "Bond" }
+func EventStringUnbond() string { return "Unbond" }
+
+// All txs fire EventDataTx, but only CallTx might have Return or Exception
+type EventDataTx struct {
+ Tx *txs.Tx
+ Return binary.HexBytes
+ Exception *errors.Exception
+}
+
+// For re-use
+var sendTxQuery = query.NewBuilder().
+ AndEquals(event.TxTypeKey, payload.TypeSend.String())
+
+var callTxQuery = query.NewBuilder().
+ AndEquals(event.TxTypeKey, payload.TypeCall.String())
+
+// Publish/Subscribe
+func PublishAccountInput(publisher event.Publisher, height uint64, address crypto.Address, tx *txs.Tx, ret []byte,
+ exception *errors.Exception) error {
+
+ ev := txEvent(height, TypeAccountInput, EventStringAccountInput(address), tx, ret, exception)
+ return publisher.Publish(context.Background(), ev, event.CombinedTags{ev.Tags(), event.TagMap{
+ event.AddressKey: address,
+ }})
+}
+
+func PublishAccountOutput(publisher event.Publisher, height uint64, address crypto.Address, tx *txs.Tx, ret []byte,
+ exception *errors.Exception) error {
+
+ ev := txEvent(height, TypeAccountOutput, EventStringAccountOutput(address), tx, ret, exception)
+ return publisher.Publish(context.Background(), ev, event.CombinedTags{ev.Tags(), event.TagMap{
+ event.AddressKey: address,
+ }})
+}
+
+func PublishNameReg(publisher event.Publisher, height uint64, tx *txs.Tx) error {
+ nameTx, ok := tx.Payload.(*payload.NameTx)
+ if !ok {
+ return fmt.Errorf("Tx payload must be NameTx to PublishNameReg")
+ }
+ ev := txEvent(height, TypeAccountInput, EventStringNameReg(nameTx.Name), tx, nil, nil)
+ return publisher.Publish(context.Background(), ev, event.CombinedTags{ev.Tags(), event.TagMap{
+ event.NameKey: nameTx.Name,
+ }})
+}
+
+func PublishPermissions(publisher event.Publisher, height uint64, tx *txs.Tx) error {
+ permTx, ok := tx.Payload.(*payload.PermissionsTx)
+ if !ok {
+ return fmt.Errorf("Tx payload must be PermissionsTx to PublishPermissions")
+ }
+ ev := txEvent(height, TypeAccountInput, EventStringPermissions(permTx.PermArgs.PermFlag), tx, nil, nil)
+ return publisher.Publish(context.Background(), ev, event.CombinedTags{ev.Tags(), event.TagMap{
+ event.PermissionKey: permTx.PermArgs.PermFlag.String(),
+ }})
+}
+
+func SubscribeAccountOutputSendTx(ctx context.Context, subscribable event.Subscribable, subscriber string,
+ address crypto.Address, txHash []byte, ch chan<- *payload.SendTx) error {
+
+ qry := sendTxQuery.And(event.QueryForEventID(EventStringAccountOutput(address))).
+ AndEquals(event.TxHashKey, hex.EncodeUpperToString(txHash))
+
+ return event.SubscribeCallback(ctx, subscribable, subscriber, qry, func(message interface{}) (stop bool) {
+ if ev, ok := message.(*Event); ok && ev.Tx != nil {
+ if sendTx, ok := ev.Tx.Tx.Payload.(*payload.SendTx); ok {
+ ch <- sendTx
+ }
+ }
+ return
+ })
+}
+
+func txEvent(height uint64, eventType Type, eventID string, tx *txs.Tx, ret []byte, exception *errors.Exception) *Event {
+ return &Event{
+ Header: &Header{
+ TxType: tx.Type(),
+ TxHash: tx.Hash(),
+ EventType: eventType,
+ EventID: eventID,
+ Height: height,
+ },
+ Tx: &EventDataTx{
+ Tx: tx,
+ Return: ret,
+ Exception: exception,
+ },
+ }
+}
+
+// Tags
+
+var txTagKeys = []string{event.ExceptionKey}
+
+func (tx *EventDataTx) Get(key string) (string, bool) {
+ var value interface{}
+ switch key {
+ case event.ExceptionKey:
+ value = tx.Exception
+ default:
+ return "", false
+ }
+ return query.StringFromValue(value), true
+}
+
+func (tx *EventDataTx) Len() int {
+ return len(txTagKeys)
+}
+
+func (tx *EventDataTx) Keys() []string {
+ return txTagKeys
+}
diff --git a/execution/events/type.go b/execution/events/type.go
new file mode 100644
index 0000000000000000000000000000000000000000..8fe49f60df52439f06d14a9b12473601a9133119
--- /dev/null
+++ b/execution/events/type.go
@@ -0,0 +1,47 @@
+package events
+
+type Type int8
+
+// Execution event types
+const (
+ TypeCall = Type(0x00)
+ TypeLog = Type(0x01)
+ TypeAccountInput = Type(0x02)
+ TypeAccountOutput = Type(0x03)
+)
+
+var nameFromType = map[Type]string{
+ TypeCall: "CallEvent",
+ TypeLog: "LogEvent",
+ TypeAccountInput: "AccountInputEvent",
+ TypeAccountOutput: "AccountOutputEvent",
+}
+
+var typeFromName = make(map[string]Type)
+
+func init() {
+ for t, n := range nameFromType {
+ typeFromName[n] = t
+ }
+}
+
+func EventTypeFromString(name string) Type {
+ return typeFromName[name]
+}
+
+func (typ Type) String() string {
+ name, ok := nameFromType[typ]
+ if ok {
+ return name
+ }
+ return "UnknownTx"
+}
+
+func (typ Type) MarshalText() ([]byte, error) {
+ return []byte(typ.String()), nil
+}
+
+func (typ *Type) UnmarshalText(data []byte) error {
+ *typ = EventTypeFromString(string(data))
+ return nil
+}
diff --git a/execution/evm/fake_app_state.go b/execution/evm/fake_app_state.go
index b618a48ad5b8a8885c032d6ec7ec6ea5c87c65f1..8b1bd9ac473eedcee79134b1a33a10016bc7de09 100644
--- a/execution/evm/fake_app_state.go
+++ b/execution/evm/fake_app_state.go
@@ -30,7 +30,7 @@ type FakeAppState struct {
storage map[string]Word256
}
-var _ state.Writer = &FakeAppState{}
+var _ state.ReaderWriter = &FakeAppState{}
func (fas *FakeAppState) GetAccount(addr crypto.Address) (acm.Account, error) {
account := fas.accounts[addr]
diff --git a/execution/evm/log_event_test.go b/execution/evm/log_event_test.go
index 500a97e7a9335a7c9bc7fc4137c7b8c9e41b7119..7789c3b96824859001cd3d5573b0fd209ff6364e 100644
--- a/execution/evm/log_event_test.go
+++ b/execution/evm/log_event_test.go
@@ -26,8 +26,8 @@ import (
. "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/events"
. "github.com/hyperledger/burrow/execution/evm/asm"
- "github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/logging"
"github.com/stretchr/testify/require"
)
@@ -42,7 +42,6 @@ var expectedTopics = []Word256{
// Tests logs and events.
func TestLog4(t *testing.T) {
-
st := newAppState()
cache := state.NewCache(st)
// Create accounts
diff --git a/execution/evm/native.go b/execution/evm/native.go
index 4a7c7e615141faf3dd92b50fe4ec095d6a8cbdb4..c4577ea901995f82eeb8a5577825c70ad5cb18ec 100644
--- a/execution/evm/native.go
+++ b/execution/evm/native.go
@@ -56,7 +56,7 @@ func registerNativeContracts() {
//-----------------------------------------------------------------------------
-func ExecuteNativeContract(address Word256, state state.Writer, caller acm.Account, input []byte, gas *uint64,
+func ExecuteNativeContract(address Word256, state state.ReaderWriter, caller acm.Account, input []byte, gas *uint64,
logger *logging.Logger) ([]byte, errors.CodedError) {
contract, ok := registeredNativeContracts[address]
@@ -71,7 +71,7 @@ func ExecuteNativeContract(address Word256, state state.Writer, caller acm.Accou
return output, nil
}
-type NativeContract func(state state.Writer, caller acm.Account, input []byte, gas *uint64,
+type NativeContract func(state state.ReaderWriter, caller acm.Account, input []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error)
/* Removed due to C dependency
@@ -98,7 +98,7 @@ OH NO STOCASTIC CAT CODING!!!!
}
*/
-func sha256Func(state state.Writer, caller acm.Account, input []byte, gas *uint64,
+func sha256Func(state state.ReaderWriter, caller acm.Account, input []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
// Deduct gas
gasRequired := uint64((len(input)+31)/32)*GasSha256Word + GasSha256Base
@@ -114,7 +114,7 @@ func sha256Func(state state.Writer, caller acm.Account, input []byte, gas *uint6
return hasher.Sum(nil), nil
}
-func ripemd160Func(state state.Writer, caller acm.Account, input []byte, gas *uint64,
+func ripemd160Func(state state.ReaderWriter, caller acm.Account, input []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
// Deduct gas
gasRequired := uint64((len(input)+31)/32)*GasRipemd160Word + GasRipemd160Base
@@ -130,7 +130,7 @@ func ripemd160Func(state state.Writer, caller acm.Account, input []byte, gas *ui
return LeftPadBytes(hasher.Sum(nil), 32), nil
}
-func identityFunc(state state.Writer, caller acm.Account, input []byte, gas *uint64,
+func identityFunc(state state.ReaderWriter, caller acm.Account, input []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
// Deduct gas
gasRequired := uint64((len(input)+31)/32)*GasIdentityWord + GasIdentityBase
diff --git a/execution/evm/snative.go b/execution/evm/snative.go
index 7f9c25e57ff60891305b15c58edd02fcb827aed1..234cfb1a547b18c4882a3df4c7f748daf6de77a9 100644
--- a/execution/evm/snative.go
+++ b/execution/evm/snative.go
@@ -230,7 +230,7 @@ func NewSNativeContract(comment, name string,
// This function is designed to be called from the EVM once a SNative contract
// has been selected. It is also placed in a registry by registerSNativeContracts
// So it can be looked up by SNative address
-func (contract *SNativeContractDescription) Dispatch(state state.Writer, caller acm.Account,
+func (contract *SNativeContractDescription) Dispatch(state state.ReaderWriter, caller acm.Account,
args []byte, gas *uint64, logger *logging.Logger) (output []byte, err error) {
logger = logger.With(structure.ScopeKey, "Dispatch", "contract_name", contract.Name)
@@ -343,7 +343,7 @@ func abiReturn(name string, abiTypeName abi.TypeName) abi.Return {
// Permission function defintions
// TODO: catch errors, log em, return 0s to the vm (should some errors cause exceptions though?)
-func hasBase(state state.Writer, caller acm.Account, args []byte, gas *uint64,
+func hasBase(state state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
addrWord256, permNum := returnTwoArgs(args)
@@ -369,7 +369,7 @@ func hasBase(state state.Writer, caller acm.Account, args []byte, gas *uint64,
return LeftPadWord256([]byte{permInt}).Bytes(), nil
}
-func setBase(stateWriter state.Writer, caller acm.Account, args []byte, gas *uint64,
+func setBase(stateWriter state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
addrWord256, permNum, permVal := returnThreeArgs(args)
@@ -396,7 +396,7 @@ func setBase(stateWriter state.Writer, caller acm.Account, args []byte, gas *uin
return effectivePermBytes(acc.Permissions().Base, globalPerms(stateWriter)), nil
}
-func unsetBase(stateWriter state.Writer, caller acm.Account, args []byte, gas *uint64,
+func unsetBase(stateWriter state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
addrWord256, permNum := returnTwoArgs(args)
@@ -423,7 +423,7 @@ func unsetBase(stateWriter state.Writer, caller acm.Account, args []byte, gas *u
return effectivePermBytes(acc.Permissions().Base, globalPerms(stateWriter)), nil
}
-func setGlobal(stateWriter state.Writer, caller acm.Account, args []byte, gas *uint64,
+func setGlobal(stateWriter state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
permNum, permVal := returnTwoArgs(args)
@@ -449,7 +449,7 @@ func setGlobal(stateWriter state.Writer, caller acm.Account, args []byte, gas *u
return permBytes(acc.Permissions().Base.ResultantPerms()), nil
}
-func hasRole(state state.Writer, caller acm.Account, args []byte, gas *uint64,
+func hasRole(state state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
addrWord256, role := returnTwoArgs(args)
@@ -470,7 +470,7 @@ func hasRole(state state.Writer, caller acm.Account, args []byte, gas *uint64,
return LeftPadWord256([]byte{permInt}).Bytes(), nil
}
-func addRole(stateWriter state.Writer, caller acm.Account, args []byte, gas *uint64,
+func addRole(stateWriter state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
addrWord256, role := returnTwoArgs(args)
@@ -492,7 +492,7 @@ func addRole(stateWriter state.Writer, caller acm.Account, args []byte, gas *uin
return LeftPadWord256([]byte{permInt}).Bytes(), nil
}
-func removeRole(stateWriter state.Writer, caller acm.Account, args []byte, gas *uint64,
+func removeRole(stateWriter state.ReaderWriter, caller acm.Account, args []byte, gas *uint64,
logger *logging.Logger) (output []byte, err error) {
addrWord256, role := returnTwoArgs(args)
@@ -523,7 +523,7 @@ func ValidPermN(n ptypes.PermFlag) bool {
}
// Get the global BasePermissions
-func globalPerms(stateWriter state.Writer) ptypes.BasePermissions {
+func globalPerms(stateWriter state.ReaderWriter) ptypes.BasePermissions {
return state.GlobalAccountPermissions(stateWriter).Base
}
diff --git a/execution/evm/vm.go b/execution/evm/vm.go
index ec4eb07e1e02f96ec6116da7ff978b8474a02efc..dda39f001067077667307c895ba50cdd76cc4db1 100644
--- a/execution/evm/vm.go
+++ b/execution/evm/vm.go
@@ -27,11 +27,12 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution/errors"
+ "github.com/hyperledger/burrow/execution/events"
. "github.com/hyperledger/burrow/execution/evm/asm"
- "github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/execution/evm/sha3"
"github.com/hyperledger/burrow/logging"
ptypes "github.com/hyperledger/burrow/permission/types"
+ "github.com/hyperledger/burrow/txs"
)
const (
@@ -50,8 +51,8 @@ type VM struct {
memoryProvider func() Memory
params Params
origin crypto.Address
- txHash []byte
- stackDepth int
+ tx *txs.Tx
+ stackDepth uint64
nestedCallErrors []errors.NestedCall
publisher event.Publisher
logger *logging.Logger
@@ -60,14 +61,13 @@ type VM struct {
dumpTokens bool
}
-func NewVM(params Params, origin crypto.Address, txid []byte,
- logger *logging.Logger, options ...func(*VM)) *VM {
+func NewVM(params Params, origin crypto.Address, tx *txs.Tx, logger *logging.Logger, options ...func(*VM)) *VM {
vm := &VM{
memoryProvider: DefaultDynamicMemoryProvider,
params: params,
origin: origin,
stackDepth: 0,
- txHash: txid,
+ tx: tx,
logger: logger.WithScope("NewVM"),
}
for _, option := range options {
@@ -93,7 +93,7 @@ func (vm *VM) SetPublisher(publisher event.Publisher) {
// on known permissions and panics else)
// If the perm is not defined in the acc nor set by default in GlobalPermissions,
// this function returns false.
-func HasPermission(stateWriter state.Writer, acc acm.Account, perm ptypes.PermFlag) bool {
+func HasPermission(stateWriter state.ReaderWriter, acc acm.Account, perm ptypes.PermFlag) bool {
value, _ := acc.Permissions().Base.Compose(state.GlobalAccountPermissions(stateWriter).Base).Get(perm)
return value
}
@@ -101,7 +101,7 @@ func HasPermission(stateWriter state.Writer, acc acm.Account, perm ptypes.PermFl
func (vm *VM) fireCallEvent(exception *errors.CodedError, output *[]byte, callerAddress, calleeAddress crypto.Address, input []byte, value uint64, gas *uint64) {
// fire the post call event (including exception if applicable)
if vm.publisher != nil {
- events.PublishAccountCall(vm.publisher, calleeAddress,
+ events.PublishAccountCall(vm.publisher, vm.tx, vm.params.BlockHeight,
&events.EventDataCall{
CallData: &events.CallData{
Caller: callerAddress,
@@ -111,7 +111,6 @@ func (vm *VM) fireCallEvent(exception *errors.CodedError, output *[]byte, caller
Gas: *gas,
},
Origin: vm.origin,
- TxHash: vm.txHash,
StackDepth: vm.stackDepth,
Return: *output,
Exception: errors.AsCodedError(*exception),
@@ -125,7 +124,7 @@ func (vm *VM) fireCallEvent(exception *errors.CodedError, output *[]byte, caller
// value: To be transferred from caller to callee. Refunded upon errors.CodedError.
// gas: Available gas. No refunds for gas.
// code: May be nil, since the CALL opcode may be used to send value from contracts to accounts
-func (vm *VM) Call(callState state.Cache, caller, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
+func (vm *VM) Call(callState *state.Cache, caller, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
exception := new(errors.CodedError)
// fire the post call event (including exception if applicable)
@@ -169,7 +168,7 @@ func (vm *VM) Call(callState state.Cache, caller, callee acm.MutableAccount, cod
// The intent of delegate call is to run the code of the callee in the storage context of the caller;
// while preserving the original caller to the previous callee.
// Different to the normal CALL or CALLCODE, the value does not need to be transferred to the callee.
-func (vm *VM) DelegateCall(callState state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
+func (vm *VM) DelegateCall(callState *state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
exception := new(string)
// fire the post call event (including exception if applicable)
@@ -209,14 +208,14 @@ func useGasNegative(gasLeft *uint64, gasToUse uint64, err *errors.CodedError) bo
}
// Just like Call() but does not transfer 'value' or modify the callDepth.
-func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
+func (vm *VM) call(callState *state.Cache, caller acm.Account, callee acm.MutableAccount, code, input []byte, value uint64, gas *uint64) (output []byte, err errors.CodedError) {
vm.Debugf("(%d) (%X) %X (code=%d) gas: %v (d) %X\n", vm.stackDepth, caller.Address().Bytes()[:4], callee.Address(),
len(callee.Code()), *gas, input)
- logger := vm.logger.With("tx_hash", vm.txHash)
+ logger := vm.logger.With("tx_hash", vm.tx.Hash())
if vm.dumpTokens {
- dumpTokens(vm.txHash, caller, callee, code)
+ dumpTokens(vm.tx.Hash(), caller, callee, code)
}
var (
@@ -840,12 +839,16 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
return nil, firstErr(err, errors.ErrorCodeMemoryOutOfBounds)
}
if vm.publisher != nil {
- events.PublishLogEvent(vm.publisher, callee.Address(), &events.EventDataLog{
+ publishErr := events.PublishLogEvent(vm.publisher, vm.tx, &events.EventDataLog{
+ Height: vm.params.BlockHeight,
Address: callee.Address(),
Topics: topics,
Data: data,
- Height: vm.params.BlockHeight,
})
+ if publishErr != nil {
+ vm.Debugf(" => Log event publish err: %s", publishErr)
+ return nil, firstErr(err, errors.ErrorCodeEventPublish)
+ }
}
vm.Debugf(" => T:%X D:%X\n", topics, data)
@@ -1108,7 +1111,7 @@ func (vm *VM) call(callState state.Cache, caller acm.Account, callee acm.Mutable
}
}
-func (vm *VM) createAccount(callState state.Cache, callee acm.MutableAccount, logger *logging.Logger) (acm.MutableAccount, errors.CodedError) {
+func (vm *VM) createAccount(callState *state.Cache, callee acm.MutableAccount, logger *logging.Logger) (acm.MutableAccount, errors.CodedError) {
newAccount := DeriveNewAccount(callee, state.GlobalAccountPermissions(callState), logger)
err := callState.UpdateAccount(newAccount)
if err != nil {
diff --git a/execution/evm/vm_test.go b/execution/evm/vm_test.go
index b7752b66c324ece4cc1d0f97d4f497934084e3cb..62d1ca3b816631af52709aa0eb0ea6f5eefec4db 100644
--- a/execution/evm/vm_test.go
+++ b/execution/evm/vm_test.go
@@ -28,9 +28,9 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution/errors"
+ "github.com/hyperledger/burrow/execution/events"
. "github.com/hyperledger/burrow/execution/evm/asm"
. "github.com/hyperledger/burrow/execution/evm/asm/bc"
- evm_events "github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/permission"
ptypes "github.com/hyperledger/burrow/permission/types"
@@ -1012,9 +1012,9 @@ func makeAccountWithCode(accountUpdater state.AccountUpdater, name string,
// and then waits for any exceptions transmitted by Data in the AccCall
// event (in the case of no direct error from call we will block waiting for
// at least 1 AccCall event)
-func runVMWaitError(vmCache state.Cache, ourVm *VM, caller, callee acm.MutableAccount, subscribeAddr crypto.Address,
+func runVMWaitError(vmCache *state.Cache, ourVm *VM, caller, callee acm.MutableAccount, subscribeAddr crypto.Address,
contractCode []byte, gas uint64) ([]byte, error) {
- eventCh := make(chan *evm_events.EventDataCall)
+ eventCh := make(chan *events.EventDataCall)
output, err := runVM(eventCh, vmCache, ourVm, caller, callee, subscribeAddr, contractCode, gas)
if err != nil {
return output, err
@@ -1030,25 +1030,25 @@ func runVMWaitError(vmCache state.Cache, ourVm *VM, caller, callee acm.MutableAc
// Subscribes to an AccCall, runs the vm, returns the output and any direct
// exception
-func runVM(eventCh chan<- *evm_events.EventDataCall, vmCache state.Cache, ourVm *VM, caller, callee acm.MutableAccount,
+func runVM(eventCh chan<- *events.EventDataCall, vmCache *state.Cache, ourVm *VM, caller, callee acm.MutableAccount,
subscribeAddr crypto.Address, contractCode []byte, gas uint64) ([]byte, error) {
// we need to catch the event from the CALL to check for exceptions
- emitter := event.NewEmitter(logging.NewNoopLogger())
+ em := event.NewEmitter(logging.NewNoopLogger())
fmt.Printf("subscribe to %s\n", subscribeAddr)
- err := evm_events.SubscribeAccountCall(context.Background(), emitter, "test", subscribeAddr,
+ err := events.SubscribeAccountCall(context.Background(), em, "test", subscribeAddr,
nil, -1, eventCh)
if err != nil {
return nil, err
}
- evc := event.NewEventCache(emitter)
+ evc := event.NewCache()
ourVm.SetPublisher(evc)
start := time.Now()
output, err := ourVm.Call(vmCache, caller, callee, contractCode, []byte{}, 0, &gas)
fmt.Printf("Output: %v Error: %v\n", output, err)
fmt.Println("Call took:", time.Since(start))
- evc.Flush()
+ evc.Flush(em)
return output, err
}
diff --git a/execution/execution.go b/execution/execution.go
index 74e6ce5fc1a97eb9ae198bbf665dab18d96357ce..22eff6e9b33dc219c5ddbd90e267533a2bd2dcf8 100644
--- a/execution/execution.go
+++ b/execution/execution.go
@@ -38,6 +38,12 @@ type Executor interface {
Execute(txEnv *txs.Envelope) error
}
+type ExecutorState interface {
+ Update(updater func(ws Updatable) error) (hash []byte, err error)
+ names.Reader
+ state.IterableReader
+}
+
type BatchExecutor interface {
// Provides access to write lock for a BatchExecutor so reads can be prevented for the duration of a commit
sync.Locker
@@ -59,8 +65,9 @@ type BatchCommitter interface {
type executor struct {
sync.RWMutex
runCall bool
- state *State
- stateCache state.Cache
+ publisher event.Publisher
+ state ExecutorState
+ stateCache *state.Cache
nameRegCache *names.Cache
eventCache *event.Cache
logger *logging.Logger
@@ -71,28 +78,29 @@ type executor struct {
var _ BatchExecutor = (*executor)(nil)
// Wraps a cache of what is variously known as the 'check cache' and 'mempool'
-func NewBatchChecker(backend *State, tip *bcm.Tip, logger *logging.Logger,
+func NewBatchChecker(backend ExecutorState, tip bcm.TipInfo, logger *logging.Logger,
options ...ExecutionOption) BatchExecutor {
return newExecutor("CheckCache", false, backend, tip, event.NewNoOpPublisher(),
logger.WithScope("NewBatchExecutor"), options...)
}
-func NewBatchCommitter(backend *State, tip *bcm.Tip, publisher event.Publisher, logger *logging.Logger,
+func NewBatchCommitter(backend ExecutorState, tip bcm.TipInfo, publisher event.Publisher, logger *logging.Logger,
options ...ExecutionOption) BatchCommitter {
return newExecutor("CommitCache", true, backend, tip, publisher,
logger.WithScope("NewBatchCommitter"), options...)
}
-func newExecutor(name string, runCall bool, backend *State, tip *bcm.Tip, publisher event.Publisher,
+func newExecutor(name string, runCall bool, backend ExecutorState, tip bcm.TipInfo, publisher event.Publisher,
logger *logging.Logger, options ...ExecutionOption) *executor {
exe := &executor{
runCall: runCall,
state: backend,
+ publisher: publisher,
stateCache: state.NewCache(backend, state.Name(name)),
- eventCache: event.NewEventCache(publisher),
+ eventCache: event.NewCache(),
nameRegCache: names.NewCache(backend),
logger: logger.With(structure.ComponentKey, "Executor"),
}
@@ -101,26 +109,28 @@ func newExecutor(name string, runCall bool, backend *State, tip *bcm.Tip, publis
}
exe.txExecutors = map[payload.Type]Executor{
payload.TypeSend: &executors.SendContext{
+ Tip: tip,
StateWriter: exe.stateCache,
EventPublisher: exe.eventCache,
Logger: exe.logger,
},
payload.TypeCall: &executors.CallContext{
+ Tip: tip,
StateWriter: exe.stateCache,
EventPublisher: exe.eventCache,
- Tip: tip,
RunCall: runCall,
VMOptions: exe.vmOptions,
Logger: exe.logger,
},
payload.TypeName: &executors.NameContext{
+ Tip: tip,
StateWriter: exe.stateCache,
EventPublisher: exe.eventCache,
NameReg: exe.nameRegCache,
- Tip: tip,
Logger: exe.logger,
},
payload.TypePermissions: &executors.PermissionsContext{
+ Tip: tip,
StateWriter: exe.stateCache,
EventPublisher: exe.eventCache,
Logger: exe.logger,
@@ -157,6 +167,44 @@ func (exe *executor) Execute(txEnv *txs.Envelope) (err error) {
return fmt.Errorf("unknown transaction type: %v", txEnv.Tx.Type())
}
+func (exe *executor) Commit() (_ []byte, err error) {
+ // The write lock to the executor is controlled by the caller (e.g. abci.App) so we do not acquire it here to avoid
+ // deadlock
+ defer func() {
+ if r := recover(); r != nil {
+ err = fmt.Errorf("recovered from panic in executor.Commit(): %v\n%v", r, debug.Stack())
+ }
+ }()
+ return exe.state.Update(func(ws Updatable) error {
+ // flush the caches
+ err := exe.stateCache.Flush(ws, exe.state)
+ if err != nil {
+ return err
+ }
+ err = exe.nameRegCache.Flush(ws, exe.state)
+ if err != nil {
+ return err
+ }
+ err = exe.eventCache.Sync(ws)
+ if err != nil {
+ return err
+ }
+ // flush events to listeners
+ err = exe.eventCache.Flush(exe.publisher)
+ if err != nil {
+ return err
+ }
+ return nil
+ })
+}
+
+func (exe *executor) Reset() error {
+ // As with Commit() we do not take the write lock here
+ exe.stateCache.Reset(exe.state)
+ exe.nameRegCache.Reset(exe.state)
+ return nil
+}
+
// executor exposes access to the underlying state cache protected by a RWMutex that prevents access while locked
// (during an ABCI commit). while access can occur (and needs to continue for CheckTx/DeliverTx to make progress)
// through calls to Execute() external readers will be blocked until the executor is unlocked that allows the Transactor
@@ -175,37 +223,3 @@ func (exe *executor) GetStorage(address crypto.Address, key binary.Word256) (bin
defer exe.RUnlock()
return exe.stateCache.GetStorage(address, key)
}
-
-func (exe *executor) Commit() (hash []byte, err error) {
- // The write lock to the executor is controlled by the caller (e.g. abci.App) so we do not acquire it here to avoid
- // deadlock
- defer func() {
- if r := recover(); r != nil {
- err = fmt.Errorf("recovered from panic in executor.Commit(): %v\n%v", r, debug.Stack())
- }
- }()
- // flush the caches
- err = exe.stateCache.Flush(exe.state)
- if err != nil {
- return nil, err
- }
- err = exe.nameRegCache.Flush(exe.state)
- if err != nil {
- return nil, err
- }
- // save state to disk
- err = exe.state.Save()
- if err != nil {
- return nil, err
- }
- // flush events to listeners
- defer exe.eventCache.Flush()
- return exe.state.Hash(), nil
-}
-
-func (exe *executor) Reset() error {
- // As with Commit() we do not take the write lock here
- exe.stateCache.Reset(exe.state)
- exe.nameRegCache.Reset(exe.state)
- return nil
-}
diff --git a/execution/execution_test.go b/execution/execution_test.go
index 4a0116d42b18802f96f702c4ebcdd61ea6ea8862..74e5689ccf1f447032e88dd2b0eac57d09bc06c5 100644
--- a/execution/execution_test.go
+++ b/execution/execution_test.go
@@ -31,10 +31,10 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution/errors"
+ "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/execution/evm"
. "github.com/hyperledger/burrow/execution/evm/asm"
"github.com/hyperledger/burrow/execution/evm/asm/bc"
- evm_events "github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/execution/evm/sha3"
"github.com/hyperledger/burrow/execution/names"
"github.com/hyperledger/burrow/genesis"
@@ -124,6 +124,12 @@ var testGenesisDoc, testPrivAccounts, _ = deterministicGenesis.
GenesisDoc(3, true, 1000, 1, true, 1000)
var testChainID = testGenesisDoc.ChainID()
+type testExecutor struct {
+ *executor
+ blockchain *bcm.Blockchain
+ event.Emitter
+}
+
func makeUsers(n int) []acm.AddressableSigner {
users := make([]acm.AddressableSigner, n)
for i := 0; i < n; i++ {
@@ -139,10 +145,14 @@ func newBlockchain(genesisDoc *genesis.GenesisDoc) *bcm.Blockchain {
return bc
}
-func makeExecutor(state *State) (*executor, event.Emitter) {
+func makeExecutor(state *State) *testExecutor {
emitter := event.NewEmitter(logger)
- return newExecutor("makeExecutorCache", true, state,
- newBlockchain(testGenesisDoc).Tip, emitter, logger), emitter
+ blockchain := newBlockchain(testGenesisDoc)
+ return &testExecutor{
+ executor: newExecutor("makeExecutorCache", true, state, blockchain.Tip, emitter, logger),
+ blockchain: blockchain,
+ Emitter: emitter,
+ }
}
func newBaseGenDoc(globalPerm, accountPerm ptypes.AccountPermissions) genesis.GenesisDoc {
@@ -193,46 +203,46 @@ func TestSendFails(t *testing.T) {
genDoc.Accounts[3].Permissions.Base.Set(ptypes.CreateContract, true)
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, _ := makeExecutor(st)
+ exe := makeExecutor(st)
//-------------------
// send txs
// simple send tx should fail
tx := payload.NewSendTx()
- if err := tx.AddInput(batchCommitter.stateCache, users[0].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(exe.stateCache, users[0].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[1].Address(), 5)
- signAndExecute(t, true, batchCommitter, testChainID, tx, users[0])
+ signAndExecute(t, true, exe, testChainID, tx, users[0])
// simple send tx with call perm should fail
tx = payload.NewSendTx()
- if err := tx.AddInput(batchCommitter.stateCache, users[2].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(exe.stateCache, users[2].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[4].Address(), 5)
- signAndExecute(t, true, batchCommitter, testChainID, tx, users[2])
+ signAndExecute(t, true, exe, testChainID, tx, users[2])
// simple send tx with create perm should fail
tx = payload.NewSendTx()
- if err := tx.AddInput(batchCommitter.stateCache, users[3].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(exe.stateCache, users[3].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[4].Address(), 5)
- signAndExecute(t, true, batchCommitter, testChainID, tx, users[3])
+ signAndExecute(t, true, exe, testChainID, tx, users[3])
// simple send tx to unknown account without create_account perm should fail
- acc := getAccount(batchCommitter.stateCache, users[3].Address())
+ acc := getAccount(exe.stateCache, users[3].Address())
acc.MutablePermissions().Base.Set(ptypes.Send, true)
- batchCommitter.stateCache.UpdateAccount(acc)
+ exe.stateCache.UpdateAccount(acc)
tx = payload.NewSendTx()
- if err := tx.AddInput(batchCommitter.stateCache, users[3].PublicKey(), 5); err != nil {
+ if err := tx.AddInput(exe.stateCache, users[3].PublicKey(), 5); err != nil {
t.Fatal(err)
}
tx.AddOutput(users[6].Address(), 5)
- signAndExecute(t, true, batchCommitter, testChainID, tx, users[3])
+ signAndExecute(t, true, exe, testChainID, tx, users[3])
}
func TestName(t *testing.T) {
@@ -243,7 +253,7 @@ func TestName(t *testing.T) {
genDoc.Accounts[1].Permissions.Base.Set(ptypes.Name, true)
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, _ := makeExecutor(st)
+ batchCommitter := makeExecutor(st)
//-------------------
// name txs
@@ -272,7 +282,7 @@ func TestCallFails(t *testing.T) {
genDoc.Accounts[3].Permissions.Base.Set(ptypes.CreateContract, true)
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, _ := makeExecutor(st)
+ batchCommitter := makeExecutor(st)
//-------------------
// call txs
@@ -313,7 +323,7 @@ func TestSendPermission(t *testing.T) {
genDoc.Accounts[0].Permissions.Base.Set(ptypes.Send, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, _ := makeExecutor(st)
+ batchCommitter := makeExecutor(st)
// A single input, having the permission, should succeed
tx := payload.NewSendTx()
@@ -338,7 +348,7 @@ func TestCallPermission(t *testing.T) {
genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, emitter := makeExecutor(st)
+ exe := makeExecutor(st)
//------------------------------
// call to simple contract
@@ -354,11 +364,11 @@ func TestCallPermission(t *testing.T) {
StorageRoot: Zero256.Bytes(),
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- st.UpdateAccount(simpleAcc)
+ st.writeState.UpdateAccount(simpleAcc)
// A single input, having the permission, should succeed
- tx, _ := payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &simpleContractAddr, nil, 100, 100, 100)
- signAndExecute(t, false, batchCommitter, testChainID, tx, users[0])
+ tx, _ := payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &simpleContractAddr, nil, 100, 100, 100)
+ signAndExecute(t, false, exe, testChainID, tx, users[0])
//----------------------------------------------------------
// call to contract that calls simple contract - without perm
@@ -375,15 +385,15 @@ func TestCallPermission(t *testing.T) {
StorageRoot: Zero256.Bytes(),
Permissions: permission.ZeroAccountPermissions,
}.MutableAccount()
- batchCommitter.stateCache.UpdateAccount(caller1Acc)
+ exe.stateCache.UpdateAccount(caller1Acc)
// A single input, having the permission, but the contract doesn't have permission
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, caller1ContractAddr) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, caller1ContractAddr) //
require.Error(t, err)
//----------------------------------------------------------
@@ -392,13 +402,13 @@ func TestCallPermission(t *testing.T) {
// A single input, having the permission, and the contract has permission
caller1Acc.MutablePermissions().Base.Set(ptypes.Call, true)
- batchCommitter.stateCache.UpdateAccount(caller1Acc)
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
+ exe.stateCache.UpdateAccount(caller1Acc)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &caller1ContractAddr, nil, 100, 10000, 100)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, caller1ContractAddr) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, caller1ContractAddr) //
require.NoError(t, err)
//----------------------------------------------------------
@@ -419,14 +429,14 @@ func TestCallPermission(t *testing.T) {
}.MutableAccount()
caller1Acc.MutablePermissions().Base.Set(ptypes.Call, false)
caller2Acc.MutablePermissions().Base.Set(ptypes.Call, true)
- batchCommitter.stateCache.UpdateAccount(caller1Acc)
- batchCommitter.stateCache.UpdateAccount(caller2Acc)
+ exe.stateCache.UpdateAccount(caller1Acc)
+ exe.stateCache.UpdateAccount(caller2Acc)
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, caller1ContractAddr) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, caller1ContractAddr) //
require.Error(t, err)
//----------------------------------------------------------
@@ -436,14 +446,14 @@ func TestCallPermission(t *testing.T) {
fmt.Println("\n##### CALL TO CONTRACT CALLING SIMPLE CONTRACT (PASS)")
caller1Acc.MutablePermissions().Base.Set(ptypes.Call, true)
- batchCommitter.stateCache.UpdateAccount(caller1Acc)
+ exe.stateCache.UpdateAccount(caller1Acc)
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &caller2ContractAddr, nil, 100, 10000, 100)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, caller1ContractAddr) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, caller1ContractAddr) //
require.NoError(t, err)
}
@@ -455,7 +465,7 @@ func TestCreatePermission(t *testing.T) {
genDoc.Accounts[0].Permissions.Base.Set(ptypes.Call, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, emitter := makeExecutor(st)
+ exe := makeExecutor(st)
//------------------------------
// create a simple contract
@@ -465,12 +475,12 @@ func TestCreatePermission(t *testing.T) {
createCode := wrapContractForCreate(contractCode)
// A single input, having the permission, should succeed
- tx, _ := payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), nil, createCode, 100, 100, 100)
- signAndExecute(t, false, batchCommitter, testChainID, tx, users[0])
+ tx, _ := payload.NewCallTx(exe.stateCache, users[0].PublicKey(), nil, createCode, 100, 100, 100)
+ signAndExecute(t, false, exe, testChainID, tx, users[0])
// ensure the contract is there
contractAddr := crypto.NewContractAddress(tx.Input.Address, tx.Input.Sequence)
- contractAcc := getAccount(batchCommitter.stateCache, contractAddr)
+ contractAcc := getAccount(exe.stateCache, contractAddr)
if contractAcc == nil {
t.Fatalf("failed to create contract %s", contractAddr)
}
@@ -488,12 +498,12 @@ func TestCreatePermission(t *testing.T) {
createFactoryCode := wrapContractForCreate(factoryCode)
// A single input, having the permission, should succeed
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), nil, createFactoryCode, 100, 100, 100)
- signAndExecute(t, false, batchCommitter, testChainID, tx, users[0])
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), nil, createFactoryCode, 100, 100, 100)
+ signAndExecute(t, false, exe, testChainID, tx, users[0])
// ensure the contract is there
contractAddr = crypto.NewContractAddress(tx.Input.Address, tx.Input.Sequence)
- contractAcc = getAccount(batchCommitter.stateCache, contractAddr)
+ contractAcc = getAccount(exe.stateCache, contractAddr)
if contractAcc == nil {
t.Fatalf("failed to create contract %s", contractAddr)
}
@@ -506,11 +516,11 @@ func TestCreatePermission(t *testing.T) {
fmt.Println("\n###### CALL THE FACTORY (FAIL)")
// A single input, having the permission, should succeed
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, contractAddr) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, contractAddr) //
require.Error(t, err)
//------------------------------
@@ -518,14 +528,14 @@ func TestCreatePermission(t *testing.T) {
fmt.Println("\n###### CALL THE FACTORY (PASS)")
contractAcc.MutablePermissions().Base.Set(ptypes.CreateContract, true)
- batchCommitter.stateCache.UpdateAccount(contractAcc)
+ exe.stateCache.UpdateAccount(contractAcc)
// A single input, having the permission, should succeed
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 100, 100)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, contractAddr) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, contractAddr) //
require.NoError(t, err)
//--------------------------------
@@ -543,16 +553,16 @@ func TestCreatePermission(t *testing.T) {
}.MutableAccount()
contractAcc.MutablePermissions().Base.Set(ptypes.Call, true)
contractAcc.MutablePermissions().Base.Set(ptypes.CreateContract, true)
- batchCommitter.stateCache.UpdateAccount(contractAcc)
+ exe.stateCache.UpdateAccount(contractAcc)
// this should call the 0 address but not create ...
- tx, _ = payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 10000, 100)
+ tx, _ = payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &contractAddr, createCode, 100, 10000, 100)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, crypto.Address{}) //
+ _, err = execTxWaitAccountCall(t, exe, txEnv, crypto.Address{}) //
require.NoError(t, err)
- zeroAcc := getAccount(batchCommitter.stateCache, crypto.Address{})
+ zeroAcc := getAccount(exe.stateCache, crypto.Address{})
if len(zeroAcc.Code()) != 0 {
t.Fatal("the zero account was given code from a CALL!")
}
@@ -567,7 +577,7 @@ func TestCreateAccountPermission(t *testing.T) {
genDoc.Accounts[0].Permissions.Base.Set(ptypes.CreateAccount, true) // give the 0 account permission
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, emitter := makeExecutor(st)
+ batchCommitter := makeExecutor(st)
//----------------------------------------------------------
// SendTx to unknown account
@@ -656,7 +666,7 @@ func TestCreateAccountPermission(t *testing.T) {
txCallEnv.Sign(users[0])
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txCallEnv, caller1ContractAddr) //
+ _, err = execTxWaitAccountCall(t, batchCommitter, txCallEnv, caller1ContractAddr) //
require.Error(t, err)
// NOTE: for a contract to be able to CreateAccount, it must be able to call
@@ -670,7 +680,7 @@ func TestCreateAccountPermission(t *testing.T) {
txCallEnv.Sign(users[0])
// we need to subscribe to the Call event to detect the exception
- _, err = execTxWaitAccountCall(t, batchCommitter, emitter, txCallEnv, caller1ContractAddr) //
+ _, err = execTxWaitAccountCall(t, batchCommitter, txCallEnv, caller1ContractAddr) //
require.NoError(t, err)
}
@@ -692,7 +702,7 @@ func TestSNativeCALL(t *testing.T) {
genDoc.Accounts[3].Permissions.AddRole("bee")
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, emitter := makeExecutor(st)
+ exe := makeExecutor(st)
//----------------------------------------------------------
// Test CALL to SNative contracts
@@ -709,13 +719,13 @@ func TestSNativeCALL(t *testing.T) {
doug.MutablePermissions().Base.Set(ptypes.Call, true)
//doug.Permissions.Base.Set(permission.HasBase, true)
- batchCommitter.stateCache.UpdateAccount(doug)
+ exe.stateCache.UpdateAccount(doug)
fmt.Println("\n#### HasBase")
// HasBase
snativeAddress, pF, data := snativePermTestInputCALL("hasBase", users[3], ptypes.Bond, false)
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
@@ -726,10 +736,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### SetBase")
// SetBase
snativeAddress, pF, data = snativePermTestInputCALL("setBase", users[3], ptypes.Bond, false)
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.Bond, false)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
@@ -737,9 +747,9 @@ func TestSNativeCALL(t *testing.T) {
return nil
})
snativeAddress, pF, data = snativePermTestInputCALL("setBase", users[3], ptypes.CreateContract, true)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.CreateContract, false)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
@@ -750,10 +760,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### UnsetBase")
// UnsetBase
snativeAddress, pF, data = snativePermTestInputCALL("unsetBase", users[3], ptypes.CreateContract, false)
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.CreateContract, false)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
@@ -763,10 +773,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### SetGlobal")
// SetGlobalPerm
snativeAddress, pF, data = snativePermTestInputCALL("setGlobal", users[3], ptypes.CreateContract, true)
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, pF, data = snativePermTestInputCALL("hasBase", users[3], ptypes.CreateContract, false)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
// return value should be true or false as a 32 byte array...
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
@@ -777,8 +787,8 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### HasRole")
// HasRole
snativeAddress, pF, data = snativeRoleTestInputCALL("hasRole", users[3], "bumble")
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
@@ -788,17 +798,17 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### AddRole")
// AddRole
snativeAddress, pF, data = snativeRoleTestInputCALL("hasRole", users[3], "chuck")
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
return nil
})
snativeAddress, pF, data = snativeRoleTestInputCALL("addRole", users[3], "chuck")
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, pF, data = snativeRoleTestInputCALL("hasRole", users[3], "chuck")
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret[:31]) || ret[31] != byte(1) {
return fmt.Errorf("Expected 1. Got %X", ret)
}
@@ -808,10 +818,10 @@ func TestSNativeCALL(t *testing.T) {
fmt.Println("\n#### RemoveRole")
// RemoveRole
snativeAddress, pF, data = snativeRoleTestInputCALL("removeRole", users[3], "chuck")
- testSNativeCALLExpectFail(t, batchCommitter, emitter, doug, snativeAddress, data)
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
+ testSNativeCALLExpectFail(t, exe, doug, snativeAddress, data)
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error { return nil })
snativeAddress, pF, data = snativeRoleTestInputCALL("hasRole", users[3], "chuck")
- testSNativeCALLExpectPass(t, batchCommitter, emitter, doug, pF, snativeAddress, data, func(ret []byte) error {
+ testSNativeCALLExpectPass(t, exe, doug, pF, snativeAddress, data, func(ret []byte) error {
if !IsZeros(ret) {
return fmt.Errorf("Expected 0. Got %X", ret)
}
@@ -829,7 +839,7 @@ func TestSNativeTx(t *testing.T) {
genDoc.Accounts[3].Permissions.AddRole("bee")
st, err := MakeGenesisState(stateDB, &genDoc)
require.NoError(t, err)
- batchCommitter, _ := makeExecutor(st)
+ batchCommitter := makeExecutor(st)
//----------------------------------------------------------
// Test SNativeTx
@@ -906,8 +916,9 @@ func TestTxSequence(t *testing.T) {
tx.AddOutput(acc1.Address(), 1)
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(privAccounts[0]))
- stateCopy := state.Copy(dbm.NewMemDB())
- err := execTxWithState(stateCopy, txEnv)
+ stateCopy, err := state.Copy(dbm.NewMemDB())
+ require.NoError(t, err)
+ err = execTxWithState(stateCopy, txEnv)
if i == 1 {
// Sequence is good.
if err != nil {
@@ -935,9 +946,9 @@ func TestTxSequence(t *testing.T) {
}
func TestNameTxs(t *testing.T) {
- state, err := MakeGenesisState(dbm.NewMemDB(), testGenesisDoc)
+ st, err := MakeGenesisState(dbm.NewMemDB(), testGenesisDoc)
require.NoError(t, err)
- state.Save()
+ st.writeState.save()
names.MinNameRegistrationPeriod = 5
blockchain := newBlockchain(testGenesisDoc)
@@ -952,11 +963,11 @@ func TestNameTxs(t *testing.T) {
for _, name := range nameStrings {
amt := fee + numDesiredBlocks*names.NameByteCostMultiplier*names.NameBlockCostMultiplier*
names.NameBaseCost(name, data)
- tx, _ := payload.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx, _ := payload.NewNameTx(st, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
txEnv := txs.Enclose(testChainID, tx)
txEnv.Sign(testPrivAccounts[0])
- if err := execTxWithState(state, txEnv); err == nil {
+ if err := execTxWithState(st, txEnv); err == nil {
t.Fatalf("Expected invalid name error from %s", name)
}
}
@@ -967,17 +978,16 @@ func TestNameTxs(t *testing.T) {
for _, data := range datas {
amt := fee + numDesiredBlocks*names.NameByteCostMultiplier*names.NameBlockCostMultiplier*
names.NameBaseCost(name, data)
- tx, _ := payload.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx, _ := payload.NewNameTx(st, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
txEnv := txs.Enclose(testChainID, tx)
txEnv.Sign(testPrivAccounts[0])
- if err := execTxWithState(state, txEnv); err == nil {
+ if err := execTxWithState(st, txEnv); err == nil {
t.Fatalf("Expected invalid data error from %s", data)
}
}
validateEntry := func(t *testing.T, entry *names.Entry, name, data string, addr crypto.Address, expires uint64) {
-
if entry == nil {
t.Fatalf("Could not find name %s", name)
}
@@ -991,7 +1001,7 @@ func TestNameTxs(t *testing.T) {
t.Fatalf("Wrong name. Got %s expected %s", entry.Name, name)
}
if expires != entry.Expires {
- t.Fatalf("Wrong expiry. Got %d, expected %d", entry.Expires, expires)
+ t.Fatalf("Wrong expiry. Got %d, expected %d: %s", entry.Expires, expires, debug.Stack())
}
}
@@ -999,96 +1009,97 @@ func TestNameTxs(t *testing.T) {
name = "@looking_good/karaoke_bar.broadband"
data = "on this side of neptune there are 1234567890 people: first is OMNIVORE+-3. Or is it. Ok this is pretty restrictive. No exclamations :(. Faces tho :')"
amt := fee + numDesiredBlocks*names.NameByteCostMultiplier*names.NameBlockCostMultiplier*names.NameBaseCost(name, data)
- tx, _ := payload.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx, _ := payload.NewNameTx(st, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[0]))
- if err := execTxWithState(state, txEnv); err != nil {
+ if err := execTxWithState(st, txEnv); err != nil {
t.Fatal(err)
}
- entry, err := state.GetNameEntry(name)
+ entry, err := st.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks)
// fail to update it as non-owner, in same block
- tx, _ = payload.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[1]))
- if err := execTxWithState(state, txEnv); err == nil {
+ if err := execTxWithState(st, txEnv); err == nil {
t.Fatal("Expected error")
}
// update it as owner, just to increase expiry, in same block
// NOTE: we have to resend the data or it will clear it (is this what we want?)
- tx, _ = payload.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[0]))
- if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
+ if err := execTxWithStateNewBlock(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*2)
// update it as owner, just to increase expiry, in next block
- tx, _ = payload.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[0]))
- if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
+ if err := execTxWithStateNewBlock(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks*3)
// fail to update it as non-owner
// Fast forward
for blockchain.Tip.LastBlockHeight() < entry.Expires-1 {
- commitNewBlock(state, blockchain)
+ commitNewBlock(st, blockchain)
}
- tx, _ = payload.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[1]))
- if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err == nil {
+ if err := execTxWithStateAndBlockchain(st, blockchain, txEnv); err == nil {
t.Fatal("Expected error")
}
- commitNewBlock(state, blockchain)
+ commitNewBlock(st, blockchain)
// once expires, non-owner succeeds
- tx, _ = payload.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ startingBlock = blockchain.LastBlockHeight()
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[1]))
- if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
+ if err := execTxWithStateAndBlockchain(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
- validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
+ validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), startingBlock+numDesiredBlocks)
// update it as new owner, with new data (longer), but keep the expiry!
data = "In the beginning there was no thing, not even the beginning. It hadn't been here, no there, nor for that matter anywhere, not especially because it had not to even exist, let alone to not. Nothing especially odd about that."
oldCredit := amt - fee
numDesiredBlocks = 10
amt = fee + numDesiredBlocks*names.NameByteCostMultiplier*names.NameBlockCostMultiplier*names.NameBaseCost(name, data) - oldCredit
- tx, _ = payload.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[1]))
- if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
+ if err := execTxWithStateAndBlockchain(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
- validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
+ validateEntry(t, entry, name, data, testPrivAccounts[1].Address(), startingBlock+numDesiredBlocks)
// test removal
amt = fee
data = ""
- tx, _ = payload.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[1]))
- if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
+ if err := execTxWithStateNewBlock(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
if entry != nil {
t.Fatal("Expected removed entry to be nil")
@@ -1096,32 +1107,33 @@ func TestNameTxs(t *testing.T) {
// create entry by key0,
// test removal by key1 after expiry
+ startingBlock = blockchain.LastBlockHeight()
name = "looking_good/karaoke_bar"
data = "some data"
amt = fee + numDesiredBlocks*names.NameByteCostMultiplier*names.NameBlockCostMultiplier*names.NameBaseCost(name, data)
- tx, _ = payload.NewNameTx(state, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[0].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[0]))
- if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
+ if err := execTxWithStateAndBlockchain(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
- validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), blockchain.LastBlockHeight()+numDesiredBlocks)
+ validateEntry(t, entry, name, data, testPrivAccounts[0].Address(), startingBlock+numDesiredBlocks)
// Fast forward
for blockchain.Tip.LastBlockHeight() < entry.Expires {
- commitNewBlock(state, blockchain)
+ commitNewBlock(st, blockchain)
}
amt = fee
data = ""
- tx, _ = payload.NewNameTx(state, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
+ tx, _ = payload.NewNameTx(st, testPrivAccounts[1].PublicKey(), name, data, amt, fee)
txEnv = txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(testPrivAccounts[1]))
- if err := execTxWithStateNewBlock(state, blockchain, txEnv); err != nil {
+ if err := execTxWithStateNewBlock(st, blockchain, txEnv); err != nil {
t.Fatal(err)
}
- entry, err = state.GetNameEntry(name)
+ entry, err = st.GetNameEntry(name)
require.NoError(t, err)
if entry != nil {
t.Fatal("Expected removed entry to be nil")
@@ -1166,8 +1178,8 @@ func TestCreates(t *testing.T) {
newAcc2 := getAccount(state, acc2.Address())
newAcc2.SetCode(factoryCode)
- state.UpdateAccount(newAcc1)
- state.UpdateAccount(newAcc2)
+ state.writeState.UpdateAccount(newAcc1)
+ state.writeState.UpdateAccount(newAcc2)
createData = append(createData, acc2.Address().Word256().Bytes()...)
@@ -1234,16 +1246,19 @@ var callerCode, _ = hex.DecodeString("60606040526000357c010000000000000000000000
var sendData, _ = hex.DecodeString("3e58c58c")
func TestContractSend(t *testing.T) {
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+ st, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
//val0 := state.GetValidatorInfo(privValidators[0].Address())
- acc0 := getAccount(state, privAccounts[0].Address())
- acc1 := getAccount(state, privAccounts[1].Address())
- acc2 := getAccount(state, privAccounts[2].Address())
+ acc0 := getAccount(st, privAccounts[0].Address())
+ acc1 := getAccount(st, privAccounts[1].Address())
+ acc2 := getAccount(st, privAccounts[2].Address())
- newAcc1 := getAccount(state, acc1.Address())
+ newAcc1 := getAccount(st, acc1.Address())
newAcc1.SetCode(callerCode)
- state.UpdateAccount(newAcc1)
+ _, err := st.Update(func(up Updatable) error {
+ return up.UpdateAccount(newAcc1)
+ })
+ require.NoError(t, err)
sendData = append(sendData, acc2.Address().Word256().Bytes()...)
sendAmt := uint64(10)
@@ -1263,12 +1278,12 @@ func TestContractSend(t *testing.T) {
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(privAccounts[0]))
- err := execTxWithState(state, txEnv)
+ err = execTxWithState(st, txEnv)
if err != nil {
t.Errorf("Got error in executing call transaction, %v", err)
}
- acc2 = getAccount(state, acc2.Address())
+ acc2 = getAccount(st, acc2.Address())
if acc2.Balance() != sendAmt+acc2Balance {
t.Errorf("Value transfer from contract failed! Got %d, expected %d", acc2.Balance(), sendAmt+acc2Balance)
}
@@ -1282,10 +1297,11 @@ func TestMerklePanic(t *testing.T) {
acc0 := getAccount(state, privAccounts[0].Address())
acc1 := getAccount(state, privAccounts[1].Address())
- state.Save()
+ state.writeState.save()
// SendTx.
{
- stateSendTx := state.Copy(dbm.NewMemDB())
+ stateSendTx, err := state.Copy(dbm.NewMemDB())
+ require.NoError(t, err)
tx := &payload.SendTx{
Inputs: []*payload.TxInput{
{
@@ -1304,20 +1320,21 @@ func TestMerklePanic(t *testing.T) {
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(privAccounts[0]))
- err := execTxWithState(stateSendTx, txEnv)
+ err = execTxWithState(stateSendTx, txEnv)
if err != nil {
t.Errorf("Got error in executing send transaction, %v", err)
}
// uncomment for panic fun!
- //stateSendTx.Save()
+ //stateSendTx.save()
}
// CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
{
- stateCallTx := state.Copy(dbm.NewMemDB())
+ stateCallTx, err := state.Copy(dbm.NewMemDB())
+ require.NoError(t, err)
newAcc1 := getAccount(stateCallTx, acc1.Address())
newAcc1.SetCode([]byte{0x60})
- stateCallTx.UpdateAccount(newAcc1)
+ stateCallTx.writeState.UpdateAccount(newAcc1)
tx := &payload.CallTx{
Input: &payload.TxInput{
Address: acc0.Address(),
@@ -1330,12 +1347,12 @@ func TestMerklePanic(t *testing.T) {
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(privAccounts[0]))
- err := execTxWithState(stateCallTx, txEnv)
+ err = execTxWithState(stateCallTx, txEnv)
if err != nil {
t.Errorf("Got error in executing call transaction, %v", err)
}
}
- state.Save()
+ state.writeState.save()
trygetacc0 := getAccount(state, privAccounts[0].Address())
fmt.Println(trygetacc0.Address())
}
@@ -1343,15 +1360,16 @@ func TestMerklePanic(t *testing.T) {
// TODO: test overflows.
// TODO: test for unbonding validators.
func TestTxs(t *testing.T) {
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+ st, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
//val0 := state.GetValidatorInfo(privValidators[0].Address())
- acc0 := getAccount(state, privAccounts[0].Address())
- acc1 := getAccount(state, privAccounts[1].Address())
+ acc0 := getAccount(st, privAccounts[0].Address())
+ acc1 := getAccount(st, privAccounts[1].Address())
// SendTx.
{
- stateSendTx := state.Copy(dbm.NewMemDB())
+ stateSendTx, err := st.Copy(dbm.NewMemDB())
+ require.NoError(t, err)
tx := &payload.SendTx{
Inputs: []*payload.TxInput{
{
@@ -1370,7 +1388,7 @@ func TestTxs(t *testing.T) {
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(privAccounts[0]))
- err := execTxWithState(stateSendTx, txEnv)
+ err = execTxWithState(stateSendTx, txEnv)
if err != nil {
t.Errorf("Got error in executing send transaction, %v", err)
}
@@ -1388,10 +1406,14 @@ func TestTxs(t *testing.T) {
// CallTx. Just runs through it and checks the transfer. See vm, rpc tests for more
{
- stateCallTx := state.Copy(dbm.NewMemDB())
+ stateCallTx, err := st.Copy(dbm.NewMemDB())
+ require.NoError(t, err)
newAcc1 := getAccount(stateCallTx, acc1.Address())
newAcc1.SetCode([]byte{0x60})
- stateCallTx.UpdateAccount(newAcc1)
+ _, err = stateCallTx.Update(func(up Updatable) error {
+ return up.UpdateAccount(newAcc1)
+ })
+ require.NoError(t, err)
tx := &payload.CallTx{
Input: &payload.TxInput{
Address: acc0.Address(),
@@ -1404,7 +1426,7 @@ func TestTxs(t *testing.T) {
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(privAccounts[0]))
- err := execTxWithState(stateCallTx, txEnv)
+ err = execTxWithState(stateCallTx, txEnv)
if err != nil {
t.Errorf("Got error in executing call transaction, %v", err)
}
@@ -1419,7 +1441,7 @@ func TestTxs(t *testing.T) {
acc1.Balance()+1, newAcc1.Balance())
}
}
- trygetacc0 := getAccount(state, privAccounts[0].Address())
+ trygetacc0 := getAccount(st, privAccounts[0].Address())
fmt.Println(trygetacc0.Address())
// NameTx.
@@ -1442,7 +1464,7 @@ basis, and nodes can leave and rejoin the network at will, acc
proof-of-work chain as proof of what happened while they were gone `
entryAmount := uint64(10000)
- stateNameTx := state
+ stateNameTx := st
tx := &payload.NameTx{
Input: &payload.TxInput{
Address: acc0.Address(),
@@ -1540,28 +1562,32 @@ proof-of-work chain as proof of what happened while they were gone `
}
func TestSelfDestruct(t *testing.T) {
- state, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
+ st, privAccounts := makeGenesisState(3, true, 1000, 1, true, 1000)
- acc0 := getAccount(state, privAccounts[0].Address())
+ acc0 := getAccount(st, privAccounts[0].Address())
acc0PubKey := privAccounts[0].PublicKey()
- acc1 := getAccount(state, privAccounts[1].Address())
- acc2 := getAccount(state, privAccounts[2].Address())
+ acc1 := getAccount(st, privAccounts[1].Address())
+ acc2 := getAccount(st, privAccounts[2].Address())
sendingAmount, refundedBalance, oldBalance := uint64(1), acc1.Balance(), acc2.Balance()
- newAcc1 := getAccount(state, acc1.Address())
+ newAcc1 := getAccount(st, acc1.Address())
// store 0x1 at 0x1, push an address, then self-destruct:)
contractCode := []byte{0x60, 0x01, 0x60, 0x01, 0x55, 0x73}
contractCode = append(contractCode, acc2.Address().Bytes()...)
contractCode = append(contractCode, 0xff)
newAcc1.SetCode(contractCode)
- state.UpdateAccount(newAcc1)
+ _, err := st.Update(func(up Updatable) error {
+ require.NoError(t, up.UpdateAccount(newAcc1))
+ return nil
+ })
+ require.NoError(t, err)
// send call tx with no data, cause self-destruct
tx := payload.NewCallTxWithSequence(acc0PubKey, addressPtr(acc1), nil, sendingAmount, 1000, 0, acc0.Sequence()+1)
// we use cache instead of execTxWithState so we can run the tx twice
- exe := NewBatchCommitter(state, newBlockchain(testGenesisDoc).Tip, event.NewNoOpPublisher(), logger)
+ exe := NewBatchCommitter(st, newBlockchain(testGenesisDoc).Tip, event.NewNoOpPublisher(), logger)
signAndExecute(t, false, exe, testChainID, tx, privAccounts[0])
// if we do it again, we won't get an error, but the self-destruct
@@ -1573,24 +1599,24 @@ func TestSelfDestruct(t *testing.T) {
exe.Commit()
// acc2 should receive the sent funds and the contracts balance
- newAcc2 := getAccount(state, acc2.Address())
+ newAcc2 := getAccount(st, acc2.Address())
newBalance := sendingAmount + refundedBalance + oldBalance
if newAcc2.Balance() != newBalance {
t.Errorf("Unexpected newAcc2 balance. Expected %v, got %v",
newAcc2.Balance(), newBalance)
}
- newAcc1 = getAccount(state, acc1.Address())
+ newAcc1 = getAccount(st, acc1.Address())
if newAcc1 != nil {
t.Errorf("Expected account to be removed")
}
}
-func signAndExecute(t *testing.T, shoudlFail bool, exe BatchExecutor, chainID string, tx payload.Payload,
+func signAndExecute(t *testing.T, shouldFail bool, exe BatchExecutor, chainID string, tx payload.Payload,
signers ...acm.AddressableSigner) *txs.Envelope {
env := txs.Enclose(chainID, tx)
require.NoError(t, env.Sign(signers...), "Could not sign tx in call: %s", debug.Stack())
- if shoudlFail {
+ if shouldFail {
require.Error(t, exe.Execute(env), "Tx should fail in call: %s", debug.Stack())
} else {
require.NoError(t, exe.Execute(env), "Could not execute tx in call: %s", debug.Stack())
@@ -1598,19 +1624,20 @@ func signAndExecute(t *testing.T, shoudlFail bool, exe BatchExecutor, chainID st
return env
}
-func execTxWithStateAndBlockchain(state *State, tip *bcm.Tip, txEnv *txs.Envelope) error {
- exe := newExecutor("execTxWithStateAndBlockchainCache", true, state, tip,
+func execTxWithStateAndBlockchain(state *State, blockchain *bcm.Blockchain, txEnv *txs.Envelope) error {
+ exe := newExecutor("execTxWithStateAndBlockchainCache", true, state, blockchain.Tip,
event.NewNoOpPublisher(), logger)
if err := exe.Execute(txEnv); err != nil {
return err
} else {
exe.Commit()
+ commitNewBlock(state, blockchain)
return nil
}
}
func execTxWithState(state *State, txEnv *txs.Envelope) error {
- return execTxWithStateAndBlockchain(state, newBlockchain(testGenesisDoc).Tip, txEnv)
+ return execTxWithStateAndBlockchain(state, newBlockchain(testGenesisDoc), txEnv)
}
func commitNewBlock(state *State, blockchain *bcm.Blockchain) {
@@ -1619,7 +1646,7 @@ func commitNewBlock(state *State, blockchain *bcm.Blockchain) {
}
func execTxWithStateNewBlock(state *State, blockchain *bcm.Blockchain, txEnv *txs.Envelope) error {
- if err := execTxWithStateAndBlockchain(state, blockchain.Tip, txEnv); err != nil {
+ if err := execTxWithStateAndBlockchain(state, blockchain, txEnv); err != nil {
return err
}
commitNewBlock(state, blockchain)
@@ -1634,7 +1661,7 @@ func makeGenesisState(numAccounts int, randBalance bool, minBalance uint64, numV
if err != nil {
panic(fmt.Errorf("could not make genesis state: %v", err))
}
- s0.Save()
+ s0.writeState.save()
return s0, privAccounts
}
@@ -1658,20 +1685,20 @@ var ExceptionTimeOut = errors.NewCodedError(errors.ErrorCodeGeneric, "timed out
// run ExecTx and wait for the Call event on given addr
// returns the msg data and an error/exception
-func execTxWaitAccountCall(t *testing.T, batchCommitter *executor, emitter event.Emitter, txEnv *txs.Envelope,
- address crypto.Address) (*evm_events.EventDataCall, error) {
+func execTxWaitAccountCall(t *testing.T, exe *testExecutor, txEnv *txs.Envelope,
+ address crypto.Address) (*events.EventDataCall, error) {
- ch := make(chan *evm_events.EventDataCall)
+ ch := make(chan *events.EventDataCall)
ctx := context.Background()
- const subscriber = "exexTxWaitEvent"
- //emitter.Subscribe(ctx, subscriber, event.QueryForEventID(eventid), ch)
- evm_events.SubscribeAccountCall(ctx, emitter, subscriber, address, txEnv.Tx.Hash(), -1, ch)
- defer emitter.UnsubscribeAll(ctx, subscriber)
- err := batchCommitter.Execute(txEnv)
+ const subscriber = "execTxWaitEvent"
+ events.SubscribeAccountCall(ctx, exe, subscriber, address, txEnv.Tx.Hash(), -1, ch)
+ defer exe.UnsubscribeAll(ctx, subscriber)
+ err := exe.Execute(txEnv)
if err != nil {
return nil, err
}
- batchCommitter.Commit()
+ exe.Commit()
+ exe.blockchain.CommitBlock(time.Time{}, nil, nil)
ticker := time.NewTicker(5 * time.Second)
select {
@@ -1686,18 +1713,18 @@ func execTxWaitAccountCall(t *testing.T, batchCommitter *executor, emitter event
}
// give a contract perms for an snative, call it, it calls the snative, but shouldn't have permission
-func testSNativeCALLExpectFail(t *testing.T, batchCommitter *executor, emitter event.Emitter, doug acm.MutableAccount,
+func testSNativeCALLExpectFail(t *testing.T, exe *testExecutor, doug acm.MutableAccount,
snativeAddress crypto.Address, data []byte) {
- testSNativeCALL(t, false, batchCommitter, emitter, doug, 0, snativeAddress, data, nil)
+ testSNativeCALL(t, false, exe, doug, 0, snativeAddress, data, nil)
}
// give a contract perms for an snative, call it, it calls the snative, ensure the check funciton (f) succeeds
-func testSNativeCALLExpectPass(t *testing.T, batchCommitter *executor, emitter event.Emitter, doug acm.MutableAccount, snativePerm ptypes.PermFlag,
+func testSNativeCALLExpectPass(t *testing.T, exe *testExecutor, doug acm.MutableAccount, snativePerm ptypes.PermFlag,
snativeAddress crypto.Address, data []byte, f func([]byte) error) {
- testSNativeCALL(t, true, batchCommitter, emitter, doug, snativePerm, snativeAddress, data, f)
+ testSNativeCALL(t, true, exe, doug, snativePerm, snativeAddress, data, f)
}
-func testSNativeCALL(t *testing.T, expectPass bool, batchCommitter *executor, emitter event.Emitter, doug acm.MutableAccount,
+func testSNativeCALL(t *testing.T, expectPass bool, exe *testExecutor, doug acm.MutableAccount,
snativePerm ptypes.PermFlag, snativeAddress crypto.Address, data []byte, f func([]byte) error) {
if expectPass {
doug.MutablePermissions().Base.Set(snativePerm, true)
@@ -1706,12 +1733,12 @@ func testSNativeCALL(t *testing.T, expectPass bool, batchCommitter *executor, em
doug.SetCode(callContractCode(snativeAddress))
dougAddress := doug.Address()
- batchCommitter.stateCache.UpdateAccount(doug)
- tx, _ := payload.NewCallTx(batchCommitter.stateCache, users[0].PublicKey(), &dougAddress, data, 100, 10000, 100)
+ exe.stateCache.UpdateAccount(doug)
+ tx, _ := payload.NewCallTx(exe.stateCache, users[0].PublicKey(), &dougAddress, data, 100, 10000, 100)
txEnv := txs.Enclose(testChainID, tx)
require.NoError(t, txEnv.Sign(users[0]))
- t.Logf("subscribing to %v", evm_events.EventStringAccountCall(snativeAddress))
- ev, err := execTxWaitAccountCall(t, batchCommitter, emitter, txEnv, snativeAddress)
+ t.Logf("subscribing to %v", events.EventStringAccountCall(snativeAddress))
+ ev, err := execTxWaitAccountCall(t, exe, txEnv, snativeAddress)
if err == ExceptionTimeOut {
t.Fatal("Timed out waiting for event")
}
@@ -1726,16 +1753,16 @@ func testSNativeCALL(t *testing.T, expectPass bool, batchCommitter *executor, em
}
}
-func testSNativeTxExpectFail(t *testing.T, batchCommitter *executor, snativeArgs snatives.PermArgs) {
+func testSNativeTxExpectFail(t *testing.T, batchCommitter *testExecutor, snativeArgs snatives.PermArgs) {
testSNativeTx(t, false, batchCommitter, 0, snativeArgs)
}
-func testSNativeTxExpectPass(t *testing.T, batchCommitter *executor, perm ptypes.PermFlag,
+func testSNativeTxExpectPass(t *testing.T, batchCommitter *testExecutor, perm ptypes.PermFlag,
snativeArgs snatives.PermArgs) {
testSNativeTx(t, true, batchCommitter, perm, snativeArgs)
}
-func testSNativeTx(t *testing.T, expectPass bool, batchCommitter *executor, perm ptypes.PermFlag,
+func testSNativeTx(t *testing.T, expectPass bool, batchCommitter *testExecutor, perm ptypes.PermFlag,
snativeArgs snatives.PermArgs) {
if expectPass {
acc := getAccount(batchCommitter.stateCache, users[0].Address())
diff --git a/execution/executors/call.go b/execution/executors/call.go
index f377e9147eb14d022400aa3380b26ced004bc292..ce79fc5c2a6ddaecca585f3c2a21ec8761dcc4a1 100644
--- a/execution/executors/call.go
+++ b/execution/executors/call.go
@@ -22,7 +22,7 @@ const GasLimit = uint64(1000000)
type CallContext struct {
Tip blockchain.TipInfo
- StateWriter state.Writer
+ StateWriter state.ReaderWriter
EventPublisher event.Publisher
RunCall bool
VMOptions []func(*evm.VM)
@@ -206,7 +206,7 @@ func (ctx *CallContext) Deliver(inAcc, outAcc acm.Account, value uint64) error {
txCache.UpdateAccount(caller)
txCache.UpdateAccount(callee)
- vmach := evm.NewVM(params, caller.Address(), ctx.txEnv.Tx.Hash(), ctx.Logger, ctx.VMOptions...)
+ vmach := evm.NewVM(params, caller.Address(), ctx.txEnv.Tx, ctx.Logger, ctx.VMOptions...)
vmach.SetPublisher(ctx.EventPublisher)
// NOTE: Call() transfers the value from caller to callee iff call succeeds.
ret, exception := vmach.Call(txCache, caller, callee, code, ctx.tx.Data, value, &gas)
@@ -238,9 +238,11 @@ func (ctx *CallContext) FireCallEvents(ret []byte, err error) {
// Fire Events for sender and receiver
// a separate event will be fired from vm for each additional call
if ctx.EventPublisher != nil {
- events.PublishAccountInput(ctx.EventPublisher, ctx.tx.Input.Address, ctx.txEnv.Tx, ret, errors.AsCodedError(err))
+ events.PublishAccountInput(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), ctx.tx.Input.Address, ctx.txEnv.Tx,
+ ret, errors.AsCodedError(err))
if ctx.tx.Address != nil {
- events.PublishAccountOutput(ctx.EventPublisher, *ctx.tx.Address, ctx.txEnv.Tx, ret, errors.AsCodedError(err))
+ events.PublishAccountOutput(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), *ctx.tx.Address, ctx.txEnv.Tx,
+ ret, errors.AsCodedError(err))
}
}
}
diff --git a/execution/executors/name.go b/execution/executors/name.go
index dbd2978a82395e5ca5a19adb6c951405f6c800d5..658992d5331687450cf34fe524ddbde96a9f9583 100644
--- a/execution/executors/name.go
+++ b/execution/executors/name.go
@@ -16,9 +16,9 @@ import (
type NameContext struct {
Tip blockchain.TipInfo
- StateWriter state.Writer
+ StateWriter state.ReaderWriter
EventPublisher event.Publisher
- NameReg names.Writer
+ NameReg names.ReaderWriter
Logger *logging.Logger
tx *payload.NameTx
}
@@ -177,8 +177,8 @@ func (ctx *NameContext) Execute(txEnv *txs.Envelope) error {
// TODO: maybe we want to take funds on error and allow txs in that don't do anythingi?
if ctx.EventPublisher != nil {
- events.PublishAccountInput(ctx.EventPublisher, ctx.tx.Input.Address, txEnv.Tx, nil, nil)
- events.PublishNameReg(ctx.EventPublisher, txEnv.Tx)
+ events.PublishAccountInput(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), ctx.tx.Input.Address, txEnv.Tx, nil, nil)
+ events.PublishNameReg(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), txEnv.Tx)
}
return nil
diff --git a/execution/executors/permissions.go b/execution/executors/permissions.go
index 06dbd8c0acb3ddc1d96ead562557b7cb58dfb7d0..0ccc62040da5a695c1ceaaac7c59074af793e9f0 100644
--- a/execution/executors/permissions.go
+++ b/execution/executors/permissions.go
@@ -5,6 +5,7 @@ import (
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/account/state"
+ "github.com/hyperledger/burrow/blockchain"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution/events"
@@ -16,7 +17,8 @@ import (
)
type PermissionsContext struct {
- StateWriter state.Writer
+ Tip blockchain.TipInfo
+ StateWriter state.ReaderWriter
EventPublisher event.Publisher
Logger *logging.Logger
tx *payload.PermissionsTx
@@ -130,8 +132,8 @@ func (ctx *PermissionsContext) Execute(txEnv *txs.Envelope) error {
}
if ctx.EventPublisher != nil {
- events.PublishAccountInput(ctx.EventPublisher, ctx.tx.Input.Address, txEnv.Tx, nil, nil)
- events.PublishPermissions(ctx.EventPublisher, permFlag, txEnv.Tx)
+ events.PublishAccountInput(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), ctx.tx.Input.Address, txEnv.Tx, nil, nil)
+ events.PublishPermissions(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), txEnv.Tx)
}
return nil
diff --git a/execution/executors/send.go b/execution/executors/send.go
index 6c79eba84f00fd214cc45e92d405c60e29ecbbc8..f7e9f752b0bfbf7ea7aaac0fa97609b987a670ad 100644
--- a/execution/executors/send.go
+++ b/execution/executors/send.go
@@ -4,6 +4,7 @@ import (
"fmt"
"github.com/hyperledger/burrow/account/state"
+ "github.com/hyperledger/burrow/blockchain"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/logging"
@@ -12,7 +13,8 @@ import (
)
type SendContext struct {
- StateWriter state.Writer
+ Tip blockchain.TipInfo
+ StateWriter state.ReaderWriter
EventPublisher event.Publisher
Logger *logging.Logger
tx *payload.SendTx
@@ -70,11 +72,11 @@ func (ctx *SendContext) Execute(txEnv *txs.Envelope) error {
if ctx.EventPublisher != nil {
for _, i := range ctx.tx.Inputs {
- events.PublishAccountInput(ctx.EventPublisher, i.Address, txEnv.Tx, nil, nil)
+ events.PublishAccountInput(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), i.Address, txEnv.Tx, nil, nil)
}
for _, o := range ctx.tx.Outputs {
- events.PublishAccountOutput(ctx.EventPublisher, o.Address, txEnv.Tx, nil, nil)
+ events.PublishAccountOutput(ctx.EventPublisher, ctx.Tip.LastBlockHeight(), o.Address, txEnv.Tx, nil, nil)
}
}
return nil
diff --git a/execution/names/cache.go b/execution/names/cache.go
index 074ff290eeba3cc401baf3a4d47a51dcd4fa02f0..7b8e060f1fa1ebe1b4095ad77c6c928598d2ef2a 100644
--- a/execution/names/cache.go
+++ b/execution/names/cache.go
@@ -23,7 +23,7 @@ import (
// The Cache helps prevent unnecessary IAVLTree updates and garbage generation.
type Cache struct {
sync.RWMutex
- backend Getter
+ backend Reader
names map[string]*nameInfo
}
@@ -39,7 +39,7 @@ var _ Writer = &Cache{}
// Returns a Cache that wraps an underlying NameRegCacheGetter to use on a cache miss, can write to an
// output Writer via Sync.
// Not goroutine safe, use syncStateCache if you need concurrent access
-func NewCache(backend Getter) *Cache {
+func NewCache(backend Reader) *Cache {
return &Cache{
backend: backend,
names: make(map[string]*nameInfo),
@@ -125,24 +125,24 @@ func (cache *Cache) Sync(state Writer) error {
}
// Resets the cache to empty initialising the backing map to the same size as the previous iteration.
-func (cache *Cache) Reset(backend Getter) {
+func (cache *Cache) Reset(backend Reader) {
cache.Lock()
defer cache.Unlock()
cache.backend = backend
cache.names = make(map[string]*nameInfo)
}
-// Syncs the Cache and Resets it to use Writer as the backend Getter
-func (cache *Cache) Flush(state Writer) error {
- err := cache.Sync(state)
+// Syncs the Cache and Resets it to use Writer as the backend Reader
+func (cache *Cache) Flush(output Writer, backend Reader) error {
+ err := cache.Sync(output)
if err != nil {
return err
}
- cache.Reset(state)
+ cache.Reset(backend)
return nil
}
-func (cache *Cache) Backend() Getter {
+func (cache *Cache) Backend() Reader {
return cache.backend
}
diff --git a/execution/names/names.go b/execution/names/names.go
index 96cd2f1dae4cdd85e07d4ccedcf36495901d0c7c..1732575f0351c50e94cb80c69aead84e706bfde0 100644
--- a/execution/names/names.go
+++ b/execution/names/names.go
@@ -62,27 +62,36 @@ func DecodeEntry(entryBytes []byte) (*Entry, error) {
return entry, nil
}
-type Getter interface {
+type Reader interface {
GetNameEntry(name string) (*Entry, error)
}
-type Updater interface {
+type Writer interface {
// Updates the name entry creating it if it does not exist
UpdateNameEntry(entry *Entry) error
// Remove the name entry
RemoveNameEntry(name string) error
}
-type Writer interface {
- Getter
- Updater
+type ReaderWriter interface {
+ Reader
+ Writer
}
type Iterable interface {
- Getter
IterateNameEntries(consumer func(*Entry) (stop bool)) (stopped bool, err error)
}
+type IterableReader interface {
+ Iterable
+ Reader
+}
+
+type IterableReaderWriter interface {
+ Iterable
+ ReaderWriter
+}
+
// base cost is "effective" number of bytes
func NameBaseCost(name, data string) uint64 {
return uint64(len(data) + 32)
diff --git a/execution/pbtransactor/transactor.pb.go b/execution/pbtransactor/transactor.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..b6f10a44c0ff1a23401c059609eb33bed5fba0b1
--- /dev/null
+++ b/execution/pbtransactor/transactor.pb.go
@@ -0,0 +1,929 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: github.com/hyperledger/burrow/execution/pbtransactor/transactor.proto
+
+package pbtransactor // import "github.com/hyperledger/burrow/execution/pbtransactor"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import pbevents "github.com/hyperledger/burrow/execution/events/pbevents"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// Params
+type CallParam struct {
+ From []byte `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
+ Address []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *CallParam) Reset() { *m = CallParam{} }
+func (m *CallParam) String() string { return proto.CompactTextString(m) }
+func (*CallParam) ProtoMessage() {}
+func (*CallParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{0}
+}
+func (m *CallParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_CallParam.Unmarshal(m, b)
+}
+func (m *CallParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_CallParam.Marshal(b, m, deterministic)
+}
+func (dst *CallParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CallParam.Merge(dst, src)
+}
+func (m *CallParam) XXX_Size() int {
+ return xxx_messageInfo_CallParam.Size(m)
+}
+func (m *CallParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_CallParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CallParam proto.InternalMessageInfo
+
+func (m *CallParam) GetFrom() []byte {
+ if m != nil {
+ return m.From
+ }
+ return nil
+}
+
+func (m *CallParam) GetAddress() []byte {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+func (m *CallParam) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+type CallCodeParam struct {
+ From []byte `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
+ Code []byte `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *CallCodeParam) Reset() { *m = CallCodeParam{} }
+func (m *CallCodeParam) String() string { return proto.CompactTextString(m) }
+func (*CallCodeParam) ProtoMessage() {}
+func (*CallCodeParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{1}
+}
+func (m *CallCodeParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_CallCodeParam.Unmarshal(m, b)
+}
+func (m *CallCodeParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_CallCodeParam.Marshal(b, m, deterministic)
+}
+func (dst *CallCodeParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CallCodeParam.Merge(dst, src)
+}
+func (m *CallCodeParam) XXX_Size() int {
+ return xxx_messageInfo_CallCodeParam.Size(m)
+}
+func (m *CallCodeParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_CallCodeParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CallCodeParam proto.InternalMessageInfo
+
+func (m *CallCodeParam) GetFrom() []byte {
+ if m != nil {
+ return m.From
+ }
+ return nil
+}
+
+func (m *CallCodeParam) GetCode() []byte {
+ if m != nil {
+ return m.Code
+ }
+ return nil
+}
+
+func (m *CallCodeParam) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+type TransactParam struct {
+ InputAccount *InputAccount `protobuf:"bytes,1,opt,name=inputAccount,proto3" json:"inputAccount,omitempty"`
+ Address []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+ Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
+ GasLimit uint64 `protobuf:"varint,4,opt,name=gasLimit,proto3" json:"gasLimit,omitempty"`
+ Fee uint64 `protobuf:"varint,5,opt,name=fee,proto3" json:"fee,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TransactParam) Reset() { *m = TransactParam{} }
+func (m *TransactParam) String() string { return proto.CompactTextString(m) }
+func (*TransactParam) ProtoMessage() {}
+func (*TransactParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{2}
+}
+func (m *TransactParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TransactParam.Unmarshal(m, b)
+}
+func (m *TransactParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TransactParam.Marshal(b, m, deterministic)
+}
+func (dst *TransactParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TransactParam.Merge(dst, src)
+}
+func (m *TransactParam) XXX_Size() int {
+ return xxx_messageInfo_TransactParam.Size(m)
+}
+func (m *TransactParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_TransactParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TransactParam proto.InternalMessageInfo
+
+func (m *TransactParam) GetInputAccount() *InputAccount {
+ if m != nil {
+ return m.InputAccount
+ }
+ return nil
+}
+
+func (m *TransactParam) GetAddress() []byte {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+func (m *TransactParam) GetData() []byte {
+ if m != nil {
+ return m.Data
+ }
+ return nil
+}
+
+func (m *TransactParam) GetGasLimit() uint64 {
+ if m != nil {
+ return m.GasLimit
+ }
+ return 0
+}
+
+func (m *TransactParam) GetFee() uint64 {
+ if m != nil {
+ return m.Fee
+ }
+ return 0
+}
+
+type SendParam struct {
+ InputAccount *InputAccount `protobuf:"bytes,1,opt,name=inputAccount,proto3" json:"inputAccount,omitempty"`
+ ToAddress []byte `protobuf:"bytes,2,opt,name=toAddress,proto3" json:"toAddress,omitempty"`
+ Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SendParam) Reset() { *m = SendParam{} }
+func (m *SendParam) String() string { return proto.CompactTextString(m) }
+func (*SendParam) ProtoMessage() {}
+func (*SendParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{3}
+}
+func (m *SendParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SendParam.Unmarshal(m, b)
+}
+func (m *SendParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SendParam.Marshal(b, m, deterministic)
+}
+func (dst *SendParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SendParam.Merge(dst, src)
+}
+func (m *SendParam) XXX_Size() int {
+ return xxx_messageInfo_SendParam.Size(m)
+}
+func (m *SendParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_SendParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SendParam proto.InternalMessageInfo
+
+func (m *SendParam) GetInputAccount() *InputAccount {
+ if m != nil {
+ return m.InputAccount
+ }
+ return nil
+}
+
+func (m *SendParam) GetToAddress() []byte {
+ if m != nil {
+ return m.ToAddress
+ }
+ return nil
+}
+
+func (m *SendParam) GetAmount() uint64 {
+ if m != nil {
+ return m.Amount
+ }
+ return 0
+}
+
+type TxParam struct {
+ Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TxParam) Reset() { *m = TxParam{} }
+func (m *TxParam) String() string { return proto.CompactTextString(m) }
+func (*TxParam) ProtoMessage() {}
+func (*TxParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{4}
+}
+func (m *TxParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TxParam.Unmarshal(m, b)
+}
+func (m *TxParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TxParam.Marshal(b, m, deterministic)
+}
+func (dst *TxParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TxParam.Merge(dst, src)
+}
+func (m *TxParam) XXX_Size() int {
+ return xxx_messageInfo_TxParam.Size(m)
+}
+func (m *TxParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_TxParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TxParam proto.InternalMessageInfo
+
+func (m *TxParam) GetTx() []byte {
+ if m != nil {
+ return m.Tx
+ }
+ return nil
+}
+
+type SignTxParam struct {
+ Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
+ PrivateAccounts []*PrivateAccount `protobuf:"bytes,2,rep,name=privateAccounts,proto3" json:"privateAccounts,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SignTxParam) Reset() { *m = SignTxParam{} }
+func (m *SignTxParam) String() string { return proto.CompactTextString(m) }
+func (*SignTxParam) ProtoMessage() {}
+func (*SignTxParam) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{5}
+}
+func (m *SignTxParam) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SignTxParam.Unmarshal(m, b)
+}
+func (m *SignTxParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SignTxParam.Marshal(b, m, deterministic)
+}
+func (dst *SignTxParam) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SignTxParam.Merge(dst, src)
+}
+func (m *SignTxParam) XXX_Size() int {
+ return xxx_messageInfo_SignTxParam.Size(m)
+}
+func (m *SignTxParam) XXX_DiscardUnknown() {
+ xxx_messageInfo_SignTxParam.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignTxParam proto.InternalMessageInfo
+
+func (m *SignTxParam) GetTx() []byte {
+ if m != nil {
+ return m.Tx
+ }
+ return nil
+}
+
+func (m *SignTxParam) GetPrivateAccounts() []*PrivateAccount {
+ if m != nil {
+ return m.PrivateAccounts
+ }
+ return nil
+}
+
+// Results
+type SignedTx struct {
+ Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SignedTx) Reset() { *m = SignedTx{} }
+func (m *SignedTx) String() string { return proto.CompactTextString(m) }
+func (*SignedTx) ProtoMessage() {}
+func (*SignedTx) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{6}
+}
+func (m *SignedTx) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SignedTx.Unmarshal(m, b)
+}
+func (m *SignedTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SignedTx.Marshal(b, m, deterministic)
+}
+func (dst *SignedTx) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SignedTx.Merge(dst, src)
+}
+func (m *SignedTx) XXX_Size() int {
+ return xxx_messageInfo_SignedTx.Size(m)
+}
+func (m *SignedTx) XXX_DiscardUnknown() {
+ xxx_messageInfo_SignedTx.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignedTx proto.InternalMessageInfo
+
+func (m *SignedTx) GetTx() []byte {
+ if m != nil {
+ return m.Tx
+ }
+ return nil
+}
+
+type CallResult struct {
+ Return []byte `protobuf:"bytes,1,opt,name=Return,proto3" json:"Return,omitempty"`
+ GasUsed uint64 `protobuf:"varint,2,opt,name=GasUsed,proto3" json:"GasUsed,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *CallResult) Reset() { *m = CallResult{} }
+func (m *CallResult) String() string { return proto.CompactTextString(m) }
+func (*CallResult) ProtoMessage() {}
+func (*CallResult) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{7}
+}
+func (m *CallResult) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_CallResult.Unmarshal(m, b)
+}
+func (m *CallResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_CallResult.Marshal(b, m, deterministic)
+}
+func (dst *CallResult) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_CallResult.Merge(dst, src)
+}
+func (m *CallResult) XXX_Size() int {
+ return xxx_messageInfo_CallResult.Size(m)
+}
+func (m *CallResult) XXX_DiscardUnknown() {
+ xxx_messageInfo_CallResult.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_CallResult proto.InternalMessageInfo
+
+func (m *CallResult) GetReturn() []byte {
+ if m != nil {
+ return m.Return
+ }
+ return nil
+}
+
+func (m *CallResult) GetGasUsed() uint64 {
+ if m != nil {
+ return m.GasUsed
+ }
+ return 0
+}
+
+type TxReceipt struct {
+ TxHash []byte `protobuf:"bytes,1,opt,name=TxHash,proto3" json:"TxHash,omitempty"`
+ CreatesContract bool `protobuf:"varint,2,opt,name=CreatesContract,proto3" json:"CreatesContract,omitempty"`
+ ContractAddress []byte `protobuf:"bytes,3,opt,name=ContractAddress,proto3" json:"ContractAddress,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *TxReceipt) Reset() { *m = TxReceipt{} }
+func (m *TxReceipt) String() string { return proto.CompactTextString(m) }
+func (*TxReceipt) ProtoMessage() {}
+func (*TxReceipt) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{8}
+}
+func (m *TxReceipt) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_TxReceipt.Unmarshal(m, b)
+}
+func (m *TxReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_TxReceipt.Marshal(b, m, deterministic)
+}
+func (dst *TxReceipt) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_TxReceipt.Merge(dst, src)
+}
+func (m *TxReceipt) XXX_Size() int {
+ return xxx_messageInfo_TxReceipt.Size(m)
+}
+func (m *TxReceipt) XXX_DiscardUnknown() {
+ xxx_messageInfo_TxReceipt.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_TxReceipt proto.InternalMessageInfo
+
+func (m *TxReceipt) GetTxHash() []byte {
+ if m != nil {
+ return m.TxHash
+ }
+ return nil
+}
+
+func (m *TxReceipt) GetCreatesContract() bool {
+ if m != nil {
+ return m.CreatesContract
+ }
+ return false
+}
+
+func (m *TxReceipt) GetContractAddress() []byte {
+ if m != nil {
+ return m.ContractAddress
+ }
+ return nil
+}
+
+type InputAccount struct {
+ PrivateKey []byte `protobuf:"bytes,1,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
+ Address []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *InputAccount) Reset() { *m = InputAccount{} }
+func (m *InputAccount) String() string { return proto.CompactTextString(m) }
+func (*InputAccount) ProtoMessage() {}
+func (*InputAccount) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{9}
+}
+func (m *InputAccount) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_InputAccount.Unmarshal(m, b)
+}
+func (m *InputAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_InputAccount.Marshal(b, m, deterministic)
+}
+func (dst *InputAccount) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_InputAccount.Merge(dst, src)
+}
+func (m *InputAccount) XXX_Size() int {
+ return xxx_messageInfo_InputAccount.Size(m)
+}
+func (m *InputAccount) XXX_DiscardUnknown() {
+ xxx_messageInfo_InputAccount.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_InputAccount proto.InternalMessageInfo
+
+func (m *InputAccount) GetPrivateKey() []byte {
+ if m != nil {
+ return m.PrivateKey
+ }
+ return nil
+}
+
+func (m *InputAccount) GetAddress() []byte {
+ if m != nil {
+ return m.Address
+ }
+ return nil
+}
+
+type PrivateAccount struct {
+ PrivateKey []byte `protobuf:"bytes,1,opt,name=PrivateKey,proto3" json:"PrivateKey,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *PrivateAccount) Reset() { *m = PrivateAccount{} }
+func (m *PrivateAccount) String() string { return proto.CompactTextString(m) }
+func (*PrivateAccount) ProtoMessage() {}
+func (*PrivateAccount) Descriptor() ([]byte, []int) {
+ return fileDescriptor_transactor_abf3bfc7b34ac7c7, []int{10}
+}
+func (m *PrivateAccount) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_PrivateAccount.Unmarshal(m, b)
+}
+func (m *PrivateAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_PrivateAccount.Marshal(b, m, deterministic)
+}
+func (dst *PrivateAccount) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PrivateAccount.Merge(dst, src)
+}
+func (m *PrivateAccount) XXX_Size() int {
+ return xxx_messageInfo_PrivateAccount.Size(m)
+}
+func (m *PrivateAccount) XXX_DiscardUnknown() {
+ xxx_messageInfo_PrivateAccount.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PrivateAccount proto.InternalMessageInfo
+
+func (m *PrivateAccount) GetPrivateKey() []byte {
+ if m != nil {
+ return m.PrivateKey
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*CallParam)(nil), "pbtransactor.CallParam")
+ proto.RegisterType((*CallCodeParam)(nil), "pbtransactor.CallCodeParam")
+ proto.RegisterType((*TransactParam)(nil), "pbtransactor.TransactParam")
+ proto.RegisterType((*SendParam)(nil), "pbtransactor.SendParam")
+ proto.RegisterType((*TxParam)(nil), "pbtransactor.TxParam")
+ proto.RegisterType((*SignTxParam)(nil), "pbtransactor.SignTxParam")
+ proto.RegisterType((*SignedTx)(nil), "pbtransactor.SignedTx")
+ proto.RegisterType((*CallResult)(nil), "pbtransactor.CallResult")
+ proto.RegisterType((*TxReceipt)(nil), "pbtransactor.TxReceipt")
+ proto.RegisterType((*InputAccount)(nil), "pbtransactor.InputAccount")
+ proto.RegisterType((*PrivateAccount)(nil), "pbtransactor.PrivateAccount")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// TransactorClient is the client API for Transactor service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type TransactorClient interface {
+ BroadcastTx(ctx context.Context, in *TxParam, opts ...grpc.CallOption) (*TxReceipt, error)
+ Call(ctx context.Context, in *CallParam, opts ...grpc.CallOption) (*CallResult, error)
+ CallCode(ctx context.Context, in *CallCodeParam, opts ...grpc.CallOption) (*CallResult, error)
+ Transact(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*TxReceipt, error)
+ TransactAndHold(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*pbevents.EventDataCall, error)
+ Send(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error)
+ SendAndHold(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error)
+ SignTx(ctx context.Context, in *SignTxParam, opts ...grpc.CallOption) (*SignedTx, error)
+}
+
+type transactorClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewTransactorClient(cc *grpc.ClientConn) TransactorClient {
+ return &transactorClient{cc}
+}
+
+func (c *transactorClient) BroadcastTx(ctx context.Context, in *TxParam, opts ...grpc.CallOption) (*TxReceipt, error) {
+ out := new(TxReceipt)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/BroadcastTx", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) Call(ctx context.Context, in *CallParam, opts ...grpc.CallOption) (*CallResult, error) {
+ out := new(CallResult)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/Call", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) CallCode(ctx context.Context, in *CallCodeParam, opts ...grpc.CallOption) (*CallResult, error) {
+ out := new(CallResult)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/CallCode", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) Transact(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*TxReceipt, error) {
+ out := new(TxReceipt)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/Transact", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) TransactAndHold(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*pbevents.EventDataCall, error) {
+ out := new(pbevents.EventDataCall)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/TransactAndHold", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) Send(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error) {
+ out := new(TxReceipt)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/Send", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) SendAndHold(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error) {
+ out := new(TxReceipt)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/SendAndHold", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *transactorClient) SignTx(ctx context.Context, in *SignTxParam, opts ...grpc.CallOption) (*SignedTx, error) {
+ out := new(SignedTx)
+ err := c.cc.Invoke(ctx, "/pbtransactor.Transactor/SignTx", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// TransactorServer is the server API for Transactor service.
+type TransactorServer interface {
+ BroadcastTx(context.Context, *TxParam) (*TxReceipt, error)
+ Call(context.Context, *CallParam) (*CallResult, error)
+ CallCode(context.Context, *CallCodeParam) (*CallResult, error)
+ Transact(context.Context, *TransactParam) (*TxReceipt, error)
+ TransactAndHold(context.Context, *TransactParam) (*pbevents.EventDataCall, error)
+ Send(context.Context, *SendParam) (*TxReceipt, error)
+ SendAndHold(context.Context, *SendParam) (*TxReceipt, error)
+ SignTx(context.Context, *SignTxParam) (*SignedTx, error)
+}
+
+func RegisterTransactorServer(s *grpc.Server, srv TransactorServer) {
+ s.RegisterService(&_Transactor_serviceDesc, srv)
+}
+
+func _Transactor_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(TxParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).BroadcastTx(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/BroadcastTx",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).BroadcastTx(ctx, req.(*TxParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(CallParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).Call(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/Call",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).Call(ctx, req.(*CallParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_CallCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(CallCodeParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).CallCode(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/CallCode",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).CallCode(ctx, req.(*CallCodeParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_Transact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(TransactParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).Transact(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/Transact",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).Transact(ctx, req.(*TransactParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_TransactAndHold_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(TransactParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).TransactAndHold(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/TransactAndHold",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).TransactAndHold(ctx, req.(*TransactParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_Send_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SendParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).Send(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/Send",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).Send(ctx, req.(*SendParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_SendAndHold_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SendParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).SendAndHold(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/SendAndHold",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).SendAndHold(ctx, req.(*SendParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Transactor_SignTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(SignTxParam)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(TransactorServer).SignTx(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/pbtransactor.Transactor/SignTx",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(TransactorServer).SignTx(ctx, req.(*SignTxParam))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _Transactor_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "pbtransactor.Transactor",
+ HandlerType: (*TransactorServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "BroadcastTx",
+ Handler: _Transactor_BroadcastTx_Handler,
+ },
+ {
+ MethodName: "Call",
+ Handler: _Transactor_Call_Handler,
+ },
+ {
+ MethodName: "CallCode",
+ Handler: _Transactor_CallCode_Handler,
+ },
+ {
+ MethodName: "Transact",
+ Handler: _Transactor_Transact_Handler,
+ },
+ {
+ MethodName: "TransactAndHold",
+ Handler: _Transactor_TransactAndHold_Handler,
+ },
+ {
+ MethodName: "Send",
+ Handler: _Transactor_Send_Handler,
+ },
+ {
+ MethodName: "SendAndHold",
+ Handler: _Transactor_SendAndHold_Handler,
+ },
+ {
+ MethodName: "SignTx",
+ Handler: _Transactor_SignTx_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "github.com/hyperledger/burrow/execution/pbtransactor/transactor.proto",
+}
+
+func init() {
+ proto.RegisterFile("github.com/hyperledger/burrow/execution/pbtransactor/transactor.proto", fileDescriptor_transactor_abf3bfc7b34ac7c7)
+}
+
+var fileDescriptor_transactor_abf3bfc7b34ac7c7 = []byte{
+ // 614 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x55, 0x51, 0x6f, 0xd3, 0x30,
+ 0x10, 0x56, 0xd7, 0xb0, 0xb5, 0xd7, 0x6e, 0x43, 0x96, 0x18, 0x59, 0x98, 0xd0, 0x94, 0xa7, 0x3e,
+ 0x35, 0x68, 0x20, 0x04, 0x42, 0x0c, 0xba, 0x6e, 0x6c, 0x68, 0x20, 0x4d, 0x59, 0x78, 0xe1, 0xcd,
+ 0x8d, 0x6f, 0x5d, 0xa4, 0x36, 0x8e, 0x1c, 0x67, 0xcb, 0x1e, 0x79, 0xe7, 0x9f, 0xf0, 0x27, 0x91,
+ 0x1d, 0xa7, 0x6d, 0x52, 0x0a, 0x0c, 0xf1, 0x94, 0xbb, 0xf3, 0xe7, 0xcf, 0xdf, 0xdd, 0xf9, 0x1c,
+ 0x38, 0x19, 0x47, 0xf2, 0x3a, 0x1b, 0xf5, 0x43, 0x3e, 0xf5, 0xae, 0xef, 0x12, 0x14, 0x13, 0x64,
+ 0x63, 0x14, 0xde, 0x28, 0x13, 0x82, 0xdf, 0x7a, 0x98, 0x63, 0x98, 0xc9, 0x88, 0xc7, 0x5e, 0x32,
+ 0x92, 0x82, 0xc6, 0x29, 0x0d, 0x25, 0x17, 0xde, 0xdc, 0xec, 0x27, 0x82, 0x4b, 0x4e, 0xba, 0x8b,
+ 0xcb, 0xce, 0xf1, 0xdf, 0x92, 0xe2, 0x0d, 0xc6, 0x32, 0xf5, 0x92, 0x91, 0x31, 0x8a, 0x4f, 0xc1,
+ 0xe9, 0x7e, 0x86, 0xf6, 0x90, 0x4e, 0x26, 0x17, 0x54, 0xd0, 0x29, 0x21, 0x60, 0x5d, 0x09, 0x3e,
+ 0xb5, 0x1b, 0xfb, 0x8d, 0x5e, 0xd7, 0xd7, 0x36, 0xb1, 0x61, 0x83, 0x32, 0x26, 0x30, 0x4d, 0xed,
+ 0x35, 0x1d, 0x2e, 0x5d, 0x85, 0x66, 0x54, 0x52, 0xbb, 0x59, 0xa0, 0x95, 0xed, 0x9e, 0xc3, 0xa6,
+ 0xa2, 0x1b, 0x72, 0x86, 0xab, 0x29, 0x09, 0x58, 0x21, 0x67, 0x68, 0xf8, 0xb4, 0xfd, 0x4b, 0xb2,
+ 0x1f, 0x0d, 0xd8, 0x0c, 0x4c, 0xc2, 0x05, 0xdb, 0x21, 0x74, 0xa3, 0x38, 0xc9, 0xe4, 0x20, 0x0c,
+ 0x79, 0x16, 0x4b, 0xcd, 0xda, 0x39, 0x70, 0xfa, 0x8b, 0x85, 0xe9, 0x7f, 0x5c, 0x40, 0xf8, 0x15,
+ 0xfc, 0xfd, 0x92, 0x21, 0x0e, 0xb4, 0xc6, 0x34, 0xfd, 0x14, 0x4d, 0x23, 0x69, 0x5b, 0xfb, 0x8d,
+ 0x9e, 0xe5, 0xcf, 0x7c, 0xf2, 0x10, 0x9a, 0x57, 0x88, 0xf6, 0x03, 0x1d, 0x56, 0xa6, 0xfb, 0xad,
+ 0x01, 0xed, 0x4b, 0x8c, 0xd9, 0xff, 0x51, 0xba, 0x07, 0x6d, 0xc9, 0x07, 0x15, 0xad, 0xf3, 0x00,
+ 0xd9, 0x81, 0x75, 0x3a, 0xd5, 0xbc, 0x4d, 0x2d, 0xc0, 0x78, 0xee, 0x2e, 0x6c, 0x04, 0x79, 0x21,
+ 0x60, 0x0b, 0xd6, 0x64, 0x6e, 0xca, 0xbe, 0x26, 0x73, 0x17, 0xa1, 0x73, 0x19, 0x8d, 0xe3, 0x15,
+ 0xcb, 0xe4, 0x03, 0x6c, 0x27, 0x22, 0xba, 0xa1, 0x12, 0x8d, 0x02, 0x75, 0x6a, 0xb3, 0xd7, 0x39,
+ 0xd8, 0xab, 0x4a, 0xbe, 0xa8, 0x80, 0xfc, 0xfa, 0x26, 0xd7, 0x81, 0x96, 0x3a, 0x06, 0x59, 0x90,
+ 0x2f, 0x49, 0x38, 0x04, 0x50, 0x97, 0xc3, 0xc7, 0x34, 0x9b, 0x48, 0x95, 0x83, 0x8f, 0x32, 0x13,
+ 0xb1, 0x41, 0x18, 0x4f, 0xf5, 0xe8, 0x94, 0xa6, 0x5f, 0x52, 0x64, 0x3a, 0x6f, 0xcb, 0x2f, 0x5d,
+ 0xf7, 0x16, 0xda, 0x41, 0xee, 0x63, 0x88, 0x51, 0xa2, 0xb7, 0x07, 0xf9, 0x19, 0x4d, 0xaf, 0xcb,
+ 0xed, 0x85, 0x47, 0x7a, 0xb0, 0x3d, 0x14, 0x48, 0x25, 0xa6, 0x43, 0x1e, 0x4b, 0x41, 0x43, 0xa9,
+ 0x69, 0x5a, 0x7e, 0x3d, 0xac, 0x91, 0xc6, 0x2e, 0x0b, 0x5d, 0x74, 0xbf, 0x1e, 0x76, 0xcf, 0xa0,
+ 0xbb, 0xd8, 0x2a, 0xf2, 0x14, 0xc0, 0xe4, 0x7d, 0x8e, 0x77, 0xe6, 0xfc, 0x85, 0xc8, 0xea, 0x6b,
+ 0xe6, 0x3e, 0x83, 0xad, 0x6a, 0x05, 0x15, 0xd7, 0xc5, 0x12, 0xd7, 0x3c, 0x72, 0xf0, 0xdd, 0x02,
+ 0x08, 0x66, 0xf5, 0x27, 0x6f, 0xa1, 0x73, 0x24, 0x38, 0x65, 0x21, 0x4d, 0x65, 0x90, 0x93, 0x47,
+ 0xd5, 0xee, 0x98, 0xee, 0x3a, 0x8f, 0xeb, 0xe1, 0xb2, 0x6a, 0xaf, 0xc1, 0x52, 0x2d, 0x20, 0x35,
+ 0xc0, 0xec, 0x09, 0x70, 0xec, 0xe5, 0x05, 0xd3, 0xaf, 0x01, 0xb4, 0xca, 0xd1, 0x26, 0x4f, 0x96,
+ 0x51, 0xb3, 0x91, 0xff, 0x0d, 0xc5, 0x7b, 0x68, 0x95, 0xa9, 0xd4, 0x29, 0x2a, 0x73, 0xbe, 0x5a,
+ 0xff, 0x29, 0x6c, 0x97, 0xc8, 0x41, 0xcc, 0xce, 0xf8, 0x84, 0xfd, 0x99, 0xc8, 0xbc, 0x77, 0x27,
+ 0xea, 0x73, 0x4c, 0x25, 0xd5, 0x05, 0x78, 0x05, 0x96, 0x1a, 0xd6, 0x7a, 0x21, 0x66, 0x03, 0xbc,
+ 0x5a, 0xc2, 0x3b, 0xe8, 0x28, 0x54, 0x79, 0xfc, 0xfd, 0x09, 0xde, 0xc0, 0x7a, 0x31, 0x89, 0x64,
+ 0xb7, 0xb6, 0x77, 0x3e, 0x9f, 0xce, 0xce, 0xf2, 0x92, 0x9a, 0xa9, 0xa3, 0x97, 0x5f, 0x5f, 0xfc,
+ 0xcb, 0xcf, 0x64, 0xb4, 0xae, 0x9f, 0xfb, 0xe7, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xe0, 0x16,
+ 0x56, 0xc5, 0x8b, 0x06, 0x00, 0x00,
+}
diff --git a/execution/pbtransactor/transactor.proto b/execution/pbtransactor/transactor.proto
new file mode 100644
index 0000000000000000000000000000000000000000..07679018bbaf77bb7397d96283c68ca8db6e8260
--- /dev/null
+++ b/execution/pbtransactor/transactor.proto
@@ -0,0 +1,81 @@
+syntax = 'proto3';
+
+package pbtransactor;
+
+option go_package = "github.com/hyperledger/burrow/execution/pbtransactor";
+
+import "github.com/hyperledger/burrow/execution/events/pbevents/events.proto";
+
+// Transaction Service Definition
+service Transactor {
+ rpc BroadcastTx (TxParam) returns (TxReceipt);
+ rpc Call (CallParam) returns (CallResult);
+ rpc CallCode (CallCodeParam) returns (CallResult);
+ rpc Transact (TransactParam) returns (TxReceipt);
+ rpc TransactAndHold (TransactParam) returns (pbevents.EventDataCall);
+ rpc Send (SendParam) returns (TxReceipt);
+ rpc SendAndHold (SendParam) returns (TxReceipt);
+ rpc SignTx (SignTxParam) returns (SignedTx);
+}
+
+// Params
+message CallParam {
+ bytes from = 1;
+ bytes address = 2;
+ bytes data = 3;
+}
+
+message CallCodeParam {
+ bytes from = 1;
+ bytes code = 2;
+ bytes data = 3;
+}
+
+message TransactParam {
+ InputAccount inputAccount = 1;
+ bytes address = 2;
+ bytes data = 3;
+ uint64 gasLimit = 4;
+ uint64 fee = 5;
+}
+
+message SendParam {
+ InputAccount inputAccount = 1;
+ bytes toAddress = 2;
+ uint64 amount = 3;
+}
+
+message TxParam {
+ bytes tx = 1;
+}
+
+message SignTxParam {
+ bytes tx = 1;
+ repeated PrivateAccount privateAccounts = 2;
+}
+
+// Results
+message SignedTx {
+ bytes tx = 1;
+}
+
+message CallResult {
+ bytes Return = 1;
+ uint64 GasUsed = 2;
+}
+
+message TxReceipt {
+ bytes TxHash = 1;
+ bool CreatesContract = 2;
+ bytes ContractAddress = 3;
+}
+
+message InputAccount {
+ bytes privateKey = 1;
+ bytes address = 2;
+}
+
+message PrivateAccount {
+ bytes PrivateKey = 1;
+}
+//--------------------------------------------------
\ No newline at end of file
diff --git a/execution/state.go b/execution/state.go
index 39942cda25ffea3cf263a964f521b18b3910a086..07409c436ab2cdfb3fc03cb7123e316c2213368f 100644
--- a/execution/state.go
+++ b/execution/state.go
@@ -15,6 +15,7 @@
package execution
import (
+ "context"
"fmt"
"sync"
"time"
@@ -23,6 +24,8 @@ import (
"github.com/hyperledger/burrow/account/state"
"github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/execution/names"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging"
@@ -34,6 +37,10 @@ import (
const (
defaultCacheCapacity = 1024
+ // Age of state versions in blocks before we remove them. This has us keeping a little over an hour's worth of blocks
+ // in principle we could manage with 2. Ideally we would lift this limit altogether but IAVL leaks memory on access
+ // to previous tree versions since it lazy loads values (nice) but gives no ability to unload them (see SaveBranch)
+ defaultVersionExpiry = 2048
// Version by state hash
versionPrefix = "v/"
@@ -42,6 +49,7 @@ const (
accountsPrefix = "a/"
storagePrefix = "s/"
nameRegPrefix = "n/"
+ eventPrefix = "e/"
)
var (
@@ -51,22 +59,47 @@ var (
)
// Implements account and blockchain state
-var _ state.AccountUpdater = &State{}
-var _ state.Iterable = &State{}
-var _ state.Writer = &State{}
+var _ state.IterableReader = &State{}
+var _ names.IterableReader = &State{}
+var _ Updatable = &writeState{}
+
+type Updatable interface {
+ state.Writer
+ names.Writer
+ event.Publisher
+}
+
+// Wraps state to give access to writer methods
+type writeState struct {
+ state *State
+}
+// Writers to state are responsible for calling State.Lock() before calling
type State struct {
+ // Values not reassigned
sync.RWMutex
- db dbm.DB
- tree *iavl.VersionedTree
- logger *logging.Logger
+ writeState *writeState
+ db dbm.DB
+ tree *iavl.VersionedTree
+ logger *logging.Logger
+
+ // Values may be reassigned (mutex protected)
+ // Previous version of IAVL tree for concurrent read-only access
+ readTree *iavl.Tree
+ // High water mark for height/index - make sure we do not overwrite events - should only increase
+ eventKeyHighWatermark events.Key
+ // Last state hash
+ hash []byte
}
+// Create a new State object
func NewState(db dbm.DB) *State {
- return &State{
+ s := &State{
db: db,
tree: iavl.NewVersionedTree(db, defaultCacheCapacity),
}
+ s.writeState = &writeState{state: s}
+ return s
}
// Make genesis state from GenesisDoc and save to DB
@@ -75,7 +108,7 @@ func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error)
return nil, fmt.Errorf("the genesis file has no validators")
}
- state := NewState(db)
+ s := NewState(db)
if genesisDoc.GenesisTime.IsZero() {
// NOTE: [ben] change GenesisTime to requirement on v0.17
@@ -94,7 +127,7 @@ func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error)
Balance: genAcc.Amount,
Permissions: perm,
}
- err := state.UpdateAccount(acc.Account())
+ err := s.writeState.UpdateAccount(acc.Account())
if err != nil {
return nil, err
}
@@ -113,17 +146,17 @@ func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error)
Balance: 1337,
Permissions: globalPerms,
}
- err := state.UpdateAccount(permsAcc.Account())
+ err := s.writeState.UpdateAccount(permsAcc.Account())
if err != nil {
return nil, err
}
- // IAVLTrees must be persisted before copy operations.
- err = state.Save()
+ // We need to save at least once so that readTree points at a non-working-state tree
+ _, err = s.writeState.save()
if err != nil {
return nil, err
}
- return state, nil
+ return s, nil
}
@@ -131,13 +164,24 @@ func MakeGenesisState(db dbm.DB, genesisDoc *genesis.GenesisDoc) (*State, error)
func LoadState(db dbm.DB, hash []byte) (*State, error) {
s := NewState(db)
// Get the version associated with this state hash
- version, err := s.GetVersion(hash)
+ version, err := s.writeState.GetVersion(hash)
if err != nil {
return nil, err
}
- treeVersion, err := s.tree.LoadVersion(version)
+ if version <= 0 {
+ return nil, fmt.Errorf("trying to load state from non-positive version: version %v, hash: %X", version, hash)
+ }
+ // Load previous version for readTree
+ treeVersion, err := s.tree.LoadVersion(version - 1)
+ if err != nil {
+ return nil, fmt.Errorf("could not load previous version of state tree: %v", version-1)
+ }
+ // Set readTree
+ s.readTree = s.tree.Tree()
+ // Load previous version for readTree
+ treeVersion, err = s.tree.LoadVersion(version)
if err != nil {
- return nil, fmt.Errorf("could not load versioned state tree")
+ return nil, fmt.Errorf("could not load current version of state tree: version %v, hash: %X", version, hash)
}
if treeVersion != version {
return nil, fmt.Errorf("tried to load state version %v for state hash %X but loaded version %v",
@@ -146,22 +190,36 @@ func LoadState(db dbm.DB, hash []byte) (*State, error) {
return s, nil
}
-func (s *State) Save() error {
+// Perform updates to state whilst holding the write lock, allows a commit to hold the write lock across multiple
+// operations while preventing interlaced reads and writes
+func (s *State) Update(updater func(up Updatable) error) ([]byte, error) {
s.Lock()
defer s.Unlock()
- // Save state at a new version may still be orphaned before we save the version against the hash
- hash, treeVersion, err := s.tree.SaveVersion()
+ updater(s.writeState)
+ return s.writeState.save()
+}
+
+func (ws *writeState) save() ([]byte, error) {
+ // Grab the current orphaning tree and save it for reads against committed state. Note that this tree will lazy
+ // load nodes from database (in-memory nodes are cleared when a version is saved - see SaveBranch in IAVL), however
+ // they are not cleared unless SaveBranch is called - and only LoadVersion/SaveVersion could do that which is a hack
+ ws.state.readTree = ws.state.tree.Tree()
+
+ // save state at a new version may still be orphaned before we save the version against the hash
+ hash, treeVersion, err := ws.state.tree.SaveVersion()
if err != nil {
- return err
+ return nil, err
}
+
// Provide a reference to load this version in the future from the state hash
- s.SetVersion(hash, treeVersion)
- return nil
+ ws.SetVersion(hash, treeVersion)
+ ws.state.hash = hash
+ return hash, err
}
// Get a previously saved tree version stored by state hash
-func (s *State) GetVersion(hash []byte) (int64, error) {
- versionBytes := s.db.Get(prefixedKey(versionPrefix, hash))
+func (ws *writeState) GetVersion(hash []byte) (int64, error) {
+ versionBytes := ws.state.db.Get(prefixedKey(versionPrefix, hash))
if versionBytes == nil {
return -1, fmt.Errorf("could not retrieve version corresponding to state hash '%X' in database", hash)
}
@@ -169,33 +227,22 @@ func (s *State) GetVersion(hash []byte) (int64, error) {
}
// Set the tree version associated with a particular hash
-func (s *State) SetVersion(hash []byte, version int64) {
+func (ws *writeState) SetVersion(hash []byte, version int64) {
versionBytes := make([]byte, 8)
binary.PutInt64BE(versionBytes, version)
- s.db.SetSync(prefixedKey(versionPrefix, hash), versionBytes)
-}
-
-// Computes the state hash, also computed on save where it is returned
-func (s *State) Hash() []byte {
- s.RLock()
- defer s.RUnlock()
- return s.tree.Hash()
+ ws.state.db.SetSync(prefixedKey(versionPrefix, hash), versionBytes)
}
// Returns nil if account does not exist with given address.
func (s *State) GetAccount(address crypto.Address) (acm.Account, error) {
- s.RLock()
- defer s.RUnlock()
- _, accBytes := s.tree.Get(prefixedKey(accountsPrefix, address.Bytes()))
+ _, accBytes := s.readTree.Get(prefixedKey(accountsPrefix, address.Bytes()))
if accBytes == nil {
return nil, nil
}
return acm.Decode(accBytes)
}
-func (s *State) UpdateAccount(account acm.Account) error {
- s.Lock()
- defer s.Unlock()
+func (ws *writeState) UpdateAccount(account acm.Account) error {
if account == nil {
return fmt.Errorf("UpdateAccount passed nil account in execution.State")
}
@@ -207,21 +254,17 @@ func (s *State) UpdateAccount(account acm.Account) error {
if err != nil {
return err
}
- s.tree.Set(prefixedKey(accountsPrefix, account.Address().Bytes()), encodedAccount)
+ ws.state.tree.Set(prefixedKey(accountsPrefix, account.Address().Bytes()), encodedAccount)
return nil
}
-func (s *State) RemoveAccount(address crypto.Address) error {
- s.Lock()
- defer s.Unlock()
- s.tree.Remove(prefixedKey(accountsPrefix, address.Bytes()))
+func (ws *writeState) RemoveAccount(address crypto.Address) error {
+ ws.state.tree.Remove(prefixedKey(accountsPrefix, address.Bytes()))
return nil
}
func (s *State) IterateAccounts(consumer func(acm.Account) (stop bool)) (stopped bool, err error) {
- s.RLock()
- defer s.RUnlock()
- stopped = s.tree.IterateRange(accountsStart, accountsEnd, true, func(key, value []byte) bool {
+ stopped = s.readTree.IterateRange(accountsStart, accountsEnd, true, func(key, value []byte) bool {
var account acm.Account
account, err = acm.Decode(value)
if err != nil {
@@ -233,29 +276,22 @@ func (s *State) IterateAccounts(consumer func(acm.Account) (stop bool)) (stopped
}
func (s *State) GetStorage(address crypto.Address, key binary.Word256) (binary.Word256, error) {
- s.RLock()
- defer s.RUnlock()
- _, value := s.tree.Get(prefixedKey(storagePrefix, address.Bytes(), key.Bytes()))
+ _, value := s.readTree.Get(prefixedKey(storagePrefix, address.Bytes(), key.Bytes()))
return binary.LeftPadWord256(value), nil
}
-func (s *State) SetStorage(address crypto.Address, key, value binary.Word256) error {
- s.Lock()
- defer s.Unlock()
+func (ws *writeState) SetStorage(address crypto.Address, key, value binary.Word256) error {
if value == binary.Zero256 {
- s.tree.Remove(key.Bytes())
+ ws.state.tree.Remove(key.Bytes())
} else {
- s.tree.Set(prefixedKey(storagePrefix, address.Bytes(), key.Bytes()), value.Bytes())
+ ws.state.tree.Set(prefixedKey(storagePrefix, address.Bytes(), key.Bytes()), value.Bytes())
}
return nil
}
func (s *State) IterateStorage(address crypto.Address,
consumer func(key, value binary.Word256) (stop bool)) (stopped bool, err error) {
- s.RLock()
- defer s.RUnlock()
-
- stopped = s.tree.IterateRange(storageStart, storageEnd, true, func(key []byte, value []byte) (stop bool) {
+ stopped = s.readTree.IterateRange(storageStart, storageEnd, true, func(key []byte, value []byte) (stop bool) {
// Note: no left padding should occur unless there is a bug and non-words have been writte to this storage tree
if len(key) != binary.Word256Length {
err = fmt.Errorf("key '%X' stored for account %s is not a %v-byte word",
@@ -274,12 +310,60 @@ func (s *State) IterateStorage(address crypto.Address,
// State.storage
//-------------------------------------
+// Events
+
+// Execution events
+func (ws *writeState) Publish(ctx context.Context, msg interface{}, tags event.Tags) error {
+ if exeEvent, ok := msg.(*events.Event); ok {
+ key := exeEvent.Header.Key()
+ if !key.IsSuccessorOf(ws.state.eventKeyHighWatermark) {
+ return fmt.Errorf("received event with non-increasing key compared with current high watermark %v: %v",
+ ws.state.eventKeyHighWatermark, exeEvent)
+ }
+ ws.state.eventKeyHighWatermark = key
+ bs, err := exeEvent.Encode()
+ if err != nil {
+ return err
+ }
+ ws.state.tree.Set(eventKey(key), bs)
+ }
+ return nil
+}
+
+func (s *State) GetEvents(startKey, endKey events.Key, consumer func(ev *events.Event) (stop bool)) (stopped bool, err error) {
+ return s.tree.IterateRange(eventKey(startKey), eventKey(endKey), true,
+ func(_, value []byte) bool {
+ var exeEvent *events.Event
+ exeEvent, err = events.DecodeEvent(value)
+ if err != nil {
+ err = fmt.Errorf("error unmarshalling ExecutionEvent in GetEvents: %v", err)
+ // stop iteration on error
+ return true
+ }
+ return consumer(exeEvent)
+ }), err
+}
+
+func (s *State) Hash() []byte {
+ s.RLock()
+ defer s.RUnlock()
+ return s.hash
+}
+
+func (s *State) LatestEventKey() events.Key {
+ s.RLock()
+ defer s.RUnlock()
+ return s.eventKeyHighWatermark
+}
+
+// Events
+//-------------------------------------
// State.nameReg
-var _ names.Iterable = &State{}
+var _ names.IterableReader = &State{}
func (s *State) GetNameEntry(name string) (*names.Entry, error) {
- _, entryBytes := s.tree.Get(prefixedKey(nameRegPrefix, []byte(name)))
+ _, entryBytes := s.readTree.Get(prefixedKey(nameRegPrefix, []byte(name)))
if entryBytes == nil {
return nil, nil
}
@@ -288,7 +372,7 @@ func (s *State) GetNameEntry(name string) (*names.Entry, error) {
}
func (s *State) IterateNameEntries(consumer func(*names.Entry) (stop bool)) (stopped bool, err error) {
- return s.tree.IterateRange(nameRegStart, nameRegEnd, true, func(key []byte, value []byte) (stop bool) {
+ return s.readTree.IterateRange(nameRegStart, nameRegEnd, true, func(key []byte, value []byte) (stop bool) {
var entry *names.Entry
entry, err = names.DecodeEntry(value)
if err != nil {
@@ -298,28 +382,36 @@ func (s *State) IterateNameEntries(consumer func(*names.Entry) (stop bool)) (sto
}), err
}
-func (s *State) UpdateNameEntry(entry *names.Entry) error {
+func (ws *writeState) UpdateNameEntry(entry *names.Entry) error {
bs, err := entry.Encode()
if err != nil {
return err
}
- s.tree.Set(prefixedKey(nameRegPrefix, []byte(entry.Name)), bs)
+ ws.state.tree.Set(prefixedKey(nameRegPrefix, []byte(entry.Name)), bs)
return nil
}
-func (s *State) RemoveNameEntry(name string) error {
- s.tree.Remove(prefixedKey(nameRegPrefix, []byte(name)))
+func (ws *writeState) RemoveNameEntry(name string) error {
+ ws.state.tree.Remove(prefixedKey(nameRegPrefix, []byte(name)))
return nil
}
// Creates a copy of the database to the supplied db
-func (s *State) Copy(db dbm.DB) *State {
- state := NewState(db)
+func (s *State) Copy(db dbm.DB) (*State, error) {
+ stateCopy := NewState(db)
s.tree.Iterate(func(key []byte, value []byte) bool {
- state.tree.Set(key, value)
+ stateCopy.tree.Set(key, value)
return false
})
- return state
+ _, err := stateCopy.writeState.save()
+ if err != nil {
+ return nil, err
+ }
+ return stateCopy, nil
+}
+
+func eventKey(key events.Key) []byte {
+ return prefixedKey(eventPrefix, key)
}
func prefixedKey(prefix string, suffices ...[]byte) []byte {
diff --git a/execution/state_test.go b/execution/state_test.go
index e72076b1359f6d07294c123a2a36b6637fd32278..360910ba9021aa0c719b75d8b6b150833667cc23 100644
--- a/execution/state_test.go
+++ b/execution/state_test.go
@@ -15,24 +15,106 @@
package execution
import (
+ "context"
+ "encoding/json"
+ "fmt"
"testing"
+ "github.com/golang/protobuf/proto"
acm "github.com/hyperledger/burrow/account"
+ "github.com/hyperledger/burrow/binary"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution/events"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/hyperledger/burrow/execution/evm/sha3"
permission "github.com/hyperledger/burrow/permission/types"
+ "github.com/hyperledger/burrow/txs"
+ "github.com/hyperledger/burrow/txs/payload"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/tendermint/tmlibs/db"
)
func TestState_UpdateAccount(t *testing.T) {
- state := NewState(db.NewMemDB())
+ s := NewState(db.NewMemDB())
account := acm.NewConcreteAccountFromSecret("Foo").MutableAccount()
account.MutablePermissions().Base.Perms = permission.SetGlobal | permission.HasRole
- err := state.UpdateAccount(account)
- err = state.Save()
+ _, err := s.Update(func(ws Updatable) error {
+ return ws.UpdateAccount(account)
+ })
+ require.NoError(t, err)
require.NoError(t, err)
- accountOut, err := state.GetAccount(account.Address())
+ accountOut, err := s.GetAccount(account.Address())
require.NoError(t, err)
assert.Equal(t, account, accountOut)
}
+
+func TestState_Publish(t *testing.T) {
+ s := NewState(db.NewMemDB())
+ ctx := context.Background()
+ evs := []*events.Event{
+ mkEvent(100, 0),
+ mkEvent(100, 1),
+ }
+ _, err := s.Update(func(ws Updatable) error {
+ for _, ev := range evs {
+ require.NoError(t, ws.Publish(ctx, ev, nil))
+ }
+ return nil
+ })
+ require.NoError(t, err)
+ i := 0
+ _, err = s.GetEvents(events.NewKey(100, 0), events.NewKey(100, 0),
+ func(ev *events.Event) (stop bool) {
+ assert.Equal(t, evs[i], ev)
+ i++
+ return false
+ })
+ require.NoError(t, err)
+ // non-increasing events
+ _, err = s.Update(func(ws Updatable) error {
+ require.Error(t, ws.Publish(ctx, mkEvent(100, 0), nil))
+ require.Error(t, ws.Publish(ctx, mkEvent(100, 1), nil))
+ require.Error(t, ws.Publish(ctx, mkEvent(99, 1324234), nil))
+ require.NoError(t, ws.Publish(ctx, mkEvent(100, 2), nil))
+ require.NoError(t, ws.Publish(ctx, mkEvent(101, 0), nil))
+ return nil
+ })
+ require.NoError(t, err)
+}
+
+func TestProtobufEventSerialisation(t *testing.T) {
+ ev := mkEvent(112, 23)
+ pbEvent := pbevents.GetExecutionEvent(ev)
+ bs, err := proto.Marshal(pbEvent)
+ require.NoError(t, err)
+ pbEventOut := new(pbevents.ExecutionEvent)
+ require.NoError(t, proto.Unmarshal(bs, pbEventOut))
+ fmt.Println(pbEventOut)
+ assert.Equal(t, asJSON(t, pbEvent), asJSON(t, pbEventOut))
+}
+
+func mkEvent(height, index uint64) *events.Event {
+ return &events.Event{
+ Header: &events.Header{
+ Height: height,
+ Index: index,
+ TxHash: sha3.Sha3([]byte(fmt.Sprintf("txhash%v%v", height, index))),
+ EventID: fmt.Sprintf("eventID: %v%v", height, index),
+ },
+ Tx: &events.EventDataTx{
+ Tx: txs.Enclose("foo", &payload.CallTx{}).Tx,
+ },
+ Log: &events.EventDataLog{
+ Address: crypto.Address{byte(height), byte(index)},
+ Topics: []binary.Word256{{1, 2, 3}},
+ },
+ }
+}
+
+func asJSON(t *testing.T, v interface{}) string {
+ bs, err := json.Marshal(v)
+ require.NoError(t, err)
+ return string(bs)
+}
diff --git a/execution/transactor.go b/execution/transactor.go
index 949dfb9c8653bd085e43b3fd944a6246fa390601..b620d481d6ddeabc034d76f0e8e4a14b1d8eb707 100644
--- a/execution/transactor.go
+++ b/execution/transactor.go
@@ -30,9 +30,8 @@ import (
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/execution/errors"
- exe_events "github.com/hyperledger/burrow/execution/events"
+ "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/execution/evm"
- evm_events "github.com/hyperledger/burrow/execution/evm/events"
"github.com/hyperledger/burrow/execution/executors"
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
@@ -211,7 +210,7 @@ func (trans *Transactor) Transact(sequentialSigningAccount *SequentialSigningAcc
}
func (trans *Transactor) TransactAndHold(ctx context.Context, sequentialSigningAccount *SequentialSigningAccount,
- address *crypto.Address, data []byte, gasLimit, fee uint64) (*evm_events.EventDataCall, error) {
+ address *crypto.Address, data []byte, gasLimit, fee uint64) (*events.EventDataCall, error) {
inputAccount, unlock, err := sequentialSigningAccount.Lock()
if err != nil {
@@ -233,9 +232,9 @@ func (trans *Transactor) TransactAndHold(ctx context.Context, sequentialSigningA
// We want non-blocking on the first event received (but buffer the value),
// after which we want to block (and then discard the value - see below)
- ch := make(chan *evm_events.EventDataCall, 1)
+ ch := make(chan *events.EventDataCall, 1)
- err = evm_events.SubscribeAccountCall(context.Background(), trans.eventEmitter, subID, expectedReceipt.ContractAddress,
+ err = events.SubscribeAccountCall(context.Background(), trans.eventEmitter, subID, expectedReceipt.ContractAddress,
expectedReceipt.TxHash, 0, ch)
if err != nil {
return nil, err
@@ -261,7 +260,7 @@ func (trans *Transactor) TransactAndHold(ctx context.Context, sequentialSigningA
case <-timer.C:
return nil, fmt.Errorf("transaction timed out TxHash: %X", expectedReceipt.TxHash)
case eventDataCall := <-ch:
- if eventDataCall.Exception != nil && eventDataCall.Exception.Code != errors.ErrorCodeExecutionReverted {
+ if eventDataCall.Exception != nil && eventDataCall.Exception.ErrorCode() != errors.ErrorCodeExecutionReverted {
return nil, fmt.Errorf("error when transacting: %v", eventDataCall.Exception)
} else {
return eventDataCall, nil
@@ -331,7 +330,7 @@ func (trans *Transactor) SendAndHold(ctx context.Context, sequentialSigningAccou
}
wc := make(chan *payload.SendTx)
- err = exe_events.SubscribeAccountOutputSendTx(context.Background(), trans.eventEmitter, subID, toAddress,
+ err = events.SubscribeAccountOutputSendTx(context.Background(), trans.eventEmitter, subID, toAddress,
expectedReceipt.TxHash, wc)
if err != nil {
return nil, err
diff --git a/keys/key_client.go b/keys/key_client.go
index fb19e5b1afc42a122ca03e2ebd7b12f1860ac44f..bae1d0ae70d4cf987f856204b96f8e0d465dbb8a 100644
--- a/keys/key_client.go
+++ b/keys/key_client.go
@@ -43,7 +43,7 @@ var _ KeyClient = (*localKeyClient)(nil)
var _ KeyClient = (*remoteKeyClient)(nil)
type localKeyClient struct {
- ks KeyStore
+ ks *KeyStore
logger *logging.Logger
}
@@ -53,7 +53,7 @@ type remoteKeyClient struct {
logger *logging.Logger
}
-func (l localKeyClient) Sign(signAddress crypto.Address, message []byte) (signature crypto.Signature, err error) {
+func (l *localKeyClient) Sign(signAddress crypto.Address, message []byte) (signature crypto.Signature, err error) {
resp, err := l.ks.Sign(nil, &pbkeys.SignRequest{Address: signAddress.String(), Message: message})
if err != nil {
return crypto.Signature{}, err
@@ -65,7 +65,7 @@ func (l localKeyClient) Sign(signAddress crypto.Address, message []byte) (signat
return crypto.SignatureFromBytes(resp.GetSignature(), curveType)
}
-func (l localKeyClient) PublicKey(address crypto.Address) (publicKey crypto.PublicKey, err error) {
+func (l *localKeyClient) PublicKey(address crypto.Address) (publicKey crypto.PublicKey, err error) {
resp, err := l.ks.PublicKey(nil, &pbkeys.PubRequest{Address: address.String()})
if err != nil {
return crypto.PublicKey{}, err
@@ -78,7 +78,7 @@ func (l localKeyClient) PublicKey(address crypto.Address) (publicKey crypto.Publ
}
// Generate requests that a key be generate within the keys instance and returns the address
-func (l localKeyClient) Generate(keyName string, curveType crypto.CurveType) (keyAddress crypto.Address, err error) {
+func (l *localKeyClient) Generate(keyName string, curveType crypto.CurveType) (keyAddress crypto.Address, err error) {
resp, err := l.ks.GenerateKey(nil, &pbkeys.GenRequest{Keyname: keyName, Curvetype: curveType.String()})
if err != nil {
return crypto.Address{}, err
@@ -87,11 +87,11 @@ func (l localKeyClient) Generate(keyName string, curveType crypto.CurveType) (ke
}
// Returns nil if the keys instance is healthy, error otherwise
-func (l localKeyClient) HealthCheck() error {
+func (l *localKeyClient) HealthCheck() error {
return nil
}
-func (l remoteKeyClient) Sign(signAddress crypto.Address, message []byte) (signature crypto.Signature, err error) {
+func (l *remoteKeyClient) Sign(signAddress crypto.Address, message []byte) (signature crypto.Signature, err error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
req := pbkeys.SignRequest{Address: signAddress.String(), Message: message}
@@ -109,7 +109,7 @@ func (l remoteKeyClient) Sign(signAddress crypto.Address, message []byte) (signa
return crypto.SignatureFromBytes(resp.GetSignature(), curveType)
}
-func (l remoteKeyClient) PublicKey(address crypto.Address) (publicKey crypto.PublicKey, err error) {
+func (l *remoteKeyClient) PublicKey(address crypto.Address) (publicKey crypto.PublicKey, err error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
req := pbkeys.PubRequest{Address: address.String()}
@@ -128,7 +128,7 @@ func (l remoteKeyClient) PublicKey(address crypto.Address) (publicKey crypto.Pub
}
// Generate requests that a key be generate within the keys instance and returns the address
-func (l remoteKeyClient) Generate(keyName string, curveType crypto.CurveType) (keyAddress crypto.Address, err error) {
+func (l *remoteKeyClient) Generate(keyName string, curveType crypto.CurveType) (keyAddress crypto.Address, err error) {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
req := pbkeys.GenRequest{Keyname: keyName, Curvetype: curveType.String()}
@@ -143,10 +143,10 @@ func (l remoteKeyClient) Generate(keyName string, curveType crypto.CurveType) (k
}
// Returns nil if the keys instance is healthy, error otherwise
-func (l remoteKeyClient) HealthCheck() error {
+func (l *remoteKeyClient) HealthCheck() error {
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
- _, err := l.kc.List(ctx, &pbkeys.Name{""})
+ _, err := l.kc.List(ctx, &pbkeys.ListRequest{})
return err
}
@@ -162,12 +162,12 @@ func NewRemoteKeyClient(rpcAddress string, logger *logging.Logger) (KeyClient, e
}
kc := pbkeys.NewKeysClient(conn)
- return remoteKeyClient{kc: kc, rpcAddress: rpcAddress, logger: logger}, nil
+ return &remoteKeyClient{kc: kc, rpcAddress: rpcAddress, logger: logger}, nil
}
-func NewLocalKeyClient(ks KeyStore, logger *logging.Logger) KeyClient {
+func NewLocalKeyClient(ks *KeyStore, logger *logging.Logger) KeyClient {
logger = logger.WithScope("LocalKeyClient")
- return localKeyClient{ks: ks, logger: logger}
+ return &localKeyClient{ks: ks, logger: logger}
}
type Signer struct {
diff --git a/keys/key_store.go b/keys/key_store.go
index bd1eda70f6e678cbc95d856b50000fdd27175692..0a8a1cf5a338698ab0f3ebaebfcfcfe3c50dea30 100644
--- a/keys/key_store.go
+++ b/keys/key_store.go
@@ -105,8 +105,8 @@ func IsValidKeyJson(j []byte) []byte {
return nil
}
-func NewKeyStore(dir string, AllowBadFilePermissions bool, logger *logging.Logger) KeyStore {
- return KeyStore{
+func NewKeyStore(dir string, AllowBadFilePermissions bool, logger *logging.Logger) *KeyStore {
+ return &KeyStore{
keysDirPath: dir,
AllowBadFilePermissions: AllowBadFilePermissions,
logger: logger.With(structure.ComponentKey, "keys").WithScope("NewKeyStore"),
@@ -120,7 +120,7 @@ type KeyStore struct {
logger *logging.Logger
}
-func (ks KeyStore) Gen(passphrase string, curveType crypto.CurveType) (key *Key, err error) {
+func (ks *KeyStore) Gen(passphrase string, curveType crypto.CurveType) (key *Key, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("GenerateNewKey error: %v", r)
@@ -134,7 +134,7 @@ func (ks KeyStore) Gen(passphrase string, curveType crypto.CurveType) (key *Key,
return key, err
}
-func (ks KeyStore) GetKey(passphrase string, keyAddr []byte) (*Key, error) {
+func (ks *KeyStore) GetKey(passphrase string, keyAddr []byte) (*Key, error) {
ks.Lock()
defer ks.Unlock()
dataDirPath, err := returnDataDir(ks.keysDirPath)
@@ -159,7 +159,7 @@ func (ks KeyStore) GetKey(passphrase string, keyAddr []byte) (*Key, error) {
}
}
-func (ks KeyStore) AllKeys() ([]*Key, error) {
+func (ks *KeyStore) AllKeys() ([]*Key, error) {
dataDirPath, err := returnDataDir(ks.keysDirPath)
if err != nil {
@@ -228,13 +228,13 @@ func DecryptKey(passphrase string, keyProtected *keyJSON) (*Key, error) {
return k, nil
}
-func (ks KeyStore) GetAllAddresses() (addresses [][]byte, err error) {
+func (ks *KeyStore) GetAllAddresses() (addresses [][]byte, err error) {
ks.Lock()
defer ks.Unlock()
return GetAllAddresses(ks.keysDirPath)
}
-func (ks KeyStore) StoreKey(passphrase string, key *Key) error {
+func (ks *KeyStore) StoreKey(passphrase string, key *Key) error {
ks.Lock()
defer ks.Unlock()
if passphrase != "" {
@@ -244,7 +244,7 @@ func (ks KeyStore) StoreKey(passphrase string, key *Key) error {
}
}
-func (ks KeyStore) StoreKeyPlain(key *Key) (err error) {
+func (ks *KeyStore) StoreKeyPlain(key *Key) (err error) {
keyJSON, err := json.Marshal(key)
if err != nil {
return err
@@ -257,7 +257,7 @@ func (ks KeyStore) StoreKeyPlain(key *Key) (err error) {
return err
}
-func (ks KeyStore) StoreKeyEncrypted(passphrase string, key *Key) error {
+func (ks *KeyStore) StoreKeyEncrypted(passphrase string, key *Key) error {
authArray := []byte(passphrase)
salt := make([]byte, 32)
_, err := rand.Read(salt)
@@ -314,7 +314,7 @@ func (ks KeyStore) StoreKeyEncrypted(passphrase string, key *Key) error {
return WriteKeyFile(key.Address[:], dataDirPath, keyJSON)
}
-func (ks KeyStore) DeleteKey(passphrase string, keyAddr []byte) (err error) {
+func (ks *KeyStore) DeleteKey(passphrase string, keyAddr []byte) (err error) {
dataDirPath, err := returnDataDir(ks.keysDirPath)
if err != nil {
return err
diff --git a/keys/pbkeys/keys.pb.go b/keys/pbkeys/keys.pb.go
index 480306389b777aa7e282a6b54769f5c179c18dc1..320ab041965a12c94c3e0757f810c9602b2f228c 100644
--- a/keys/pbkeys/keys.pb.go
+++ b/keys/pbkeys/keys.pb.go
@@ -1,33 +1,6 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: keys.proto
-
-/*
-Package pbkeys is a generated protocol buffer package.
-
-It is generated from these files:
- keys.proto
-
-It has these top-level messages:
- Name
- Empty
- GenRequest
- GenResponse
- PubRequest
- PubResponse
- ImportJSONRequest
- ImportResponse
- ImportRequest
- ExportRequest
- ExportResponse
- SignRequest
- SignResponse
- VerifyRequest
- HashRequest
- HashResponse
- Key
- ListResponse
- AddNameRequest
-*/
+// source: github.com/hyperledger/burrow/keys/pbkeys/keys.proto
+
package pbkeys
import proto "github.com/golang/protobuf/proto"
@@ -50,40 +23,196 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-type Name struct {
- Keyname string `protobuf:"bytes,1,opt,name=keyname" json:"keyname,omitempty"`
+type ListRequest struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ListRequest) Reset() { *m = ListRequest{} }
+func (m *ListRequest) String() string { return proto.CompactTextString(m) }
+func (*ListRequest) ProtoMessage() {}
+func (*ListRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{0}
+}
+func (m *ListRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ListRequest.Unmarshal(m, b)
+}
+func (m *ListRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ListRequest.Marshal(b, m, deterministic)
+}
+func (dst *ListRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ListRequest.Merge(dst, src)
+}
+func (m *ListRequest) XXX_Size() int {
+ return xxx_messageInfo_ListRequest.Size(m)
+}
+func (m *ListRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ListRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListRequest proto.InternalMessageInfo
+
+type VerifyResponse struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *VerifyResponse) Reset() { *m = VerifyResponse{} }
+func (m *VerifyResponse) String() string { return proto.CompactTextString(m) }
+func (*VerifyResponse) ProtoMessage() {}
+func (*VerifyResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{1}
+}
+func (m *VerifyResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_VerifyResponse.Unmarshal(m, b)
+}
+func (m *VerifyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_VerifyResponse.Marshal(b, m, deterministic)
+}
+func (dst *VerifyResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_VerifyResponse.Merge(dst, src)
+}
+func (m *VerifyResponse) XXX_Size() int {
+ return xxx_messageInfo_VerifyResponse.Size(m)
+}
+func (m *VerifyResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_VerifyResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VerifyResponse proto.InternalMessageInfo
+
+type RemoveNameResponse struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *RemoveNameResponse) Reset() { *m = RemoveNameResponse{} }
+func (m *RemoveNameResponse) String() string { return proto.CompactTextString(m) }
+func (*RemoveNameResponse) ProtoMessage() {}
+func (*RemoveNameResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{2}
+}
+func (m *RemoveNameResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_RemoveNameResponse.Unmarshal(m, b)
+}
+func (m *RemoveNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_RemoveNameResponse.Marshal(b, m, deterministic)
+}
+func (dst *RemoveNameResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_RemoveNameResponse.Merge(dst, src)
+}
+func (m *RemoveNameResponse) XXX_Size() int {
+ return xxx_messageInfo_RemoveNameResponse.Size(m)
+}
+func (m *RemoveNameResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_RemoveNameResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RemoveNameResponse proto.InternalMessageInfo
+
+type AddNameResponse struct {
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *AddNameResponse) Reset() { *m = AddNameResponse{} }
+func (m *AddNameResponse) String() string { return proto.CompactTextString(m) }
+func (*AddNameResponse) ProtoMessage() {}
+func (*AddNameResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{3}
+}
+func (m *AddNameResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AddNameResponse.Unmarshal(m, b)
+}
+func (m *AddNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AddNameResponse.Marshal(b, m, deterministic)
+}
+func (dst *AddNameResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AddNameResponse.Merge(dst, src)
+}
+func (m *AddNameResponse) XXX_Size() int {
+ return xxx_messageInfo_AddNameResponse.Size(m)
+}
+func (m *AddNameResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_AddNameResponse.DiscardUnknown(m)
}
-func (m *Name) Reset() { *m = Name{} }
-func (m *Name) String() string { return proto.CompactTextString(m) }
-func (*Name) ProtoMessage() {}
-func (*Name) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+var xxx_messageInfo_AddNameResponse proto.InternalMessageInfo
-func (m *Name) GetKeyname() string {
+type RemoveNameRequest struct {
+ Keyname string `protobuf:"bytes,1,opt,name=keyname,proto3" json:"keyname,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *RemoveNameRequest) Reset() { *m = RemoveNameRequest{} }
+func (m *RemoveNameRequest) String() string { return proto.CompactTextString(m) }
+func (*RemoveNameRequest) ProtoMessage() {}
+func (*RemoveNameRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{4}
+}
+func (m *RemoveNameRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_RemoveNameRequest.Unmarshal(m, b)
+}
+func (m *RemoveNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_RemoveNameRequest.Marshal(b, m, deterministic)
+}
+func (dst *RemoveNameRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_RemoveNameRequest.Merge(dst, src)
+}
+func (m *RemoveNameRequest) XXX_Size() int {
+ return xxx_messageInfo_RemoveNameRequest.Size(m)
+}
+func (m *RemoveNameRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_RemoveNameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RemoveNameRequest proto.InternalMessageInfo
+
+func (m *RemoveNameRequest) GetKeyname() string {
if m != nil {
return m.Keyname
}
return ""
}
-type Empty struct {
+type GenRequest struct {
+ Passphrase string `protobuf:"bytes,1,opt,name=passphrase,proto3" json:"passphrase,omitempty"`
+ Curvetype string `protobuf:"bytes,2,opt,name=curvetype,proto3" json:"curvetype,omitempty"`
+ Keyname string `protobuf:"bytes,3,opt,name=keyname,proto3" json:"keyname,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *Empty) Reset() { *m = Empty{} }
-func (m *Empty) String() string { return proto.CompactTextString(m) }
-func (*Empty) ProtoMessage() {}
-func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
-
-type GenRequest struct {
- Passphrase string `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
- Curvetype string `protobuf:"bytes,2,opt,name=curvetype" json:"curvetype,omitempty"`
- Keyname string `protobuf:"bytes,3,opt,name=keyname" json:"keyname,omitempty"`
+func (m *GenRequest) Reset() { *m = GenRequest{} }
+func (m *GenRequest) String() string { return proto.CompactTextString(m) }
+func (*GenRequest) ProtoMessage() {}
+func (*GenRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{5}
+}
+func (m *GenRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GenRequest.Unmarshal(m, b)
+}
+func (m *GenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GenRequest.Marshal(b, m, deterministic)
+}
+func (dst *GenRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GenRequest.Merge(dst, src)
+}
+func (m *GenRequest) XXX_Size() int {
+ return xxx_messageInfo_GenRequest.Size(m)
+}
+func (m *GenRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_GenRequest.DiscardUnknown(m)
}
-func (m *GenRequest) Reset() { *m = GenRequest{} }
-func (m *GenRequest) String() string { return proto.CompactTextString(m) }
-func (*GenRequest) ProtoMessage() {}
-func (*GenRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
+var xxx_messageInfo_GenRequest proto.InternalMessageInfo
func (m *GenRequest) GetPassphrase() string {
if m != nil {
@@ -107,13 +236,35 @@ func (m *GenRequest) GetKeyname() string {
}
type GenResponse struct {
- Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *GenResponse) Reset() { *m = GenResponse{} }
-func (m *GenResponse) String() string { return proto.CompactTextString(m) }
-func (*GenResponse) ProtoMessage() {}
-func (*GenResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
+func (m *GenResponse) Reset() { *m = GenResponse{} }
+func (m *GenResponse) String() string { return proto.CompactTextString(m) }
+func (*GenResponse) ProtoMessage() {}
+func (*GenResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{6}
+}
+func (m *GenResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GenResponse.Unmarshal(m, b)
+}
+func (m *GenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GenResponse.Marshal(b, m, deterministic)
+}
+func (dst *GenResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GenResponse.Merge(dst, src)
+}
+func (m *GenResponse) XXX_Size() int {
+ return xxx_messageInfo_GenResponse.Size(m)
+}
+func (m *GenResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_GenResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenResponse proto.InternalMessageInfo
func (m *GenResponse) GetAddress() string {
if m != nil {
@@ -123,14 +274,36 @@ func (m *GenResponse) GetAddress() string {
}
type PubRequest struct {
- Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
- Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+ Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *PubRequest) Reset() { *m = PubRequest{} }
-func (m *PubRequest) String() string { return proto.CompactTextString(m) }
-func (*PubRequest) ProtoMessage() {}
-func (*PubRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
+func (m *PubRequest) Reset() { *m = PubRequest{} }
+func (m *PubRequest) String() string { return proto.CompactTextString(m) }
+func (*PubRequest) ProtoMessage() {}
+func (*PubRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{7}
+}
+func (m *PubRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_PubRequest.Unmarshal(m, b)
+}
+func (m *PubRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_PubRequest.Marshal(b, m, deterministic)
+}
+func (dst *PubRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PubRequest.Merge(dst, src)
+}
+func (m *PubRequest) XXX_Size() int {
+ return xxx_messageInfo_PubRequest.Size(m)
+}
+func (m *PubRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_PubRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_PubRequest proto.InternalMessageInfo
func (m *PubRequest) GetAddress() string {
if m != nil {
@@ -147,14 +320,36 @@ func (m *PubRequest) GetName() string {
}
type PubResponse struct {
- Pub []byte `protobuf:"bytes,1,opt,name=pub,proto3" json:"pub,omitempty"`
- Curvetype string `protobuf:"bytes,2,opt,name=curvetype" json:"curvetype,omitempty"`
+ Pub []byte `protobuf:"bytes,1,opt,name=pub,proto3" json:"pub,omitempty"`
+ Curvetype string `protobuf:"bytes,2,opt,name=curvetype,proto3" json:"curvetype,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *PubResponse) Reset() { *m = PubResponse{} }
+func (m *PubResponse) String() string { return proto.CompactTextString(m) }
+func (*PubResponse) ProtoMessage() {}
+func (*PubResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{8}
+}
+func (m *PubResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_PubResponse.Unmarshal(m, b)
+}
+func (m *PubResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_PubResponse.Marshal(b, m, deterministic)
+}
+func (dst *PubResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_PubResponse.Merge(dst, src)
+}
+func (m *PubResponse) XXX_Size() int {
+ return xxx_messageInfo_PubResponse.Size(m)
+}
+func (m *PubResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_PubResponse.DiscardUnknown(m)
}
-func (m *PubResponse) Reset() { *m = PubResponse{} }
-func (m *PubResponse) String() string { return proto.CompactTextString(m) }
-func (*PubResponse) ProtoMessage() {}
-func (*PubResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
+var xxx_messageInfo_PubResponse proto.InternalMessageInfo
func (m *PubResponse) GetPub() []byte {
if m != nil {
@@ -171,14 +366,36 @@ func (m *PubResponse) GetCurvetype() string {
}
type ImportJSONRequest struct {
- Passphrase string `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
- JSON string `protobuf:"bytes,2,opt,name=JSON" json:"JSON,omitempty"`
+ Passphrase string `protobuf:"bytes,1,opt,name=passphrase,proto3" json:"passphrase,omitempty"`
+ JSON string `protobuf:"bytes,2,opt,name=JSON,proto3" json:"JSON,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *ImportJSONRequest) Reset() { *m = ImportJSONRequest{} }
-func (m *ImportJSONRequest) String() string { return proto.CompactTextString(m) }
-func (*ImportJSONRequest) ProtoMessage() {}
-func (*ImportJSONRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
+func (m *ImportJSONRequest) Reset() { *m = ImportJSONRequest{} }
+func (m *ImportJSONRequest) String() string { return proto.CompactTextString(m) }
+func (*ImportJSONRequest) ProtoMessage() {}
+func (*ImportJSONRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{9}
+}
+func (m *ImportJSONRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ImportJSONRequest.Unmarshal(m, b)
+}
+func (m *ImportJSONRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ImportJSONRequest.Marshal(b, m, deterministic)
+}
+func (dst *ImportJSONRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ImportJSONRequest.Merge(dst, src)
+}
+func (m *ImportJSONRequest) XXX_Size() int {
+ return xxx_messageInfo_ImportJSONRequest.Size(m)
+}
+func (m *ImportJSONRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ImportJSONRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportJSONRequest proto.InternalMessageInfo
func (m *ImportJSONRequest) GetPassphrase() string {
if m != nil {
@@ -195,13 +412,35 @@ func (m *ImportJSONRequest) GetJSON() string {
}
type ImportResponse struct {
- Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *ImportResponse) Reset() { *m = ImportResponse{} }
-func (m *ImportResponse) String() string { return proto.CompactTextString(m) }
-func (*ImportResponse) ProtoMessage() {}
-func (*ImportResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} }
+func (m *ImportResponse) Reset() { *m = ImportResponse{} }
+func (m *ImportResponse) String() string { return proto.CompactTextString(m) }
+func (*ImportResponse) ProtoMessage() {}
+func (*ImportResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{10}
+}
+func (m *ImportResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ImportResponse.Unmarshal(m, b)
+}
+func (m *ImportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ImportResponse.Marshal(b, m, deterministic)
+}
+func (dst *ImportResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ImportResponse.Merge(dst, src)
+}
+func (m *ImportResponse) XXX_Size() int {
+ return xxx_messageInfo_ImportResponse.Size(m)
+}
+func (m *ImportResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ImportResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ImportResponse proto.InternalMessageInfo
func (m *ImportResponse) GetAddress() string {
if m != nil {
@@ -211,16 +450,38 @@ func (m *ImportResponse) GetAddress() string {
}
type ImportRequest struct {
- Passphrase string `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
- Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
- Curvetype string `protobuf:"bytes,3,opt,name=curvetype" json:"curvetype,omitempty"`
- Keybytes []byte `protobuf:"bytes,4,opt,name=keybytes,proto3" json:"keybytes,omitempty"`
+ Passphrase string `protobuf:"bytes,1,opt,name=passphrase,proto3" json:"passphrase,omitempty"`
+ Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+ Curvetype string `protobuf:"bytes,3,opt,name=curvetype,proto3" json:"curvetype,omitempty"`
+ Keybytes []byte `protobuf:"bytes,4,opt,name=keybytes,proto3" json:"keybytes,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ImportRequest) Reset() { *m = ImportRequest{} }
+func (m *ImportRequest) String() string { return proto.CompactTextString(m) }
+func (*ImportRequest) ProtoMessage() {}
+func (*ImportRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{11}
+}
+func (m *ImportRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ImportRequest.Unmarshal(m, b)
+}
+func (m *ImportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ImportRequest.Marshal(b, m, deterministic)
+}
+func (dst *ImportRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ImportRequest.Merge(dst, src)
+}
+func (m *ImportRequest) XXX_Size() int {
+ return xxx_messageInfo_ImportRequest.Size(m)
+}
+func (m *ImportRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ImportRequest.DiscardUnknown(m)
}
-func (m *ImportRequest) Reset() { *m = ImportRequest{} }
-func (m *ImportRequest) String() string { return proto.CompactTextString(m) }
-func (*ImportRequest) ProtoMessage() {}
-func (*ImportRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} }
+var xxx_messageInfo_ImportRequest proto.InternalMessageInfo
func (m *ImportRequest) GetPassphrase() string {
if m != nil {
@@ -251,15 +512,37 @@ func (m *ImportRequest) GetKeybytes() []byte {
}
type ExportRequest struct {
- Passphrase string `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
- Name string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
- Address string `protobuf:"bytes,3,opt,name=address" json:"address,omitempty"`
+ Passphrase string `protobuf:"bytes,1,opt,name=passphrase,proto3" json:"passphrase,omitempty"`
+ Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+ Address string `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *ExportRequest) Reset() { *m = ExportRequest{} }
-func (m *ExportRequest) String() string { return proto.CompactTextString(m) }
-func (*ExportRequest) ProtoMessage() {}
-func (*ExportRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} }
+func (m *ExportRequest) Reset() { *m = ExportRequest{} }
+func (m *ExportRequest) String() string { return proto.CompactTextString(m) }
+func (*ExportRequest) ProtoMessage() {}
+func (*ExportRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{12}
+}
+func (m *ExportRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExportRequest.Unmarshal(m, b)
+}
+func (m *ExportRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExportRequest.Marshal(b, m, deterministic)
+}
+func (dst *ExportRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExportRequest.Merge(dst, src)
+}
+func (m *ExportRequest) XXX_Size() int {
+ return xxx_messageInfo_ExportRequest.Size(m)
+}
+func (m *ExportRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExportRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExportRequest proto.InternalMessageInfo
func (m *ExportRequest) GetPassphrase() string {
if m != nil {
@@ -283,16 +566,38 @@ func (m *ExportRequest) GetAddress() string {
}
type ExportResponse struct {
- Publickey []byte `protobuf:"bytes,1,opt,name=publickey,proto3" json:"publickey,omitempty"`
- Privatekey []byte `protobuf:"bytes,2,opt,name=privatekey,proto3" json:"privatekey,omitempty"`
- Address []byte `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
- Curvetype string `protobuf:"bytes,4,opt,name=curvetype" json:"curvetype,omitempty"`
+ Publickey []byte `protobuf:"bytes,1,opt,name=publickey,proto3" json:"publickey,omitempty"`
+ Privatekey []byte `protobuf:"bytes,2,opt,name=privatekey,proto3" json:"privatekey,omitempty"`
+ Address []byte `protobuf:"bytes,3,opt,name=address,proto3" json:"address,omitempty"`
+ Curvetype string `protobuf:"bytes,4,opt,name=curvetype,proto3" json:"curvetype,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *ExportResponse) Reset() { *m = ExportResponse{} }
-func (m *ExportResponse) String() string { return proto.CompactTextString(m) }
-func (*ExportResponse) ProtoMessage() {}
-func (*ExportResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} }
+func (m *ExportResponse) Reset() { *m = ExportResponse{} }
+func (m *ExportResponse) String() string { return proto.CompactTextString(m) }
+func (*ExportResponse) ProtoMessage() {}
+func (*ExportResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{13}
+}
+func (m *ExportResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExportResponse.Unmarshal(m, b)
+}
+func (m *ExportResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExportResponse.Marshal(b, m, deterministic)
+}
+func (dst *ExportResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExportResponse.Merge(dst, src)
+}
+func (m *ExportResponse) XXX_Size() int {
+ return xxx_messageInfo_ExportResponse.Size(m)
+}
+func (m *ExportResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExportResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExportResponse proto.InternalMessageInfo
func (m *ExportResponse) GetPublickey() []byte {
if m != nil {
@@ -323,16 +628,38 @@ func (m *ExportResponse) GetCurvetype() string {
}
type SignRequest struct {
- Passphrase string `protobuf:"bytes,1,opt,name=passphrase" json:"passphrase,omitempty"`
- Address string `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"`
- Name string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
- Message []byte `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
+ Passphrase string `protobuf:"bytes,1,opt,name=passphrase,proto3" json:"passphrase,omitempty"`
+ Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+ Name string `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
+ Message []byte `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *SignRequest) Reset() { *m = SignRequest{} }
-func (m *SignRequest) String() string { return proto.CompactTextString(m) }
-func (*SignRequest) ProtoMessage() {}
-func (*SignRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} }
+func (m *SignRequest) Reset() { *m = SignRequest{} }
+func (m *SignRequest) String() string { return proto.CompactTextString(m) }
+func (*SignRequest) ProtoMessage() {}
+func (*SignRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{14}
+}
+func (m *SignRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SignRequest.Unmarshal(m, b)
+}
+func (m *SignRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SignRequest.Marshal(b, m, deterministic)
+}
+func (dst *SignRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SignRequest.Merge(dst, src)
+}
+func (m *SignRequest) XXX_Size() int {
+ return xxx_messageInfo_SignRequest.Size(m)
+}
+func (m *SignRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_SignRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignRequest proto.InternalMessageInfo
func (m *SignRequest) GetPassphrase() string {
if m != nil {
@@ -363,14 +690,36 @@ func (m *SignRequest) GetMessage() []byte {
}
type SignResponse struct {
- Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
- Curvetype string `protobuf:"bytes,2,opt,name=curvetype" json:"curvetype,omitempty"`
+ Signature []byte `protobuf:"bytes,1,opt,name=signature,proto3" json:"signature,omitempty"`
+ Curvetype string `protobuf:"bytes,2,opt,name=curvetype,proto3" json:"curvetype,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *SignResponse) Reset() { *m = SignResponse{} }
-func (m *SignResponse) String() string { return proto.CompactTextString(m) }
-func (*SignResponse) ProtoMessage() {}
-func (*SignResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} }
+func (m *SignResponse) Reset() { *m = SignResponse{} }
+func (m *SignResponse) String() string { return proto.CompactTextString(m) }
+func (*SignResponse) ProtoMessage() {}
+func (*SignResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{15}
+}
+func (m *SignResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SignResponse.Unmarshal(m, b)
+}
+func (m *SignResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SignResponse.Marshal(b, m, deterministic)
+}
+func (dst *SignResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SignResponse.Merge(dst, src)
+}
+func (m *SignResponse) XXX_Size() int {
+ return xxx_messageInfo_SignResponse.Size(m)
+}
+func (m *SignResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_SignResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SignResponse proto.InternalMessageInfo
func (m *SignResponse) GetSignature() []byte {
if m != nil {
@@ -387,16 +736,38 @@ func (m *SignResponse) GetCurvetype() string {
}
type VerifyRequest struct {
- Curvetype string `protobuf:"bytes,1,opt,name=curvetype" json:"curvetype,omitempty"`
- Pub []byte `protobuf:"bytes,2,opt,name=pub,proto3" json:"pub,omitempty"`
- Message []byte `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
- Signature []byte `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
+ Curvetype string `protobuf:"bytes,1,opt,name=curvetype,proto3" json:"curvetype,omitempty"`
+ Pub []byte `protobuf:"bytes,2,opt,name=pub,proto3" json:"pub,omitempty"`
+ Message []byte `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
+ Signature []byte `protobuf:"bytes,4,opt,name=signature,proto3" json:"signature,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *VerifyRequest) Reset() { *m = VerifyRequest{} }
+func (m *VerifyRequest) String() string { return proto.CompactTextString(m) }
+func (*VerifyRequest) ProtoMessage() {}
+func (*VerifyRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{16}
+}
+func (m *VerifyRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_VerifyRequest.Unmarshal(m, b)
+}
+func (m *VerifyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_VerifyRequest.Marshal(b, m, deterministic)
+}
+func (dst *VerifyRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_VerifyRequest.Merge(dst, src)
+}
+func (m *VerifyRequest) XXX_Size() int {
+ return xxx_messageInfo_VerifyRequest.Size(m)
+}
+func (m *VerifyRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_VerifyRequest.DiscardUnknown(m)
}
-func (m *VerifyRequest) Reset() { *m = VerifyRequest{} }
-func (m *VerifyRequest) String() string { return proto.CompactTextString(m) }
-func (*VerifyRequest) ProtoMessage() {}
-func (*VerifyRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} }
+var xxx_messageInfo_VerifyRequest proto.InternalMessageInfo
func (m *VerifyRequest) GetCurvetype() string {
if m != nil {
@@ -427,14 +798,36 @@ func (m *VerifyRequest) GetSignature() []byte {
}
type HashRequest struct {
- Hashtype string `protobuf:"bytes,1,opt,name=hashtype" json:"hashtype,omitempty"`
- Message []byte `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+ Hashtype string `protobuf:"bytes,1,opt,name=hashtype,proto3" json:"hashtype,omitempty"`
+ Message []byte `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *HashRequest) Reset() { *m = HashRequest{} }
-func (m *HashRequest) String() string { return proto.CompactTextString(m) }
-func (*HashRequest) ProtoMessage() {}
-func (*HashRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} }
+func (m *HashRequest) Reset() { *m = HashRequest{} }
+func (m *HashRequest) String() string { return proto.CompactTextString(m) }
+func (*HashRequest) ProtoMessage() {}
+func (*HashRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{17}
+}
+func (m *HashRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_HashRequest.Unmarshal(m, b)
+}
+func (m *HashRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_HashRequest.Marshal(b, m, deterministic)
+}
+func (dst *HashRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_HashRequest.Merge(dst, src)
+}
+func (m *HashRequest) XXX_Size() int {
+ return xxx_messageInfo_HashRequest.Size(m)
+}
+func (m *HashRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_HashRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_HashRequest proto.InternalMessageInfo
func (m *HashRequest) GetHashtype() string {
if m != nil {
@@ -451,13 +844,35 @@ func (m *HashRequest) GetMessage() []byte {
}
type HashResponse struct {
- Hash string `protobuf:"bytes,1,opt,name=hash" json:"hash,omitempty"`
+ Hash string `protobuf:"bytes,1,opt,name=hash,proto3" json:"hash,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *HashResponse) Reset() { *m = HashResponse{} }
+func (m *HashResponse) String() string { return proto.CompactTextString(m) }
+func (*HashResponse) ProtoMessage() {}
+func (*HashResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{18}
+}
+func (m *HashResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_HashResponse.Unmarshal(m, b)
+}
+func (m *HashResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_HashResponse.Marshal(b, m, deterministic)
+}
+func (dst *HashResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_HashResponse.Merge(dst, src)
+}
+func (m *HashResponse) XXX_Size() int {
+ return xxx_messageInfo_HashResponse.Size(m)
+}
+func (m *HashResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_HashResponse.DiscardUnknown(m)
}
-func (m *HashResponse) Reset() { *m = HashResponse{} }
-func (m *HashResponse) String() string { return proto.CompactTextString(m) }
-func (*HashResponse) ProtoMessage() {}
-func (*HashResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} }
+var xxx_messageInfo_HashResponse proto.InternalMessageInfo
func (m *HashResponse) GetHash() string {
if m != nil {
@@ -467,14 +882,36 @@ func (m *HashResponse) GetHash() string {
}
type Key struct {
- Address string `protobuf:"bytes,1,opt,name=address" json:"address,omitempty"`
- Keyname string `protobuf:"bytes,2,opt,name=keyname" json:"keyname,omitempty"`
+ Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
+ Keyname string `protobuf:"bytes,2,opt,name=keyname,proto3" json:"keyname,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *Key) Reset() { *m = Key{} }
-func (m *Key) String() string { return proto.CompactTextString(m) }
-func (*Key) ProtoMessage() {}
-func (*Key) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} }
+func (m *Key) Reset() { *m = Key{} }
+func (m *Key) String() string { return proto.CompactTextString(m) }
+func (*Key) ProtoMessage() {}
+func (*Key) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{19}
+}
+func (m *Key) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_Key.Unmarshal(m, b)
+}
+func (m *Key) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_Key.Marshal(b, m, deterministic)
+}
+func (dst *Key) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Key.Merge(dst, src)
+}
+func (m *Key) XXX_Size() int {
+ return xxx_messageInfo_Key.Size(m)
+}
+func (m *Key) XXX_DiscardUnknown() {
+ xxx_messageInfo_Key.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Key proto.InternalMessageInfo
func (m *Key) GetAddress() string {
if m != nil {
@@ -491,13 +928,35 @@ func (m *Key) GetKeyname() string {
}
type ListResponse struct {
- Key []*Key `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
+ Key []*Key `protobuf:"bytes,1,rep,name=key,proto3" json:"key,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *ListResponse) Reset() { *m = ListResponse{} }
-func (m *ListResponse) String() string { return proto.CompactTextString(m) }
-func (*ListResponse) ProtoMessage() {}
-func (*ListResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} }
+func (m *ListResponse) Reset() { *m = ListResponse{} }
+func (m *ListResponse) String() string { return proto.CompactTextString(m) }
+func (*ListResponse) ProtoMessage() {}
+func (*ListResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{20}
+}
+func (m *ListResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ListResponse.Unmarshal(m, b)
+}
+func (m *ListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ListResponse.Marshal(b, m, deterministic)
+}
+func (dst *ListResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ListResponse.Merge(dst, src)
+}
+func (m *ListResponse) XXX_Size() int {
+ return xxx_messageInfo_ListResponse.Size(m)
+}
+func (m *ListResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ListResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListResponse proto.InternalMessageInfo
func (m *ListResponse) GetKey() []*Key {
if m != nil {
@@ -507,14 +966,36 @@ func (m *ListResponse) GetKey() []*Key {
}
type AddNameRequest struct {
- Keyname string `protobuf:"bytes,1,opt,name=keyname" json:"keyname,omitempty"`
- Address string `protobuf:"bytes,2,opt,name=address" json:"address,omitempty"`
+ Keyname string `protobuf:"bytes,1,opt,name=keyname,proto3" json:"keyname,omitempty"`
+ Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
}
-func (m *AddNameRequest) Reset() { *m = AddNameRequest{} }
-func (m *AddNameRequest) String() string { return proto.CompactTextString(m) }
-func (*AddNameRequest) ProtoMessage() {}
-func (*AddNameRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
+func (m *AddNameRequest) Reset() { *m = AddNameRequest{} }
+func (m *AddNameRequest) String() string { return proto.CompactTextString(m) }
+func (*AddNameRequest) ProtoMessage() {}
+func (*AddNameRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_keys_ff2cb7ec9ea3671c, []int{21}
+}
+func (m *AddNameRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_AddNameRequest.Unmarshal(m, b)
+}
+func (m *AddNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_AddNameRequest.Marshal(b, m, deterministic)
+}
+func (dst *AddNameRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_AddNameRequest.Merge(dst, src)
+}
+func (m *AddNameRequest) XXX_Size() int {
+ return xxx_messageInfo_AddNameRequest.Size(m)
+}
+func (m *AddNameRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_AddNameRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_AddNameRequest proto.InternalMessageInfo
func (m *AddNameRequest) GetKeyname() string {
if m != nil {
@@ -531,8 +1012,11 @@ func (m *AddNameRequest) GetAddress() string {
}
func init() {
- proto.RegisterType((*Name)(nil), "pbkeys.Name")
- proto.RegisterType((*Empty)(nil), "pbkeys.Empty")
+ proto.RegisterType((*ListRequest)(nil), "pbkeys.ListRequest")
+ proto.RegisterType((*VerifyResponse)(nil), "pbkeys.VerifyResponse")
+ proto.RegisterType((*RemoveNameResponse)(nil), "pbkeys.RemoveNameResponse")
+ proto.RegisterType((*AddNameResponse)(nil), "pbkeys.AddNameResponse")
+ proto.RegisterType((*RemoveNameRequest)(nil), "pbkeys.RemoveNameRequest")
proto.RegisterType((*GenRequest)(nil), "pbkeys.GenRequest")
proto.RegisterType((*GenResponse)(nil), "pbkeys.GenResponse")
proto.RegisterType((*PubRequest)(nil), "pbkeys.PubRequest")
@@ -560,20 +1044,21 @@ var _ grpc.ClientConn
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4
-// Client API for Keys service
-
+// KeysClient is the client API for Keys service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type KeysClient interface {
GenerateKey(ctx context.Context, in *GenRequest, opts ...grpc.CallOption) (*GenResponse, error)
PublicKey(ctx context.Context, in *PubRequest, opts ...grpc.CallOption) (*PubResponse, error)
Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
- Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*Empty, error)
+ Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error)
Import(ctx context.Context, in *ImportRequest, opts ...grpc.CallOption) (*ImportResponse, error)
ImportJSON(ctx context.Context, in *ImportJSONRequest, opts ...grpc.CallOption) (*ImportResponse, error)
Export(ctx context.Context, in *ExportRequest, opts ...grpc.CallOption) (*ExportResponse, error)
Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error)
- RemoveName(ctx context.Context, in *Name, opts ...grpc.CallOption) (*Empty, error)
- List(ctx context.Context, in *Name, opts ...grpc.CallOption) (*ListResponse, error)
- AddName(ctx context.Context, in *AddNameRequest, opts ...grpc.CallOption) (*Empty, error)
+ RemoveName(ctx context.Context, in *RemoveNameRequest, opts ...grpc.CallOption) (*RemoveNameResponse, error)
+ List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error)
+ AddName(ctx context.Context, in *AddNameRequest, opts ...grpc.CallOption) (*AddNameResponse, error)
}
type keysClient struct {
@@ -586,7 +1071,7 @@ func NewKeysClient(cc *grpc.ClientConn) KeysClient {
func (c *keysClient) GenerateKey(ctx context.Context, in *GenRequest, opts ...grpc.CallOption) (*GenResponse, error) {
out := new(GenResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/GenerateKey", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/GenerateKey", in, out, opts...)
if err != nil {
return nil, err
}
@@ -595,7 +1080,7 @@ func (c *keysClient) GenerateKey(ctx context.Context, in *GenRequest, opts ...gr
func (c *keysClient) PublicKey(ctx context.Context, in *PubRequest, opts ...grpc.CallOption) (*PubResponse, error) {
out := new(PubResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/PublicKey", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/PublicKey", in, out, opts...)
if err != nil {
return nil, err
}
@@ -604,16 +1089,16 @@ func (c *keysClient) PublicKey(ctx context.Context, in *PubRequest, opts ...grpc
func (c *keysClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
out := new(SignResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/Sign", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/Sign", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *keysClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*Empty, error) {
- out := new(Empty)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/Verify", in, out, c.cc, opts...)
+func (c *keysClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc.CallOption) (*VerifyResponse, error) {
+ out := new(VerifyResponse)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/Verify", in, out, opts...)
if err != nil {
return nil, err
}
@@ -622,7 +1107,7 @@ func (c *keysClient) Verify(ctx context.Context, in *VerifyRequest, opts ...grpc
func (c *keysClient) Import(ctx context.Context, in *ImportRequest, opts ...grpc.CallOption) (*ImportResponse, error) {
out := new(ImportResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/Import", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/Import", in, out, opts...)
if err != nil {
return nil, err
}
@@ -631,7 +1116,7 @@ func (c *keysClient) Import(ctx context.Context, in *ImportRequest, opts ...grpc
func (c *keysClient) ImportJSON(ctx context.Context, in *ImportJSONRequest, opts ...grpc.CallOption) (*ImportResponse, error) {
out := new(ImportResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/ImportJSON", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/ImportJSON", in, out, opts...)
if err != nil {
return nil, err
}
@@ -640,7 +1125,7 @@ func (c *keysClient) ImportJSON(ctx context.Context, in *ImportJSONRequest, opts
func (c *keysClient) Export(ctx context.Context, in *ExportRequest, opts ...grpc.CallOption) (*ExportResponse, error) {
out := new(ExportResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/Export", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/Export", in, out, opts...)
if err != nil {
return nil, err
}
@@ -649,54 +1134,53 @@ func (c *keysClient) Export(ctx context.Context, in *ExportRequest, opts ...grpc
func (c *keysClient) Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error) {
out := new(HashResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/Hash", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/Hash", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *keysClient) RemoveName(ctx context.Context, in *Name, opts ...grpc.CallOption) (*Empty, error) {
- out := new(Empty)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/RemoveName", in, out, c.cc, opts...)
+func (c *keysClient) RemoveName(ctx context.Context, in *RemoveNameRequest, opts ...grpc.CallOption) (*RemoveNameResponse, error) {
+ out := new(RemoveNameResponse)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/RemoveName", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *keysClient) List(ctx context.Context, in *Name, opts ...grpc.CallOption) (*ListResponse, error) {
+func (c *keysClient) List(ctx context.Context, in *ListRequest, opts ...grpc.CallOption) (*ListResponse, error) {
out := new(ListResponse)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/List", in, out, c.cc, opts...)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/List", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-func (c *keysClient) AddName(ctx context.Context, in *AddNameRequest, opts ...grpc.CallOption) (*Empty, error) {
- out := new(Empty)
- err := grpc.Invoke(ctx, "/pbkeys.Keys/AddName", in, out, c.cc, opts...)
+func (c *keysClient) AddName(ctx context.Context, in *AddNameRequest, opts ...grpc.CallOption) (*AddNameResponse, error) {
+ out := new(AddNameResponse)
+ err := c.cc.Invoke(ctx, "/pbkeys.Keys/AddName", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
-// Server API for Keys service
-
+// KeysServer is the server API for Keys service.
type KeysServer interface {
GenerateKey(context.Context, *GenRequest) (*GenResponse, error)
PublicKey(context.Context, *PubRequest) (*PubResponse, error)
Sign(context.Context, *SignRequest) (*SignResponse, error)
- Verify(context.Context, *VerifyRequest) (*Empty, error)
+ Verify(context.Context, *VerifyRequest) (*VerifyResponse, error)
Import(context.Context, *ImportRequest) (*ImportResponse, error)
ImportJSON(context.Context, *ImportJSONRequest) (*ImportResponse, error)
Export(context.Context, *ExportRequest) (*ExportResponse, error)
Hash(context.Context, *HashRequest) (*HashResponse, error)
- RemoveName(context.Context, *Name) (*Empty, error)
- List(context.Context, *Name) (*ListResponse, error)
- AddName(context.Context, *AddNameRequest) (*Empty, error)
+ RemoveName(context.Context, *RemoveNameRequest) (*RemoveNameResponse, error)
+ List(context.Context, *ListRequest) (*ListResponse, error)
+ AddName(context.Context, *AddNameRequest) (*AddNameResponse, error)
}
func RegisterKeysServer(s *grpc.Server, srv KeysServer) {
@@ -848,7 +1332,7 @@ func _Keys_Hash_Handler(srv interface{}, ctx context.Context, dec func(interface
}
func _Keys_RemoveName_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Name)
+ in := new(RemoveNameRequest)
if err := dec(in); err != nil {
return nil, err
}
@@ -860,13 +1344,13 @@ func _Keys_RemoveName_Handler(srv interface{}, ctx context.Context, dec func(int
FullMethod: "/pbkeys.Keys/RemoveName",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(KeysServer).RemoveName(ctx, req.(*Name))
+ return srv.(KeysServer).RemoveName(ctx, req.(*RemoveNameRequest))
}
return interceptor(ctx, in, info, handler)
}
func _Keys_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Name)
+ in := new(ListRequest)
if err := dec(in); err != nil {
return nil, err
}
@@ -878,7 +1362,7 @@ func _Keys_List_Handler(srv interface{}, ctx context.Context, dec func(interface
FullMethod: "/pbkeys.Keys/List",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(KeysServer).List(ctx, req.(*Name))
+ return srv.(KeysServer).List(ctx, req.(*ListRequest))
}
return interceptor(ctx, in, info, handler)
}
@@ -951,53 +1435,58 @@ var _Keys_serviceDesc = grpc.ServiceDesc{
},
},
Streams: []grpc.StreamDesc{},
- Metadata: "keys.proto",
-}
-
-func init() { proto.RegisterFile("keys.proto", fileDescriptor0) }
-
-var fileDescriptor0 = []byte{
- // 661 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x55, 0x4d, 0x6f, 0xd3, 0x40,
- 0x10, 0x55, 0x62, 0x93, 0x36, 0x2f, 0x49, 0x05, 0xcb, 0x87, 0x42, 0x54, 0x50, 0xb5, 0x17, 0x4a,
- 0x25, 0x22, 0x5a, 0x10, 0x15, 0x48, 0x08, 0x21, 0xa8, 0x0a, 0x2d, 0x2a, 0x55, 0x2a, 0x71, 0xe3,
- 0xe0, 0x34, 0x43, 0x13, 0x85, 0x24, 0xc6, 0x6b, 0x17, 0x7c, 0xe0, 0xca, 0x4f, 0xe3, 0x77, 0xa1,
- 0x5d, 0x7b, 0xbd, 0x1f, 0x6a, 0x20, 0x12, 0xb7, 0x9d, 0xd9, 0x99, 0x79, 0x33, 0xb3, 0xcf, 0xcf,
- 0xc0, 0x94, 0x72, 0xd1, 0x8f, 0x93, 0x45, 0xba, 0x60, 0x8d, 0x78, 0x28, 0x2d, 0xbe, 0x85, 0xf0,
- 0x24, 0x9a, 0x11, 0xeb, 0x62, 0x6d, 0x4a, 0xf9, 0x3c, 0x9a, 0x51, 0xb7, 0xb6, 0x55, 0xdb, 0x6e,
- 0x0e, 0xb4, 0xc9, 0xd7, 0x70, 0xed, 0x60, 0x16, 0xa7, 0x39, 0x1f, 0x01, 0x87, 0x34, 0x1f, 0xd0,
- 0xb7, 0x8c, 0x44, 0xca, 0xee, 0x03, 0x71, 0x24, 0x44, 0x3c, 0x4e, 0x22, 0xa1, 0x73, 0x2c, 0x0f,
- 0xdb, 0x44, 0xf3, 0x3c, 0x4b, 0x2e, 0x29, 0xcd, 0x63, 0xea, 0xd6, 0xd5, 0xb5, 0x71, 0xd8, 0x70,
- 0x81, 0x0b, 0xf7, 0x00, 0x2d, 0x85, 0x22, 0xe2, 0xc5, 0x5c, 0xa8, 0xc0, 0x68, 0x34, 0x4a, 0x48,
- 0x08, 0xdd, 0x57, 0x69, 0xf2, 0x17, 0xc0, 0x69, 0x36, 0xd4, 0xed, 0x2c, 0x8d, 0x63, 0x0c, 0xa1,
- 0xc2, 0x29, 0x7a, 0x50, 0x67, 0xfe, 0x12, 0x2d, 0x95, 0x5b, 0x82, 0x5c, 0x47, 0x10, 0x67, 0x43,
- 0x95, 0xd8, 0x1e, 0xc8, 0xe3, 0xdf, 0xbb, 0xe7, 0x87, 0xb8, 0xf1, 0x7e, 0x16, 0x2f, 0x92, 0xf4,
- 0xe8, 0xec, 0xe3, 0xc9, 0xaa, 0x0b, 0x61, 0x08, 0x65, 0xb8, 0xee, 0x43, 0x9e, 0xf9, 0x0e, 0x36,
- 0x8a, 0x42, 0x2b, 0xcc, 0xfb, 0x13, 0x1d, 0x1d, 0xbb, 0x32, 0xa0, 0x3f, 0xb8, 0x3b, 0x57, 0xe0,
- 0xbf, 0x4a, 0x0f, 0xeb, 0x53, 0xca, 0x87, 0x79, 0x4a, 0xa2, 0x1b, 0xaa, 0x65, 0x54, 0x36, 0xff,
- 0x8c, 0xce, 0xc1, 0x8f, 0xff, 0x85, 0xb7, 0xa6, 0x0b, 0xdc, 0xe9, 0x7e, 0xd5, 0xb0, 0xa1, 0xeb,
- 0x97, 0xab, 0xd8, 0x44, 0x33, 0xce, 0x86, 0x5f, 0x27, 0xe7, 0x53, 0xca, 0xcb, 0xb7, 0x31, 0x0e,
- 0x05, 0x9f, 0x4c, 0x2e, 0xa3, 0x94, 0xe4, 0x75, 0x5d, 0x5d, 0x5b, 0x1e, 0x1f, 0xaa, 0x6d, 0x08,
- 0xe1, 0xec, 0x20, 0xf4, 0xdf, 0x36, 0x43, 0xeb, 0x6c, 0x72, 0xb1, 0x32, 0xcd, 0x2d, 0x98, 0xfa,
- 0xd5, 0xbc, 0x0b, 0xdc, 0xf9, 0x67, 0x24, 0x44, 0x74, 0x41, 0xe5, 0x7e, 0xb5, 0xc9, 0x8f, 0xd0,
- 0x2e, 0x60, 0xcd, 0xf0, 0x62, 0x72, 0x31, 0x8f, 0xd2, 0x2c, 0x21, 0x3d, 0x7c, 0xe5, 0xf8, 0x07,
- 0x3d, 0xbf, 0xa3, 0xf3, 0x89, 0x92, 0xc9, 0x97, 0x5c, 0x0f, 0xe1, 0x84, 0xd7, 0xfc, 0x57, 0x2f,
- 0xd9, 0x5f, 0x37, 0xec, 0xb7, 0xda, 0x0c, 0x9c, 0x36, 0xdd, 0xb6, 0x42, 0xaf, 0x2d, 0xfe, 0x06,
- 0xad, 0x77, 0x91, 0x18, 0x6b, 0xd8, 0x1e, 0xd6, 0xc7, 0x91, 0x18, 0x5b, 0xa8, 0x95, 0x6d, 0x43,
- 0xd4, 0xdd, 0x4d, 0x70, 0xb4, 0x8b, 0x22, 0xe5, 0x26, 0x18, 0x42, 0x99, 0x55, 0x56, 0x50, 0x67,
- 0xfe, 0x1c, 0xc1, 0xb1, 0xfb, 0xc6, 0xde, 0x47, 0x6f, 0xe9, 0x4b, 0xdd, 0xd5, 0x97, 0x47, 0x68,
- 0x7f, 0x98, 0x08, 0xc3, 0xb2, 0x7b, 0x08, 0x0a, 0x7e, 0x05, 0xdb, 0xad, 0xbd, 0x56, 0xbf, 0x90,
- 0xc5, 0xfe, 0x31, 0xe5, 0x03, 0xe9, 0xe7, 0x6f, 0xb1, 0xf1, 0x7a, 0x34, 0x92, 0x12, 0x69, 0x29,
- 0xcd, 0xd5, 0x4a, 0xb9, 0x9c, 0x0b, 0x7b, 0xbf, 0x43, 0x84, 0xc7, 0x94, 0x0b, 0xf6, 0x4c, 0xa9,
- 0x1b, 0x25, 0x51, 0x4a, 0x72, 0x00, 0xa6, 0xf1, 0x8c, 0xb0, 0xf6, 0x6e, 0x3a, 0xbe, 0xb2, 0xcb,
- 0xa7, 0x68, 0x9e, 0x2a, 0xea, 0x3b, 0x59, 0x46, 0xff, 0x4c, 0x96, 0xad, 0x6b, 0xbb, 0x08, 0x25,
- 0xa9, 0x58, 0x75, 0x69, 0x31, 0xbb, 0x77, 0xcb, 0x75, 0x96, 0x29, 0x7d, 0x34, 0x0a, 0xee, 0xb0,
- 0xdb, 0xfa, 0xde, 0xe1, 0x52, 0xaf, 0xa3, 0xdd, 0xea, 0xa7, 0xc0, 0xf6, 0xd1, 0x28, 0x54, 0xc9,
- 0xc4, 0x3b, 0x2a, 0xd5, 0xbb, 0xe3, 0xbb, 0x4b, 0xa0, 0x57, 0x80, 0xd1, 0x50, 0x76, 0xd7, 0x8d,
- 0xb2, 0x74, 0x75, 0x69, 0x81, 0x7d, 0x34, 0x0a, 0xc1, 0x30, 0xc8, 0x8e, 0x40, 0x99, 0x44, 0x4f,
- 0x57, 0x76, 0x11, 0x4a, 0x82, 0x99, 0xad, 0x58, 0x9c, 0x35, 0x5b, 0x71, 0x38, 0xf8, 0x10, 0x18,
- 0xd0, 0x6c, 0x71, 0x49, 0xea, 0x5f, 0xd9, 0xd6, 0x31, 0xd2, 0xf2, 0x17, 0xb2, 0x83, 0x50, 0xf2,
- 0xcb, 0x0b, 0xaa, 0xca, 0x3a, 0xdc, 0x7b, 0x8c, 0xb5, 0x92, 0x5c, 0xac, 0x6a, 0xd6, 0x65, 0x9b,
- 0x57, 0x7d, 0xd8, 0x50, 0x7f, 0xef, 0x27, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x64, 0xd5, 0x2f,
- 0xa7, 0xcb, 0x07, 0x00, 0x00,
+ Metadata: "github.com/hyperledger/burrow/keys/pbkeys/keys.proto",
+}
+
+func init() {
+ proto.RegisterFile("github.com/hyperledger/burrow/keys/pbkeys/keys.proto", fileDescriptor_keys_ff2cb7ec9ea3671c)
+}
+
+var fileDescriptor_keys_ff2cb7ec9ea3671c = []byte{
+ // 716 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xd1, 0x6f, 0xd3, 0x3c,
+ 0x10, 0x57, 0x9b, 0xa8, 0x5b, 0x2f, 0x6d, 0xbf, 0xcd, 0xdf, 0xbe, 0x8f, 0x12, 0x0d, 0x84, 0xfc,
+ 0xc2, 0x84, 0xb4, 0x56, 0x1b, 0x13, 0x13, 0x93, 0x10, 0x42, 0x03, 0x0d, 0x36, 0x34, 0xa6, 0x4e,
+ 0xe2, 0x8d, 0x87, 0x64, 0x3d, 0xda, 0xa8, 0x6b, 0x13, 0xec, 0x64, 0x23, 0x0f, 0xbc, 0xf2, 0x47,
+ 0xf3, 0x84, 0x62, 0xc7, 0xb1, 0x9d, 0x6d, 0xac, 0x12, 0x2f, 0xad, 0x7d, 0xbe, 0xbb, 0xdf, 0xdd,
+ 0xf9, 0xd7, 0x9f, 0x0b, 0x7b, 0x93, 0x28, 0x9d, 0x66, 0xe1, 0xe0, 0x22, 0x9e, 0x0f, 0xa7, 0x79,
+ 0x82, 0xec, 0x12, 0xc7, 0x13, 0x64, 0xc3, 0x30, 0x63, 0x2c, 0xbe, 0x1e, 0xce, 0x30, 0xe7, 0xc3,
+ 0x24, 0x14, 0x5f, 0xc5, 0xc7, 0x20, 0x61, 0x71, 0x1a, 0x93, 0x96, 0x34, 0xd1, 0x2e, 0x78, 0x1f,
+ 0x23, 0x9e, 0x8e, 0xf0, 0x5b, 0x86, 0x3c, 0xa5, 0x6b, 0xd0, 0xfb, 0x8c, 0x2c, 0xfa, 0x9a, 0x8f,
+ 0x90, 0x27, 0xf1, 0x82, 0x23, 0xdd, 0x00, 0x32, 0xc2, 0x79, 0x7c, 0x85, 0xa7, 0xc1, 0x1c, 0x2b,
+ 0xeb, 0x3a, 0xfc, 0xf3, 0x66, 0x3c, 0xb6, 0x4c, 0xdb, 0xb0, 0x6e, 0x3a, 0x8a, 0x7c, 0xa4, 0x0f,
+ 0x2b, 0x33, 0xcc, 0x17, 0xc1, 0x1c, 0xfb, 0x8d, 0x27, 0x8d, 0xad, 0xf6, 0x48, 0x6d, 0xe9, 0x18,
+ 0xe0, 0x08, 0x17, 0xca, 0xef, 0x31, 0x40, 0x12, 0x70, 0x9e, 0x4c, 0x59, 0xc0, 0x95, 0xab, 0x61,
+ 0x21, 0x9b, 0xd0, 0xbe, 0xc8, 0xd8, 0x15, 0xa6, 0x79, 0x82, 0xfd, 0xa6, 0x38, 0xd6, 0x06, 0x13,
+ 0xc5, 0xb1, 0x51, 0x9e, 0x82, 0x27, 0x50, 0x64, 0x8d, 0x85, 0x63, 0x30, 0x1e, 0x33, 0xe4, 0x5c,
+ 0x95, 0x53, 0x6e, 0xe9, 0x01, 0xc0, 0x59, 0x16, 0x1a, 0x65, 0xdf, 0xee, 0x47, 0x08, 0xb8, 0x02,
+ 0x47, 0xd6, 0x20, 0xd6, 0xf4, 0x15, 0x78, 0x22, 0xb6, 0x04, 0x59, 0x03, 0x27, 0xc9, 0x42, 0x11,
+ 0xd8, 0x19, 0x15, 0xcb, 0x3f, 0x57, 0x4f, 0x8f, 0x60, 0xfd, 0xc3, 0x3c, 0x89, 0x59, 0x7a, 0x7c,
+ 0xfe, 0xe9, 0x74, 0xd9, 0x81, 0x10, 0x70, 0x0b, 0x77, 0x55, 0x47, 0xb1, 0xa6, 0xcf, 0xa0, 0x27,
+ 0x13, 0x2d, 0xd1, 0xef, 0x0f, 0xe8, 0x2a, 0xdf, 0xa5, 0x01, 0xeb, 0x8d, 0xdb, 0x7d, 0x39, 0xf5,
+ 0x5b, 0xf1, 0x61, 0x75, 0x86, 0x79, 0x98, 0xa7, 0xc8, 0xfb, 0xae, 0x18, 0x46, 0xb5, 0xa7, 0x5f,
+ 0xa0, 0xfb, 0xee, 0xfb, 0xdf, 0xc2, 0x1b, 0xdd, 0x39, 0x76, 0x77, 0x3f, 0x1b, 0xd0, 0x53, 0xf9,
+ 0xcb, 0x51, 0x6c, 0x42, 0x3b, 0xc9, 0xc2, 0xcb, 0xe8, 0x62, 0x86, 0x79, 0x79, 0x37, 0xda, 0x20,
+ 0xe0, 0x59, 0x74, 0x15, 0xa4, 0x58, 0x1c, 0x37, 0xc5, 0xb1, 0x61, 0xa9, 0x43, 0x75, 0x34, 0x21,
+ 0xac, 0x19, 0xb8, 0xf5, 0xbb, 0xcd, 0xc0, 0x3b, 0x8f, 0x26, 0x4b, 0xd3, 0xdc, 0x80, 0x69, 0xde,
+ 0xce, 0x3b, 0xc7, 0xee, 0x7f, 0x8e, 0x9c, 0x07, 0x13, 0x2c, 0xe7, 0xab, 0xb6, 0xf4, 0x18, 0x3a,
+ 0x12, 0x56, 0x37, 0xcf, 0xa3, 0xc9, 0x22, 0x48, 0x33, 0x86, 0xaa, 0xf9, 0xca, 0x70, 0x0f, 0x3d,
+ 0xaf, 0xa1, 0xab, 0x24, 0x41, 0x36, 0x61, 0xb9, 0x37, 0xea, 0xb7, 0x5e, 0xb2, 0xbf, 0xa9, 0xd9,
+ 0x6f, 0x94, 0xe9, 0x58, 0x65, 0xda, 0x65, 0xb9, 0xb5, 0xb2, 0xe8, 0x21, 0x78, 0xef, 0x03, 0x3e,
+ 0x55, 0xb0, 0x3e, 0xac, 0x4e, 0x03, 0x3e, 0x35, 0x50, 0xab, 0xbd, 0x09, 0xd1, 0xb4, 0x27, 0x41,
+ 0xa1, 0x23, 0x93, 0x94, 0x93, 0x20, 0xe0, 0x16, 0x51, 0x65, 0x06, 0xb1, 0xa6, 0x2f, 0xc1, 0x39,
+ 0xb1, 0xef, 0xb8, 0xf6, 0xa3, 0x37, 0xf4, 0xa5, 0x69, 0xeb, 0xcb, 0x36, 0x74, 0xa4, 0x7c, 0x96,
+ 0xe9, 0x1f, 0x81, 0x23, 0xf9, 0xe5, 0x6c, 0x79, 0xbb, 0xde, 0x40, 0x8a, 0xec, 0xe0, 0x04, 0xf3,
+ 0x51, 0x61, 0xa7, 0x6f, 0xa1, 0x57, 0xc9, 0xe6, 0x3d, 0x02, 0x79, 0x37, 0x17, 0x76, 0x7f, 0xb9,
+ 0xe0, 0x9e, 0x60, 0xce, 0xc9, 0x0b, 0xa1, 0x6e, 0xc8, 0x82, 0x14, 0x8b, 0x06, 0x88, 0xc2, 0xd3,
+ 0xc2, 0xea, 0xff, 0x6b, 0xd9, 0xca, 0x2a, 0xf7, 0xa0, 0x7d, 0x26, 0xa8, 0x6f, 0x45, 0x69, 0xfd,
+ 0xd3, 0x51, 0xa6, 0xae, 0xed, 0x80, 0x5b, 0x90, 0x8a, 0x54, 0x87, 0x06, 0xb3, 0xfd, 0x0d, 0xdb,
+ 0x58, 0x86, 0xec, 0x43, 0x4b, 0x72, 0x87, 0xfc, 0xa7, 0xce, 0x2d, 0x2e, 0xf9, 0xff, 0xd7, 0xcd,
+ 0x3a, 0x50, 0xca, 0x93, 0x0e, 0xb4, 0xe4, 0x4a, 0x07, 0xd6, 0x14, 0xef, 0x35, 0x80, 0x16, 0x53,
+ 0xf2, 0xd0, 0xf6, 0x32, 0x04, 0xf6, 0xce, 0x04, 0xfb, 0xd0, 0x92, 0xca, 0xa1, 0x91, 0x2d, 0xa5,
+ 0xd2, 0x81, 0x35, 0x81, 0xd9, 0x01, 0xb7, 0x60, 0x9a, 0x1e, 0x8f, 0x41, 0x5e, 0x3d, 0x1e, 0x8b,
+ 0x8c, 0x87, 0x00, 0xfa, 0xc9, 0xd4, 0xc5, 0xde, 0x78, 0x46, 0x7d, 0xff, 0xb6, 0x23, 0x8d, 0x5b,
+ 0x50, 0x50, 0xe3, 0x1a, 0xef, 0xb9, 0xc6, 0xb5, 0x58, 0x7a, 0x00, 0x2b, 0x25, 0x0d, 0x49, 0xd5,
+ 0x8d, 0xcd, 0x4b, 0xff, 0xc1, 0x0d, 0xbb, 0x8c, 0x0d, 0x5b, 0xe2, 0xff, 0xc3, 0xf3, 0xdf, 0x01,
+ 0x00, 0x00, 0xff, 0xff, 0x73, 0x20, 0x9f, 0xdf, 0x77, 0x08, 0x00, 0x00,
}
diff --git a/keys/pbkeys/keys.proto b/keys/pbkeys/keys.proto
index e530c4d5990374346e409e70ecb26525cc1d35d9..b1ceeb4cd3e4c2daf5bd0d7340d7a25043bdb54f 100644
--- a/keys/pbkeys/keys.proto
+++ b/keys/pbkeys/keys.proto
@@ -6,24 +6,39 @@ service Keys {
rpc GenerateKey(GenRequest) returns (GenResponse);
rpc PublicKey(PubRequest) returns (PubResponse);
rpc Sign(SignRequest) returns (SignResponse);
- rpc Verify(VerifyRequest) returns (Empty);
+ rpc Verify(VerifyRequest) returns (VerifyResponse);
rpc Import(ImportRequest) returns (ImportResponse);
rpc ImportJSON(ImportJSONRequest) returns (ImportResponse);
rpc Export(ExportRequest) returns (ExportResponse);
rpc Hash(HashRequest) returns (HashResponse);
- rpc RemoveName(Name) returns (Empty);
- rpc List(Name) returns (ListResponse);
- rpc AddName(AddNameRequest) returns (Empty);
+ rpc RemoveName(RemoveNameRequest) returns (RemoveNameResponse);
+ rpc List(ListRequest) returns (ListResponse);
+ rpc AddName(AddNameRequest) returns (AddNameResponse);
}
-message Name {
- string keyname = 1;
+// Some empty types we may define later
+
+message ListRequest {
+
}
-message Empty {
+message VerifyResponse {
}
+message RemoveNameResponse {
+
+}
+
+message AddNameResponse {
+
+}
+
+message RemoveNameRequest {
+ string keyname = 1;
+}
+
+
message GenRequest {
string passphrase = 1;
string curvetype = 2;
diff --git a/keys/server.go b/keys/server.go
index 71f5082603c6af920e51f0de4bcca5dd751d274d..576c819c656fdda11e9286d7bc562f511c825f2a 100644
--- a/keys/server.go
+++ b/keys/server.go
@@ -25,11 +25,8 @@ func StartStandAloneServer(keysDir, host, port string, AllowBadFilePermissions b
if err != nil {
return err
}
-
- ks := NewKeyStore(keysDir, AllowBadFilePermissions, logger)
-
grpcServer := grpc.NewServer()
- pbkeys.RegisterKeysServer(grpcServer, &ks)
+ pbkeys.RegisterKeysServer(grpcServer, NewKeyStore(keysDir, AllowBadFilePermissions, logger))
return grpcServer.Serve(listen)
}
@@ -125,7 +122,7 @@ func (k *KeyStore) Sign(ctx context.Context, in *pbkeys.SignRequest) (*pbkeys.Si
return &pbkeys.SignResponse{Signature: sig, Curvetype: key.CurveType.String()}, nil
}
-func (k *KeyStore) Verify(ctx context.Context, in *pbkeys.VerifyRequest) (*pbkeys.Empty, error) {
+func (k *KeyStore) Verify(ctx context.Context, in *pbkeys.VerifyRequest) (*pbkeys.VerifyResponse, error) {
if in.GetPub() == nil {
return nil, fmt.Errorf("must provide a pubkey")
}
@@ -153,7 +150,7 @@ func (k *KeyStore) Verify(ctx context.Context, in *pbkeys.VerifyRequest) (*pbkey
return nil, fmt.Errorf("Signature does not match")
}
- return &pbkeys.Empty{}, nil
+ return &pbkeys.VerifyResponse{}, nil
}
func (k *KeyStore) Hash(ctx context.Context, in *pbkeys.HashRequest) (*pbkeys.HashResponse, error) {
@@ -211,7 +208,7 @@ func (k *KeyStore) Import(ctx context.Context, in *pbkeys.ImportRequest) (*pbkey
return &pbkeys.ImportResponse{Address: hex.EncodeUpperToString(key.Address[:])}, nil
}
-func (k *KeyStore) List(ctx context.Context, in *pbkeys.Name) (*pbkeys.ListResponse, error) {
+func (k *KeyStore) List(ctx context.Context, in *pbkeys.ListRequest) (*pbkeys.ListResponse, error) {
names, err := coreNameList(k.keysDirPath)
if err != nil {
return nil, err
@@ -226,15 +223,15 @@ func (k *KeyStore) List(ctx context.Context, in *pbkeys.Name) (*pbkeys.ListRespo
return &pbkeys.ListResponse{Key: list}, nil
}
-func (k *KeyStore) RemoveName(ctx context.Context, in *pbkeys.Name) (*pbkeys.Empty, error) {
+func (k *KeyStore) RemoveName(ctx context.Context, in *pbkeys.RemoveNameRequest) (*pbkeys.RemoveNameResponse, error) {
if in.GetKeyname() == "" {
return nil, fmt.Errorf("please specify a name")
}
- return &pbkeys.Empty{}, coreNameRm(k.keysDirPath, in.GetKeyname())
+ return &pbkeys.RemoveNameResponse{}, coreNameRm(k.keysDirPath, in.GetKeyname())
}
-func (k *KeyStore) AddName(ctx context.Context, in *pbkeys.AddNameRequest) (*pbkeys.Empty, error) {
+func (k *KeyStore) AddName(ctx context.Context, in *pbkeys.AddNameRequest) (*pbkeys.AddNameResponse, error) {
if in.GetKeyname() == "" {
return nil, fmt.Errorf("please specify a name")
}
@@ -243,5 +240,5 @@ func (k *KeyStore) AddName(ctx context.Context, in *pbkeys.AddNameRequest) (*pbk
return nil, fmt.Errorf("please specify an address")
}
- return &pbkeys.Empty{}, coreNameAdd(k.keysDirPath, in.GetKeyname(), strings.ToUpper(in.GetAddress()))
+ return &pbkeys.AddNameResponse{}, coreNameAdd(k.keysDirPath, in.GetKeyname(), strings.ToUpper(in.GetAddress()))
}
diff --git a/logging/metadata.go b/logging/metadata.go
deleted file mode 100644
index 485c8f2be568d20c70c0d9041c44d035401d4ce2..0000000000000000000000000000000000000000
--- a/logging/metadata.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2017 Monax Industries Limited
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package logging
-
-import (
- kitlog "github.com/go-kit/kit/log"
- "github.com/go-stack/stack"
- "github.com/hyperledger/burrow/logging/structure"
-)
-
-const (
- // To get the Caller information correct on the log, we need to count the
- // number of calls from a log call in the code to the time it hits a kitlog
- // context: [log call site (5), Info/Trace (4), MultipleChannelLogger.Log (3),
- // kitlog.Context.Log (2), kitlog.bindValues (1) (binding occurs),
- // kitlog.Caller (0), stack.caller]
- infoTraceLoggerCallDepth = 5
-)
-
-func WithMetadata(logger *Logger) *Logger {
- return logger.With(structure.TimeKey, kitlog.DefaultTimestampUTC,
- structure.TraceKey, TraceValuer(),
- structure.CallerKey, kitlog.Caller(infoTraceLoggerCallDepth))
-}
-
-func TraceValuer() kitlog.Valuer {
- return func() interface{} { return stack.Trace() }
-}
diff --git a/rpc/burrow/burrow.proto b/rpc/burrow.proto.stashed
similarity index 99%
rename from rpc/burrow/burrow.proto
rename to rpc/burrow.proto.stashed
index 24f7333d289c606b7f584860d599d4d44a1c12eb..4fe98c95f5edae68f590c3ba45b7e8b66542eebc 100644
--- a/rpc/burrow/burrow.proto
+++ b/rpc/burrow.proto.stashed
@@ -1,3 +1,6 @@
+// Keeping this for source material to fold into burrow over time
+// Original Author: Tyler Jackson
+
syntax = "proto3";
diff --git a/rpc/burrow/burrow.pb.go b/rpc/burrow/burrow.pb.go
deleted file mode 100644
index 37ec3405d0336144b4a771168c965602c264aecc..0000000000000000000000000000000000000000
--- a/rpc/burrow/burrow.pb.go
+++ /dev/null
@@ -1,4842 +0,0 @@
-// Code generated by protoc-gen-go. DO NOT EDIT.
-// source: burrow.proto
-
-package burrow
-
-import proto "github.com/golang/protobuf/proto"
-import fmt "fmt"
-import math "math"
-
-import (
- context "golang.org/x/net/context"
- grpc "google.golang.org/grpc"
-)
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ = proto.Marshal
-var _ = fmt.Errorf
-var _ = math.Inf
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the proto package it is being compiled against.
-// A compilation error at this line likely means your copy of the
-// proto package needs to be updated.
-const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
-
-// #BEGIN(common)
-// Common Messages
-type Empty struct {
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Empty) Reset() { *m = Empty{} }
-func (m *Empty) String() string { return proto.CompactTextString(m) }
-func (*Empty) ProtoMessage() {}
-func (*Empty) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{0}
-}
-func (m *Empty) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Empty.Unmarshal(m, b)
-}
-func (m *Empty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Empty.Marshal(b, m, deterministic)
-}
-func (dst *Empty) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Empty.Merge(dst, src)
-}
-func (m *Empty) XXX_Size() int {
- return xxx_messageInfo_Empty.Size(m)
-}
-func (m *Empty) XXX_DiscardUnknown() {
- xxx_messageInfo_Empty.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Empty proto.InternalMessageInfo
-
-type InputAccount struct {
- PrivateKey []byte `protobuf:"bytes,1,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
- Address []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *InputAccount) Reset() { *m = InputAccount{} }
-func (m *InputAccount) String() string { return proto.CompactTextString(m) }
-func (*InputAccount) ProtoMessage() {}
-func (*InputAccount) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{1}
-}
-func (m *InputAccount) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_InputAccount.Unmarshal(m, b)
-}
-func (m *InputAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_InputAccount.Marshal(b, m, deterministic)
-}
-func (dst *InputAccount) XXX_Merge(src proto.Message) {
- xxx_messageInfo_InputAccount.Merge(dst, src)
-}
-func (m *InputAccount) XXX_Size() int {
- return xxx_messageInfo_InputAccount.Size(m)
-}
-func (m *InputAccount) XXX_DiscardUnknown() {
- xxx_messageInfo_InputAccount.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_InputAccount proto.InternalMessageInfo
-
-func (m *InputAccount) GetPrivateKey() []byte {
- if m != nil {
- return m.PrivateKey
- }
- return nil
-}
-
-func (m *InputAccount) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-type FilterData struct {
- Field string `protobuf:"bytes,1,opt,name=field,proto3" json:"field,omitempty"`
- Op string `protobuf:"bytes,2,opt,name=op,proto3" json:"op,omitempty"`
- Value string `protobuf:"bytes,3,opt,name=value,proto3" json:"value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *FilterData) Reset() { *m = FilterData{} }
-func (m *FilterData) String() string { return proto.CompactTextString(m) }
-func (*FilterData) ProtoMessage() {}
-func (*FilterData) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{2}
-}
-func (m *FilterData) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_FilterData.Unmarshal(m, b)
-}
-func (m *FilterData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_FilterData.Marshal(b, m, deterministic)
-}
-func (dst *FilterData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_FilterData.Merge(dst, src)
-}
-func (m *FilterData) XXX_Size() int {
- return xxx_messageInfo_FilterData.Size(m)
-}
-func (m *FilterData) XXX_DiscardUnknown() {
- xxx_messageInfo_FilterData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FilterData proto.InternalMessageInfo
-
-func (m *FilterData) GetField() string {
- if m != nil {
- return m.Field
- }
- return ""
-}
-
-func (m *FilterData) GetOp() string {
- if m != nil {
- return m.Op
- }
- return ""
-}
-
-func (m *FilterData) GetValue() string {
- if m != nil {
- return m.Value
- }
- return ""
-}
-
-type FilterListParam struct {
- Filters []*FilterData `protobuf:"bytes,1,rep,name=filters,proto3" json:"filters,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *FilterListParam) Reset() { *m = FilterListParam{} }
-func (m *FilterListParam) String() string { return proto.CompactTextString(m) }
-func (*FilterListParam) ProtoMessage() {}
-func (*FilterListParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{3}
-}
-func (m *FilterListParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_FilterListParam.Unmarshal(m, b)
-}
-func (m *FilterListParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_FilterListParam.Marshal(b, m, deterministic)
-}
-func (dst *FilterListParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_FilterListParam.Merge(dst, src)
-}
-func (m *FilterListParam) XXX_Size() int {
- return xxx_messageInfo_FilterListParam.Size(m)
-}
-func (m *FilterListParam) XXX_DiscardUnknown() {
- xxx_messageInfo_FilterListParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_FilterListParam proto.InternalMessageInfo
-
-func (m *FilterListParam) GetFilters() []*FilterData {
- if m != nil {
- return m.Filters
- }
- return nil
-}
-
-// This is here because it is required by both transactions and namereg
-// This situation can be remedied multiple ways
-type TxReceipt struct {
- TxHash []byte `protobuf:"bytes,1,opt,name=TxHash,proto3" json:"TxHash,omitempty"`
- CreatesContract bool `protobuf:"varint,2,opt,name=CreatesContract,proto3" json:"CreatesContract,omitempty"`
- ContractAddress []byte `protobuf:"bytes,3,opt,name=ContractAddress,proto3" json:"ContractAddress,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *TxReceipt) Reset() { *m = TxReceipt{} }
-func (m *TxReceipt) String() string { return proto.CompactTextString(m) }
-func (*TxReceipt) ProtoMessage() {}
-func (*TxReceipt) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{4}
-}
-func (m *TxReceipt) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_TxReceipt.Unmarshal(m, b)
-}
-func (m *TxReceipt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_TxReceipt.Marshal(b, m, deterministic)
-}
-func (dst *TxReceipt) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TxReceipt.Merge(dst, src)
-}
-func (m *TxReceipt) XXX_Size() int {
- return xxx_messageInfo_TxReceipt.Size(m)
-}
-func (m *TxReceipt) XXX_DiscardUnknown() {
- xxx_messageInfo_TxReceipt.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TxReceipt proto.InternalMessageInfo
-
-func (m *TxReceipt) GetTxHash() []byte {
- if m != nil {
- return m.TxHash
- }
- return nil
-}
-
-func (m *TxReceipt) GetCreatesContract() bool {
- if m != nil {
- return m.CreatesContract
- }
- return false
-}
-
-func (m *TxReceipt) GetContractAddress() []byte {
- if m != nil {
- return m.ContractAddress
- }
- return nil
-}
-
-// This is here because it is used in both the Account Service (GenPrivAccount)
-// And in the transaction service (SignTx)
-type PrivateAccount struct {
- PrivateKey []byte `protobuf:"bytes,1,opt,name=PrivateKey,proto3" json:"PrivateKey,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PrivateAccount) Reset() { *m = PrivateAccount{} }
-func (m *PrivateAccount) String() string { return proto.CompactTextString(m) }
-func (*PrivateAccount) ProtoMessage() {}
-func (*PrivateAccount) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{5}
-}
-func (m *PrivateAccount) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PrivateAccount.Unmarshal(m, b)
-}
-func (m *PrivateAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PrivateAccount.Marshal(b, m, deterministic)
-}
-func (dst *PrivateAccount) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PrivateAccount.Merge(dst, src)
-}
-func (m *PrivateAccount) XXX_Size() int {
- return xxx_messageInfo_PrivateAccount.Size(m)
-}
-func (m *PrivateAccount) XXX_DiscardUnknown() {
- xxx_messageInfo_PrivateAccount.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PrivateAccount proto.InternalMessageInfo
-
-func (m *PrivateAccount) GetPrivateKey() []byte {
- if m != nil {
- return m.PrivateKey
- }
- return nil
-}
-
-// This is hear because it is used by both the Events service (Poll) and the
-// Transaction service (TransactAndHold)
-type EventDataCall struct {
- CallData *CallData `protobuf:"bytes,1,opt,name=CallData,proto3" json:"CallData,omitempty"`
- Origin []byte `protobuf:"bytes,2,opt,name=Origin,proto3" json:"Origin,omitempty"`
- TxHash []byte `protobuf:"bytes,3,opt,name=TxHash,proto3" json:"TxHash,omitempty"`
- StackDepth int64 `protobuf:"varint,4,opt,name=StackDepth,proto3" json:"StackDepth,omitempty"`
- Return []byte `protobuf:"bytes,5,opt,name=Return,proto3" json:"Return,omitempty"`
- Exception string `protobuf:"bytes,6,opt,name=Exception,proto3" json:"Exception,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EventDataCall) Reset() { *m = EventDataCall{} }
-func (m *EventDataCall) String() string { return proto.CompactTextString(m) }
-func (*EventDataCall) ProtoMessage() {}
-func (*EventDataCall) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{6}
-}
-func (m *EventDataCall) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EventDataCall.Unmarshal(m, b)
-}
-func (m *EventDataCall) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EventDataCall.Marshal(b, m, deterministic)
-}
-func (dst *EventDataCall) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EventDataCall.Merge(dst, src)
-}
-func (m *EventDataCall) XXX_Size() int {
- return xxx_messageInfo_EventDataCall.Size(m)
-}
-func (m *EventDataCall) XXX_DiscardUnknown() {
- xxx_messageInfo_EventDataCall.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventDataCall proto.InternalMessageInfo
-
-func (m *EventDataCall) GetCallData() *CallData {
- if m != nil {
- return m.CallData
- }
- return nil
-}
-
-func (m *EventDataCall) GetOrigin() []byte {
- if m != nil {
- return m.Origin
- }
- return nil
-}
-
-func (m *EventDataCall) GetTxHash() []byte {
- if m != nil {
- return m.TxHash
- }
- return nil
-}
-
-func (m *EventDataCall) GetStackDepth() int64 {
- if m != nil {
- return m.StackDepth
- }
- return 0
-}
-
-func (m *EventDataCall) GetReturn() []byte {
- if m != nil {
- return m.Return
- }
- return nil
-}
-
-func (m *EventDataCall) GetException() string {
- if m != nil {
- return m.Exception
- }
- return ""
-}
-
-type CallData struct {
- Caller []byte `protobuf:"bytes,1,opt,name=Caller,proto3" json:"Caller,omitempty"`
- Callee []byte `protobuf:"bytes,2,opt,name=Callee,proto3" json:"Callee,omitempty"`
- Data []byte `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
- Value uint64 `protobuf:"varint,4,opt,name=Value,proto3" json:"Value,omitempty"`
- Gas uint64 `protobuf:"varint,5,opt,name=Gas,proto3" json:"Gas,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CallData) Reset() { *m = CallData{} }
-func (m *CallData) String() string { return proto.CompactTextString(m) }
-func (*CallData) ProtoMessage() {}
-func (*CallData) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{7}
-}
-func (m *CallData) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CallData.Unmarshal(m, b)
-}
-func (m *CallData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CallData.Marshal(b, m, deterministic)
-}
-func (dst *CallData) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CallData.Merge(dst, src)
-}
-func (m *CallData) XXX_Size() int {
- return xxx_messageInfo_CallData.Size(m)
-}
-func (m *CallData) XXX_DiscardUnknown() {
- xxx_messageInfo_CallData.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CallData proto.InternalMessageInfo
-
-func (m *CallData) GetCaller() []byte {
- if m != nil {
- return m.Caller
- }
- return nil
-}
-
-func (m *CallData) GetCallee() []byte {
- if m != nil {
- return m.Callee
- }
- return nil
-}
-
-func (m *CallData) GetData() []byte {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-func (m *CallData) GetValue() uint64 {
- if m != nil {
- return m.Value
- }
- return 0
-}
-
-func (m *CallData) GetGas() uint64 {
- if m != nil {
- return m.Gas
- }
- return 0
-}
-
-// Params
-type AddressParam struct {
- Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AddressParam) Reset() { *m = AddressParam{} }
-func (m *AddressParam) String() string { return proto.CompactTextString(m) }
-func (*AddressParam) ProtoMessage() {}
-func (*AddressParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{8}
-}
-func (m *AddressParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AddressParam.Unmarshal(m, b)
-}
-func (m *AddressParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AddressParam.Marshal(b, m, deterministic)
-}
-func (dst *AddressParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AddressParam.Merge(dst, src)
-}
-func (m *AddressParam) XXX_Size() int {
- return xxx_messageInfo_AddressParam.Size(m)
-}
-func (m *AddressParam) XXX_DiscardUnknown() {
- xxx_messageInfo_AddressParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AddressParam proto.InternalMessageInfo
-
-func (m *AddressParam) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-type PrivateKeyParam struct {
- PrivateKey []byte `protobuf:"bytes,1,opt,name=privateKey,proto3" json:"privateKey,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PrivateKeyParam) Reset() { *m = PrivateKeyParam{} }
-func (m *PrivateKeyParam) String() string { return proto.CompactTextString(m) }
-func (*PrivateKeyParam) ProtoMessage() {}
-func (*PrivateKeyParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{9}
-}
-func (m *PrivateKeyParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PrivateKeyParam.Unmarshal(m, b)
-}
-func (m *PrivateKeyParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PrivateKeyParam.Marshal(b, m, deterministic)
-}
-func (dst *PrivateKeyParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PrivateKeyParam.Merge(dst, src)
-}
-func (m *PrivateKeyParam) XXX_Size() int {
- return xxx_messageInfo_PrivateKeyParam.Size(m)
-}
-func (m *PrivateKeyParam) XXX_DiscardUnknown() {
- xxx_messageInfo_PrivateKeyParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PrivateKeyParam proto.InternalMessageInfo
-
-func (m *PrivateKeyParam) GetPrivateKey() []byte {
- if m != nil {
- return m.PrivateKey
- }
- return nil
-}
-
-type StorageAtParam struct {
- Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
- Key []byte `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *StorageAtParam) Reset() { *m = StorageAtParam{} }
-func (m *StorageAtParam) String() string { return proto.CompactTextString(m) }
-func (*StorageAtParam) ProtoMessage() {}
-func (*StorageAtParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{10}
-}
-func (m *StorageAtParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_StorageAtParam.Unmarshal(m, b)
-}
-func (m *StorageAtParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_StorageAtParam.Marshal(b, m, deterministic)
-}
-func (dst *StorageAtParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_StorageAtParam.Merge(dst, src)
-}
-func (m *StorageAtParam) XXX_Size() int {
- return xxx_messageInfo_StorageAtParam.Size(m)
-}
-func (m *StorageAtParam) XXX_DiscardUnknown() {
- xxx_messageInfo_StorageAtParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StorageAtParam proto.InternalMessageInfo
-
-func (m *StorageAtParam) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *StorageAtParam) GetKey() []byte {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-type BasePermissions struct {
- Perms uint64 `protobuf:"varint,1,opt,name=Perms,proto3" json:"Perms,omitempty"`
- SetBit uint64 `protobuf:"varint,2,opt,name=SetBit,proto3" json:"SetBit,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BasePermissions) Reset() { *m = BasePermissions{} }
-func (m *BasePermissions) String() string { return proto.CompactTextString(m) }
-func (*BasePermissions) ProtoMessage() {}
-func (*BasePermissions) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{11}
-}
-func (m *BasePermissions) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BasePermissions.Unmarshal(m, b)
-}
-func (m *BasePermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BasePermissions.Marshal(b, m, deterministic)
-}
-func (dst *BasePermissions) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BasePermissions.Merge(dst, src)
-}
-func (m *BasePermissions) XXX_Size() int {
- return xxx_messageInfo_BasePermissions.Size(m)
-}
-func (m *BasePermissions) XXX_DiscardUnknown() {
- xxx_messageInfo_BasePermissions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BasePermissions proto.InternalMessageInfo
-
-func (m *BasePermissions) GetPerms() uint64 {
- if m != nil {
- return m.Perms
- }
- return 0
-}
-
-func (m *BasePermissions) GetSetBit() uint64 {
- if m != nil {
- return m.SetBit
- }
- return 0
-}
-
-type AccountPermissions struct {
- Base *BasePermissions `protobuf:"bytes,1,opt,name=Base,proto3" json:"Base,omitempty"`
- Roles []string `protobuf:"bytes,2,rep,name=Roles,proto3" json:"Roles,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AccountPermissions) Reset() { *m = AccountPermissions{} }
-func (m *AccountPermissions) String() string { return proto.CompactTextString(m) }
-func (*AccountPermissions) ProtoMessage() {}
-func (*AccountPermissions) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{12}
-}
-func (m *AccountPermissions) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AccountPermissions.Unmarshal(m, b)
-}
-func (m *AccountPermissions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AccountPermissions.Marshal(b, m, deterministic)
-}
-func (dst *AccountPermissions) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AccountPermissions.Merge(dst, src)
-}
-func (m *AccountPermissions) XXX_Size() int {
- return xxx_messageInfo_AccountPermissions.Size(m)
-}
-func (m *AccountPermissions) XXX_DiscardUnknown() {
- xxx_messageInfo_AccountPermissions.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AccountPermissions proto.InternalMessageInfo
-
-func (m *AccountPermissions) GetBase() *BasePermissions {
- if m != nil {
- return m.Base
- }
- return nil
-}
-
-func (m *AccountPermissions) GetRoles() []string {
- if m != nil {
- return m.Roles
- }
- return nil
-}
-
-type Account struct {
- Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
- PublicKey []byte `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
- Sequence uint64 `protobuf:"varint,3,opt,name=Sequence,proto3" json:"Sequence,omitempty"`
- Balance uint64 `protobuf:"varint,4,opt,name=Balance,proto3" json:"Balance,omitempty"`
- Code []byte `protobuf:"bytes,5,opt,name=Code,proto3" json:"Code,omitempty"`
- StorageRoot []byte `protobuf:"bytes,6,opt,name=StorageRoot,proto3" json:"StorageRoot,omitempty"`
- Permissions *AccountPermissions `protobuf:"bytes,7,opt,name=Permissions,proto3" json:"Permissions,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Account) Reset() { *m = Account{} }
-func (m *Account) String() string { return proto.CompactTextString(m) }
-func (*Account) ProtoMessage() {}
-func (*Account) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{13}
-}
-func (m *Account) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Account.Unmarshal(m, b)
-}
-func (m *Account) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Account.Marshal(b, m, deterministic)
-}
-func (dst *Account) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Account.Merge(dst, src)
-}
-func (m *Account) XXX_Size() int {
- return xxx_messageInfo_Account.Size(m)
-}
-func (m *Account) XXX_DiscardUnknown() {
- xxx_messageInfo_Account.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Account proto.InternalMessageInfo
-
-func (m *Account) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *Account) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-func (m *Account) GetSequence() uint64 {
- if m != nil {
- return m.Sequence
- }
- return 0
-}
-
-func (m *Account) GetBalance() uint64 {
- if m != nil {
- return m.Balance
- }
- return 0
-}
-
-func (m *Account) GetCode() []byte {
- if m != nil {
- return m.Code
- }
- return nil
-}
-
-func (m *Account) GetStorageRoot() []byte {
- if m != nil {
- return m.StorageRoot
- }
- return nil
-}
-
-func (m *Account) GetPermissions() *AccountPermissions {
- if m != nil {
- return m.Permissions
- }
- return nil
-}
-
-type AccountList struct {
- BlockHeight uint64 `protobuf:"varint,1,opt,name=BlockHeight,proto3" json:"BlockHeight,omitempty"`
- Accounts []*Account `protobuf:"bytes,2,rep,name=Accounts,proto3" json:"Accounts,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *AccountList) Reset() { *m = AccountList{} }
-func (m *AccountList) String() string { return proto.CompactTextString(m) }
-func (*AccountList) ProtoMessage() {}
-func (*AccountList) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{14}
-}
-func (m *AccountList) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_AccountList.Unmarshal(m, b)
-}
-func (m *AccountList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_AccountList.Marshal(b, m, deterministic)
-}
-func (dst *AccountList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_AccountList.Merge(dst, src)
-}
-func (m *AccountList) XXX_Size() int {
- return xxx_messageInfo_AccountList.Size(m)
-}
-func (m *AccountList) XXX_DiscardUnknown() {
- xxx_messageInfo_AccountList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_AccountList proto.InternalMessageInfo
-
-func (m *AccountList) GetBlockHeight() uint64 {
- if m != nil {
- return m.BlockHeight
- }
- return 0
-}
-
-func (m *AccountList) GetAccounts() []*Account {
- if m != nil {
- return m.Accounts
- }
- return nil
-}
-
-type Validator struct {
- Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
- PublicKey []byte `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
- Power uint64 `protobuf:"varint,3,opt,name=Power,proto3" json:"Power,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Validator) Reset() { *m = Validator{} }
-func (m *Validator) String() string { return proto.CompactTextString(m) }
-func (*Validator) ProtoMessage() {}
-func (*Validator) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{15}
-}
-func (m *Validator) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Validator.Unmarshal(m, b)
-}
-func (m *Validator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Validator.Marshal(b, m, deterministic)
-}
-func (dst *Validator) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Validator.Merge(dst, src)
-}
-func (m *Validator) XXX_Size() int {
- return xxx_messageInfo_Validator.Size(m)
-}
-func (m *Validator) XXX_DiscardUnknown() {
- xxx_messageInfo_Validator.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Validator proto.InternalMessageInfo
-
-func (m *Validator) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *Validator) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-func (m *Validator) GetPower() uint64 {
- if m != nil {
- return m.Power
- }
- return 0
-}
-
-type ValidatorList struct {
- BlockHeight uint64 `protobuf:"varint,1,opt,name=BlockHeight,proto3" json:"BlockHeight,omitempty"`
- BondedValidators []*Validator `protobuf:"bytes,2,rep,name=BondedValidators,proto3" json:"BondedValidators,omitempty"`
- UnbondingValidators []*Validator `protobuf:"bytes,3,rep,name=UnbondingValidators,proto3" json:"UnbondingValidators,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ValidatorList) Reset() { *m = ValidatorList{} }
-func (m *ValidatorList) String() string { return proto.CompactTextString(m) }
-func (*ValidatorList) ProtoMessage() {}
-func (*ValidatorList) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{16}
-}
-func (m *ValidatorList) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ValidatorList.Unmarshal(m, b)
-}
-func (m *ValidatorList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ValidatorList.Marshal(b, m, deterministic)
-}
-func (dst *ValidatorList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ValidatorList.Merge(dst, src)
-}
-func (m *ValidatorList) XXX_Size() int {
- return xxx_messageInfo_ValidatorList.Size(m)
-}
-func (m *ValidatorList) XXX_DiscardUnknown() {
- xxx_messageInfo_ValidatorList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ValidatorList proto.InternalMessageInfo
-
-func (m *ValidatorList) GetBlockHeight() uint64 {
- if m != nil {
- return m.BlockHeight
- }
- return 0
-}
-
-func (m *ValidatorList) GetBondedValidators() []*Validator {
- if m != nil {
- return m.BondedValidators
- }
- return nil
-}
-
-func (m *ValidatorList) GetUnbondingValidators() []*Validator {
- if m != nil {
- return m.UnbondingValidators
- }
- return nil
-}
-
-type StorageItem struct {
- Key []byte `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
- Value []byte `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *StorageItem) Reset() { *m = StorageItem{} }
-func (m *StorageItem) String() string { return proto.CompactTextString(m) }
-func (*StorageItem) ProtoMessage() {}
-func (*StorageItem) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{17}
-}
-func (m *StorageItem) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_StorageItem.Unmarshal(m, b)
-}
-func (m *StorageItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_StorageItem.Marshal(b, m, deterministic)
-}
-func (dst *StorageItem) XXX_Merge(src proto.Message) {
- xxx_messageInfo_StorageItem.Merge(dst, src)
-}
-func (m *StorageItem) XXX_Size() int {
- return xxx_messageInfo_StorageItem.Size(m)
-}
-func (m *StorageItem) XXX_DiscardUnknown() {
- xxx_messageInfo_StorageItem.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StorageItem proto.InternalMessageInfo
-
-func (m *StorageItem) GetKey() []byte {
- if m != nil {
- return m.Key
- }
- return nil
-}
-
-func (m *StorageItem) GetValue() []byte {
- if m != nil {
- return m.Value
- }
- return nil
-}
-
-type StorageDump struct {
- StorageRoot []byte `protobuf:"bytes,1,opt,name=StorageRoot,proto3" json:"StorageRoot,omitempty"`
- StorageItems []*StorageItem `protobuf:"bytes,2,rep,name=StorageItems,proto3" json:"StorageItems,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *StorageDump) Reset() { *m = StorageDump{} }
-func (m *StorageDump) String() string { return proto.CompactTextString(m) }
-func (*StorageDump) ProtoMessage() {}
-func (*StorageDump) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{18}
-}
-func (m *StorageDump) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_StorageDump.Unmarshal(m, b)
-}
-func (m *StorageDump) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_StorageDump.Marshal(b, m, deterministic)
-}
-func (dst *StorageDump) XXX_Merge(src proto.Message) {
- xxx_messageInfo_StorageDump.Merge(dst, src)
-}
-func (m *StorageDump) XXX_Size() int {
- return xxx_messageInfo_StorageDump.Size(m)
-}
-func (m *StorageDump) XXX_DiscardUnknown() {
- xxx_messageInfo_StorageDump.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_StorageDump proto.InternalMessageInfo
-
-func (m *StorageDump) GetStorageRoot() []byte {
- if m != nil {
- return m.StorageRoot
- }
- return nil
-}
-
-func (m *StorageDump) GetStorageItems() []*StorageItem {
- if m != nil {
- return m.StorageItems
- }
- return nil
-}
-
-// Params
-type HeightParam struct {
- Height uint64 `protobuf:"varint,1,opt,name=height,proto3" json:"height,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *HeightParam) Reset() { *m = HeightParam{} }
-func (m *HeightParam) String() string { return proto.CompactTextString(m) }
-func (*HeightParam) ProtoMessage() {}
-func (*HeightParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{19}
-}
-func (m *HeightParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_HeightParam.Unmarshal(m, b)
-}
-func (m *HeightParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_HeightParam.Marshal(b, m, deterministic)
-}
-func (dst *HeightParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_HeightParam.Merge(dst, src)
-}
-func (m *HeightParam) XXX_Size() int {
- return xxx_messageInfo_HeightParam.Size(m)
-}
-func (m *HeightParam) XXX_DiscardUnknown() {
- xxx_messageInfo_HeightParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_HeightParam proto.InternalMessageInfo
-
-func (m *HeightParam) GetHeight() uint64 {
- if m != nil {
- return m.Height
- }
- return 0
-}
-
-type BlocksParam struct {
- MinHeight uint64 `protobuf:"varint,1,opt,name=minHeight,proto3" json:"minHeight,omitempty"`
- MaxHeight uint64 `protobuf:"varint,2,opt,name=maxHeight,proto3" json:"maxHeight,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BlocksParam) Reset() { *m = BlocksParam{} }
-func (m *BlocksParam) String() string { return proto.CompactTextString(m) }
-func (*BlocksParam) ProtoMessage() {}
-func (*BlocksParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{20}
-}
-func (m *BlocksParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BlocksParam.Unmarshal(m, b)
-}
-func (m *BlocksParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BlocksParam.Marshal(b, m, deterministic)
-}
-func (dst *BlocksParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BlocksParam.Merge(dst, src)
-}
-func (m *BlocksParam) XXX_Size() int {
- return xxx_messageInfo_BlocksParam.Size(m)
-}
-func (m *BlocksParam) XXX_DiscardUnknown() {
- xxx_messageInfo_BlocksParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BlocksParam proto.InternalMessageInfo
-
-func (m *BlocksParam) GetMinHeight() uint64 {
- if m != nil {
- return m.MinHeight
- }
- return 0
-}
-
-func (m *BlocksParam) GetMaxHeight() uint64 {
- if m != nil {
- return m.MaxHeight
- }
- return 0
-}
-
-// Results
-type Header struct {
- ChainID string `protobuf:"bytes,1,opt,name=ChainID,proto3" json:"ChainID,omitempty"`
- Height int64 `protobuf:"varint,2,opt,name=Height,proto3" json:"Height,omitempty"`
- Time int64 `protobuf:"varint,3,opt,name=Time,proto3" json:"Time,omitempty"`
- NumTxs int64 `protobuf:"varint,4,opt,name=NumTxs,proto3" json:"NumTxs,omitempty"`
- LastBlockID []byte `protobuf:"bytes,5,opt,name=LastBlockID,proto3" json:"LastBlockID,omitempty"`
- LastCommitHash []byte `protobuf:"bytes,6,opt,name=LastCommitHash,proto3" json:"LastCommitHash,omitempty"`
- DataHash []byte `protobuf:"bytes,7,opt,name=DataHash,proto3" json:"DataHash,omitempty"`
- ValidatorsHash []byte `protobuf:"bytes,8,opt,name=ValidatorsHash,proto3" json:"ValidatorsHash,omitempty"`
- AppHash []byte `protobuf:"bytes,9,opt,name=AppHash,proto3" json:"AppHash,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Header) Reset() { *m = Header{} }
-func (m *Header) String() string { return proto.CompactTextString(m) }
-func (*Header) ProtoMessage() {}
-func (*Header) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{21}
-}
-func (m *Header) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Header.Unmarshal(m, b)
-}
-func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Header.Marshal(b, m, deterministic)
-}
-func (dst *Header) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Header.Merge(dst, src)
-}
-func (m *Header) XXX_Size() int {
- return xxx_messageInfo_Header.Size(m)
-}
-func (m *Header) XXX_DiscardUnknown() {
- xxx_messageInfo_Header.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Header proto.InternalMessageInfo
-
-func (m *Header) GetChainID() string {
- if m != nil {
- return m.ChainID
- }
- return ""
-}
-
-func (m *Header) GetHeight() int64 {
- if m != nil {
- return m.Height
- }
- return 0
-}
-
-func (m *Header) GetTime() int64 {
- if m != nil {
- return m.Time
- }
- return 0
-}
-
-func (m *Header) GetNumTxs() int64 {
- if m != nil {
- return m.NumTxs
- }
- return 0
-}
-
-func (m *Header) GetLastBlockID() []byte {
- if m != nil {
- return m.LastBlockID
- }
- return nil
-}
-
-func (m *Header) GetLastCommitHash() []byte {
- if m != nil {
- return m.LastCommitHash
- }
- return nil
-}
-
-func (m *Header) GetDataHash() []byte {
- if m != nil {
- return m.DataHash
- }
- return nil
-}
-
-func (m *Header) GetValidatorsHash() []byte {
- if m != nil {
- return m.ValidatorsHash
- }
- return nil
-}
-
-func (m *Header) GetAppHash() []byte {
- if m != nil {
- return m.AppHash
- }
- return nil
-}
-
-type Data struct {
- Txs [][]byte `protobuf:"bytes,1,rep,name=Txs,proto3" json:"Txs,omitempty"`
- Hash []byte `protobuf:"bytes,2,opt,name=hash,proto3" json:"hash,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Data) Reset() { *m = Data{} }
-func (m *Data) String() string { return proto.CompactTextString(m) }
-func (*Data) ProtoMessage() {}
-func (*Data) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{22}
-}
-func (m *Data) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Data.Unmarshal(m, b)
-}
-func (m *Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Data.Marshal(b, m, deterministic)
-}
-func (dst *Data) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Data.Merge(dst, src)
-}
-func (m *Data) XXX_Size() int {
- return xxx_messageInfo_Data.Size(m)
-}
-func (m *Data) XXX_DiscardUnknown() {
- xxx_messageInfo_Data.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Data proto.InternalMessageInfo
-
-func (m *Data) GetTxs() [][]byte {
- if m != nil {
- return m.Txs
- }
- return nil
-}
-
-func (m *Data) GetHash() []byte {
- if m != nil {
- return m.Hash
- }
- return nil
-}
-
-type Block struct {
- BlockID []byte `protobuf:"bytes,1,opt,name=BlockID,proto3" json:"BlockID,omitempty"`
- Header *Header `protobuf:"bytes,2,opt,name=Header,proto3" json:"Header,omitempty"`
- Data *Data `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Block) Reset() { *m = Block{} }
-func (m *Block) String() string { return proto.CompactTextString(m) }
-func (*Block) ProtoMessage() {}
-func (*Block) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{23}
-}
-func (m *Block) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Block.Unmarshal(m, b)
-}
-func (m *Block) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Block.Marshal(b, m, deterministic)
-}
-func (dst *Block) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Block.Merge(dst, src)
-}
-func (m *Block) XXX_Size() int {
- return xxx_messageInfo_Block.Size(m)
-}
-func (m *Block) XXX_DiscardUnknown() {
- xxx_messageInfo_Block.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Block proto.InternalMessageInfo
-
-func (m *Block) GetBlockID() []byte {
- if m != nil {
- return m.BlockID
- }
- return nil
-}
-
-func (m *Block) GetHeader() *Header {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-func (m *Block) GetData() *Data {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-type BlockMeta struct {
- BlockID []byte `protobuf:"bytes,1,opt,name=BlockID,proto3" json:"BlockID,omitempty"`
- Header *Header `protobuf:"bytes,2,opt,name=Header,proto3" json:"Header,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BlockMeta) Reset() { *m = BlockMeta{} }
-func (m *BlockMeta) String() string { return proto.CompactTextString(m) }
-func (*BlockMeta) ProtoMessage() {}
-func (*BlockMeta) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{24}
-}
-func (m *BlockMeta) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BlockMeta.Unmarshal(m, b)
-}
-func (m *BlockMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BlockMeta.Marshal(b, m, deterministic)
-}
-func (dst *BlockMeta) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BlockMeta.Merge(dst, src)
-}
-func (m *BlockMeta) XXX_Size() int {
- return xxx_messageInfo_BlockMeta.Size(m)
-}
-func (m *BlockMeta) XXX_DiscardUnknown() {
- xxx_messageInfo_BlockMeta.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BlockMeta proto.InternalMessageInfo
-
-func (m *BlockMeta) GetBlockID() []byte {
- if m != nil {
- return m.BlockID
- }
- return nil
-}
-
-func (m *BlockMeta) GetHeader() *Header {
- if m != nil {
- return m.Header
- }
- return nil
-}
-
-type BlockList struct {
- LastHeight uint64 `protobuf:"varint,1,opt,name=LastHeight,proto3" json:"LastHeight,omitempty"`
- BlockMetas []*BlockMeta `protobuf:"bytes,2,rep,name=BlockMetas,proto3" json:"BlockMetas,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *BlockList) Reset() { *m = BlockList{} }
-func (m *BlockList) String() string { return proto.CompactTextString(m) }
-func (*BlockList) ProtoMessage() {}
-func (*BlockList) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{25}
-}
-func (m *BlockList) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_BlockList.Unmarshal(m, b)
-}
-func (m *BlockList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_BlockList.Marshal(b, m, deterministic)
-}
-func (dst *BlockList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_BlockList.Merge(dst, src)
-}
-func (m *BlockList) XXX_Size() int {
- return xxx_messageInfo_BlockList.Size(m)
-}
-func (m *BlockList) XXX_DiscardUnknown() {
- xxx_messageInfo_BlockList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_BlockList proto.InternalMessageInfo
-
-func (m *BlockList) GetLastHeight() uint64 {
- if m != nil {
- return m.LastHeight
- }
- return 0
-}
-
-func (m *BlockList) GetBlockMetas() []*BlockMeta {
- if m != nil {
- return m.BlockMetas
- }
- return nil
-}
-
-type ChainId struct {
- ChainName string `protobuf:"bytes,1,opt,name=ChainName,proto3" json:"ChainName,omitempty"`
- ChainId string `protobuf:"bytes,2,opt,name=ChainId,proto3" json:"ChainId,omitempty"`
- GenesisHash []byte `protobuf:"bytes,3,opt,name=GenesisHash,proto3" json:"GenesisHash,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ChainId) Reset() { *m = ChainId{} }
-func (m *ChainId) String() string { return proto.CompactTextString(m) }
-func (*ChainId) ProtoMessage() {}
-func (*ChainId) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{26}
-}
-func (m *ChainId) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ChainId.Unmarshal(m, b)
-}
-func (m *ChainId) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ChainId.Marshal(b, m, deterministic)
-}
-func (dst *ChainId) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ChainId.Merge(dst, src)
-}
-func (m *ChainId) XXX_Size() int {
- return xxx_messageInfo_ChainId.Size(m)
-}
-func (m *ChainId) XXX_DiscardUnknown() {
- xxx_messageInfo_ChainId.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ChainId proto.InternalMessageInfo
-
-func (m *ChainId) GetChainName() string {
- if m != nil {
- return m.ChainName
- }
- return ""
-}
-
-func (m *ChainId) GetChainId() string {
- if m != nil {
- return m.ChainId
- }
- return ""
-}
-
-func (m *ChainId) GetGenesisHash() []byte {
- if m != nil {
- return m.GenesisHash
- }
- return nil
-}
-
-type GenesisDoc struct {
- GenesisTime uint64 `protobuf:"varint,1,opt,name=GenesisTime,proto3" json:"GenesisTime,omitempty"`
- ChainName string `protobuf:"bytes,2,opt,name=ChainName,proto3" json:"ChainName,omitempty"`
- Salt []byte `protobuf:"bytes,3,opt,name=Salt,proto3" json:"Salt,omitempty"`
- GlobalPermissions uint64 `protobuf:"varint,4,opt,name=GlobalPermissions,proto3" json:"GlobalPermissions,omitempty"`
- Accounts []*GenesisDoc_GenesisAccount `protobuf:"bytes,5,rep,name=Accounts,proto3" json:"Accounts,omitempty"`
- Validators []*GenesisDoc_GenesisValidator `protobuf:"bytes,6,rep,name=Validators,proto3" json:"Validators,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GenesisDoc) Reset() { *m = GenesisDoc{} }
-func (m *GenesisDoc) String() string { return proto.CompactTextString(m) }
-func (*GenesisDoc) ProtoMessage() {}
-func (*GenesisDoc) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{27}
-}
-func (m *GenesisDoc) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GenesisDoc.Unmarshal(m, b)
-}
-func (m *GenesisDoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GenesisDoc.Marshal(b, m, deterministic)
-}
-func (dst *GenesisDoc) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GenesisDoc.Merge(dst, src)
-}
-func (m *GenesisDoc) XXX_Size() int {
- return xxx_messageInfo_GenesisDoc.Size(m)
-}
-func (m *GenesisDoc) XXX_DiscardUnknown() {
- xxx_messageInfo_GenesisDoc.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenesisDoc proto.InternalMessageInfo
-
-func (m *GenesisDoc) GetGenesisTime() uint64 {
- if m != nil {
- return m.GenesisTime
- }
- return 0
-}
-
-func (m *GenesisDoc) GetChainName() string {
- if m != nil {
- return m.ChainName
- }
- return ""
-}
-
-func (m *GenesisDoc) GetSalt() []byte {
- if m != nil {
- return m.Salt
- }
- return nil
-}
-
-func (m *GenesisDoc) GetGlobalPermissions() uint64 {
- if m != nil {
- return m.GlobalPermissions
- }
- return 0
-}
-
-func (m *GenesisDoc) GetAccounts() []*GenesisDoc_GenesisAccount {
- if m != nil {
- return m.Accounts
- }
- return nil
-}
-
-func (m *GenesisDoc) GetValidators() []*GenesisDoc_GenesisValidator {
- if m != nil {
- return m.Validators
- }
- return nil
-}
-
-type GenesisDoc_GenesisAccount struct {
- Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
- PublicKey []byte `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
- Amount uint64 `protobuf:"varint,3,opt,name=Amount,proto3" json:"Amount,omitempty"`
- Name string `protobuf:"bytes,4,opt,name=Name,proto3" json:"Name,omitempty"`
- Permissions *AccountPermissions `protobuf:"bytes,5,opt,name=Permissions,proto3" json:"Permissions,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GenesisDoc_GenesisAccount) Reset() { *m = GenesisDoc_GenesisAccount{} }
-func (m *GenesisDoc_GenesisAccount) String() string { return proto.CompactTextString(m) }
-func (*GenesisDoc_GenesisAccount) ProtoMessage() {}
-func (*GenesisDoc_GenesisAccount) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{27, 0}
-}
-func (m *GenesisDoc_GenesisAccount) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GenesisDoc_GenesisAccount.Unmarshal(m, b)
-}
-func (m *GenesisDoc_GenesisAccount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GenesisDoc_GenesisAccount.Marshal(b, m, deterministic)
-}
-func (dst *GenesisDoc_GenesisAccount) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GenesisDoc_GenesisAccount.Merge(dst, src)
-}
-func (m *GenesisDoc_GenesisAccount) XXX_Size() int {
- return xxx_messageInfo_GenesisDoc_GenesisAccount.Size(m)
-}
-func (m *GenesisDoc_GenesisAccount) XXX_DiscardUnknown() {
- xxx_messageInfo_GenesisDoc_GenesisAccount.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenesisDoc_GenesisAccount proto.InternalMessageInfo
-
-func (m *GenesisDoc_GenesisAccount) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *GenesisDoc_GenesisAccount) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-func (m *GenesisDoc_GenesisAccount) GetAmount() uint64 {
- if m != nil {
- return m.Amount
- }
- return 0
-}
-
-func (m *GenesisDoc_GenesisAccount) GetName() string {
- if m != nil {
- return m.Name
- }
- return ""
-}
-
-func (m *GenesisDoc_GenesisAccount) GetPermissions() *AccountPermissions {
- if m != nil {
- return m.Permissions
- }
- return nil
-}
-
-type GenesisDoc_GenesisValidator struct {
- Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
- PublicKey []byte `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
- Amount uint64 `protobuf:"varint,3,opt,name=Amount,proto3" json:"Amount,omitempty"`
- Name string `protobuf:"bytes,4,opt,name=Name,proto3" json:"Name,omitempty"`
- UnbondTo [][]byte `protobuf:"bytes,5,rep,name=UnbondTo,proto3" json:"UnbondTo,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *GenesisDoc_GenesisValidator) Reset() { *m = GenesisDoc_GenesisValidator{} }
-func (m *GenesisDoc_GenesisValidator) String() string { return proto.CompactTextString(m) }
-func (*GenesisDoc_GenesisValidator) ProtoMessage() {}
-func (*GenesisDoc_GenesisValidator) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{27, 1}
-}
-func (m *GenesisDoc_GenesisValidator) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_GenesisDoc_GenesisValidator.Unmarshal(m, b)
-}
-func (m *GenesisDoc_GenesisValidator) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_GenesisDoc_GenesisValidator.Marshal(b, m, deterministic)
-}
-func (dst *GenesisDoc_GenesisValidator) XXX_Merge(src proto.Message) {
- xxx_messageInfo_GenesisDoc_GenesisValidator.Merge(dst, src)
-}
-func (m *GenesisDoc_GenesisValidator) XXX_Size() int {
- return xxx_messageInfo_GenesisDoc_GenesisValidator.Size(m)
-}
-func (m *GenesisDoc_GenesisValidator) XXX_DiscardUnknown() {
- xxx_messageInfo_GenesisDoc_GenesisValidator.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_GenesisDoc_GenesisValidator proto.InternalMessageInfo
-
-func (m *GenesisDoc_GenesisValidator) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *GenesisDoc_GenesisValidator) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-func (m *GenesisDoc_GenesisValidator) GetAmount() uint64 {
- if m != nil {
- return m.Amount
- }
- return 0
-}
-
-func (m *GenesisDoc_GenesisValidator) GetName() string {
- if m != nil {
- return m.Name
- }
- return ""
-}
-
-func (m *GenesisDoc_GenesisValidator) GetUnbondTo() [][]byte {
- if m != nil {
- return m.UnbondTo
- }
- return nil
-}
-
-type UnconfirmedTxList struct {
- NumTxs uint64 `protobuf:"varint,1,opt,name=NumTxs,proto3" json:"NumTxs,omitempty"`
- Txs [][]byte `protobuf:"bytes,2,rep,name=Txs,proto3" json:"Txs,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *UnconfirmedTxList) Reset() { *m = UnconfirmedTxList{} }
-func (m *UnconfirmedTxList) String() string { return proto.CompactTextString(m) }
-func (*UnconfirmedTxList) ProtoMessage() {}
-func (*UnconfirmedTxList) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{28}
-}
-func (m *UnconfirmedTxList) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_UnconfirmedTxList.Unmarshal(m, b)
-}
-func (m *UnconfirmedTxList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_UnconfirmedTxList.Marshal(b, m, deterministic)
-}
-func (dst *UnconfirmedTxList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_UnconfirmedTxList.Merge(dst, src)
-}
-func (m *UnconfirmedTxList) XXX_Size() int {
- return xxx_messageInfo_UnconfirmedTxList.Size(m)
-}
-func (m *UnconfirmedTxList) XXX_DiscardUnknown() {
- xxx_messageInfo_UnconfirmedTxList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_UnconfirmedTxList proto.InternalMessageInfo
-
-func (m *UnconfirmedTxList) GetNumTxs() uint64 {
- if m != nil {
- return m.NumTxs
- }
- return 0
-}
-
-func (m *UnconfirmedTxList) GetTxs() [][]byte {
- if m != nil {
- return m.Txs
- }
- return nil
-}
-
-type Status struct {
- NodeInfo *NodeInfo `protobuf:"bytes,1,opt,name=NodeInfo,proto3" json:"NodeInfo,omitempty"`
- GenesisHash []byte `protobuf:"bytes,2,opt,name=GenesisHash,proto3" json:"GenesisHash,omitempty"`
- PublicKey []byte `protobuf:"bytes,3,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
- LatestBlockHash []byte `protobuf:"bytes,4,opt,name=LatestBlockHash,proto3" json:"LatestBlockHash,omitempty"`
- LatestBlockHeight uint64 `protobuf:"varint,5,opt,name=LatestBlockHeight,proto3" json:"LatestBlockHeight,omitempty"`
- LatestBlockTime int64 `protobuf:"varint,6,opt,name=LatestBlockTime,proto3" json:"LatestBlockTime,omitempty"`
- NodeVersion string `protobuf:"bytes,7,opt,name=NodeVersion,proto3" json:"NodeVersion,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Status) Reset() { *m = Status{} }
-func (m *Status) String() string { return proto.CompactTextString(m) }
-func (*Status) ProtoMessage() {}
-func (*Status) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{29}
-}
-func (m *Status) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Status.Unmarshal(m, b)
-}
-func (m *Status) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Status.Marshal(b, m, deterministic)
-}
-func (dst *Status) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Status.Merge(dst, src)
-}
-func (m *Status) XXX_Size() int {
- return xxx_messageInfo_Status.Size(m)
-}
-func (m *Status) XXX_DiscardUnknown() {
- xxx_messageInfo_Status.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Status proto.InternalMessageInfo
-
-func (m *Status) GetNodeInfo() *NodeInfo {
- if m != nil {
- return m.NodeInfo
- }
- return nil
-}
-
-func (m *Status) GetGenesisHash() []byte {
- if m != nil {
- return m.GenesisHash
- }
- return nil
-}
-
-func (m *Status) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-func (m *Status) GetLatestBlockHash() []byte {
- if m != nil {
- return m.LatestBlockHash
- }
- return nil
-}
-
-func (m *Status) GetLatestBlockHeight() uint64 {
- if m != nil {
- return m.LatestBlockHeight
- }
- return 0
-}
-
-func (m *Status) GetLatestBlockTime() int64 {
- if m != nil {
- return m.LatestBlockTime
- }
- return 0
-}
-
-func (m *Status) GetNodeVersion() string {
- if m != nil {
- return m.NodeVersion
- }
- return ""
-}
-
-// These are used for get consensus state. There is a lot of information that could be included
-// We should decided what the minimum we want inccluded is.
-type RoundState struct {
- Height int64 `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
- Round int64 `protobuf:"varint,2,opt,name=Round,proto3" json:"Round,omitempty"`
- Step int64 `protobuf:"varint,3,opt,name=Step,proto3" json:"Step,omitempty"`
- StartTime uint64 `protobuf:"varint,4,opt,name=StartTime,proto3" json:"StartTime,omitempty"`
- CommitTime uint64 `protobuf:"varint,5,opt,name=CommitTime,proto3" json:"CommitTime,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *RoundState) Reset() { *m = RoundState{} }
-func (m *RoundState) String() string { return proto.CompactTextString(m) }
-func (*RoundState) ProtoMessage() {}
-func (*RoundState) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{30}
-}
-func (m *RoundState) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_RoundState.Unmarshal(m, b)
-}
-func (m *RoundState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_RoundState.Marshal(b, m, deterministic)
-}
-func (dst *RoundState) XXX_Merge(src proto.Message) {
- xxx_messageInfo_RoundState.Merge(dst, src)
-}
-func (m *RoundState) XXX_Size() int {
- return xxx_messageInfo_RoundState.Size(m)
-}
-func (m *RoundState) XXX_DiscardUnknown() {
- xxx_messageInfo_RoundState.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_RoundState proto.InternalMessageInfo
-
-func (m *RoundState) GetHeight() int64 {
- if m != nil {
- return m.Height
- }
- return 0
-}
-
-func (m *RoundState) GetRound() int64 {
- if m != nil {
- return m.Round
- }
- return 0
-}
-
-func (m *RoundState) GetStep() int64 {
- if m != nil {
- return m.Step
- }
- return 0
-}
-
-func (m *RoundState) GetStartTime() uint64 {
- if m != nil {
- return m.StartTime
- }
- return 0
-}
-
-func (m *RoundState) GetCommitTime() uint64 {
- if m != nil {
- return m.CommitTime
- }
- return 0
-}
-
-type PeerRoundState struct {
- Height int64 `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
- Round int64 `protobuf:"varint,2,opt,name=Round,proto3" json:"Round,omitempty"`
- Step int64 `protobuf:"varint,3,opt,name=Step,proto3" json:"Step,omitempty"`
- StartTime uint64 `protobuf:"varint,4,opt,name=StartTime,proto3" json:"StartTime,omitempty"`
- Proposal bool `protobuf:"varint,5,opt,name=Proposal,proto3" json:"Proposal,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PeerRoundState) Reset() { *m = PeerRoundState{} }
-func (m *PeerRoundState) String() string { return proto.CompactTextString(m) }
-func (*PeerRoundState) ProtoMessage() {}
-func (*PeerRoundState) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{31}
-}
-func (m *PeerRoundState) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PeerRoundState.Unmarshal(m, b)
-}
-func (m *PeerRoundState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PeerRoundState.Marshal(b, m, deterministic)
-}
-func (dst *PeerRoundState) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PeerRoundState.Merge(dst, src)
-}
-func (m *PeerRoundState) XXX_Size() int {
- return xxx_messageInfo_PeerRoundState.Size(m)
-}
-func (m *PeerRoundState) XXX_DiscardUnknown() {
- xxx_messageInfo_PeerRoundState.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PeerRoundState proto.InternalMessageInfo
-
-func (m *PeerRoundState) GetHeight() int64 {
- if m != nil {
- return m.Height
- }
- return 0
-}
-
-func (m *PeerRoundState) GetRound() int64 {
- if m != nil {
- return m.Round
- }
- return 0
-}
-
-func (m *PeerRoundState) GetStep() int64 {
- if m != nil {
- return m.Step
- }
- return 0
-}
-
-func (m *PeerRoundState) GetStartTime() uint64 {
- if m != nil {
- return m.StartTime
- }
- return 0
-}
-
-func (m *PeerRoundState) GetProposal() bool {
- if m != nil {
- return m.Proposal
- }
- return false
-}
-
-type ConsensusState struct {
- RoundState *RoundState `protobuf:"bytes,1,opt,name=RoundState,proto3" json:"RoundState,omitempty"`
- PeerRoundStates []*PeerRoundState `protobuf:"bytes,2,rep,name=PeerRoundStates,proto3" json:"PeerRoundStates,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ConsensusState) Reset() { *m = ConsensusState{} }
-func (m *ConsensusState) String() string { return proto.CompactTextString(m) }
-func (*ConsensusState) ProtoMessage() {}
-func (*ConsensusState) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{32}
-}
-func (m *ConsensusState) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ConsensusState.Unmarshal(m, b)
-}
-func (m *ConsensusState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ConsensusState.Marshal(b, m, deterministic)
-}
-func (dst *ConsensusState) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ConsensusState.Merge(dst, src)
-}
-func (m *ConsensusState) XXX_Size() int {
- return xxx_messageInfo_ConsensusState.Size(m)
-}
-func (m *ConsensusState) XXX_DiscardUnknown() {
- xxx_messageInfo_ConsensusState.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ConsensusState proto.InternalMessageInfo
-
-func (m *ConsensusState) GetRoundState() *RoundState {
- if m != nil {
- return m.RoundState
- }
- return nil
-}
-
-func (m *ConsensusState) GetPeerRoundStates() []*PeerRoundState {
- if m != nil {
- return m.PeerRoundStates
- }
- return nil
-}
-
-// Params
-type EventIdParam struct {
- EventId string `protobuf:"bytes,1,opt,name=eventId,proto3" json:"eventId,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EventIdParam) Reset() { *m = EventIdParam{} }
-func (m *EventIdParam) String() string { return proto.CompactTextString(m) }
-func (*EventIdParam) ProtoMessage() {}
-func (*EventIdParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{33}
-}
-func (m *EventIdParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EventIdParam.Unmarshal(m, b)
-}
-func (m *EventIdParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EventIdParam.Marshal(b, m, deterministic)
-}
-func (dst *EventIdParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EventIdParam.Merge(dst, src)
-}
-func (m *EventIdParam) XXX_Size() int {
- return xxx_messageInfo_EventIdParam.Size(m)
-}
-func (m *EventIdParam) XXX_DiscardUnknown() {
- xxx_messageInfo_EventIdParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventIdParam proto.InternalMessageInfo
-
-func (m *EventIdParam) GetEventId() string {
- if m != nil {
- return m.EventId
- }
- return ""
-}
-
-type SubIdParam struct {
- SubId string `protobuf:"bytes,1,opt,name=subId,proto3" json:"subId,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *SubIdParam) Reset() { *m = SubIdParam{} }
-func (m *SubIdParam) String() string { return proto.CompactTextString(m) }
-func (*SubIdParam) ProtoMessage() {}
-func (*SubIdParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{34}
-}
-func (m *SubIdParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_SubIdParam.Unmarshal(m, b)
-}
-func (m *SubIdParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_SubIdParam.Marshal(b, m, deterministic)
-}
-func (dst *SubIdParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SubIdParam.Merge(dst, src)
-}
-func (m *SubIdParam) XXX_Size() int {
- return xxx_messageInfo_SubIdParam.Size(m)
-}
-func (m *SubIdParam) XXX_DiscardUnknown() {
- xxx_messageInfo_SubIdParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SubIdParam proto.InternalMessageInfo
-
-func (m *SubIdParam) GetSubId() string {
- if m != nil {
- return m.SubId
- }
- return ""
-}
-
-// Results
-type EventUnSub struct {
- Result bool `protobuf:"varint,1,opt,name=result,proto3" json:"result,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EventUnSub) Reset() { *m = EventUnSub{} }
-func (m *EventUnSub) String() string { return proto.CompactTextString(m) }
-func (*EventUnSub) ProtoMessage() {}
-func (*EventUnSub) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{35}
-}
-func (m *EventUnSub) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EventUnSub.Unmarshal(m, b)
-}
-func (m *EventUnSub) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EventUnSub.Marshal(b, m, deterministic)
-}
-func (dst *EventUnSub) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EventUnSub.Merge(dst, src)
-}
-func (m *EventUnSub) XXX_Size() int {
- return xxx_messageInfo_EventUnSub.Size(m)
-}
-func (m *EventUnSub) XXX_DiscardUnknown() {
- xxx_messageInfo_EventUnSub.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventUnSub proto.InternalMessageInfo
-
-func (m *EventUnSub) GetResult() bool {
- if m != nil {
- return m.Result
- }
- return false
-}
-
-type EventDataLog struct {
- Address []byte `protobuf:"bytes,1,opt,name=Address,proto3" json:"Address,omitempty"`
- Data []byte `protobuf:"bytes,2,opt,name=Data,proto3" json:"Data,omitempty"`
- Height uint64 `protobuf:"varint,3,opt,name=Height,proto3" json:"Height,omitempty"`
- Topics []string `protobuf:"bytes,4,rep,name=Topics,proto3" json:"Topics,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EventDataLog) Reset() { *m = EventDataLog{} }
-func (m *EventDataLog) String() string { return proto.CompactTextString(m) }
-func (*EventDataLog) ProtoMessage() {}
-func (*EventDataLog) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{36}
-}
-func (m *EventDataLog) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EventDataLog.Unmarshal(m, b)
-}
-func (m *EventDataLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EventDataLog.Marshal(b, m, deterministic)
-}
-func (dst *EventDataLog) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EventDataLog.Merge(dst, src)
-}
-func (m *EventDataLog) XXX_Size() int {
- return xxx_messageInfo_EventDataLog.Size(m)
-}
-func (m *EventDataLog) XXX_DiscardUnknown() {
- xxx_messageInfo_EventDataLog.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventDataLog proto.InternalMessageInfo
-
-func (m *EventDataLog) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *EventDataLog) GetData() []byte {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-func (m *EventDataLog) GetHeight() uint64 {
- if m != nil {
- return m.Height
- }
- return 0
-}
-
-func (m *EventDataLog) GetTopics() []string {
- if m != nil {
- return m.Topics
- }
- return nil
-}
-
-type EventDataTx struct {
- Tx []byte `protobuf:"bytes,1,opt,name=Tx,proto3" json:"Tx,omitempty"`
- Return []byte `protobuf:"bytes,2,opt,name=Return,proto3" json:"Return,omitempty"`
- Exception string `protobuf:"bytes,3,opt,name=Exception,proto3" json:"Exception,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *EventDataTx) Reset() { *m = EventDataTx{} }
-func (m *EventDataTx) String() string { return proto.CompactTextString(m) }
-func (*EventDataTx) ProtoMessage() {}
-func (*EventDataTx) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{37}
-}
-func (m *EventDataTx) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_EventDataTx.Unmarshal(m, b)
-}
-func (m *EventDataTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_EventDataTx.Marshal(b, m, deterministic)
-}
-func (dst *EventDataTx) XXX_Merge(src proto.Message) {
- xxx_messageInfo_EventDataTx.Merge(dst, src)
-}
-func (m *EventDataTx) XXX_Size() int {
- return xxx_messageInfo_EventDataTx.Size(m)
-}
-func (m *EventDataTx) XXX_DiscardUnknown() {
- xxx_messageInfo_EventDataTx.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_EventDataTx proto.InternalMessageInfo
-
-func (m *EventDataTx) GetTx() []byte {
- if m != nil {
- return m.Tx
- }
- return nil
-}
-
-func (m *EventDataTx) GetReturn() []byte {
- if m != nil {
- return m.Return
- }
- return nil
-}
-
-func (m *EventDataTx) GetException() string {
- if m != nil {
- return m.Exception
- }
- return ""
-}
-
-type Event struct {
- Event string `protobuf:"bytes,1,opt,name=Event,proto3" json:"Event,omitempty"`
- EventDataTx *EventDataTx `protobuf:"bytes,2,opt,name=EventDataTx,proto3" json:"EventDataTx,omitempty"`
- EventDataCall *EventDataCall `protobuf:"bytes,3,opt,name=EventDataCall,proto3" json:"EventDataCall,omitempty"`
- EventDataLog *EventDataLog `protobuf:"bytes,4,opt,name=EventDataLog,proto3" json:"EventDataLog,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Event) Reset() { *m = Event{} }
-func (m *Event) String() string { return proto.CompactTextString(m) }
-func (*Event) ProtoMessage() {}
-func (*Event) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{38}
-}
-func (m *Event) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Event.Unmarshal(m, b)
-}
-func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Event.Marshal(b, m, deterministic)
-}
-func (dst *Event) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Event.Merge(dst, src)
-}
-func (m *Event) XXX_Size() int {
- return xxx_messageInfo_Event.Size(m)
-}
-func (m *Event) XXX_DiscardUnknown() {
- xxx_messageInfo_Event.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Event proto.InternalMessageInfo
-
-func (m *Event) GetEvent() string {
- if m != nil {
- return m.Event
- }
- return ""
-}
-
-func (m *Event) GetEventDataTx() *EventDataTx {
- if m != nil {
- return m.EventDataTx
- }
- return nil
-}
-
-func (m *Event) GetEventDataCall() *EventDataCall {
- if m != nil {
- return m.EventDataCall
- }
- return nil
-}
-
-func (m *Event) GetEventDataLog() *EventDataLog {
- if m != nil {
- return m.EventDataLog
- }
- return nil
-}
-
-type PollResponse struct {
- Events []*Event `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PollResponse) Reset() { *m = PollResponse{} }
-func (m *PollResponse) String() string { return proto.CompactTextString(m) }
-func (*PollResponse) ProtoMessage() {}
-func (*PollResponse) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{39}
-}
-func (m *PollResponse) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PollResponse.Unmarshal(m, b)
-}
-func (m *PollResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PollResponse.Marshal(b, m, deterministic)
-}
-func (dst *PollResponse) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PollResponse.Merge(dst, src)
-}
-func (m *PollResponse) XXX_Size() int {
- return xxx_messageInfo_PollResponse.Size(m)
-}
-func (m *PollResponse) XXX_DiscardUnknown() {
- xxx_messageInfo_PollResponse.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PollResponse proto.InternalMessageInfo
-
-func (m *PollResponse) GetEvents() []*Event {
- if m != nil {
- return m.Events
- }
- return nil
-}
-
-// Params
-type NameRegEntryParam struct {
- Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NameRegEntryParam) Reset() { *m = NameRegEntryParam{} }
-func (m *NameRegEntryParam) String() string { return proto.CompactTextString(m) }
-func (*NameRegEntryParam) ProtoMessage() {}
-func (*NameRegEntryParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{40}
-}
-func (m *NameRegEntryParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NameRegEntryParam.Unmarshal(m, b)
-}
-func (m *NameRegEntryParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NameRegEntryParam.Marshal(b, m, deterministic)
-}
-func (dst *NameRegEntryParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NameRegEntryParam.Merge(dst, src)
-}
-func (m *NameRegEntryParam) XXX_Size() int {
- return xxx_messageInfo_NameRegEntryParam.Size(m)
-}
-func (m *NameRegEntryParam) XXX_DiscardUnknown() {
- xxx_messageInfo_NameRegEntryParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NameRegEntryParam proto.InternalMessageInfo
-
-func (m *NameRegEntryParam) GetName() string {
- if m != nil {
- return m.Name
- }
- return ""
-}
-
-type TransactNameRegParam struct {
- InputAccount *InputAccount `protobuf:"bytes,1,opt,name=inputAccount,proto3" json:"inputAccount,omitempty"`
- Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
- Data string `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
- Fee uint64 `protobuf:"varint,4,opt,name=fee,proto3" json:"fee,omitempty"`
- Amount uint64 `protobuf:"varint,5,opt,name=amount,proto3" json:"amount,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *TransactNameRegParam) Reset() { *m = TransactNameRegParam{} }
-func (m *TransactNameRegParam) String() string { return proto.CompactTextString(m) }
-func (*TransactNameRegParam) ProtoMessage() {}
-func (*TransactNameRegParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{41}
-}
-func (m *TransactNameRegParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_TransactNameRegParam.Unmarshal(m, b)
-}
-func (m *TransactNameRegParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_TransactNameRegParam.Marshal(b, m, deterministic)
-}
-func (dst *TransactNameRegParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TransactNameRegParam.Merge(dst, src)
-}
-func (m *TransactNameRegParam) XXX_Size() int {
- return xxx_messageInfo_TransactNameRegParam.Size(m)
-}
-func (m *TransactNameRegParam) XXX_DiscardUnknown() {
- xxx_messageInfo_TransactNameRegParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TransactNameRegParam proto.InternalMessageInfo
-
-func (m *TransactNameRegParam) GetInputAccount() *InputAccount {
- if m != nil {
- return m.InputAccount
- }
- return nil
-}
-
-func (m *TransactNameRegParam) GetName() string {
- if m != nil {
- return m.Name
- }
- return ""
-}
-
-func (m *TransactNameRegParam) GetData() string {
- if m != nil {
- return m.Data
- }
- return ""
-}
-
-func (m *TransactNameRegParam) GetFee() uint64 {
- if m != nil {
- return m.Fee
- }
- return 0
-}
-
-func (m *TransactNameRegParam) GetAmount() uint64 {
- if m != nil {
- return m.Amount
- }
- return 0
-}
-
-// Results
-type NameRegEntry struct {
- // registered name for the entry
- Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
- Owner []byte `protobuf:"bytes,2,opt,name=Owner,proto3" json:"Owner,omitempty"`
- Data string `protobuf:"bytes,3,opt,name=Data,proto3" json:"Data,omitempty"`
- Expires uint64 `protobuf:"varint,4,opt,name=Expires,proto3" json:"Expires,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NameRegEntry) Reset() { *m = NameRegEntry{} }
-func (m *NameRegEntry) String() string { return proto.CompactTextString(m) }
-func (*NameRegEntry) ProtoMessage() {}
-func (*NameRegEntry) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{42}
-}
-func (m *NameRegEntry) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NameRegEntry.Unmarshal(m, b)
-}
-func (m *NameRegEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NameRegEntry.Marshal(b, m, deterministic)
-}
-func (dst *NameRegEntry) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NameRegEntry.Merge(dst, src)
-}
-func (m *NameRegEntry) XXX_Size() int {
- return xxx_messageInfo_NameRegEntry.Size(m)
-}
-func (m *NameRegEntry) XXX_DiscardUnknown() {
- xxx_messageInfo_NameRegEntry.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NameRegEntry proto.InternalMessageInfo
-
-func (m *NameRegEntry) GetName() string {
- if m != nil {
- return m.Name
- }
- return ""
-}
-
-func (m *NameRegEntry) GetOwner() []byte {
- if m != nil {
- return m.Owner
- }
- return nil
-}
-
-func (m *NameRegEntry) GetData() string {
- if m != nil {
- return m.Data
- }
- return ""
-}
-
-func (m *NameRegEntry) GetExpires() uint64 {
- if m != nil {
- return m.Expires
- }
- return 0
-}
-
-type NameRegEntryList struct {
- BlockHeight uint64 `protobuf:"varint,1,opt,name=BlockHeight,proto3" json:"BlockHeight,omitempty"`
- Names []*NameRegEntry `protobuf:"bytes,2,rep,name=Names,proto3" json:"Names,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NameRegEntryList) Reset() { *m = NameRegEntryList{} }
-func (m *NameRegEntryList) String() string { return proto.CompactTextString(m) }
-func (*NameRegEntryList) ProtoMessage() {}
-func (*NameRegEntryList) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{43}
-}
-func (m *NameRegEntryList) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NameRegEntryList.Unmarshal(m, b)
-}
-func (m *NameRegEntryList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NameRegEntryList.Marshal(b, m, deterministic)
-}
-func (dst *NameRegEntryList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NameRegEntryList.Merge(dst, src)
-}
-func (m *NameRegEntryList) XXX_Size() int {
- return xxx_messageInfo_NameRegEntryList.Size(m)
-}
-func (m *NameRegEntryList) XXX_DiscardUnknown() {
- xxx_messageInfo_NameRegEntryList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NameRegEntryList proto.InternalMessageInfo
-
-func (m *NameRegEntryList) GetBlockHeight() uint64 {
- if m != nil {
- return m.BlockHeight
- }
- return 0
-}
-
-func (m *NameRegEntryList) GetNames() []*NameRegEntry {
- if m != nil {
- return m.Names
- }
- return nil
-}
-
-// Params
-type PeerParam struct {
- Address []byte `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PeerParam) Reset() { *m = PeerParam{} }
-func (m *PeerParam) String() string { return proto.CompactTextString(m) }
-func (*PeerParam) ProtoMessage() {}
-func (*PeerParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{44}
-}
-func (m *PeerParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PeerParam.Unmarshal(m, b)
-}
-func (m *PeerParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PeerParam.Marshal(b, m, deterministic)
-}
-func (dst *PeerParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PeerParam.Merge(dst, src)
-}
-func (m *PeerParam) XXX_Size() int {
- return xxx_messageInfo_PeerParam.Size(m)
-}
-func (m *PeerParam) XXX_DiscardUnknown() {
- xxx_messageInfo_PeerParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PeerParam proto.InternalMessageInfo
-
-func (m *PeerParam) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-// Results
-type ClientVersion struct {
- Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *ClientVersion) Reset() { *m = ClientVersion{} }
-func (m *ClientVersion) String() string { return proto.CompactTextString(m) }
-func (*ClientVersion) ProtoMessage() {}
-func (*ClientVersion) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{45}
-}
-func (m *ClientVersion) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_ClientVersion.Unmarshal(m, b)
-}
-func (m *ClientVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_ClientVersion.Marshal(b, m, deterministic)
-}
-func (dst *ClientVersion) XXX_Merge(src proto.Message) {
- xxx_messageInfo_ClientVersion.Merge(dst, src)
-}
-func (m *ClientVersion) XXX_Size() int {
- return xxx_messageInfo_ClientVersion.Size(m)
-}
-func (m *ClientVersion) XXX_DiscardUnknown() {
- xxx_messageInfo_ClientVersion.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_ClientVersion proto.InternalMessageInfo
-
-func (m *ClientVersion) GetVersion() string {
- if m != nil {
- return m.Version
- }
- return ""
-}
-
-type NodeID struct {
- Name string `protobuf:"bytes,1,opt,name=Name,proto3" json:"Name,omitempty"`
- PublicKey []byte `protobuf:"bytes,2,opt,name=PublicKey,proto3" json:"PublicKey,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NodeID) Reset() { *m = NodeID{} }
-func (m *NodeID) String() string { return proto.CompactTextString(m) }
-func (*NodeID) ProtoMessage() {}
-func (*NodeID) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{46}
-}
-func (m *NodeID) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NodeID.Unmarshal(m, b)
-}
-func (m *NodeID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NodeID.Marshal(b, m, deterministic)
-}
-func (dst *NodeID) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NodeID.Merge(dst, src)
-}
-func (m *NodeID) XXX_Size() int {
- return xxx_messageInfo_NodeID.Size(m)
-}
-func (m *NodeID) XXX_DiscardUnknown() {
- xxx_messageInfo_NodeID.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NodeID proto.InternalMessageInfo
-
-func (m *NodeID) GetName() string {
- if m != nil {
- return m.Name
- }
- return ""
-}
-
-func (m *NodeID) GetPublicKey() []byte {
- if m != nil {
- return m.PublicKey
- }
- return nil
-}
-
-type NodeInfo struct {
- ID *NodeID `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
- ListenAddr string `protobuf:"bytes,2,opt,name=ListenAddr,proto3" json:"ListenAddr,omitempty"`
- Network string `protobuf:"bytes,3,opt,name=Network,proto3" json:"Network,omitempty"`
- Version string `protobuf:"bytes,4,opt,name=Version,proto3" json:"Version,omitempty"`
- Channels []byte `protobuf:"bytes,5,opt,name=Channels,proto3" json:"Channels,omitempty"`
- Moniker string `protobuf:"bytes,6,opt,name=Moniker,proto3" json:"Moniker,omitempty"`
- Other []string `protobuf:"bytes,7,rep,name=Other,proto3" json:"Other,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NodeInfo) Reset() { *m = NodeInfo{} }
-func (m *NodeInfo) String() string { return proto.CompactTextString(m) }
-func (*NodeInfo) ProtoMessage() {}
-func (*NodeInfo) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{47}
-}
-func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NodeInfo.Unmarshal(m, b)
-}
-func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NodeInfo.Marshal(b, m, deterministic)
-}
-func (dst *NodeInfo) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NodeInfo.Merge(dst, src)
-}
-func (m *NodeInfo) XXX_Size() int {
- return xxx_messageInfo_NodeInfo.Size(m)
-}
-func (m *NodeInfo) XXX_DiscardUnknown() {
- xxx_messageInfo_NodeInfo.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NodeInfo proto.InternalMessageInfo
-
-func (m *NodeInfo) GetID() *NodeID {
- if m != nil {
- return m.ID
- }
- return nil
-}
-
-func (m *NodeInfo) GetListenAddr() string {
- if m != nil {
- return m.ListenAddr
- }
- return ""
-}
-
-func (m *NodeInfo) GetNetwork() string {
- if m != nil {
- return m.Network
- }
- return ""
-}
-
-func (m *NodeInfo) GetVersion() string {
- if m != nil {
- return m.Version
- }
- return ""
-}
-
-func (m *NodeInfo) GetChannels() []byte {
- if m != nil {
- return m.Channels
- }
- return nil
-}
-
-func (m *NodeInfo) GetMoniker() string {
- if m != nil {
- return m.Moniker
- }
- return ""
-}
-
-func (m *NodeInfo) GetOther() []string {
- if m != nil {
- return m.Other
- }
- return nil
-}
-
-type NetworkInfo struct {
- Listening bool `protobuf:"varint,1,opt,name=Listening,proto3" json:"Listening,omitempty"`
- Listeners []string `protobuf:"bytes,2,rep,name=Listeners,proto3" json:"Listeners,omitempty"`
- Peers []*Peer `protobuf:"bytes,3,rep,name=Peers,proto3" json:"Peers,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *NetworkInfo) Reset() { *m = NetworkInfo{} }
-func (m *NetworkInfo) String() string { return proto.CompactTextString(m) }
-func (*NetworkInfo) ProtoMessage() {}
-func (*NetworkInfo) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{48}
-}
-func (m *NetworkInfo) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_NetworkInfo.Unmarshal(m, b)
-}
-func (m *NetworkInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_NetworkInfo.Marshal(b, m, deterministic)
-}
-func (dst *NetworkInfo) XXX_Merge(src proto.Message) {
- xxx_messageInfo_NetworkInfo.Merge(dst, src)
-}
-func (m *NetworkInfo) XXX_Size() int {
- return xxx_messageInfo_NetworkInfo.Size(m)
-}
-func (m *NetworkInfo) XXX_DiscardUnknown() {
- xxx_messageInfo_NetworkInfo.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_NetworkInfo proto.InternalMessageInfo
-
-func (m *NetworkInfo) GetListening() bool {
- if m != nil {
- return m.Listening
- }
- return false
-}
-
-func (m *NetworkInfo) GetListeners() []string {
- if m != nil {
- return m.Listeners
- }
- return nil
-}
-
-func (m *NetworkInfo) GetPeers() []*Peer {
- if m != nil {
- return m.Peers
- }
- return nil
-}
-
-type Peer struct {
- NodeInfo *NodeInfo `protobuf:"bytes,1,opt,name=NodeInfo,proto3" json:"NodeInfo,omitempty"`
- IsOutbound bool `protobuf:"varint,2,opt,name=IsOutbound,proto3" json:"IsOutbound,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *Peer) Reset() { *m = Peer{} }
-func (m *Peer) String() string { return proto.CompactTextString(m) }
-func (*Peer) ProtoMessage() {}
-func (*Peer) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{49}
-}
-func (m *Peer) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_Peer.Unmarshal(m, b)
-}
-func (m *Peer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_Peer.Marshal(b, m, deterministic)
-}
-func (dst *Peer) XXX_Merge(src proto.Message) {
- xxx_messageInfo_Peer.Merge(dst, src)
-}
-func (m *Peer) XXX_Size() int {
- return xxx_messageInfo_Peer.Size(m)
-}
-func (m *Peer) XXX_DiscardUnknown() {
- xxx_messageInfo_Peer.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_Peer proto.InternalMessageInfo
-
-func (m *Peer) GetNodeInfo() *NodeInfo {
- if m != nil {
- return m.NodeInfo
- }
- return nil
-}
-
-func (m *Peer) GetIsOutbound() bool {
- if m != nil {
- return m.IsOutbound
- }
- return false
-}
-
-type PeerList struct {
- Peers []*Peer `protobuf:"bytes,1,rep,name=Peers,proto3" json:"Peers,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *PeerList) Reset() { *m = PeerList{} }
-func (m *PeerList) String() string { return proto.CompactTextString(m) }
-func (*PeerList) ProtoMessage() {}
-func (*PeerList) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{50}
-}
-func (m *PeerList) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_PeerList.Unmarshal(m, b)
-}
-func (m *PeerList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_PeerList.Marshal(b, m, deterministic)
-}
-func (dst *PeerList) XXX_Merge(src proto.Message) {
- xxx_messageInfo_PeerList.Merge(dst, src)
-}
-func (m *PeerList) XXX_Size() int {
- return xxx_messageInfo_PeerList.Size(m)
-}
-func (m *PeerList) XXX_DiscardUnknown() {
- xxx_messageInfo_PeerList.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_PeerList proto.InternalMessageInfo
-
-func (m *PeerList) GetPeers() []*Peer {
- if m != nil {
- return m.Peers
- }
- return nil
-}
-
-// Params
-type CallParam struct {
- From []byte `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
- Address []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
- Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CallParam) Reset() { *m = CallParam{} }
-func (m *CallParam) String() string { return proto.CompactTextString(m) }
-func (*CallParam) ProtoMessage() {}
-func (*CallParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{51}
-}
-func (m *CallParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CallParam.Unmarshal(m, b)
-}
-func (m *CallParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CallParam.Marshal(b, m, deterministic)
-}
-func (dst *CallParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CallParam.Merge(dst, src)
-}
-func (m *CallParam) XXX_Size() int {
- return xxx_messageInfo_CallParam.Size(m)
-}
-func (m *CallParam) XXX_DiscardUnknown() {
- xxx_messageInfo_CallParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CallParam proto.InternalMessageInfo
-
-func (m *CallParam) GetFrom() []byte {
- if m != nil {
- return m.From
- }
- return nil
-}
-
-func (m *CallParam) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *CallParam) GetData() []byte {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-type CallCodeParam struct {
- From []byte `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
- Code []byte `protobuf:"bytes,2,opt,name=code,proto3" json:"code,omitempty"`
- Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CallCodeParam) Reset() { *m = CallCodeParam{} }
-func (m *CallCodeParam) String() string { return proto.CompactTextString(m) }
-func (*CallCodeParam) ProtoMessage() {}
-func (*CallCodeParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{52}
-}
-func (m *CallCodeParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CallCodeParam.Unmarshal(m, b)
-}
-func (m *CallCodeParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CallCodeParam.Marshal(b, m, deterministic)
-}
-func (dst *CallCodeParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CallCodeParam.Merge(dst, src)
-}
-func (m *CallCodeParam) XXX_Size() int {
- return xxx_messageInfo_CallCodeParam.Size(m)
-}
-func (m *CallCodeParam) XXX_DiscardUnknown() {
- xxx_messageInfo_CallCodeParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CallCodeParam proto.InternalMessageInfo
-
-func (m *CallCodeParam) GetFrom() []byte {
- if m != nil {
- return m.From
- }
- return nil
-}
-
-func (m *CallCodeParam) GetCode() []byte {
- if m != nil {
- return m.Code
- }
- return nil
-}
-
-func (m *CallCodeParam) GetData() []byte {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-type TransactParam struct {
- InputAccount *InputAccount `protobuf:"bytes,1,opt,name=inputAccount,proto3" json:"inputAccount,omitempty"`
- Address []byte `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
- Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
- GasLimit uint64 `protobuf:"varint,4,opt,name=gasLimit,proto3" json:"gasLimit,omitempty"`
- Fee uint64 `protobuf:"varint,5,opt,name=fee,proto3" json:"fee,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *TransactParam) Reset() { *m = TransactParam{} }
-func (m *TransactParam) String() string { return proto.CompactTextString(m) }
-func (*TransactParam) ProtoMessage() {}
-func (*TransactParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{53}
-}
-func (m *TransactParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_TransactParam.Unmarshal(m, b)
-}
-func (m *TransactParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_TransactParam.Marshal(b, m, deterministic)
-}
-func (dst *TransactParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TransactParam.Merge(dst, src)
-}
-func (m *TransactParam) XXX_Size() int {
- return xxx_messageInfo_TransactParam.Size(m)
-}
-func (m *TransactParam) XXX_DiscardUnknown() {
- xxx_messageInfo_TransactParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TransactParam proto.InternalMessageInfo
-
-func (m *TransactParam) GetInputAccount() *InputAccount {
- if m != nil {
- return m.InputAccount
- }
- return nil
-}
-
-func (m *TransactParam) GetAddress() []byte {
- if m != nil {
- return m.Address
- }
- return nil
-}
-
-func (m *TransactParam) GetData() []byte {
- if m != nil {
- return m.Data
- }
- return nil
-}
-
-func (m *TransactParam) GetGasLimit() uint64 {
- if m != nil {
- return m.GasLimit
- }
- return 0
-}
-
-func (m *TransactParam) GetFee() uint64 {
- if m != nil {
- return m.Fee
- }
- return 0
-}
-
-type SendParam struct {
- InputAccount *InputAccount `protobuf:"bytes,1,opt,name=inputAccount,proto3" json:"inputAccount,omitempty"`
- ToAddress []byte `protobuf:"bytes,2,opt,name=toAddress,proto3" json:"toAddress,omitempty"`
- Amount uint64 `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *SendParam) Reset() { *m = SendParam{} }
-func (m *SendParam) String() string { return proto.CompactTextString(m) }
-func (*SendParam) ProtoMessage() {}
-func (*SendParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{54}
-}
-func (m *SendParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_SendParam.Unmarshal(m, b)
-}
-func (m *SendParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_SendParam.Marshal(b, m, deterministic)
-}
-func (dst *SendParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SendParam.Merge(dst, src)
-}
-func (m *SendParam) XXX_Size() int {
- return xxx_messageInfo_SendParam.Size(m)
-}
-func (m *SendParam) XXX_DiscardUnknown() {
- xxx_messageInfo_SendParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SendParam proto.InternalMessageInfo
-
-func (m *SendParam) GetInputAccount() *InputAccount {
- if m != nil {
- return m.InputAccount
- }
- return nil
-}
-
-func (m *SendParam) GetToAddress() []byte {
- if m != nil {
- return m.ToAddress
- }
- return nil
-}
-
-func (m *SendParam) GetAmount() uint64 {
- if m != nil {
- return m.Amount
- }
- return 0
-}
-
-type TxParam struct {
- Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *TxParam) Reset() { *m = TxParam{} }
-func (m *TxParam) String() string { return proto.CompactTextString(m) }
-func (*TxParam) ProtoMessage() {}
-func (*TxParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{55}
-}
-func (m *TxParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_TxParam.Unmarshal(m, b)
-}
-func (m *TxParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_TxParam.Marshal(b, m, deterministic)
-}
-func (dst *TxParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_TxParam.Merge(dst, src)
-}
-func (m *TxParam) XXX_Size() int {
- return xxx_messageInfo_TxParam.Size(m)
-}
-func (m *TxParam) XXX_DiscardUnknown() {
- xxx_messageInfo_TxParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_TxParam proto.InternalMessageInfo
-
-func (m *TxParam) GetTx() []byte {
- if m != nil {
- return m.Tx
- }
- return nil
-}
-
-type SignTxParam struct {
- Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
- PrivateAccounts []*PrivateAccount `protobuf:"bytes,2,rep,name=privateAccounts,proto3" json:"privateAccounts,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *SignTxParam) Reset() { *m = SignTxParam{} }
-func (m *SignTxParam) String() string { return proto.CompactTextString(m) }
-func (*SignTxParam) ProtoMessage() {}
-func (*SignTxParam) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{56}
-}
-func (m *SignTxParam) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_SignTxParam.Unmarshal(m, b)
-}
-func (m *SignTxParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_SignTxParam.Marshal(b, m, deterministic)
-}
-func (dst *SignTxParam) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SignTxParam.Merge(dst, src)
-}
-func (m *SignTxParam) XXX_Size() int {
- return xxx_messageInfo_SignTxParam.Size(m)
-}
-func (m *SignTxParam) XXX_DiscardUnknown() {
- xxx_messageInfo_SignTxParam.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SignTxParam proto.InternalMessageInfo
-
-func (m *SignTxParam) GetTx() []byte {
- if m != nil {
- return m.Tx
- }
- return nil
-}
-
-func (m *SignTxParam) GetPrivateAccounts() []*PrivateAccount {
- if m != nil {
- return m.PrivateAccounts
- }
- return nil
-}
-
-// Results
-type SignedTx struct {
- Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *SignedTx) Reset() { *m = SignedTx{} }
-func (m *SignedTx) String() string { return proto.CompactTextString(m) }
-func (*SignedTx) ProtoMessage() {}
-func (*SignedTx) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{57}
-}
-func (m *SignedTx) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_SignedTx.Unmarshal(m, b)
-}
-func (m *SignedTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_SignedTx.Marshal(b, m, deterministic)
-}
-func (dst *SignedTx) XXX_Merge(src proto.Message) {
- xxx_messageInfo_SignedTx.Merge(dst, src)
-}
-func (m *SignedTx) XXX_Size() int {
- return xxx_messageInfo_SignedTx.Size(m)
-}
-func (m *SignedTx) XXX_DiscardUnknown() {
- xxx_messageInfo_SignedTx.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_SignedTx proto.InternalMessageInfo
-
-func (m *SignedTx) GetTx() []byte {
- if m != nil {
- return m.Tx
- }
- return nil
-}
-
-type CallResult struct {
- Return []byte `protobuf:"bytes,1,opt,name=Return,proto3" json:"Return,omitempty"`
- GasUsed uint64 `protobuf:"varint,2,opt,name=GasUsed,proto3" json:"GasUsed,omitempty"`
- XXX_NoUnkeyedLiteral struct{} `json:"-"`
- XXX_unrecognized []byte `json:"-"`
- XXX_sizecache int32 `json:"-"`
-}
-
-func (m *CallResult) Reset() { *m = CallResult{} }
-func (m *CallResult) String() string { return proto.CompactTextString(m) }
-func (*CallResult) ProtoMessage() {}
-func (*CallResult) Descriptor() ([]byte, []int) {
- return fileDescriptor_burrow_5b05719ae28d1091, []int{58}
-}
-func (m *CallResult) XXX_Unmarshal(b []byte) error {
- return xxx_messageInfo_CallResult.Unmarshal(m, b)
-}
-func (m *CallResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
- return xxx_messageInfo_CallResult.Marshal(b, m, deterministic)
-}
-func (dst *CallResult) XXX_Merge(src proto.Message) {
- xxx_messageInfo_CallResult.Merge(dst, src)
-}
-func (m *CallResult) XXX_Size() int {
- return xxx_messageInfo_CallResult.Size(m)
-}
-func (m *CallResult) XXX_DiscardUnknown() {
- xxx_messageInfo_CallResult.DiscardUnknown(m)
-}
-
-var xxx_messageInfo_CallResult proto.InternalMessageInfo
-
-func (m *CallResult) GetReturn() []byte {
- if m != nil {
- return m.Return
- }
- return nil
-}
-
-func (m *CallResult) GetGasUsed() uint64 {
- if m != nil {
- return m.GasUsed
- }
- return 0
-}
-
-func init() {
- proto.RegisterType((*Empty)(nil), "Empty")
- proto.RegisterType((*InputAccount)(nil), "InputAccount")
- proto.RegisterType((*FilterData)(nil), "FilterData")
- proto.RegisterType((*FilterListParam)(nil), "FilterListParam")
- proto.RegisterType((*TxReceipt)(nil), "TxReceipt")
- proto.RegisterType((*PrivateAccount)(nil), "PrivateAccount")
- proto.RegisterType((*EventDataCall)(nil), "EventDataCall")
- proto.RegisterType((*CallData)(nil), "CallData")
- proto.RegisterType((*AddressParam)(nil), "AddressParam")
- proto.RegisterType((*PrivateKeyParam)(nil), "PrivateKeyParam")
- proto.RegisterType((*StorageAtParam)(nil), "StorageAtParam")
- proto.RegisterType((*BasePermissions)(nil), "BasePermissions")
- proto.RegisterType((*AccountPermissions)(nil), "AccountPermissions")
- proto.RegisterType((*Account)(nil), "Account")
- proto.RegisterType((*AccountList)(nil), "AccountList")
- proto.RegisterType((*Validator)(nil), "Validator")
- proto.RegisterType((*ValidatorList)(nil), "ValidatorList")
- proto.RegisterType((*StorageItem)(nil), "StorageItem")
- proto.RegisterType((*StorageDump)(nil), "StorageDump")
- proto.RegisterType((*HeightParam)(nil), "HeightParam")
- proto.RegisterType((*BlocksParam)(nil), "BlocksParam")
- proto.RegisterType((*Header)(nil), "Header")
- proto.RegisterType((*Data)(nil), "Data")
- proto.RegisterType((*Block)(nil), "Block")
- proto.RegisterType((*BlockMeta)(nil), "BlockMeta")
- proto.RegisterType((*BlockList)(nil), "BlockList")
- proto.RegisterType((*ChainId)(nil), "ChainId")
- proto.RegisterType((*GenesisDoc)(nil), "GenesisDoc")
- proto.RegisterType((*GenesisDoc_GenesisAccount)(nil), "GenesisDoc.GenesisAccount")
- proto.RegisterType((*GenesisDoc_GenesisValidator)(nil), "GenesisDoc.GenesisValidator")
- proto.RegisterType((*UnconfirmedTxList)(nil), "UnconfirmedTxList")
- proto.RegisterType((*Status)(nil), "Status")
- proto.RegisterType((*RoundState)(nil), "RoundState")
- proto.RegisterType((*PeerRoundState)(nil), "PeerRoundState")
- proto.RegisterType((*ConsensusState)(nil), "ConsensusState")
- proto.RegisterType((*EventIdParam)(nil), "EventIdParam")
- proto.RegisterType((*SubIdParam)(nil), "SubIdParam")
- proto.RegisterType((*EventUnSub)(nil), "EventUnSub")
- proto.RegisterType((*EventDataLog)(nil), "EventDataLog")
- proto.RegisterType((*EventDataTx)(nil), "EventDataTx")
- proto.RegisterType((*Event)(nil), "Event")
- proto.RegisterType((*PollResponse)(nil), "PollResponse")
- proto.RegisterType((*NameRegEntryParam)(nil), "NameRegEntryParam")
- proto.RegisterType((*TransactNameRegParam)(nil), "TransactNameRegParam")
- proto.RegisterType((*NameRegEntry)(nil), "NameRegEntry")
- proto.RegisterType((*NameRegEntryList)(nil), "NameRegEntryList")
- proto.RegisterType((*PeerParam)(nil), "PeerParam")
- proto.RegisterType((*ClientVersion)(nil), "ClientVersion")
- proto.RegisterType((*NodeID)(nil), "NodeID")
- proto.RegisterType((*NodeInfo)(nil), "NodeInfo")
- proto.RegisterType((*NetworkInfo)(nil), "NetworkInfo")
- proto.RegisterType((*Peer)(nil), "Peer")
- proto.RegisterType((*PeerList)(nil), "PeerList")
- proto.RegisterType((*CallParam)(nil), "CallParam")
- proto.RegisterType((*CallCodeParam)(nil), "CallCodeParam")
- proto.RegisterType((*TransactParam)(nil), "TransactParam")
- proto.RegisterType((*SendParam)(nil), "SendParam")
- proto.RegisterType((*TxParam)(nil), "TxParam")
- proto.RegisterType((*SignTxParam)(nil), "SignTxParam")
- proto.RegisterType((*SignedTx)(nil), "SignedTx")
- proto.RegisterType((*CallResult)(nil), "CallResult")
-}
-
-// Reference imports to suppress errors if they are not otherwise used.
-var _ context.Context
-var _ grpc.ClientConn
-
-// This is a compile-time assertion to ensure that this generated file
-// is compatible with the grpc package it is being compiled against.
-const _ = grpc.SupportPackageIsVersion4
-
-// AccountsClient is the client API for Accounts service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type AccountsClient interface {
- GenPrivAccount(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PrivateAccount, error)
- GenPrivAccountFromKey(ctx context.Context, in *PrivateKeyParam, opts ...grpc.CallOption) (*PrivateAccount, error)
- GetAccount(ctx context.Context, in *AddressParam, opts ...grpc.CallOption) (*Account, error)
- GetAccounts(ctx context.Context, in *FilterListParam, opts ...grpc.CallOption) (*AccountList, error)
- GetValidators(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ValidatorList, error)
- GetStorage(ctx context.Context, in *AddressParam, opts ...grpc.CallOption) (*StorageDump, error)
- GetStorageAt(ctx context.Context, in *StorageAtParam, opts ...grpc.CallOption) (*StorageItem, error)
-}
-
-type accountsClient struct {
- cc *grpc.ClientConn
-}
-
-func NewAccountsClient(cc *grpc.ClientConn) AccountsClient {
- return &accountsClient{cc}
-}
-
-func (c *accountsClient) GenPrivAccount(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PrivateAccount, error) {
- out := new(PrivateAccount)
- err := c.cc.Invoke(ctx, "/Accounts/GenPrivAccount", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *accountsClient) GenPrivAccountFromKey(ctx context.Context, in *PrivateKeyParam, opts ...grpc.CallOption) (*PrivateAccount, error) {
- out := new(PrivateAccount)
- err := c.cc.Invoke(ctx, "/Accounts/GenPrivAccountFromKey", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *accountsClient) GetAccount(ctx context.Context, in *AddressParam, opts ...grpc.CallOption) (*Account, error) {
- out := new(Account)
- err := c.cc.Invoke(ctx, "/Accounts/GetAccount", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *accountsClient) GetAccounts(ctx context.Context, in *FilterListParam, opts ...grpc.CallOption) (*AccountList, error) {
- out := new(AccountList)
- err := c.cc.Invoke(ctx, "/Accounts/GetAccounts", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *accountsClient) GetValidators(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ValidatorList, error) {
- out := new(ValidatorList)
- err := c.cc.Invoke(ctx, "/Accounts/GetValidators", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *accountsClient) GetStorage(ctx context.Context, in *AddressParam, opts ...grpc.CallOption) (*StorageDump, error) {
- out := new(StorageDump)
- err := c.cc.Invoke(ctx, "/Accounts/GetStorage", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *accountsClient) GetStorageAt(ctx context.Context, in *StorageAtParam, opts ...grpc.CallOption) (*StorageItem, error) {
- out := new(StorageItem)
- err := c.cc.Invoke(ctx, "/Accounts/GetStorageAt", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// AccountsServer is the server API for Accounts service.
-type AccountsServer interface {
- GenPrivAccount(context.Context, *Empty) (*PrivateAccount, error)
- GenPrivAccountFromKey(context.Context, *PrivateKeyParam) (*PrivateAccount, error)
- GetAccount(context.Context, *AddressParam) (*Account, error)
- GetAccounts(context.Context, *FilterListParam) (*AccountList, error)
- GetValidators(context.Context, *Empty) (*ValidatorList, error)
- GetStorage(context.Context, *AddressParam) (*StorageDump, error)
- GetStorageAt(context.Context, *StorageAtParam) (*StorageItem, error)
-}
-
-func RegisterAccountsServer(s *grpc.Server, srv AccountsServer) {
- s.RegisterService(&_Accounts_serviceDesc, srv)
-}
-
-func _Accounts_GenPrivAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GenPrivAccount(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GenPrivAccount",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GenPrivAccount(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Accounts_GenPrivAccountFromKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(PrivateKeyParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GenPrivAccountFromKey(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GenPrivAccountFromKey",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GenPrivAccountFromKey(ctx, req.(*PrivateKeyParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Accounts_GetAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(AddressParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GetAccount(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GetAccount",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GetAccount(ctx, req.(*AddressParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Accounts_GetAccounts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(FilterListParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GetAccounts(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GetAccounts",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GetAccounts(ctx, req.(*FilterListParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Accounts_GetValidators_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GetValidators(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GetValidators",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GetValidators(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Accounts_GetStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(AddressParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GetStorage(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GetStorage",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GetStorage(ctx, req.(*AddressParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Accounts_GetStorageAt_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(StorageAtParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(AccountsServer).GetStorageAt(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Accounts/GetStorageAt",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(AccountsServer).GetStorageAt(ctx, req.(*StorageAtParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _Accounts_serviceDesc = grpc.ServiceDesc{
- ServiceName: "Accounts",
- HandlerType: (*AccountsServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "GenPrivAccount",
- Handler: _Accounts_GenPrivAccount_Handler,
- },
- {
- MethodName: "GenPrivAccountFromKey",
- Handler: _Accounts_GenPrivAccountFromKey_Handler,
- },
- {
- MethodName: "GetAccount",
- Handler: _Accounts_GetAccount_Handler,
- },
- {
- MethodName: "GetAccounts",
- Handler: _Accounts_GetAccounts_Handler,
- },
- {
- MethodName: "GetValidators",
- Handler: _Accounts_GetValidators_Handler,
- },
- {
- MethodName: "GetStorage",
- Handler: _Accounts_GetStorage_Handler,
- },
- {
- MethodName: "GetStorageAt",
- Handler: _Accounts_GetStorageAt_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "burrow.proto",
-}
-
-// BlockchainClient is the client API for Blockchain service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type BlockchainClient interface {
- GetBlock(ctx context.Context, in *HeightParam, opts ...grpc.CallOption) (*Block, error)
- GetBlocks(ctx context.Context, in *BlocksParam, opts ...grpc.CallOption) (*BlockList, error)
- GetBlockchainInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Status, error)
- GetChainId(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ChainId, error)
- GetGenesis(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GenesisDoc, error)
- GetLatestBlock(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Block, error)
- GetUnconfirmedTxs(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*UnconfirmedTxList, error)
- GetConsensusState(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ConsensusState, error)
-}
-
-type blockchainClient struct {
- cc *grpc.ClientConn
-}
-
-func NewBlockchainClient(cc *grpc.ClientConn) BlockchainClient {
- return &blockchainClient{cc}
-}
-
-func (c *blockchainClient) GetBlock(ctx context.Context, in *HeightParam, opts ...grpc.CallOption) (*Block, error) {
- out := new(Block)
- err := c.cc.Invoke(ctx, "/Blockchain/GetBlock", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetBlocks(ctx context.Context, in *BlocksParam, opts ...grpc.CallOption) (*BlockList, error) {
- out := new(BlockList)
- err := c.cc.Invoke(ctx, "/Blockchain/GetBlocks", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetBlockchainInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Status, error) {
- out := new(Status)
- err := c.cc.Invoke(ctx, "/Blockchain/GetBlockchainInfo", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetChainId(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ChainId, error) {
- out := new(ChainId)
- err := c.cc.Invoke(ctx, "/Blockchain/GetChainId", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetGenesis(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*GenesisDoc, error) {
- out := new(GenesisDoc)
- err := c.cc.Invoke(ctx, "/Blockchain/GetGenesis", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetLatestBlock(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Block, error) {
- out := new(Block)
- err := c.cc.Invoke(ctx, "/Blockchain/GetLatestBlock", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetUnconfirmedTxs(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*UnconfirmedTxList, error) {
- out := new(UnconfirmedTxList)
- err := c.cc.Invoke(ctx, "/Blockchain/GetUnconfirmedTxs", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *blockchainClient) GetConsensusState(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ConsensusState, error) {
- out := new(ConsensusState)
- err := c.cc.Invoke(ctx, "/Blockchain/GetConsensusState", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// BlockchainServer is the server API for Blockchain service.
-type BlockchainServer interface {
- GetBlock(context.Context, *HeightParam) (*Block, error)
- GetBlocks(context.Context, *BlocksParam) (*BlockList, error)
- GetBlockchainInfo(context.Context, *Empty) (*Status, error)
- GetChainId(context.Context, *Empty) (*ChainId, error)
- GetGenesis(context.Context, *Empty) (*GenesisDoc, error)
- GetLatestBlock(context.Context, *Empty) (*Block, error)
- GetUnconfirmedTxs(context.Context, *Empty) (*UnconfirmedTxList, error)
- GetConsensusState(context.Context, *Empty) (*ConsensusState, error)
-}
-
-func RegisterBlockchainServer(s *grpc.Server, srv BlockchainServer) {
- s.RegisterService(&_Blockchain_serviceDesc, srv)
-}
-
-func _Blockchain_GetBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(HeightParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetBlock(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetBlock",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetBlock(ctx, req.(*HeightParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetBlocks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(BlocksParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetBlocks(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetBlocks",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetBlocks(ctx, req.(*BlocksParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetBlockchainInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetBlockchainInfo(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetBlockchainInfo",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetBlockchainInfo(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetChainId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetChainId(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetChainId",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetChainId(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetGenesis_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetGenesis(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetGenesis",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetGenesis(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetLatestBlock_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetLatestBlock(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetLatestBlock",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetLatestBlock(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetUnconfirmedTxs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetUnconfirmedTxs(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetUnconfirmedTxs",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetUnconfirmedTxs(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Blockchain_GetConsensusState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(BlockchainServer).GetConsensusState(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Blockchain/GetConsensusState",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(BlockchainServer).GetConsensusState(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _Blockchain_serviceDesc = grpc.ServiceDesc{
- ServiceName: "Blockchain",
- HandlerType: (*BlockchainServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "GetBlock",
- Handler: _Blockchain_GetBlock_Handler,
- },
- {
- MethodName: "GetBlocks",
- Handler: _Blockchain_GetBlocks_Handler,
- },
- {
- MethodName: "GetBlockchainInfo",
- Handler: _Blockchain_GetBlockchainInfo_Handler,
- },
- {
- MethodName: "GetChainId",
- Handler: _Blockchain_GetChainId_Handler,
- },
- {
- MethodName: "GetGenesis",
- Handler: _Blockchain_GetGenesis_Handler,
- },
- {
- MethodName: "GetLatestBlock",
- Handler: _Blockchain_GetLatestBlock_Handler,
- },
- {
- MethodName: "GetUnconfirmedTxs",
- Handler: _Blockchain_GetUnconfirmedTxs_Handler,
- },
- {
- MethodName: "GetConsensusState",
- Handler: _Blockchain_GetConsensusState_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "burrow.proto",
-}
-
-// EventsClient is the client API for Events service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type EventsClient interface {
- EventPoll(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*PollResponse, error)
- EventSubscribe(ctx context.Context, in *EventIdParam, opts ...grpc.CallOption) (*SubIdParam, error)
- EventUnsubscribe(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*EventUnSub, error)
-}
-
-type eventsClient struct {
- cc *grpc.ClientConn
-}
-
-func NewEventsClient(cc *grpc.ClientConn) EventsClient {
- return &eventsClient{cc}
-}
-
-func (c *eventsClient) EventPoll(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*PollResponse, error) {
- out := new(PollResponse)
- err := c.cc.Invoke(ctx, "/Events/EventPoll", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *eventsClient) EventSubscribe(ctx context.Context, in *EventIdParam, opts ...grpc.CallOption) (*SubIdParam, error) {
- out := new(SubIdParam)
- err := c.cc.Invoke(ctx, "/Events/EventSubscribe", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *eventsClient) EventUnsubscribe(ctx context.Context, in *SubIdParam, opts ...grpc.CallOption) (*EventUnSub, error) {
- out := new(EventUnSub)
- err := c.cc.Invoke(ctx, "/Events/EventUnsubscribe", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// EventsServer is the server API for Events service.
-type EventsServer interface {
- EventPoll(context.Context, *SubIdParam) (*PollResponse, error)
- EventSubscribe(context.Context, *EventIdParam) (*SubIdParam, error)
- EventUnsubscribe(context.Context, *SubIdParam) (*EventUnSub, error)
-}
-
-func RegisterEventsServer(s *grpc.Server, srv EventsServer) {
- s.RegisterService(&_Events_serviceDesc, srv)
-}
-
-func _Events_EventPoll_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(SubIdParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(EventsServer).EventPoll(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Events/EventPoll",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(EventsServer).EventPoll(ctx, req.(*SubIdParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Events_EventSubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(EventIdParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(EventsServer).EventSubscribe(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Events/EventSubscribe",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(EventsServer).EventSubscribe(ctx, req.(*EventIdParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Events_EventUnsubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(SubIdParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(EventsServer).EventUnsubscribe(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Events/EventUnsubscribe",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(EventsServer).EventUnsubscribe(ctx, req.(*SubIdParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _Events_serviceDesc = grpc.ServiceDesc{
- ServiceName: "Events",
- HandlerType: (*EventsServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "EventPoll",
- Handler: _Events_EventPoll_Handler,
- },
- {
- MethodName: "EventSubscribe",
- Handler: _Events_EventSubscribe_Handler,
- },
- {
- MethodName: "EventUnsubscribe",
- Handler: _Events_EventUnsubscribe_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "burrow.proto",
-}
-
-// NameRegClient is the client API for NameReg service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type NameRegClient interface {
- GetEntry(ctx context.Context, in *NameRegEntryParam, opts ...grpc.CallOption) (*NameRegEntry, error)
- GetEntries(ctx context.Context, in *FilterListParam, opts ...grpc.CallOption) (*NameRegEntryList, error)
- TransactNameReg(ctx context.Context, in *TransactNameRegParam, opts ...grpc.CallOption) (*TxReceipt, error)
- TransactNameRegAndHold(ctx context.Context, in *TransactNameRegParam, opts ...grpc.CallOption) (*NameRegEntry, error)
-}
-
-type nameRegClient struct {
- cc *grpc.ClientConn
-}
-
-func NewNameRegClient(cc *grpc.ClientConn) NameRegClient {
- return &nameRegClient{cc}
-}
-
-func (c *nameRegClient) GetEntry(ctx context.Context, in *NameRegEntryParam, opts ...grpc.CallOption) (*NameRegEntry, error) {
- out := new(NameRegEntry)
- err := c.cc.Invoke(ctx, "/NameReg/GetEntry", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *nameRegClient) GetEntries(ctx context.Context, in *FilterListParam, opts ...grpc.CallOption) (*NameRegEntryList, error) {
- out := new(NameRegEntryList)
- err := c.cc.Invoke(ctx, "/NameReg/GetEntries", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *nameRegClient) TransactNameReg(ctx context.Context, in *TransactNameRegParam, opts ...grpc.CallOption) (*TxReceipt, error) {
- out := new(TxReceipt)
- err := c.cc.Invoke(ctx, "/NameReg/TransactNameReg", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *nameRegClient) TransactNameRegAndHold(ctx context.Context, in *TransactNameRegParam, opts ...grpc.CallOption) (*NameRegEntry, error) {
- out := new(NameRegEntry)
- err := c.cc.Invoke(ctx, "/NameReg/TransactNameRegAndHold", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// NameRegServer is the server API for NameReg service.
-type NameRegServer interface {
- GetEntry(context.Context, *NameRegEntryParam) (*NameRegEntry, error)
- GetEntries(context.Context, *FilterListParam) (*NameRegEntryList, error)
- TransactNameReg(context.Context, *TransactNameRegParam) (*TxReceipt, error)
- TransactNameRegAndHold(context.Context, *TransactNameRegParam) (*NameRegEntry, error)
-}
-
-func RegisterNameRegServer(s *grpc.Server, srv NameRegServer) {
- s.RegisterService(&_NameReg_serviceDesc, srv)
-}
-
-func _NameReg_GetEntry_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(NameRegEntryParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NameRegServer).GetEntry(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/NameReg/GetEntry",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NameRegServer).GetEntry(ctx, req.(*NameRegEntryParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _NameReg_GetEntries_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(FilterListParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NameRegServer).GetEntries(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/NameReg/GetEntries",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NameRegServer).GetEntries(ctx, req.(*FilterListParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _NameReg_TransactNameReg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(TransactNameRegParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NameRegServer).TransactNameReg(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/NameReg/TransactNameReg",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NameRegServer).TransactNameReg(ctx, req.(*TransactNameRegParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _NameReg_TransactNameRegAndHold_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(TransactNameRegParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NameRegServer).TransactNameRegAndHold(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/NameReg/TransactNameRegAndHold",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NameRegServer).TransactNameRegAndHold(ctx, req.(*TransactNameRegParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _NameReg_serviceDesc = grpc.ServiceDesc{
- ServiceName: "NameReg",
- HandlerType: (*NameRegServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "GetEntry",
- Handler: _NameReg_GetEntry_Handler,
- },
- {
- MethodName: "GetEntries",
- Handler: _NameReg_GetEntries_Handler,
- },
- {
- MethodName: "TransactNameReg",
- Handler: _NameReg_TransactNameReg_Handler,
- },
- {
- MethodName: "TransactNameRegAndHold",
- Handler: _NameReg_TransactNameRegAndHold_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "burrow.proto",
-}
-
-// NetworkClient is the client API for Network service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type NetworkClient interface {
- GetClientVersion(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ClientVersion, error)
- GetNetworkInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NetworkInfo, error)
- GetNodeInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NodeInfo, error)
- GetPeer(ctx context.Context, in *PeerParam, opts ...grpc.CallOption) (*Peer, error)
- GetPeers(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PeerList, error)
-}
-
-type networkClient struct {
- cc *grpc.ClientConn
-}
-
-func NewNetworkClient(cc *grpc.ClientConn) NetworkClient {
- return &networkClient{cc}
-}
-
-func (c *networkClient) GetClientVersion(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*ClientVersion, error) {
- out := new(ClientVersion)
- err := c.cc.Invoke(ctx, "/Network/GetClientVersion", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *networkClient) GetNetworkInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NetworkInfo, error) {
- out := new(NetworkInfo)
- err := c.cc.Invoke(ctx, "/Network/GetNetworkInfo", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *networkClient) GetNodeInfo(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*NodeInfo, error) {
- out := new(NodeInfo)
- err := c.cc.Invoke(ctx, "/Network/GetNodeInfo", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *networkClient) GetPeer(ctx context.Context, in *PeerParam, opts ...grpc.CallOption) (*Peer, error) {
- out := new(Peer)
- err := c.cc.Invoke(ctx, "/Network/GetPeer", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *networkClient) GetPeers(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*PeerList, error) {
- out := new(PeerList)
- err := c.cc.Invoke(ctx, "/Network/GetPeers", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// NetworkServer is the server API for Network service.
-type NetworkServer interface {
- GetClientVersion(context.Context, *Empty) (*ClientVersion, error)
- GetNetworkInfo(context.Context, *Empty) (*NetworkInfo, error)
- GetNodeInfo(context.Context, *Empty) (*NodeInfo, error)
- GetPeer(context.Context, *PeerParam) (*Peer, error)
- GetPeers(context.Context, *Empty) (*PeerList, error)
-}
-
-func RegisterNetworkServer(s *grpc.Server, srv NetworkServer) {
- s.RegisterService(&_Network_serviceDesc, srv)
-}
-
-func _Network_GetClientVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NetworkServer).GetClientVersion(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Network/GetClientVersion",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NetworkServer).GetClientVersion(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Network_GetNetworkInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NetworkServer).GetNetworkInfo(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Network/GetNetworkInfo",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NetworkServer).GetNetworkInfo(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Network_GetNodeInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NetworkServer).GetNodeInfo(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Network/GetNodeInfo",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NetworkServer).GetNodeInfo(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Network_GetPeer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(PeerParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NetworkServer).GetPeer(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Network/GetPeer",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NetworkServer).GetPeer(ctx, req.(*PeerParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Network_GetPeers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(Empty)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(NetworkServer).GetPeers(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Network/GetPeers",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(NetworkServer).GetPeers(ctx, req.(*Empty))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _Network_serviceDesc = grpc.ServiceDesc{
- ServiceName: "Network",
- HandlerType: (*NetworkServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "GetClientVersion",
- Handler: _Network_GetClientVersion_Handler,
- },
- {
- MethodName: "GetNetworkInfo",
- Handler: _Network_GetNetworkInfo_Handler,
- },
- {
- MethodName: "GetNodeInfo",
- Handler: _Network_GetNodeInfo_Handler,
- },
- {
- MethodName: "GetPeer",
- Handler: _Network_GetPeer_Handler,
- },
- {
- MethodName: "GetPeers",
- Handler: _Network_GetPeers_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "burrow.proto",
-}
-
-// TransactionClient is the client API for Transaction service.
-//
-// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
-type TransactionClient interface {
- BroadcastTx(ctx context.Context, in *TxParam, opts ...grpc.CallOption) (*TxReceipt, error)
- Call(ctx context.Context, in *CallParam, opts ...grpc.CallOption) (*CallResult, error)
- CallCode(ctx context.Context, in *CallCodeParam, opts ...grpc.CallOption) (*CallResult, error)
- Transact(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*TxReceipt, error)
- TransactAndHold(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*EventDataCall, error)
- Send(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error)
- SendAndHold(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error)
- SignTx(ctx context.Context, in *SignTxParam, opts ...grpc.CallOption) (*SignedTx, error)
-}
-
-type transactionClient struct {
- cc *grpc.ClientConn
-}
-
-func NewTransactionClient(cc *grpc.ClientConn) TransactionClient {
- return &transactionClient{cc}
-}
-
-func (c *transactionClient) BroadcastTx(ctx context.Context, in *TxParam, opts ...grpc.CallOption) (*TxReceipt, error) {
- out := new(TxReceipt)
- err := c.cc.Invoke(ctx, "/Transaction/BroadcastTx", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) Call(ctx context.Context, in *CallParam, opts ...grpc.CallOption) (*CallResult, error) {
- out := new(CallResult)
- err := c.cc.Invoke(ctx, "/Transaction/Call", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) CallCode(ctx context.Context, in *CallCodeParam, opts ...grpc.CallOption) (*CallResult, error) {
- out := new(CallResult)
- err := c.cc.Invoke(ctx, "/Transaction/CallCode", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) Transact(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*TxReceipt, error) {
- out := new(TxReceipt)
- err := c.cc.Invoke(ctx, "/Transaction/Transact", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) TransactAndHold(ctx context.Context, in *TransactParam, opts ...grpc.CallOption) (*EventDataCall, error) {
- out := new(EventDataCall)
- err := c.cc.Invoke(ctx, "/Transaction/TransactAndHold", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) Send(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error) {
- out := new(TxReceipt)
- err := c.cc.Invoke(ctx, "/Transaction/Send", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) SendAndHold(ctx context.Context, in *SendParam, opts ...grpc.CallOption) (*TxReceipt, error) {
- out := new(TxReceipt)
- err := c.cc.Invoke(ctx, "/Transaction/SendAndHold", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-func (c *transactionClient) SignTx(ctx context.Context, in *SignTxParam, opts ...grpc.CallOption) (*SignedTx, error) {
- out := new(SignedTx)
- err := c.cc.Invoke(ctx, "/Transaction/SignTx", in, out, opts...)
- if err != nil {
- return nil, err
- }
- return out, nil
-}
-
-// TransactionServer is the server API for Transaction service.
-type TransactionServer interface {
- BroadcastTx(context.Context, *TxParam) (*TxReceipt, error)
- Call(context.Context, *CallParam) (*CallResult, error)
- CallCode(context.Context, *CallCodeParam) (*CallResult, error)
- Transact(context.Context, *TransactParam) (*TxReceipt, error)
- TransactAndHold(context.Context, *TransactParam) (*EventDataCall, error)
- Send(context.Context, *SendParam) (*TxReceipt, error)
- SendAndHold(context.Context, *SendParam) (*TxReceipt, error)
- SignTx(context.Context, *SignTxParam) (*SignedTx, error)
-}
-
-func RegisterTransactionServer(s *grpc.Server, srv TransactionServer) {
- s.RegisterService(&_Transaction_serviceDesc, srv)
-}
-
-func _Transaction_BroadcastTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(TxParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).BroadcastTx(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/BroadcastTx",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).BroadcastTx(ctx, req.(*TxParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_Call_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(CallParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).Call(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/Call",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).Call(ctx, req.(*CallParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_CallCode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(CallCodeParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).CallCode(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/CallCode",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).CallCode(ctx, req.(*CallCodeParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_Transact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(TransactParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).Transact(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/Transact",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).Transact(ctx, req.(*TransactParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_TransactAndHold_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(TransactParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).TransactAndHold(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/TransactAndHold",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).TransactAndHold(ctx, req.(*TransactParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_Send_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(SendParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).Send(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/Send",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).Send(ctx, req.(*SendParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_SendAndHold_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(SendParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).SendAndHold(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/SendAndHold",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).SendAndHold(ctx, req.(*SendParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-func _Transaction_SignTx_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
- in := new(SignTxParam)
- if err := dec(in); err != nil {
- return nil, err
- }
- if interceptor == nil {
- return srv.(TransactionServer).SignTx(ctx, in)
- }
- info := &grpc.UnaryServerInfo{
- Server: srv,
- FullMethod: "/Transaction/SignTx",
- }
- handler := func(ctx context.Context, req interface{}) (interface{}, error) {
- return srv.(TransactionServer).SignTx(ctx, req.(*SignTxParam))
- }
- return interceptor(ctx, in, info, handler)
-}
-
-var _Transaction_serviceDesc = grpc.ServiceDesc{
- ServiceName: "Transaction",
- HandlerType: (*TransactionServer)(nil),
- Methods: []grpc.MethodDesc{
- {
- MethodName: "BroadcastTx",
- Handler: _Transaction_BroadcastTx_Handler,
- },
- {
- MethodName: "Call",
- Handler: _Transaction_Call_Handler,
- },
- {
- MethodName: "CallCode",
- Handler: _Transaction_CallCode_Handler,
- },
- {
- MethodName: "Transact",
- Handler: _Transaction_Transact_Handler,
- },
- {
- MethodName: "TransactAndHold",
- Handler: _Transaction_TransactAndHold_Handler,
- },
- {
- MethodName: "Send",
- Handler: _Transaction_Send_Handler,
- },
- {
- MethodName: "SendAndHold",
- Handler: _Transaction_SendAndHold_Handler,
- },
- {
- MethodName: "SignTx",
- Handler: _Transaction_SignTx_Handler,
- },
- },
- Streams: []grpc.StreamDesc{},
- Metadata: "burrow.proto",
-}
-
-func init() { proto.RegisterFile("burrow.proto", fileDescriptor_burrow_5b05719ae28d1091) }
-
-var fileDescriptor_burrow_5b05719ae28d1091 = []byte{
- // 2596 bytes of a gzipped FileDescriptorProto
- 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x19, 0x5d, 0x6f, 0x1b, 0xc7,
- 0x11, 0xfc, 0x26, 0x87, 0x14, 0x25, 0x6f, 0x1c, 0x97, 0x61, 0x5d, 0xc5, 0xd9, 0x58, 0xb1, 0x93,
- 0x3a, 0xdb, 0x58, 0x4d, 0x82, 0x36, 0x48, 0x53, 0xc8, 0x92, 0x23, 0x0b, 0x71, 0x1c, 0x61, 0x49,
- 0xa7, 0xcd, 0x43, 0x1f, 0x4e, 0xe4, 0x4a, 0x3a, 0x98, 0xbc, 0x63, 0xef, 0x96, 0x36, 0xf3, 0x1f,
- 0xda, 0x3e, 0xb4, 0x8f, 0x05, 0xfa, 0xda, 0x87, 0xbe, 0xf7, 0x29, 0x40, 0x51, 0xf4, 0xa1, 0x40,
- 0xff, 0x45, 0x81, 0xfe, 0x90, 0x62, 0x66, 0x77, 0xef, 0xf6, 0x8e, 0x52, 0xec, 0xba, 0x40, 0x9e,
- 0x78, 0x33, 0x3b, 0x3b, 0x3b, 0x33, 0x3b, 0x9f, 0x4b, 0xe8, 0x9d, 0x2c, 0x93, 0x24, 0x7e, 0x26,
- 0x16, 0x49, 0xac, 0x63, 0xde, 0x82, 0xc6, 0xfd, 0xf9, 0x42, 0x7f, 0xcd, 0x1f, 0x40, 0xef, 0x28,
- 0x5a, 0x2c, 0xf5, 0xde, 0x64, 0x12, 0x2f, 0x23, 0xcd, 0xb6, 0x01, 0x16, 0x49, 0xf8, 0x34, 0xd0,
- 0xea, 0x33, 0xf5, 0xf5, 0xa0, 0x72, 0xa3, 0x72, 0xbb, 0x27, 0x3d, 0x0c, 0x1b, 0x40, 0x2b, 0x98,
- 0x4e, 0x13, 0x95, 0xa6, 0x83, 0x2a, 0x2d, 0x3a, 0x90, 0x3f, 0x00, 0xf8, 0x34, 0x9c, 0x69, 0x95,
- 0x1c, 0x04, 0x3a, 0x60, 0x57, 0xa1, 0x71, 0x1a, 0xaa, 0xd9, 0x94, 0x58, 0x74, 0xa4, 0x01, 0x58,
- 0x1f, 0xaa, 0xf1, 0x82, 0x36, 0x76, 0x64, 0x35, 0x5e, 0x20, 0xd5, 0xd3, 0x60, 0xb6, 0x54, 0x83,
- 0x9a, 0xa1, 0x22, 0x80, 0xff, 0x04, 0x36, 0x0d, 0xa7, 0x87, 0x61, 0xaa, 0x8f, 0x83, 0x24, 0x98,
- 0xb3, 0x1d, 0x68, 0x9d, 0x12, 0x2a, 0x1d, 0x54, 0x6e, 0xd4, 0x6e, 0x77, 0x77, 0xbb, 0x22, 0x3f,
- 0x4c, 0xba, 0x35, 0xfe, 0x0c, 0x3a, 0xe3, 0x95, 0x54, 0x13, 0x15, 0x2e, 0x34, 0xbb, 0x06, 0xcd,
- 0xf1, 0xea, 0x41, 0x90, 0x9e, 0x5b, 0x35, 0x2c, 0xc4, 0x6e, 0xc3, 0xe6, 0x7e, 0xa2, 0x02, 0xad,
- 0xd2, 0xfd, 0x38, 0xd2, 0x49, 0x30, 0xd1, 0x24, 0x51, 0x5b, 0x96, 0xd1, 0x44, 0x69, 0xbf, 0xf7,
- 0xac, 0xd2, 0x35, 0x62, 0x55, 0x46, 0xf3, 0xf7, 0xa0, 0x7f, 0x6c, 0x8c, 0xe4, 0x19, 0xf2, 0x78,
- 0xcd, 0x90, 0x39, 0x86, 0x7f, 0x53, 0x81, 0x8d, 0xfb, 0x4f, 0x55, 0xa4, 0x51, 0x83, 0xfd, 0x60,
- 0x36, 0x63, 0x3b, 0xd0, 0xc6, 0x5f, 0x84, 0x89, 0xbe, 0xbb, 0xdb, 0x11, 0x0e, 0x21, 0xb3, 0x25,
- 0x54, 0xeb, 0x8b, 0x24, 0x3c, 0x0b, 0x23, 0x7b, 0x01, 0x16, 0xf2, 0xd4, 0xad, 0x15, 0xd4, 0xdd,
- 0x06, 0x18, 0xe9, 0x60, 0xf2, 0xe4, 0x40, 0x2d, 0xf4, 0xf9, 0xa0, 0x7e, 0xa3, 0x72, 0xbb, 0x26,
- 0x3d, 0x0c, 0xee, 0x93, 0x4a, 0x2f, 0x93, 0x68, 0xd0, 0x30, 0xfb, 0x0c, 0xc4, 0xae, 0x43, 0xe7,
- 0xfe, 0x6a, 0xa2, 0x16, 0x3a, 0x8c, 0xa3, 0x41, 0x93, 0xee, 0x27, 0x47, 0xf0, 0xa7, 0x50, 0x90,
- 0x08, 0xbf, 0x55, 0xe2, 0x0c, 0x6d, 0xa0, 0x0c, 0xaf, 0x9c, 0xa4, 0x06, 0x62, 0x0c, 0xea, 0xa4,
- 0xa4, 0x91, 0xb3, 0xee, 0xfc, 0xe5, 0x4b, 0xf2, 0x04, 0x14, 0xb0, 0x2e, 0x0d, 0xc0, 0xb6, 0xa0,
- 0x76, 0x18, 0xa4, 0x24, 0x58, 0x5d, 0xe2, 0x27, 0xbf, 0x0d, 0x3d, 0x6b, 0x73, 0xe3, 0x18, 0x9e,
- 0x3f, 0x56, 0x8a, 0xfe, 0x78, 0x17, 0x36, 0x73, 0x73, 0x1b, 0xe2, 0xe7, 0x38, 0x37, 0xff, 0x18,
- 0xfa, 0x23, 0x1d, 0x27, 0xc1, 0x99, 0xda, 0xd3, 0xcf, 0x61, 0x8f, 0xa2, 0x3d, 0x51, 0x5f, 0x5b,
- 0xcd, 0xf0, 0x93, 0xff, 0x1c, 0x36, 0xef, 0x05, 0xa9, 0x3a, 0x56, 0xc9, 0x3c, 0x4c, 0xd3, 0x30,
- 0x8e, 0x52, 0xd4, 0x0a, 0x41, 0xb3, 0xb9, 0x2e, 0x0d, 0x80, 0x76, 0x19, 0x29, 0x7d, 0x2f, 0x34,
- 0x7e, 0x57, 0x97, 0x16, 0xe2, 0xc7, 0xc0, 0xac, 0xf7, 0xf8, 0x3c, 0x6e, 0x42, 0x1d, 0xd9, 0x5a,
- 0x97, 0xd8, 0x12, 0xa5, 0x33, 0x24, 0xad, 0xe2, 0x49, 0x32, 0x9e, 0x29, 0x8c, 0xca, 0x1a, 0x46,
- 0x12, 0x01, 0xfc, 0x3f, 0x15, 0x68, 0x39, 0x87, 0x1c, 0x40, 0x6b, 0xaf, 0xa8, 0x8a, 0x05, 0xf1,
- 0xa6, 0x8f, 0x97, 0x27, 0xb3, 0x70, 0xf2, 0x59, 0xa6, 0x50, 0x8e, 0x60, 0x43, 0x68, 0x8f, 0xd4,
- 0xaf, 0x97, 0x2a, 0x9a, 0x98, 0x30, 0xad, 0xcb, 0x0c, 0x46, 0x9e, 0xf7, 0x82, 0x59, 0x80, 0x4b,
- 0xe6, 0xde, 0x1c, 0x88, 0x77, 0xbc, 0x1f, 0x4f, 0x95, 0xf5, 0x29, 0xfa, 0x66, 0x37, 0xa0, 0x6b,
- 0xcd, 0x2b, 0xe3, 0x58, 0x93, 0x4f, 0xf5, 0xa4, 0x8f, 0x62, 0x1f, 0x40, 0xd7, 0x53, 0x6d, 0xd0,
- 0x22, 0x95, 0x5f, 0x11, 0xeb, 0x56, 0x91, 0x3e, 0x1d, 0x7f, 0x0c, 0x5d, 0x4b, 0x82, 0x19, 0x03,
- 0xcf, 0xb9, 0x37, 0x8b, 0x27, 0x4f, 0x1e, 0xa8, 0xf0, 0xec, 0x5c, 0x5b, 0xdb, 0xfb, 0x28, 0x76,
- 0x13, 0xda, 0x76, 0x83, 0x31, 0x58, 0x77, 0xb7, 0xed, 0x0e, 0x91, 0xd9, 0x0a, 0xff, 0x0a, 0x3a,
- 0x5f, 0x06, 0xb3, 0x70, 0x1a, 0xe8, 0x38, 0x79, 0x69, 0xf3, 0xa1, 0x0b, 0xc4, 0xcf, 0x54, 0x62,
- 0x6d, 0x67, 0x00, 0xfe, 0xe7, 0x0a, 0x6c, 0x64, 0xbc, 0x5f, 0x50, 0xe8, 0x0f, 0x61, 0xeb, 0x5e,
- 0x1c, 0x4d, 0xd5, 0x34, 0xdb, 0xe8, 0x84, 0x07, 0x91, 0xa1, 0xe4, 0x1a, 0x0d, 0xfb, 0x18, 0x5e,
- 0x79, 0x1c, 0x9d, 0xc4, 0xd1, 0x34, 0x8c, 0xce, 0xbc, 0xad, 0xb5, 0xb5, 0xad, 0x17, 0x91, 0xf1,
- 0x0f, 0xb2, 0x4b, 0x3b, 0xd2, 0x6a, 0x8e, 0x6e, 0x9f, 0xc7, 0x4e, 0xcd, 0x2a, 0x68, 0x22, 0xd7,
- 0xa8, 0x6e, 0x00, 0x1e, 0x64, 0xdb, 0x0e, 0x96, 0xf3, 0x45, 0xf9, 0xea, 0x2b, 0xeb, 0x57, 0xff,
- 0x1e, 0xf4, 0xbc, 0x73, 0x9c, 0x66, 0x3d, 0xe1, 0x21, 0x65, 0x81, 0x82, 0xef, 0x40, 0xd7, 0x58,
- 0xc6, 0x84, 0xea, 0x35, 0x68, 0x9e, 0xfb, 0xb6, 0xb3, 0x10, 0x3f, 0xb2, 0x86, 0xb5, 0x09, 0xe3,
- 0x3a, 0x74, 0xe6, 0x61, 0x54, 0xb0, 0x72, 0x8e, 0xa0, 0xd5, 0x60, 0x65, 0x57, 0xab, 0x76, 0xd5,
- 0x21, 0xf8, 0xef, 0xaa, 0xd0, 0x7c, 0xa0, 0x82, 0xa9, 0x22, 0x77, 0xd8, 0x3f, 0x0f, 0xc2, 0xe8,
- 0xe8, 0xc0, 0x56, 0x38, 0x07, 0xa2, 0x1c, 0xde, 0xfe, 0x9a, 0xb4, 0x10, 0x46, 0xc4, 0x38, 0x9c,
- 0x9b, 0x18, 0xaa, 0x49, 0xfa, 0x46, 0xda, 0x47, 0xcb, 0xf9, 0x78, 0x95, 0xda, 0xbc, 0x6c, 0x21,
- 0x34, 0xd7, 0xc3, 0x20, 0xd5, 0x24, 0xf7, 0xd1, 0x81, 0x0d, 0x22, 0x1f, 0xc5, 0xde, 0x82, 0x3e,
- 0x82, 0xfb, 0xf1, 0x7c, 0x1e, 0x6a, 0xca, 0xfa, 0x26, 0x9c, 0x4a, 0x58, 0x8c, 0x5e, 0xcc, 0xaf,
- 0x44, 0xd1, 0x22, 0x8a, 0x0c, 0x46, 0x1e, 0xf9, 0x45, 0x13, 0x45, 0xdb, 0xf0, 0x28, 0x62, 0xc9,
- 0xf5, 0x17, 0x0b, 0x22, 0xe8, 0x58, 0xd7, 0x37, 0x20, 0xbf, 0x63, 0x32, 0x39, 0x7a, 0x05, 0x2a,
- 0x81, 0xa5, 0xb9, 0x27, 0xf1, 0x13, 0xb5, 0x3d, 0xc7, 0x0d, 0xc6, 0x29, 0xe8, 0x9b, 0xff, 0x0a,
- 0x1a, 0x24, 0x3e, 0xa5, 0x0d, 0xab, 0x9a, 0x8d, 0x25, 0xa7, 0xd6, 0xeb, 0xce, 0xc0, 0xb4, 0xb1,
- 0xbb, 0xdb, 0x12, 0x06, 0x94, 0xce, 0xee, 0xaf, 0x79, 0xb5, 0xa3, 0xbb, 0xdb, 0x10, 0x54, 0x1c,
- 0x09, 0xc5, 0x3f, 0x85, 0x0e, 0xb1, 0xf9, 0x5c, 0xe9, 0xe0, 0xff, 0x38, 0x82, 0xff, 0xc2, 0xf2,
- 0xa1, 0xb0, 0xdc, 0x06, 0x40, 0x8b, 0x16, 0xfc, 0xc5, 0xc3, 0xb0, 0x77, 0x00, 0xb2, 0x43, 0xf3,
- 0x70, 0xcc, 0x50, 0xd2, 0x5b, 0xe5, 0x13, 0xe7, 0x33, 0x53, 0xf4, 0x33, 0xfa, 0x7c, 0x14, 0xcc,
- 0x95, 0x75, 0xa0, 0x1c, 0x91, 0x3b, 0xd7, 0xd4, 0xf6, 0x4a, 0xd9, 0xbe, 0x1b, 0xd0, 0x3d, 0x54,
- 0x91, 0x4a, 0xc3, 0xd4, 0xab, 0xf4, 0x3e, 0x8a, 0xff, 0xb3, 0x0e, 0x60, 0xe1, 0x83, 0x78, 0xe2,
- 0x6d, 0x20, 0xe7, 0xb3, 0x69, 0xc5, 0x43, 0x15, 0x45, 0xa9, 0x96, 0x45, 0x61, 0x50, 0x1f, 0x05,
- 0x33, 0xed, 0x6a, 0x35, 0x7e, 0xb3, 0x3b, 0x70, 0xe5, 0x70, 0x16, 0x9f, 0x04, 0x33, 0x3f, 0x57,
- 0x9b, 0xfc, 0xbf, 0xbe, 0xc0, 0x3e, 0xf4, 0x72, 0x6d, 0x83, 0xec, 0x33, 0x14, 0xb9, 0x80, 0xee,
- 0x73, 0x2d, 0xfb, 0xb2, 0x8f, 0x01, 0xbc, 0x6c, 0xd5, 0xa4, 0x9d, 0xd7, 0x2f, 0xd8, 0x99, 0xe7,
- 0x2f, 0x8f, 0x7e, 0xf8, 0x97, 0x0a, 0xf4, 0x8b, 0xac, 0x5f, 0x3a, 0x83, 0x5f, 0x83, 0xe6, 0xde,
- 0x1c, 0x39, 0xd8, 0x14, 0x6e, 0x21, 0x34, 0x0d, 0xd9, 0xac, 0x4e, 0x36, 0xa3, 0xef, 0x72, 0x01,
- 0x6b, 0xbc, 0x58, 0x01, 0x1b, 0xfe, 0xbe, 0x02, 0x5b, 0x65, 0x75, 0xbe, 0x13, 0x79, 0x87, 0xd0,
- 0x36, 0x49, 0x7f, 0x1c, 0xd3, 0xe5, 0xf4, 0x64, 0x06, 0xf3, 0x9f, 0xc1, 0x95, 0xc7, 0xd1, 0x24,
- 0x8e, 0x4e, 0xc3, 0x64, 0xae, 0xa6, 0xe3, 0x15, 0xc5, 0x43, 0x9e, 0xb1, 0x6c, 0x96, 0xb5, 0x19,
- 0xcb, 0x66, 0x80, 0x6a, 0x96, 0x01, 0xf8, 0x1f, 0xaa, 0xd0, 0x1c, 0xe9, 0x40, 0x2f, 0x53, 0xec,
- 0x6c, 0x1f, 0xc5, 0x53, 0x75, 0x14, 0x9d, 0xc6, 0x59, 0x67, 0xeb, 0x10, 0x32, 0x5b, 0x2a, 0x3b,
- 0x77, 0x75, 0xcd, 0xb9, 0x8b, 0x8a, 0xd7, 0xca, 0x8a, 0xdf, 0x86, 0xcd, 0x87, 0xd8, 0xbf, 0x9b,
- 0x24, 0x49, 0x3c, 0xea, 0xa6, 0x5d, 0x2f, 0xa1, 0xd1, 0x83, 0x7d, 0x94, 0x09, 0x6e, 0xd3, 0x65,
- 0xae, 0x2f, 0x94, 0xf8, 0x52, 0x1c, 0x35, 0x29, 0x5d, 0x97, 0xd1, 0xa8, 0x01, 0x6a, 0xf3, 0xa5,
- 0x4a, 0xf0, 0x5e, 0x29, 0xe1, 0x76, 0xa4, 0x8f, 0xe2, 0xbf, 0xa9, 0x00, 0xc8, 0x78, 0x19, 0x4d,
- 0xd1, 0x34, 0xca, 0x2b, 0x16, 0x95, 0x42, 0xb1, 0xa0, 0x76, 0x6e, 0x19, 0x4d, 0x6d, 0x0d, 0x31,
- 0x00, 0x05, 0xa3, 0x56, 0x0b, 0x57, 0x42, 0xf0, 0x1b, 0x4d, 0x32, 0xd2, 0x41, 0xa2, 0x49, 0x2c,
- 0x13, 0x84, 0x39, 0x02, 0xd3, 0x97, 0x29, 0x06, 0xb4, 0x6c, 0x34, 0xf4, 0x30, 0x28, 0x4e, 0xff,
- 0x58, 0xa9, 0xe4, 0x3b, 0x14, 0x69, 0x08, 0xed, 0xe3, 0x24, 0x5e, 0xc4, 0x69, 0x30, 0x23, 0x81,
- 0xda, 0x32, 0x83, 0xf9, 0x0a, 0xfa, 0xfb, 0x71, 0x94, 0xaa, 0x28, 0x5d, 0xa6, 0x46, 0x9a, 0x1f,
- 0xfa, 0xe6, 0xb2, 0xce, 0xd3, 0x15, 0x39, 0x4a, 0xfa, 0xd6, 0xfc, 0x29, 0x6c, 0x16, 0x95, 0x71,
- 0x19, 0x79, 0x53, 0x14, 0xf1, 0xb2, 0x4c, 0x87, 0x73, 0x05, 0x4d, 0x63, 0x47, 0xd3, 0xac, 0xf1,
- 0x57, 0x06, 0x76, 0xf5, 0xdd, 0x82, 0x9c, 0x03, 0x8c, 0x96, 0x27, 0x8e, 0xee, 0x2a, 0x34, 0x52,
- 0x84, 0xdc, 0x9c, 0x4b, 0x00, 0xbf, 0x09, 0x40, 0xdc, 0x1e, 0x47, 0xa3, 0xe5, 0x09, 0x5a, 0x34,
- 0x51, 0xe9, 0x72, 0x66, 0x2c, 0xda, 0x96, 0x16, 0xe2, 0x33, 0x7b, 0x26, 0x56, 0xaf, 0x87, 0xf1,
- 0xd9, 0xb7, 0x04, 0xbc, 0x9b, 0x98, 0xaa, 0xde, 0xc4, 0x94, 0xdf, 0x93, 0x0d, 0x73, 0x7b, 0x4f,
- 0x38, 0x07, 0xc6, 0x8b, 0x70, 0x82, 0x29, 0x19, 0x47, 0x01, 0x0b, 0xf1, 0x11, 0x74, 0xb3, 0xd3,
- 0xc6, 0x2b, 0x1c, 0xc5, 0xc7, 0x2b, 0x7b, 0x4e, 0x75, 0xbc, 0xf2, 0xc6, 0xc0, 0xea, 0xe5, 0x63,
- 0x60, 0xad, 0x3c, 0x06, 0xfe, 0xb5, 0x02, 0x0d, 0xe2, 0x8a, 0x86, 0xa0, 0x0f, 0x67, 0x08, 0x83,
- 0x15, 0x85, 0x43, 0x6d, 0xc5, 0xed, 0x09, 0x0f, 0x27, 0x0b, 0x52, 0xbd, 0x5f, 0x1a, 0x8a, 0x6d,
- 0x9d, 0xef, 0x8b, 0x02, 0x56, 0x96, 0x26, 0xe7, 0xbb, 0x45, 0x43, 0x92, 0xcf, 0x75, 0x77, 0x37,
- 0x84, 0x8f, 0x94, 0x05, 0x12, 0x2e, 0xa0, 0x77, 0x1c, 0xcf, 0x66, 0x52, 0xa5, 0x0b, 0x74, 0x38,
- 0xb6, 0x0d, 0x4d, 0xba, 0x60, 0xf7, 0xbe, 0xd0, 0x34, 0x9b, 0xa5, 0xc5, 0xf2, 0x5b, 0x70, 0x05,
- 0x13, 0xa6, 0x54, 0x67, 0xf7, 0x23, 0x9d, 0xd8, 0x79, 0x92, 0x41, 0x3d, 0xca, 0x0b, 0x38, 0x7d,
- 0xf3, 0x3f, 0x56, 0xe0, 0xea, 0x38, 0x09, 0xa2, 0x34, 0x98, 0x68, 0xbb, 0xc3, 0x10, 0xdf, 0x85,
- 0x5e, 0xe8, 0xbd, 0xb4, 0x58, 0x5f, 0xde, 0x10, 0xfe, 0xf3, 0x8b, 0x2c, 0x90, 0x64, 0xfc, 0xab,
- 0x39, 0x7f, 0xc4, 0x4d, 0x5d, 0x03, 0xd4, 0x91, 0xf4, 0x8d, 0xc9, 0xf7, 0x54, 0xb9, 0x50, 0xc3,
- 0x4f, 0xbc, 0xcd, 0xc0, 0xd4, 0x00, 0x13, 0xf3, 0x16, 0xe2, 0xa7, 0xd0, 0xf3, 0xd5, 0xc8, 0x6a,
- 0x42, 0xc5, 0xab, 0x09, 0x57, 0xa1, 0xf1, 0xc5, 0xb3, 0xc8, 0xf6, 0x47, 0x3d, 0x69, 0x80, 0xc2,
- 0xd0, 0xde, 0xb1, 0x2e, 0x38, 0x80, 0xd6, 0xfd, 0xd5, 0x22, 0x4c, 0x94, 0x2b, 0xff, 0x0e, 0xe4,
- 0x5f, 0xc1, 0x96, 0x7f, 0xce, 0x0b, 0x4e, 0x38, 0x6f, 0x42, 0x03, 0x77, 0xb9, 0xa8, 0xdd, 0x10,
- 0x3e, 0x0f, 0x69, 0xd6, 0xf8, 0x0e, 0x74, 0x30, 0x78, 0x9f, 0x37, 0xfe, 0xbf, 0x0d, 0x1b, 0xfb,
- 0xb3, 0x50, 0x45, 0xda, 0x66, 0x5e, 0x24, 0x7d, 0x6a, 0xf3, 0xb2, 0x8d, 0x68, 0x0b, 0xf2, 0x8f,
- 0xa0, 0x49, 0x35, 0xe8, 0xe0, 0x42, 0x73, 0x7c, 0x6b, 0xb1, 0xe5, 0xff, 0xa8, 0xe4, 0xb5, 0x8d,
- 0x7d, 0x0f, 0xaa, 0xb6, 0xdf, 0xc4, 0xb6, 0xd2, 0xf0, 0x94, 0xd5, 0xa3, 0x03, 0xea, 0x22, 0xc3,
- 0x54, 0xab, 0x08, 0x03, 0xda, 0x5e, 0xa7, 0x87, 0x41, 0xd9, 0x1e, 0x29, 0xfd, 0x2c, 0x4e, 0x9e,
- 0x58, 0xfb, 0x3a, 0x10, 0x57, 0x5c, 0x35, 0x31, 0x75, 0xdb, 0x81, 0x98, 0x47, 0xf7, 0xcf, 0x83,
- 0x28, 0x52, 0xb3, 0xd4, 0x0e, 0x08, 0x19, 0x8c, 0xbb, 0x3e, 0x8f, 0xa3, 0xf0, 0x89, 0x4a, 0xec,
- 0xcb, 0x8d, 0x03, 0xe9, 0x72, 0xf5, 0xb9, 0x4a, 0x06, 0x2d, 0xf3, 0x4e, 0x40, 0x00, 0x3f, 0x85,
- 0xae, 0x3d, 0x90, 0xf4, 0xb8, 0x0e, 0x1d, 0x23, 0x5c, 0x18, 0x9d, 0xd9, 0x9c, 0x95, 0x23, 0xf2,
- 0x55, 0x95, 0xb8, 0xe7, 0x86, 0x1c, 0xc1, 0xbe, 0x0f, 0x0d, 0xbc, 0x1e, 0x37, 0x5f, 0x36, 0x4c,
- 0xe6, 0x35, 0x38, 0xfe, 0x39, 0xd4, 0xf1, 0xe3, 0x45, 0x1b, 0x82, 0x6d, 0x80, 0xa3, 0xf4, 0x8b,
- 0xa5, 0x3e, 0xc9, 0xea, 0x4e, 0x5b, 0x7a, 0x18, 0x7e, 0x0b, 0xda, 0xc8, 0x8e, 0xbc, 0x2b, 0x3b,
- 0xb7, 0x72, 0xe1, 0xb9, 0x1d, 0x4c, 0x14, 0x59, 0xd4, 0x9e, 0x26, 0xf1, 0xdc, 0x3a, 0x0c, 0x7d,
- 0x5f, 0xfe, 0xac, 0x59, 0x88, 0xb7, 0x9e, 0x89, 0x37, 0xfe, 0x19, 0x6c, 0x20, 0xbb, 0xfd, 0x78,
- 0xaa, 0x2e, 0x67, 0xc9, 0xa0, 0x3e, 0x89, 0xa7, 0x6e, 0x2c, 0xa6, 0xef, 0x0b, 0x99, 0xfd, 0xa9,
- 0x02, 0x1b, 0x2e, 0x61, 0xbc, 0x74, 0xa6, 0xf8, 0x9f, 0xe4, 0x47, 0xd7, 0x39, 0x0b, 0xd2, 0x87,
- 0xe1, 0x3c, 0xd4, 0x36, 0x70, 0x33, 0xd8, 0xe5, 0x92, 0x46, 0x96, 0x4b, 0xb8, 0x86, 0xce, 0x48,
- 0x45, 0xd3, 0x97, 0x96, 0xed, 0x3a, 0x74, 0x74, 0xbc, 0x57, 0x90, 0x2e, 0x47, 0x78, 0x99, 0xaa,
- 0x56, 0xc8, 0x54, 0xaf, 0x41, 0x6b, 0xbc, 0x32, 0x67, 0xf6, 0xa1, 0xaa, 0xb3, 0x52, 0xa5, 0x57,
- 0xfc, 0x97, 0xd0, 0x1d, 0x85, 0x67, 0xd1, 0x25, 0xcb, 0xd8, 0x05, 0x2c, 0x0a, 0x6f, 0xb1, 0x5e,
- 0x17, 0x50, 0xc0, 0xcb, 0x32, 0x1d, 0x1f, 0x42, 0x1b, 0x39, 0x63, 0xb7, 0xbb, 0x76, 0xea, 0x27,
- 0x00, 0x54, 0x7b, 0xa8, 0x76, 0x7b, 0xe5, 0xb2, 0x52, 0x28, 0x97, 0x03, 0x68, 0x1d, 0x06, 0xe9,
- 0xe3, 0x54, 0x4d, 0xed, 0xf3, 0x81, 0x03, 0x77, 0xff, 0x55, 0xcd, 0x07, 0x21, 0xf6, 0x36, 0x4d,
- 0x27, 0x28, 0x8e, 0xb3, 0x52, 0x53, 0xd0, 0x83, 0xfc, 0xb0, 0x2c, 0x24, 0xfb, 0x08, 0x5e, 0x2d,
- 0x92, 0x7e, 0x9a, 0xc4, 0x73, 0x6c, 0x77, 0xb7, 0x44, 0xe9, 0x7d, 0x73, 0x7d, 0xef, 0x0e, 0xce,
- 0x82, 0xd9, 0x45, 0x6c, 0x08, 0xff, 0xe9, 0x74, 0x98, 0x3d, 0x79, 0xb1, 0x77, 0xb1, 0xf1, 0xd6,
- 0x99, 0x70, 0x5b, 0xa2, 0xf4, 0xfc, 0x3e, 0xec, 0x09, 0xff, 0x7d, 0xed, 0x16, 0x6c, 0x1c, 0x2a,
- 0xed, 0xbd, 0x30, 0x39, 0xd9, 0xfb, 0xa2, 0xf8, 0xa6, 0xf5, 0x36, 0x1d, 0x6f, 0x1f, 0x6d, 0xca,
- 0xc7, 0x67, 0x4f, 0x3b, 0xf4, 0x40, 0xf4, 0x2e, 0xf4, 0x72, 0xd2, 0x3d, 0xcd, 0x36, 0x45, 0xf1,
- 0x25, 0x76, 0x58, 0x78, 0x09, 0xda, 0xfd, 0x5b, 0xd5, 0xce, 0xdd, 0x13, 0x9c, 0x54, 0xd9, 0x0d,
- 0x68, 0x1f, 0x2a, 0xd3, 0x87, 0xb3, 0x9e, 0xf0, 0x5e, 0x85, 0x86, 0x4d, 0x33, 0x8b, 0xb3, 0x1d,
- 0xe8, 0x38, 0x8a, 0x94, 0xf5, 0x84, 0xf7, 0x22, 0x34, 0xb4, 0xe3, 0x3a, 0x49, 0x7c, 0x13, 0xae,
- 0x38, 0x32, 0xe2, 0x4c, 0x69, 0xc8, 0xa9, 0xd7, 0x12, 0x76, 0x9e, 0xd9, 0x26, 0xbd, 0xdc, 0x4c,
- 0xee, 0x96, 0xdb, 0xc2, 0x61, 0xde, 0xa0, 0x75, 0x3b, 0xb8, 0x64, 0xeb, 0x5d, 0x51, 0x98, 0xcb,
- 0xfb, 0x87, 0x4a, 0x7b, 0xf3, 0x43, 0x46, 0xe6, 0x24, 0xfe, 0x11, 0x89, 0x52, 0x98, 0xc0, 0x72,
- 0x5e, 0x4c, 0xac, 0x8f, 0x66, 0x77, 0x68, 0x43, 0xa9, 0x7f, 0xce, 0xdd, 0xaa, 0xb8, 0xb0, 0xfb,
- 0xdb, 0x0a, 0x34, 0xa9, 0xc5, 0x49, 0xd9, 0x2d, 0xe8, 0xd0, 0x17, 0x36, 0x44, 0xac, 0x2b, 0xf2,
- 0xee, 0x76, 0xb8, 0x21, 0x0a, 0x4d, 0xd2, 0x1d, 0xe8, 0x13, 0xe1, 0x68, 0x79, 0x92, 0x4e, 0x92,
- 0xf0, 0x04, 0xef, 0xd4, 0xef, 0x9a, 0x87, 0xfe, 0x66, 0x76, 0x07, 0xb6, 0x6c, 0x13, 0x9c, 0x66,
- 0xf4, 0x05, 0xee, 0x5d, 0x91, 0x37, 0xc9, 0xbb, 0xff, 0xae, 0x40, 0xcb, 0x96, 0x7b, 0xf6, 0x2e,
- 0x5d, 0xa7, 0xed, 0x50, 0xc4, 0x5a, 0xdf, 0x35, 0x2c, 0x36, 0x06, 0xec, 0x2e, 0x99, 0x1b, 0xbf,
- 0x43, 0x75, 0x91, 0xf7, 0x5e, 0x11, 0x6b, 0xbd, 0xc8, 0xfb, 0xb0, 0x59, 0x6a, 0xd2, 0xd8, 0xab,
- 0xe2, 0xa2, 0xb6, 0x6d, 0x08, 0x22, 0xff, 0x47, 0xe9, 0x13, 0xb8, 0x56, 0xa2, 0xd9, 0x8b, 0xa6,
- 0x0f, 0xe2, 0xd9, 0xf4, 0xb2, 0xcd, 0x45, 0x41, 0x77, 0xbf, 0xa9, 0x64, 0x75, 0x9e, 0xbd, 0x83,
- 0x13, 0xbf, 0x2e, 0xb6, 0x28, 0x79, 0x1c, 0x15, 0xf1, 0x6f, 0x91, 0xb3, 0xf8, 0x15, 0xda, 0x51,
- 0xf6, 0x84, 0x8f, 0xa5, 0x01, 0x5a, 0x67, 0xe5, 0xd3, 0x11, 0xe5, 0xb5, 0x95, 0x5d, 0x87, 0xd6,
- 0xa1, 0xd2, 0x54, 0x83, 0x41, 0x64, 0x6d, 0xd4, 0xd0, 0x54, 0x4b, 0xf6, 0x03, 0xb2, 0x3b, 0x95,
- 0x4c, 0x6f, 0xb3, 0x2b, 0xb1, 0xbb, 0x7f, 0xaf, 0x42, 0xd7, 0xa9, 0x89, 0x62, 0xbd, 0x09, 0xdd,
- 0x7b, 0x49, 0x1c, 0x4c, 0x27, 0x41, 0xaa, 0xc7, 0x2b, 0xd6, 0x16, 0x36, 0x23, 0x17, 0x6c, 0xf6,
- 0x3a, 0xd4, 0xa9, 0x47, 0x07, 0x91, 0x55, 0xe0, 0x61, 0x57, 0x78, 0x99, 0xf4, 0x96, 0xf9, 0x27,
- 0x89, 0xfe, 0x21, 0xe8, 0x8b, 0x42, 0x5d, 0x2d, 0x12, 0xbe, 0x05, 0x6d, 0x77, 0x3a, 0xeb, 0x8b,
- 0x42, 0xc9, 0x2c, 0x9c, 0x78, 0x37, 0xbf, 0x5b, 0x77, 0x3d, 0x65, 0xf2, 0xd2, 0x3c, 0xc1, 0xb6,
- 0xa1, 0x8e, 0x25, 0x8e, 0x81, 0xc8, 0x2a, 0x5d, 0x81, 0xe5, 0x0e, 0x74, 0x71, 0xc1, 0xb1, 0xbb,
- 0x8c, 0xec, 0x0d, 0x68, 0x9a, 0xc2, 0xc4, 0x7a, 0xc2, 0xab, 0x50, 0xc3, 0x8e, 0x70, 0x55, 0xe5,
- 0xa4, 0x49, 0xff, 0xbf, 0xfe, 0xf8, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x36, 0xb5, 0x06, 0x7c,
- 0x8f, 0x1d, 0x00, 0x00,
-}
diff --git a/rpc/burrow/split.py b/rpc/burrow/split.py
deleted file mode 100644
index 9bfb2e5bce6984422562699c39de97bb6797787c..0000000000000000000000000000000000000000
--- a/rpc/burrow/split.py
+++ /dev/null
@@ -1,22 +0,0 @@
-import sys
-import re
-
-masterfile = sys.argv[1]
-print (masterfile)
-
-outfile = None;
-
-beginRE = re.compile(r"^\s*\/\/\s*#\s*begin\s*\(\s*(\w+)\s*\)", re.I)
-
-for line in open(masterfile, 'r'):
- match = beginRE.search(line)
- if match is not None and match.group(1) is not "":
- outfile = open(match.group(1) + ".proto", 'w')
- outfile.write("syntax = 'proto3';\n\nimport \"common.proto\";\n\n")
- elif outfile is not None:
- outfile.write(line)
- else:
- print "skip"
-
-print "done"
-
diff --git a/rpc/burrow/transaction_server.go b/rpc/burrow/transaction_server.go
deleted file mode 100644
index d2c5dc6145815baf52b8067482e223285d1a5d69..0000000000000000000000000000000000000000
--- a/rpc/burrow/transaction_server.go
+++ /dev/null
@@ -1,206 +0,0 @@
-package burrow
-
-import (
- acm "github.com/hyperledger/burrow/account"
- "github.com/hyperledger/burrow/account/state"
- "github.com/hyperledger/burrow/crypto"
- "github.com/hyperledger/burrow/execution"
- "github.com/hyperledger/burrow/execution/evm/events"
- "github.com/hyperledger/burrow/rpc"
- "github.com/hyperledger/burrow/txs"
- "golang.org/x/net/context"
-)
-
-type transactionServer struct {
- service *rpc.Service
- txCodec txs.Codec
- reader state.Reader
-}
-
-func NewTransactionServer(service *rpc.Service, reader state.Reader, txCodec txs.Codec) TransactionServer {
- return &transactionServer{
- service: service,
- reader: reader,
- txCodec: txCodec,
- }
-}
-
-func (ts *transactionServer) BroadcastTx(ctx context.Context, param *TxParam) (*TxReceipt, error) {
- receipt, err := ts.service.Transactor().BroadcastTxRaw(param.GetTx())
- if err != nil {
- return nil, err
- }
- return txReceipt(receipt), nil
-}
-
-func (ts *transactionServer) Call(ctx context.Context, param *CallParam) (*CallResult, error) {
- fromAddress, err := crypto.AddressFromBytes(param.GetFrom())
- if err != nil {
- return nil, err
- }
- address, err := crypto.AddressFromBytes(param.GetAddress())
- if err != nil {
- return nil, err
- }
- call, err := ts.service.Transactor().Call(ts.reader, fromAddress, address, param.GetData())
- return &CallResult{
- Return: call.Return,
- GasUsed: call.GasUsed,
- }, nil
-}
-
-func (ts *transactionServer) CallCode(ctx context.Context, param *CallCodeParam) (*CallResult, error) {
- fromAddress, err := crypto.AddressFromBytes(param.GetFrom())
- if err != nil {
- return nil, err
- }
- call, err := ts.service.Transactor().CallCode(ts.reader, fromAddress, param.GetCode(), param.GetData())
- return &CallResult{
- Return: call.Return,
- GasUsed: call.GasUsed,
- }, nil
-}
-
-func (ts *transactionServer) Transact(ctx context.Context, param *TransactParam) (*TxReceipt, error) {
- inputAccount, err := ts.inputAccount(param.GetInputAccount())
- if err != nil {
- return nil, err
- }
- address, err := crypto.MaybeAddressFromBytes(param.GetAddress())
- if err != nil {
- return nil, err
- }
- receipt, err := ts.service.Transactor().Transact(inputAccount, address, param.GetData(), param.GetGasLimit(),
- param.GetFee())
- if err != nil {
- return nil, err
- }
- return txReceipt(receipt), nil
-}
-
-func (ts *transactionServer) TransactAndHold(ctx context.Context, param *TransactParam) (*EventDataCall, error) {
- inputAccount, err := ts.inputAccount(param.GetInputAccount())
- if err != nil {
- return nil, err
- }
- address, err := crypto.MaybeAddressFromBytes(param.GetAddress())
- if err != nil {
- return nil, err
- }
- edt, err := ts.service.Transactor().TransactAndHold(ctx, inputAccount, address, param.GetData(),
- param.GetGasLimit(), param.GetFee())
- if err != nil {
- return nil, err
- }
- return eventDataCall(edt), nil
-}
-
-func (ts *transactionServer) Send(ctx context.Context, param *SendParam) (*TxReceipt, error) {
- inputAccount, err := ts.inputAccount(param.GetInputAccount())
- if err != nil {
- return nil, err
- }
- toAddress, err := crypto.AddressFromBytes(param.GetToAddress())
- if err != nil {
- return nil, err
- }
- receipt, err := ts.service.Transactor().Send(inputAccount, toAddress, param.GetAmount())
- if err != nil {
- return nil, err
- }
- return txReceipt(receipt), nil
-}
-
-func (ts *transactionServer) SendAndHold(ctx context.Context, param *SendParam) (*TxReceipt, error) {
- inputAccount, err := ts.inputAccount(param.GetInputAccount())
- if err != nil {
- return nil, err
- }
- toAddress, err := crypto.AddressFromBytes(param.GetToAddress())
- if err != nil {
- return nil, err
- }
- receipt, err := ts.service.Transactor().SendAndHold(ctx, inputAccount, toAddress, param.GetAmount())
- if err != nil {
- return nil, err
- }
- return txReceipt(receipt), nil
-}
-
-func (ts *transactionServer) SignTx(ctx context.Context, param *SignTxParam) (*SignedTx, error) {
- txEnv, err := ts.txCodec.DecodeTx(param.GetTx())
- if err != nil {
- return nil, err
- }
- signers, err := signersFromPrivateAccounts(param.GetPrivateAccounts())
- if err != nil {
- return nil, err
- }
- txEnvSigned, err := ts.service.Transactor().SignTx(txEnv, signers)
- if err != nil {
- return nil, err
- }
- bs, err := ts.txCodec.EncodeTx(txEnvSigned)
- if err != nil {
- return nil, err
- }
- return &SignedTx{
- Tx: bs,
- }, nil
-}
-
-func (ts *transactionServer) inputAccount(inAcc *InputAccount) (*execution.SequentialSigningAccount, error) {
- return ts.service.SigningAccount(inAcc.GetAddress(), inAcc.GetPrivateKey())
-}
-
-func eventDataCall(edt *events.EventDataCall) *EventDataCall {
- return &EventDataCall{
- Origin: edt.Origin.Bytes(),
- TxHash: edt.TxHash,
- CallData: callData(edt.CallData),
- StackDepth: int64(edt.StackDepth),
- Return: edt.Return,
- Exception: edt.Exception.Error(),
- }
-}
-func callData(cd *events.CallData) *CallData {
- return &CallData{
- Caller: cd.Caller.Bytes(),
- Callee: cd.Callee.Bytes(),
- Data: cd.Data,
- Gas: cd.Gas,
- }
-}
-
-func txReceipt(receipt *txs.Receipt) *TxReceipt {
- return &TxReceipt{
- ContractAddress: receipt.ContractAddress.Bytes(),
- CreatesContract: receipt.CreatesContract,
- TxHash: receipt.TxHash,
- }
-}
-
-func signersFromPrivateAccounts(privateAccounts []*PrivateAccount) ([]acm.AddressableSigner, error) {
- signers := make([]acm.AddressableSigner, len(privateAccounts))
- var err error
- for i, pa := range privateAccounts {
- signers[i], err = privateAccount(pa)
- if err != nil {
- return nil, err
- }
- }
- return signers, nil
-}
-
-func privateAccount(privateAccount *PrivateAccount) (acm.PrivateAccount, error) {
- privateKey, err := crypto.PrivateKeyFromRawBytes(privateAccount.PrivateKey, crypto.CurveTypeEd25519)
- if err != nil {
- return nil, err
- }
- publicKey := privateKey.GetPublicKey()
- return acm.ConcretePrivateAccount{
- Address: publicKey.Address(),
- PrivateKey: privateKey,
- PublicKey: publicKey,
- }.PrivateAccount(), nil
-}
diff --git a/rpc/grpc.go b/rpc/grpc.go
index 49a42fd04a22be9a56b35c1bd3600cbcac757a15..a30bdad14dd20607bdaaf04f31cee111e349f778 100644
--- a/rpc/grpc.go
+++ b/rpc/grpc.go
@@ -3,6 +3,8 @@ package rpc
import (
"fmt"
+ "runtime/debug"
+
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
"golang.org/x/net/context"
@@ -18,13 +20,15 @@ func unaryInterceptor(logger *logging.Logger) grpc.UnaryServerInterceptor {
return func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo,
handler grpc.UnaryHandler) (resp interface{}, err error) {
+ logger = logger.With("method", info.FullMethod)
+
defer func() {
if r := recover(); r != nil {
- logger.InfoMsg("panic in GRPC unary call", "method", info.FullMethod,
- structure.ErrorKey, fmt.Sprintf("%v", r))
+ logger.InfoMsg("panic in GRPC unary call", structure.ErrorKey, fmt.Sprintf("%v", r))
err = fmt.Errorf("panic in GRPC unary call %s: %v", info.FullMethod, r)
}
}()
+ logger.TraceMsg("GRPC unary call")
return handler(ctx, req)
}
}
@@ -32,15 +36,17 @@ func unaryInterceptor(logger *logging.Logger) grpc.UnaryServerInterceptor {
func streamInterceptor(logger *logging.Logger) grpc.StreamServerInterceptor {
return func(srv interface{}, ss grpc.ServerStream, info *grpc.StreamServerInfo,
handler grpc.StreamHandler) (err error) {
+ logger = logger.With("method", info.FullMethod,
+ "is_client_stream", info.IsClientStream,
+ "is_server_stream", info.IsServerStream)
defer func() {
if r := recover(); r != nil {
- logger.InfoMsg("panic in GRPC stream", "method", info.FullMethod,
- "is_client_stream", info.IsClientStream, "is_server_stream", info.IsServerStream,
- structure.ErrorKey, fmt.Sprintf("%v", r))
- err = fmt.Errorf("panic in GRPC stream %s: %v", info.FullMethod, r)
+ logger.InfoMsg("panic in GRPC stream", structure.ErrorKey, fmt.Sprintf("%v", r))
+ err = fmt.Errorf("panic in GRPC stream %s: %v: %s", info.FullMethod, r, debug.Stack())
}
}()
+ logger.TraceMsg("GRPC stream call")
return handler(srv, ss)
}
}
diff --git a/rpc/result.go b/rpc/result.go
index 05ab9a853b6f11b1bb1566e035daac72ae56fa4d..3159690e33135a908f76daa1e93402f2228f9e6a 100644
--- a/rpc/result.go
+++ b/rpc/result.go
@@ -22,8 +22,8 @@ import (
"github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/execution"
- exeEvents "github.com/hyperledger/burrow/execution/events"
- evmEvents "github.com/hyperledger/burrow/execution/evm/events"
+ "github.com/hyperledger/burrow/execution/events"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
"github.com/hyperledger/burrow/execution/names"
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/txs"
@@ -239,11 +239,9 @@ func (te *TendermintEvent) EventDataNewBlock() *tmTypes.EventDataNewBlock {
}
type ResultEvent struct {
- Event string
- Tendermint *TendermintEvent `json:",omitempty"`
- EventDataTx *exeEvents.EventDataTx `json:",omitempty"`
- EventDataCall *evmEvents.EventDataCall `json:",omitempty"`
- EventDataLog *evmEvents.EventDataLog `json:",omitempty"`
+ Event string
+ Tendermint *TendermintEvent `json:",omitempty"`
+ Execution *events.Event `json:",omitempty"`
}
// Map any supported event data element to our ResultEvent sum type
@@ -254,14 +252,32 @@ func NewResultEvent(event string, eventData interface{}) (*ResultEvent, error) {
switch ed := eventData.(type) {
case tmTypes.TMEventData:
res.Tendermint = &TendermintEvent{ed}
- case *exeEvents.EventDataTx:
- res.EventDataTx = ed
- case *evmEvents.EventDataCall:
- res.EventDataCall = ed
- case *evmEvents.EventDataLog:
- res.EventDataLog = ed
+ case *events.Event:
+ res.Execution = ed
default:
return nil, fmt.Errorf("could not map event data of type %T to ResultEvent", eventData)
}
return res, nil
}
+
+func (re *ResultEvent) GetEvent() (*pbevents.Event, error) {
+ ev := &pbevents.Event{
+ Name: re.Event,
+ }
+ if re.Tendermint != nil {
+ bs, err := json.Marshal(re.Tendermint)
+ if err != nil {
+ return nil, err
+ }
+ ev.Event = &pbevents.Event_TendermintEventJSON{
+ TendermintEventJSON: string(bs),
+ }
+ } else if re.Execution != nil {
+ ev.Event = &pbevents.Event_ExecutionEvent{
+ ExecutionEvent: pbevents.GetExecutionEvent(re.Execution),
+ }
+ } else {
+ return nil, fmt.Errorf("ResultEvent is empty")
+ }
+ return ev, nil
+}
diff --git a/rpc/rpcevents/events_server.go b/rpc/rpcevents/events_server.go
new file mode 100644
index 0000000000000000000000000000000000000000..699edcbff002a9ab6901b735d9c03344ac5f9b78
--- /dev/null
+++ b/rpc/rpcevents/events_server.go
@@ -0,0 +1,57 @@
+package rpcevents
+
+import (
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/hyperledger/burrow/rpc"
+ "golang.org/x/net/context"
+)
+
+type eventServer struct {
+ subscriptions *rpc.Subscriptions
+}
+
+func NewEventsServer(subscriptions *rpc.Subscriptions) pbevents.EventsServer {
+ return &eventServer{
+ subscriptions: subscriptions,
+ }
+}
+
+func (es *eventServer) EventPoll(ctx context.Context, param *pbevents.SubIdParam) (*pbevents.PollResponse, error) {
+ msgs, err := es.subscriptions.Poll(param.GetSubId())
+ if err != nil {
+ return nil, err
+ }
+ resp := &pbevents.PollResponse{
+ Events: make([]*pbevents.Event, 0, len(msgs)),
+ }
+ for _, msg := range msgs {
+ if resultEvent, ok := msg.(*rpc.ResultEvent); ok {
+ ev, err := resultEvent.GetEvent()
+ if err != nil {
+ return nil, err
+ }
+ resp.Events = append(resp.Events, ev)
+ }
+ }
+ return resp, nil
+}
+
+func (es *eventServer) EventSubscribe(ctx context.Context, param *pbevents.EventIdParam) (*pbevents.SubIdParam, error) {
+ subID, err := es.subscriptions.Add(param.GetEventId())
+ if err != nil {
+ return nil, err
+ }
+ return &pbevents.SubIdParam{
+ SubId: subID,
+ }, nil
+}
+
+func (es *eventServer) EventUnsubscribe(ctx context.Context, param *pbevents.SubIdParam) (*pbevents.EventUnSub, error) {
+ err := es.subscriptions.Remove(param.GetSubId())
+ if err != nil {
+ return nil, err
+ }
+ return &pbevents.EventUnSub{
+ Result: true,
+ }, nil
+}
diff --git a/rpc/rpcevents/execution_events_server.go b/rpc/rpcevents/execution_events_server.go
new file mode 100644
index 0000000000000000000000000000000000000000..57645b8bb4cd6daeba49107ac3ee4b8ccddcfa72
--- /dev/null
+++ b/rpc/rpcevents/execution_events_server.go
@@ -0,0 +1,116 @@
+package rpcevents
+
+import (
+ "fmt"
+
+ "context"
+
+ bcm "github.com/hyperledger/burrow/blockchain"
+ "github.com/hyperledger/burrow/consensus/tendermint"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
+ "github.com/hyperledger/burrow/execution/events"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/tendermint/tendermint/libs/pubsub"
+)
+
+type executionEventsServer struct {
+ eventsProvider events.Provider
+ emitter event.Emitter
+ tip bcm.TipInfo
+}
+
+func NewExecutionEventsServer(eventsProvider events.Provider, emitter event.Emitter,
+ tip bcm.TipInfo) pbevents.ExecutionEventsServer {
+
+ return &executionEventsServer{
+ eventsProvider: eventsProvider,
+ emitter: emitter,
+ tip: tip,
+ }
+}
+
+func (ees *executionEventsServer) GetEvents(request *pbevents.GetEventsRequest,
+ stream pbevents.ExecutionEvents_GetEventsServer) error {
+
+ blockRange := request.GetBlockRange()
+ start, end, streaming := blockRange.Bounds(ees.tip.LastBlockHeight())
+ qry, err := query.NewBuilder(request.Query).Query()
+ if err != nil {
+ return fmt.Errorf("could not parse event query: %v", err)
+ }
+
+ if !streaming {
+ return ees.steamEvents(stream, start, end, 1, qry)
+ }
+
+ // Streaming
+ if err != nil {
+ return err
+ }
+
+ out, err := tendermint.SubscribeNewBlock(context.Background(), ees.emitter)
+ if err != nil {
+ return err
+ }
+
+ for newBlock := range out {
+ if newBlock == nil {
+ return fmt.Errorf("received non-new-block event when subscribed with query")
+ }
+ if newBlock.Block == nil {
+ return fmt.Errorf("new block contains no block info: %v", newBlock)
+ }
+ height := uint64(newBlock.Block.Height)
+ start = end
+ end = events.NewKey(height, 0)
+ err := ees.steamEvents(stream, start, end, 1, qry)
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func (ees *executionEventsServer) steamEvents(stream pbevents.ExecutionEvents_GetEventsServer, start, end events.Key,
+ batchSize uint64, qry pubsub.Query) error {
+
+ var streamErr error
+ buf := new(pbevents.GetEventsResponse)
+
+ batchStart := start.Height()
+ _, err := ees.eventsProvider.GetEvents(start, end, func(ev *events.Event) (stop bool) {
+ if qry.Matches(ev) {
+ // Start a new batch, flush the last lot
+ if ev.Header.Index == 0 && (ev.Header.Height-batchStart)%batchSize == 0 {
+ streamErr = flush(stream, buf)
+ if streamErr != nil {
+ return true
+ }
+ batchStart = ev.Header.Height
+ buf = new(pbevents.GetEventsResponse)
+ }
+ buf.Events = append(buf.Events, pbevents.GetExecutionEvent(ev))
+ }
+ return false
+ })
+ if err != nil {
+ return err
+ }
+ if streamErr != nil {
+ return streamErr
+ }
+ // Flush any remaining events not filling batchSize many blocks
+ return flush(stream, buf)
+}
+
+func flush(stream pbevents.ExecutionEvents_GetEventsServer, buf *pbevents.GetEventsResponse) error {
+ if len(buf.Events) > 0 {
+ err := stream.Send(buf)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/rpc/rpcevents/integration/events_server_test.go b/rpc/rpcevents/integration/events_server_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7c5e471573c4503ba8cfe0b149f4c6f164d778cb
--- /dev/null
+++ b/rpc/rpcevents/integration/events_server_test.go
@@ -0,0 +1,81 @@
+// +build integration
+
+// Space above here matters
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration
+
+import (
+ "context"
+ "testing"
+
+ "github.com/hyperledger/burrow/execution/pbtransactor"
+ "github.com/hyperledger/burrow/rpc/test"
+ "github.com/stretchr/testify/require"
+ "github.com/tmthrgd/go-hex"
+)
+
+func TestEventSubscribe(t *testing.T) {
+ //cli := test.NewEventsClient(t)
+ //sub, err := cli.EventSubscribe(context.Background(), &pbevents.EventIdParam{
+ // EventId: tmTypes.EventNewBlock,
+ //})
+ //require.NoError(t, err)
+ //defer cli.EventUnsubscribe(context.Background(), sub)
+ //
+ //pollCh := make(chan *pbevents.PollResponse)
+ //go func() {
+ // poll := new(pbevents.PollResponse)
+ // for len(poll.Events) == 0 {
+ // poll, err = cli.EventPoll(context.Background(), sub)
+ // require.NoError(t, err)
+ // time.Sleep(1)
+ // }
+ // pollCh <- poll
+ //}()
+ //select {
+ //case poll := <-pollCh:
+ // require.True(t, len(poll.Events) > 0, "event poll should return at least 1 event")
+ // tendermintEvent := new(rpc.TendermintEvent)
+ // tendermintEventJSON := poll.Events[0].GetTendermintEventJSON()
+ // require.NoError(t, json.Unmarshal([]byte(tendermintEventJSON), tendermintEvent))
+ // newBlock, ok := tendermintEvent.TMEventData.(tmTypes.EventDataNewBlock)
+ // require.True(t, ok, "new block event expected")
+ // assert.Equal(t, genesisDoc.ChainID(), newBlock.Block.ChainID)
+ //case <-time.After(3 * time.Second):
+ // t.Fatal("timed out waiting for poll event")
+ //}
+}
+
+func testEventsCall(t *testing.T, numTxs int) {
+ cli := test.NewTransactorClient(t)
+
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
+
+ require.NoError(t, err)
+
+ countCh := test.CommittedTxCount(t, kern.Emitter)
+ for i := 0; i < numTxs; i++ {
+ _, err := cli.Transact(context.Background(), &pbtransactor.TransactParam{
+ InputAccount: inputAccount,
+ Address: nil,
+ Data: bc,
+ Fee: 2,
+ GasLimit: 10000,
+ })
+ require.NoError(t, err)
+ }
+ require.Equal(t, numTxs, <-countCh)
+}
diff --git a/rpc/rpcevents/integration/execution_events_server_test.go b/rpc/rpcevents/integration/execution_events_server_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..cdd80b1df22a6c3e48de046f84dc0fd0a21762c0
--- /dev/null
+++ b/rpc/rpcevents/integration/execution_events_server_test.go
@@ -0,0 +1,118 @@
+// +build integration
+
+// Space above here matters
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration
+
+import (
+ "context"
+ "testing"
+
+ "io"
+
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/event/query"
+ "github.com/hyperledger/burrow/execution/events"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/hyperledger/burrow/execution/pbtransactor"
+ "github.com/hyperledger/burrow/rpc/test"
+ "github.com/hyperledger/burrow/txs/payload"
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+)
+
+func TestExecutionEventsSendStream(t *testing.T) {
+ request := &pbevents.GetEventsRequest{
+ BlockRange: pbevents.NewBlockRange(pbevents.LatestBound(), pbevents.StreamBound()),
+ }
+ tcli := test.NewTransactorClient(t)
+ ecli := test.NewExecutionEventsClient(t)
+ stream, err := ecli.GetEvents(context.Background(), request)
+ require.NoError(t, err)
+ numSends := 1
+ for i := 0; i < numSends; i++ {
+ doSends(t, 2, tcli)
+ response, err := stream.Recv()
+ require.NoError(t, err)
+ require.Len(t, response.Events, 4, "expect multiple events")
+ assert.Equal(t, payload.TypeSend.String(), response.Events[0].GetHeader().GetTxType())
+ assert.Equal(t, payload.TypeSend.String(), response.Events[1].GetHeader().GetTxType())
+ }
+ require.NoError(t, stream.CloseSend())
+}
+
+func TestExecutionEventsSend(t *testing.T) {
+ request := &pbevents.GetEventsRequest{
+ BlockRange: pbevents.NewBlockRange(pbevents.AbsoluteBound(kern.Blockchain.LastBlockHeight()),
+ pbevents.AbsoluteBound(300)),
+ }
+ numSends := 1100
+ responses := testExecutionEventsSend(t, numSends, request)
+ assert.Equal(t, numSends*2, totalEvents(responses), "should receive and input and output event per send")
+}
+
+func TestExecutionEventsSendFiltered(t *testing.T) {
+ request := &pbevents.GetEventsRequest{
+ BlockRange: pbevents.NewBlockRange(pbevents.AbsoluteBound(kern.Blockchain.LastBlockHeight()),
+ pbevents.AbsoluteBound(300)),
+ Query: query.NewBuilder().AndEquals(event.EventTypeKey, events.TypeAccountInput.String()).String(),
+ }
+ numSends := 500
+ responses := testExecutionEventsSend(t, numSends, request)
+ assert.Equal(t, numSends, totalEvents(responses), "should receive a single input event per send")
+}
+
+func testExecutionEventsSend(t *testing.T, numSends int, request *pbevents.GetEventsRequest) []*pbevents.GetEventsResponse {
+ doSends(t, numSends, test.NewTransactorClient(t))
+ ecli := test.NewExecutionEventsClient(t)
+
+ evs, err := ecli.GetEvents(context.Background(), request)
+ require.NoError(t, err)
+ var responses []*pbevents.GetEventsResponse
+ for {
+ resp, err := evs.Recv()
+ if err != nil {
+ if err == io.EOF {
+ break
+ }
+ require.NoError(t, err)
+ }
+ responses = append(responses, resp)
+ }
+ return responses
+}
+
+func doSends(t *testing.T, numSends int, cli pbtransactor.TransactorClient) {
+ countCh := test.CommittedTxCount(t, kern.Emitter)
+ for i := 0; i < numSends; i++ {
+ send, err := cli.Send(context.Background(), &pbtransactor.SendParam{
+ InputAccount: inputAccount,
+ Amount: 2003,
+ ToAddress: privateAccounts[3].Address().Bytes(),
+ })
+ require.NoError(t, err)
+ assert.Equal(t, false, send.CreatesContract)
+ }
+ require.Equal(t, numSends, <-countCh)
+}
+
+func totalEvents(respones []*pbevents.GetEventsResponse) int {
+ i := 0
+ for _, resp := range respones {
+ i += len(resp.Events)
+ }
+ return i
+}
diff --git a/rpc/rpcevents/integration/main_test.go b/rpc/rpcevents/integration/main_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..338b533457def710c8e5d9e6895a8606d8d49c97
--- /dev/null
+++ b/rpc/rpcevents/integration/main_test.go
@@ -0,0 +1,44 @@
+// +build integration
+
+// Space above here matters
+// Copyright 2017 Monax Industries Limited
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package integration
+
+import (
+ "os"
+ "testing"
+ "time"
+
+ "github.com/hyperledger/burrow/core"
+ "github.com/hyperledger/burrow/core/integration"
+ "github.com/hyperledger/burrow/execution/pbtransactor"
+)
+
+var privateAccounts = integration.MakePrivateAccounts(5) // make keys
+var genesisDoc = integration.TestGenesisDoc(privateAccounts)
+var inputAccount = &pbtransactor.InputAccount{Address: privateAccounts[0].Address().Bytes()}
+var kern *core.Kernel
+
+// Needs to be in a _test.go file to be picked up
+func TestMain(m *testing.M) {
+ returnValue := integration.TestWrapper(privateAccounts, genesisDoc, func(k *core.Kernel) int {
+ kern = k
+ return m.Run()
+ })
+
+ time.Sleep(3 * time.Second)
+ os.Exit(returnValue)
+}
diff --git a/rpc/burrow/integration/main_test.go b/rpc/rpctransactor/integration/main_test.go
similarity index 100%
rename from rpc/burrow/integration/main_test.go
rename to rpc/rpctransactor/integration/main_test.go
diff --git a/rpc/burrow/integration/transaction_service_test.go b/rpc/rpctransactor/integration/transactor_server_test.go
similarity index 68%
rename from rpc/burrow/integration/transaction_service_test.go
rename to rpc/rpctransactor/integration/transactor_server_test.go
index db7f825489c76fb74a429cdfd03603f444b47b2b..9eb2ca6ba47d5dbb7474d9c98a66d679686b25af 100644
--- a/rpc/burrow/integration/transaction_service_test.go
+++ b/rpc/rpctransactor/integration/transactor_server_test.go
@@ -20,18 +20,16 @@ package integration
import (
"context"
"encoding/hex"
- "fmt"
"sync"
"testing"
"github.com/hyperledger/burrow/binary"
- "github.com/hyperledger/burrow/consensus/tendermint"
"github.com/hyperledger/burrow/execution/evm/abi"
+ "github.com/hyperledger/burrow/execution/pbtransactor"
"github.com/hyperledger/burrow/rpc"
- "github.com/hyperledger/burrow/rpc/burrow"
+ "github.com/hyperledger/burrow/rpc/test"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
- "github.com/tendermint/tendermint/types"
"google.golang.org/grpc"
)
@@ -42,9 +40,9 @@ func TestTransactCallNoCode(t *testing.T) {
toAddress := privateAccounts[2].Address()
numCreates := 1000
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numCreates; i++ {
- receipt, err := cli.Transact(context.Background(), &burrow.TransactParam{
+ receipt, err := cli.Transact(context.Background(), &pbtransactor.TransactParam{
InputAccount: inputAccount(i),
Address: toAddress.Bytes(),
Data: []byte{},
@@ -65,13 +63,13 @@ func TestTransactCreate(t *testing.T) {
wg := new(sync.WaitGroup)
wg.Add(numGoroutines)
// Flip flops between sending private key and input address to test private key and address based signing
- bc, err := hex.DecodeString(strangeLoopBytecode)
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
require.NoError(t, err)
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numGoroutines; i++ {
go func() {
for j := 0; j < numCreates; j++ {
- create, err := cli.Transact(context.Background(), &burrow.TransactParam{
+ create, err := cli.Transact(context.Background(), &pbtransactor.TransactParam{
InputAccount: inputAccount(i),
Address: nil,
Data: bc,
@@ -92,10 +90,10 @@ func TestTransactCreate(t *testing.T) {
func BenchmarkTransactCreateContract(b *testing.B) {
cli := newClient(b)
- bc, err := hex.DecodeString(strangeLoopBytecode)
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
require.NoError(b, err)
for i := 0; i < b.N; i++ {
- create, err := cli.Transact(context.Background(), &burrow.TransactParam{
+ create, err := cli.Transact(context.Background(), &pbtransactor.TransactParam{
InputAccount: inputAccount(i),
Address: nil,
Data: bc,
@@ -109,14 +107,14 @@ func BenchmarkTransactCreateContract(b *testing.B) {
func TestTransactAndHold(t *testing.T) {
cli := newClient(t)
- bc, err := hex.DecodeString(strangeLoopBytecode)
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
require.NoError(t, err)
numGoroutines := 5
numRuns := 2
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numGoroutines; i++ {
for j := 0; j < numRuns; j++ {
- create, err := cli.TransactAndHold(context.Background(), &burrow.TransactParam{
+ create, err := cli.TransactAndHold(context.Background(), &pbtransactor.TransactParam{
InputAccount: inputAccount(i),
Address: nil,
Data: bc,
@@ -124,9 +122,9 @@ func TestTransactAndHold(t *testing.T) {
GasLimit: 10000,
})
require.NoError(t, err)
- assert.Equal(t, int64(0), create.StackDepth)
+ assert.Equal(t, uint64(0), create.StackDepth)
functionID := abi.FunctionID("UpsieDownsie()")
- call, err := cli.TransactAndHold(context.Background(), &burrow.TransactParam{
+ call, err := cli.TransactAndHold(context.Background(), &pbtransactor.TransactParam{
InputAccount: inputAccount(i),
Address: create.CallData.Callee,
Data: functionID[:],
@@ -145,9 +143,9 @@ func TestTransactAndHold(t *testing.T) {
func TestSend(t *testing.T) {
cli := newClient(t)
numSends := 1000
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numSends; i++ {
- send, err := cli.Send(context.Background(), &burrow.SendParam{
+ send, err := cli.Send(context.Background(), &pbtransactor.SendParam{
InputAccount: inputAccount(i),
Amount: 2003,
ToAddress: privateAccounts[3].Address().Bytes(),
@@ -161,7 +159,7 @@ func TestSend(t *testing.T) {
func TestSendAndHold(t *testing.T) {
cli := newClient(t)
for i := 0; i < 2; i++ {
- send, err := cli.SendAndHold(context.Background(), &burrow.SendParam{
+ send, err := cli.SendAndHold(context.Background(), &pbtransactor.SendParam{
InputAccount: inputAccount(i),
Amount: 2003,
ToAddress: privateAccounts[3].Address().Bytes(),
@@ -172,49 +170,17 @@ func TestSendAndHold(t *testing.T) {
}
// Helpers
-func newClient(t testing.TB) burrow.TransactionClient {
+func newClient(t testing.TB) pbtransactor.TransactorClient {
conn, err := grpc.Dial(rpc.DefaultGRPCConfig().ListenAddress, grpc.WithInsecure())
require.NoError(t, err)
- return burrow.NewTransactionClient(conn)
-}
-
-var committedTxCountIndex = 0
-
-func committedTxCount(t *testing.T) chan int {
- var numTxs int64
- emptyBlocks := 0
- maxEmptyBlocks := 2
- outCh := make(chan int)
- ch := make(chan *types.EventDataNewBlock)
- ctx := context.Background()
- subscriber := fmt.Sprintf("committedTxCount_%v", committedTxCountIndex)
- committedTxCountIndex++
- require.NoError(t, tendermint.SubscribeNewBlock(ctx, kern.Emitter, subscriber, ch))
-
- go func() {
- for ed := range ch {
- if ed.Block.NumTxs == 0 {
- emptyBlocks++
- } else {
- emptyBlocks = 0
- }
- if emptyBlocks > maxEmptyBlocks {
- break
- }
- numTxs += ed.Block.NumTxs
- t.Logf("Total TXs committed at block %v: %v (+%v)\n", ed.Block.Height, numTxs, ed.Block.NumTxs)
- }
- require.NoError(t, kern.Emitter.UnsubscribeAll(ctx, subscriber))
- outCh <- int(numTxs)
- }()
- return outCh
+ return pbtransactor.NewTransactorClient(conn)
}
var inputPrivateKey = privateAccounts[0].PrivateKey().RawBytes()
var inputAddress = privateAccounts[0].Address().Bytes()
-func inputAccount(i int) *burrow.InputAccount {
- ia := new(burrow.InputAccount)
+func inputAccount(i int) *pbtransactor.InputAccount {
+ ia := new(pbtransactor.InputAccount)
if i%2 == 0 {
ia.PrivateKey = inputPrivateKey
} else {
diff --git a/rpc/rpctransactor/transactor_server.go b/rpc/rpctransactor/transactor_server.go
new file mode 100644
index 0000000000000000000000000000000000000000..53c973fd0b647d1fffd4216a5280a42381c55ec5
--- /dev/null
+++ b/rpc/rpctransactor/transactor_server.go
@@ -0,0 +1,190 @@
+package rpctransactor
+
+import (
+ acm "github.com/hyperledger/burrow/account"
+ "github.com/hyperledger/burrow/account/state"
+ "github.com/hyperledger/burrow/crypto"
+ "github.com/hyperledger/burrow/execution"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/hyperledger/burrow/execution/pbtransactor"
+ "github.com/hyperledger/burrow/txs"
+ "golang.org/x/net/context"
+)
+
+type transactorServer struct {
+ transactor *execution.Transactor
+ accounts *execution.Accounts
+ txCodec txs.Codec
+ reader state.Reader
+}
+
+func NewTransactorServer(transactor *execution.Transactor, accounts *execution.Accounts, reader state.Reader,
+ txCodec txs.Codec) pbtransactor.TransactorServer {
+ return &transactorServer{
+ transactor: transactor,
+ accounts: accounts,
+ reader: reader,
+ txCodec: txCodec,
+ }
+}
+
+func (ts *transactorServer) BroadcastTx(ctx context.Context, param *pbtransactor.TxParam) (*pbtransactor.TxReceipt, error) {
+ receipt, err := ts.transactor.BroadcastTxRaw(param.GetTx())
+ if err != nil {
+ return nil, err
+ }
+ return txReceipt(receipt), nil
+}
+
+func (ts *transactorServer) Call(ctx context.Context, param *pbtransactor.CallParam) (*pbtransactor.CallResult, error) {
+ fromAddress, err := crypto.AddressFromBytes(param.GetFrom())
+ if err != nil {
+ return nil, err
+ }
+ address, err := crypto.AddressFromBytes(param.GetAddress())
+ if err != nil {
+ return nil, err
+ }
+ call, err := ts.transactor.Call(ts.reader, fromAddress, address, param.GetData())
+ return &pbtransactor.CallResult{
+ Return: call.Return,
+ GasUsed: call.GasUsed,
+ }, nil
+}
+
+func (ts *transactorServer) CallCode(ctx context.Context, param *pbtransactor.CallCodeParam) (*pbtransactor.CallResult, error) {
+ fromAddress, err := crypto.AddressFromBytes(param.GetFrom())
+ if err != nil {
+ return nil, err
+ }
+ call, err := ts.transactor.CallCode(ts.reader, fromAddress, param.GetCode(), param.GetData())
+ return &pbtransactor.CallResult{
+ Return: call.Return,
+ GasUsed: call.GasUsed,
+ }, nil
+}
+
+func (ts *transactorServer) Transact(ctx context.Context, param *pbtransactor.TransactParam) (*pbtransactor.TxReceipt, error) {
+ inputAccount, err := ts.inputAccount(param.GetInputAccount())
+ if err != nil {
+ return nil, err
+ }
+ address, err := crypto.MaybeAddressFromBytes(param.GetAddress())
+ if err != nil {
+ return nil, err
+ }
+ receipt, err := ts.transactor.Transact(inputAccount, address, param.GetData(), param.GetGasLimit(),
+ param.GetFee())
+ if err != nil {
+ return nil, err
+ }
+ return txReceipt(receipt), nil
+}
+
+func (ts *transactorServer) TransactAndHold(ctx context.Context, param *pbtransactor.TransactParam) (*pbevents.EventDataCall, error) {
+ inputAccount, err := ts.inputAccount(param.GetInputAccount())
+ if err != nil {
+ return nil, err
+ }
+ address, err := crypto.MaybeAddressFromBytes(param.GetAddress())
+ if err != nil {
+ return nil, err
+ }
+ edt, err := ts.transactor.TransactAndHold(ctx, inputAccount, address, param.GetData(),
+ param.GetGasLimit(), param.GetFee())
+ if err != nil {
+ return nil, err
+ }
+ return pbevents.GetEventDataCall(edt), nil
+}
+
+func (ts *transactorServer) Send(ctx context.Context, param *pbtransactor.SendParam) (*pbtransactor.TxReceipt, error) {
+ inputAccount, err := ts.inputAccount(param.GetInputAccount())
+ if err != nil {
+ return nil, err
+ }
+ toAddress, err := crypto.AddressFromBytes(param.GetToAddress())
+ if err != nil {
+ return nil, err
+ }
+ receipt, err := ts.transactor.Send(inputAccount, toAddress, param.GetAmount())
+ if err != nil {
+ return nil, err
+ }
+ return txReceipt(receipt), nil
+}
+
+func (ts *transactorServer) SendAndHold(ctx context.Context, param *pbtransactor.SendParam) (*pbtransactor.TxReceipt, error) {
+ inputAccount, err := ts.inputAccount(param.GetInputAccount())
+ if err != nil {
+ return nil, err
+ }
+ toAddress, err := crypto.AddressFromBytes(param.GetToAddress())
+ if err != nil {
+ return nil, err
+ }
+ receipt, err := ts.transactor.SendAndHold(ctx, inputAccount, toAddress, param.GetAmount())
+ if err != nil {
+ return nil, err
+ }
+ return txReceipt(receipt), nil
+}
+
+func (ts *transactorServer) SignTx(ctx context.Context, param *pbtransactor.SignTxParam) (*pbtransactor.SignedTx, error) {
+ txEnv, err := ts.txCodec.DecodeTx(param.GetTx())
+ if err != nil {
+ return nil, err
+ }
+ signers, err := signersFromPrivateAccounts(param.GetPrivateAccounts())
+ if err != nil {
+ return nil, err
+ }
+ txEnvSigned, err := ts.transactor.SignTx(txEnv, signers)
+ if err != nil {
+ return nil, err
+ }
+ bs, err := ts.txCodec.EncodeTx(txEnvSigned)
+ if err != nil {
+ return nil, err
+ }
+ return &pbtransactor.SignedTx{
+ Tx: bs,
+ }, nil
+}
+
+func (ts *transactorServer) inputAccount(inAcc *pbtransactor.InputAccount) (*execution.SequentialSigningAccount, error) {
+ return ts.accounts.GetSequentialSigningAccount(inAcc.GetAddress(), inAcc.GetPrivateKey())
+}
+
+func txReceipt(receipt *txs.Receipt) *pbtransactor.TxReceipt {
+ return &pbtransactor.TxReceipt{
+ ContractAddress: receipt.ContractAddress.Bytes(),
+ CreatesContract: receipt.CreatesContract,
+ TxHash: receipt.TxHash,
+ }
+}
+
+func signersFromPrivateAccounts(privateAccounts []*pbtransactor.PrivateAccount) ([]acm.AddressableSigner, error) {
+ signers := make([]acm.AddressableSigner, len(privateAccounts))
+ var err error
+ for i, pa := range privateAccounts {
+ signers[i], err = privateAccount(pa)
+ if err != nil {
+ return nil, err
+ }
+ }
+ return signers, nil
+}
+
+func privateAccount(privateAccount *pbtransactor.PrivateAccount) (acm.PrivateAccount, error) {
+ privateKey, err := crypto.PrivateKeyFromRawBytes(privateAccount.PrivateKey, crypto.CurveTypeEd25519)
+ if err != nil {
+ return nil, err
+ }
+ publicKey := privateKey.GetPublicKey()
+ return acm.ConcretePrivateAccount{
+ Address: publicKey.Address(),
+ PrivateKey: privateKey,
+ PublicKey: publicKey,
+ }.PrivateAccount(), nil
+}
diff --git a/rpc/service.go b/rpc/service.go
index ecf7b3bc4e3d8171755922e66cd6ad65844b714b..81afee6098b3b6b0f40eb08b48f2421400e84a6a 100644
--- a/rpc/service.go
+++ b/rpc/service.go
@@ -45,18 +45,18 @@ const AccountsRingMutexCount = 100
// Base service that provides implementation for all underlying RPC methods
type Service struct {
ctx context.Context
- state state.Iterable
- nameReg names.Iterable
+ state state.IterableReader
+ nameReg names.IterableReader
mempoolAccounts *execution.Accounts
subscribable event.Subscribable
- blockchain *bcm.Blockchain
+ blockchain bcm.BlockchainInfo
transactor *execution.Transactor
nodeView *query.NodeView
logger *logging.Logger
}
-func NewService(ctx context.Context, state state.Iterable, nameReg names.Iterable,
- checker state.Reader, subscribable event.Subscribable, blockchain *bcm.Blockchain, keyClient keys.KeyClient,
+func NewService(ctx context.Context, state state.IterableReader, nameReg names.IterableReader,
+ checker state.Reader, subscribable event.Subscribable, blockchain bcm.BlockchainInfo, keyClient keys.KeyClient,
transactor *execution.Transactor, nodeView *query.NodeView, logger *logging.Logger) *Service {
return &Service{
@@ -124,7 +124,7 @@ func (s *Service) ListUnconfirmedTxs(maxTxs int) (*ResultListUnconfirmedTxs, err
}
func (s *Service) Subscribe(ctx context.Context, subscriptionID string, eventID string,
- callback func(resultEvent *ResultEvent) bool) error {
+ callback func(resultEvent *ResultEvent) (stop bool)) error {
queryBuilder := event.QueryForEventID(eventID)
s.logger.InfoMsg("Subscribing to events",
@@ -132,14 +132,14 @@ func (s *Service) Subscribe(ctx context.Context, subscriptionID string, eventID
"subscription_id", subscriptionID,
"event_id", eventID)
return event.SubscribeCallback(ctx, s.subscribable, subscriptionID, queryBuilder,
- func(message interface{}) bool {
+ func(message interface{}) (stop bool) {
resultEvent, err := NewResultEvent(eventID, message)
if err != nil {
s.logger.InfoMsg("Received event that could not be mapped to ResultEvent",
structure.ErrorKey, err,
"subscription_id", subscriptionID,
"event_id", eventID)
- return true
+ return false
}
return callback(resultEvent)
})
@@ -156,8 +156,7 @@ func (s *Service) Unsubscribe(ctx context.Context, subscriptionID string) error
}
func (s *Service) Status() (*ResultStatus, error) {
- tip := s.blockchain.Tip
- latestHeight := tip.LastBlockHeight()
+ latestHeight := s.blockchain.LastBlockHeight()
var (
latestBlockMeta *tm_types.BlockMeta
latestBlockHash []byte
@@ -246,7 +245,7 @@ func (s *Service) ListAccounts(predicate func(acm.Account) bool) (*ResultListAcc
})
return &ResultListAccounts{
- BlockHeight: s.blockchain.Tip.LastBlockHeight(),
+ BlockHeight: s.blockchain.LastBlockHeight(),
Accounts: accounts,
}, nil
}
@@ -340,7 +339,7 @@ func (s *Service) ListNames(predicate func(*names.Entry) bool) (*ResultListNames
return
})
return &ResultListNames{
- BlockHeight: s.blockchain.Tip.LastBlockHeight(),
+ BlockHeight: s.blockchain.LastBlockHeight(),
Names: nms,
}, nil
}
@@ -358,7 +357,7 @@ func (s *Service) GetBlock(height uint64) (*ResultGetBlock, error) {
// Passing 0 for maxHeight sets the upper height of the range to the current
// blockchain height.
func (s *Service) ListBlocks(minHeight, maxHeight uint64) (*ResultListBlocks, error) {
- latestHeight := s.blockchain.Tip.LastBlockHeight()
+ latestHeight := s.blockchain.LastBlockHeight()
if minHeight == 0 {
minHeight = 1
@@ -393,7 +392,7 @@ func (s *Service) ListValidators() (*ResultListValidators, error) {
return
})
return &ResultListValidators{
- BlockHeight: s.blockchain.Tip.LastBlockHeight(),
+ BlockHeight: s.blockchain.LastBlockHeight(),
BondedValidators: concreteValidators,
UnbondingValidators: nil,
}, nil
@@ -419,19 +418,3 @@ func (s *Service) GeneratePrivateAccount() (*ResultGeneratePrivateAccount, error
PrivateAccount: acm.AsConcretePrivateAccount(privateAccount),
}, nil
}
-
-// Gets signing account from onr of private key or address - failing if both are provided
-func (s *Service) SigningAccount(address, privateKey []byte) (*execution.SequentialSigningAccount, error) {
- if len(address) > 0 {
- if len(privateKey) > 0 {
- return nil, fmt.Errorf("privKey and address provided but only one or the other should be given")
- }
- address, err := crypto.AddressFromBytes(address)
- if err != nil {
- return nil, err
- }
- return s.MempoolAccounts().SequentialSigningAccount(address)
- }
-
- return s.mempoolAccounts.SequentialSigningAccountFromPrivateKey(privateKey)
-}
diff --git a/rpc/v0/subscriptions.go b/rpc/subscriptions.go
similarity index 85%
rename from rpc/v0/subscriptions.go
rename to rpc/subscriptions.go
index 74fff345ab2df6d98307bb5fa148b221434ac05f..35808890bcf78067304934bd41c0d7015bd82fda 100644
--- a/rpc/v0/subscriptions.go
+++ b/rpc/subscriptions.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package v0
+package rpc
import (
"context"
@@ -21,7 +21,6 @@ import (
"time"
"github.com/hyperledger/burrow/event"
- "github.com/hyperledger/burrow/rpc"
)
var (
@@ -32,7 +31,7 @@ var (
// Catches events that callers subscribe to and adds them to an array ready to be polled.
type Subscriptions struct {
mtx *sync.RWMutex
- service *rpc.Service
+ service *Service
subs map[string]*SubscriptionsCache
reap bool
}
@@ -41,10 +40,10 @@ type SubscriptionsCache struct {
mtx *sync.Mutex
events []interface{}
ts time.Time
- subId string
+ subID string
}
-func NewSubscriptions(service *rpc.Service) *Subscriptions {
+func NewSubscriptions(service *Service) *Subscriptions {
es := &Subscriptions{
mtx: &sync.RWMutex{},
service: service,
@@ -57,12 +56,12 @@ func NewSubscriptions(service *rpc.Service) *Subscriptions {
return es
}
-func newSubscriptionsCache() *SubscriptionsCache {
+func newSubscriptionsCache(subID string) *SubscriptionsCache {
return &SubscriptionsCache{
- &sync.Mutex{},
- make([]interface{}, 0),
- time.Now(),
- "",
+ subID: subID,
+ mtx: &sync.Mutex{},
+ events: make([]interface{}, 0),
+ ts: time.Now(),
}
}
@@ -101,26 +100,26 @@ func reap(es *Subscriptions) {
// happen it's for an insignificant amount of time (the time it takes to
// carry out SubscriptionsCache.poll() ).
func (subs *Subscriptions) Add(eventId string) (string, error) {
- subId, err := event.GenerateSubscriptionID()
+ subID, err := event.GenerateSubscriptionID()
if err != nil {
return "", err
}
- cache := newSubscriptionsCache()
- err = subs.service.Subscribe(context.Background(), subId, eventId, func(resultEvent *rpc.ResultEvent) bool {
+ subs.mtx.Lock()
+ defer subs.mtx.Unlock()
+ cache := newSubscriptionsCache(subID)
+ subs.subs[subID] = cache
+
+ err = subs.service.Subscribe(context.Background(), subID, eventId, func(resultEvent *ResultEvent) (stop bool) {
cache.mtx.Lock()
defer cache.mtx.Unlock()
cache.events = append(cache.events, resultEvent)
- return true
+ return
})
if err != nil {
return "", err
}
- cache.subId = subId
- subs.mtx.Lock()
- defer subs.mtx.Unlock()
- subs.subs[subId] = cache
- return subId, nil
+ return subID, nil
}
func (subs *Subscriptions) Poll(subId string) ([]interface{}, error) {
diff --git a/rpc/v0/subscriptions_test.go b/rpc/subscriptions_test.go
similarity index 92%
rename from rpc/v0/subscriptions_test.go
rename to rpc/subscriptions_test.go
index 96be266f7032972ec8b266c262c850284929506b..fa67f6cf706636ccfd40b0abfb9f6b468a00c02a 100644
--- a/rpc/v0/subscriptions_test.go
+++ b/rpc/subscriptions_test.go
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-package v0
+package rpc
import (
"encoding/hex"
@@ -22,7 +22,6 @@ import (
"github.com/hyperledger/burrow/event"
"github.com/hyperledger/burrow/logging"
- "github.com/hyperledger/burrow/rpc"
"github.com/stretchr/testify/assert"
)
@@ -35,7 +34,7 @@ func TestSubReaping(t *testing.T) {
reaperPeriod = 100 * time.Millisecond
mee := event.NewEmitter(logging.NewNoopLogger())
- eSubs := NewSubscriptions(rpc.NewSubscribableService(mee, logging.NewNoopLogger()))
+ eSubs := NewSubscriptions(NewSubscribableService(mee, logging.NewNoopLogger()))
doneChan := make(chan error)
go func() {
for i := 0; i < NUM_SUBS; i++ {
@@ -79,7 +78,7 @@ func TestSubManualClose(t *testing.T) {
reaperPeriod = 10000 * time.Millisecond
mee := event.NewEmitter(logging.NewNoopLogger())
- eSubs := NewSubscriptions(rpc.NewSubscribableService(mee, logging.NewNoopLogger()))
+ eSubs := NewSubscriptions(NewSubscribableService(mee, logging.NewNoopLogger()))
doneChan := make(chan error)
go func() {
for i := 0; i < NUM_SUBS; i++ {
@@ -127,7 +126,7 @@ func TestSubFlooding(t *testing.T) {
// Crank it up. Now pressure is 10 times higher on each sub.
mockInterval = 1 * time.Millisecond
mee := event.NewEmitter(logging.NewNoopLogger())
- eSubs := NewSubscriptions(rpc.NewSubscribableService(mee, logging.NewNoopLogger()))
+ eSubs := NewSubscriptions(NewSubscribableService(mee, logging.NewNoopLogger()))
doneChan := make(chan error)
go func() {
for i := 0; i < NUM_SUBS; i++ {
diff --git a/rpc/test/helpers.go b/rpc/test/helpers.go
new file mode 100644
index 0000000000000000000000000000000000000000..b04a6e27744bbb502cefbd19ad146772625e480b
--- /dev/null
+++ b/rpc/test/helpers.go
@@ -0,0 +1,60 @@
+package test
+
+import (
+ "context"
+ "testing"
+
+ "github.com/hyperledger/burrow/consensus/tendermint"
+ "github.com/hyperledger/burrow/event"
+ "github.com/hyperledger/burrow/execution/events/pbevents"
+ "github.com/hyperledger/burrow/execution/pbtransactor"
+ "github.com/hyperledger/burrow/rpc"
+ "github.com/stretchr/testify/require"
+ "google.golang.org/grpc"
+)
+
+// Helpers
+func NewTransactorClient(t testing.TB) pbtransactor.TransactorClient {
+ conn, err := grpc.Dial(rpc.DefaultGRPCConfig().ListenAddress, grpc.WithInsecure())
+ require.NoError(t, err)
+ return pbtransactor.NewTransactorClient(conn)
+}
+
+func NewExecutionEventsClient(t testing.TB) pbevents.ExecutionEventsClient {
+ conn, err := grpc.Dial(rpc.DefaultGRPCConfig().ListenAddress, grpc.WithInsecure())
+ require.NoError(t, err)
+ return pbevents.NewExecutionEventsClient(conn)
+}
+
+func NewEventsClient(t testing.TB) pbevents.EventsClient {
+ conn, err := grpc.Dial(rpc.DefaultGRPCConfig().ListenAddress, grpc.WithInsecure())
+ require.NoError(t, err)
+ return pbevents.NewEventsClient(conn)
+}
+
+func CommittedTxCount(t *testing.T, em event.Emitter) chan int {
+ var numTxs int64
+ emptyBlocks := 0
+ maxEmptyBlocks := 2
+ outCh := make(chan int)
+ ctx := context.Background()
+ ch, err := tendermint.SubscribeNewBlock(ctx, em)
+ require.NoError(t, err)
+
+ go func() {
+ for ed := range ch {
+ if ed.Block.NumTxs == 0 {
+ emptyBlocks++
+ } else {
+ emptyBlocks = 0
+ }
+ if emptyBlocks > maxEmptyBlocks {
+ break
+ }
+ numTxs += ed.Block.NumTxs
+ t.Logf("Total TXs committed at block %v: %v (+%v)\n", ed.Block.Height, numTxs, ed.Block.NumTxs)
+ }
+ outCh <- int(numTxs)
+ }()
+ return outCh
+}
diff --git a/rpc/burrow/integration/strange_loop.go b/rpc/test/strange_loop.go
similarity index 94%
rename from rpc/burrow/integration/strange_loop.go
rename to rpc/test/strange_loop.go
index f8137df9465c72ab725616c6463092a4006d9db0..7d30938f339d3055d1fe968918fe4e6a871c0e17 100644
--- a/rpc/burrow/integration/strange_loop.go
+++ b/rpc/test/strange_loop.go
@@ -1,3 +1,3 @@
-package integration
+package test
-const strangeLoopBytecode = "60606040526017600055602260015560116002556001600360006101000a81548160ff021916908315150217905550341561003957600080fd5b6102c9806100486000396000f300606060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063ebb384dd14610046575b600080fd5b341561005157600080fd5b61005961006f565b6040518082815260200191505060405180910390f35b60006002549050600360009054906101000a900460ff16156101cf57600154600254121561012e5760026000815480929190600101919050555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b151561011157600080fd5b5af1151561011e57600080fd5b50505060405180519050506101ca565b6000600360006101000a81548160ff02191690831515021790555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b15156101b157600080fd5b5af115156101be57600080fd5b50505060405180519050505b610299565b6000546002541315610273576002600081548092919060019003919050555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b151561025657600080fd5b5af1151561026357600080fd5b5050506040518051905050610298565b6001600360006101000a81548160ff021916908315150217905550600254905061029a565b5b5b905600a165627a7a7230582071446a8de59540361bd59bb4f5a84f884006f53e50c1c89d2bfbdb72f92fd4700029"
+const StrangeLoopByteCode = "60606040526017600055602260015560116002556001600360006101000a81548160ff021916908315150217905550341561003957600080fd5b6102c9806100486000396000f300606060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063ebb384dd14610046575b600080fd5b341561005157600080fd5b61005961006f565b6040518082815260200191505060405180910390f35b60006002549050600360009054906101000a900460ff16156101cf57600154600254121561012e5760026000815480929190600101919050555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b151561011157600080fd5b5af1151561011e57600080fd5b50505060405180519050506101ca565b6000600360006101000a81548160ff02191690831515021790555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b15156101b157600080fd5b5af115156101be57600080fd5b50505060405180519050505b610299565b6000546002541315610273576002600081548092919060019003919050555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b151561025657600080fd5b5af1151561026357600080fd5b5050506040518051905050610298565b6001600360006101000a81548160ff021916908315150217905550600254905061029a565b5b5b905600a165627a7a7230582071446a8de59540361bd59bb4f5a84f884006f53e50c1c89d2bfbdb72f92fd4700029"
diff --git a/rpc/burrow/integration/strange_loop.sh b/rpc/test/strange_loop.sh
similarity index 100%
rename from rpc/burrow/integration/strange_loop.sh
rename to rpc/test/strange_loop.sh
diff --git a/rpc/burrow/integration/strange_loop.sol b/rpc/test/strange_loop.sol
similarity index 100%
rename from rpc/burrow/integration/strange_loop.sol
rename to rpc/test/strange_loop.sol
diff --git a/rpc/tm/integration/client_test.go b/rpc/tm/integration/server_test.go
similarity index 99%
rename from rpc/tm/integration/client_test.go
rename to rpc/tm/integration/server_test.go
index 260cb82926a763d7ef00466e8352bf1c608589dc..b30a66ec13da1107732b75f8d97337f858827e90 100644
--- a/rpc/tm/integration/client_test.go
+++ b/rpc/tm/integration/server_test.go
@@ -200,7 +200,7 @@ func TestNameReg(t *testing.T) {
},
func(eventID string, resultEvent *rpc.ResultEvent) (bool, error) {
- eventDataTx := resultEvent.EventDataTx
+ eventDataTx := resultEvent.Execution.GetTx()
assert.NotNil(t, eventDataTx, "could not convert %s to EventDataTx", resultEvent)
tx, ok := eventDataTx.Tx.Payload.(*payload.NameTx)
if !ok {
diff --git a/rpc/tm/integration/websocket_client_test.go b/rpc/tm/integration/websocket_client_test.go
index 19ab475388e08153cc6049692e550519c25aadac..2c996ac1ec956a4745d80e535117a2b572334a89 100644
--- a/rpc/tm/integration/websocket_client_test.go
+++ b/rpc/tm/integration/websocket_client_test.go
@@ -24,15 +24,14 @@ import (
"time"
"github.com/hyperledger/burrow/crypto"
- exe_events "github.com/hyperledger/burrow/execution/events"
- evm_events "github.com/hyperledger/burrow/execution/evm/events"
+ "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/rpc"
- tm_client "github.com/hyperledger/burrow/rpc/tm/client"
+ tmClient "github.com/hyperledger/burrow/rpc/tm/client"
"github.com/hyperledger/burrow/txs"
"github.com/hyperledger/burrow/txs/payload"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
- tm_types "github.com/tendermint/tendermint/types"
+ tmTypes "github.com/tendermint/tendermint/types"
)
//--------------------------------------------------------------------------------
@@ -47,7 +46,7 @@ func TestWSConnect(t *testing.T) {
// receive a new block message
func TestWSNewBlock(t *testing.T) {
wsc := newWSClient()
- eid := tm_types.EventNewBlock
+ eid := tmTypes.EventNewBlock
subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
unsubscribe(t, wsc, subId)
@@ -66,7 +65,7 @@ func TestWSBlockchainGrowth(t *testing.T) {
t.Skip("skipping test in short mode.")
}
wsc := newWSClient()
- eid := tm_types.EventNewBlock
+ eid := tmTypes.EventNewBlock
subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
unsubscribe(t, wsc, subId)
@@ -100,8 +99,8 @@ func TestWSSend(t *testing.T) {
wsc := newWSClient()
toAddr := privateAccounts[1].Address()
amt := uint64(100)
- eidInput := exe_events.EventStringAccountInput(privateAccounts[0].Address())
- eidOutput := exe_events.EventStringAccountOutput(toAddr)
+ eidInput := events.EventStringAccountInput(privateAccounts[0].Address())
+ eidOutput := events.EventStringAccountOutput(toAddr)
subIdInput := subscribeAndGetSubscriptionId(t, wsc, eidInput)
subIdOutput := subscribeAndGetSubscriptionId(t, wsc, eidOutput)
defer func() {
@@ -114,7 +113,7 @@ func TestWSSend(t *testing.T) {
broadcastTx(t, jsonRpcClient, tx)
// Set of response IDs we expect
- rids := map[string]struct{}{tm_client.EventResponseID(eidInput): {}, tm_client.EventResponseID(eidOutput): {}}
+ rids := map[string]struct{}{tmClient.EventResponseID(eidInput): {}, tmClient.EventResponseID(eidOutput): {}}
r := <-wsc.ResponsesCh
result, err := readResponse(r)
@@ -138,7 +137,7 @@ func TestWSDoubleFire(t *testing.T) {
t.Skip("skipping test in short mode.")
}
wsc := newWSClient()
- eid := exe_events.EventStringAccountInput(privateAccounts[0].Address())
+ eid := events.EventStringAccountInput(privateAccounts[0].Address())
subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer func() {
unsubscribe(t, wsc, subId)
@@ -173,7 +172,7 @@ func TestWSCallWait(t *testing.T) {
amt, gasLim, fee := uint64(10000), uint64(1000), uint64(1000)
code, returnCode, returnVal := simpleContract()
var contractAddr crypto.Address
- eid1 := exe_events.EventStringAccountInput(privateAccounts[0].Address())
+ eid1 := events.EventStringAccountInput(privateAccounts[0].Address())
subId1 := subscribeAndGetSubscriptionId(t, wsc, eid1)
// wait for the contract to be created
waitForEvent(t, wsc, eid1, func() {
@@ -186,7 +185,7 @@ func TestWSCallWait(t *testing.T) {
// susbscribe to the new contract
amt = uint64(10001)
- eid2 := exe_events.EventStringAccountOutput(contractAddr)
+ eid2 := events.EventStringAccountOutput(contractAddr)
subId2 := subscribeAndGetSubscriptionId(t, wsc, eid2)
// get the return value from a call
data := []byte{0x1}
@@ -217,7 +216,7 @@ func TestWSCallNoWait(t *testing.T) {
// susbscribe to the new contract
amt = uint64(10001)
- eid := exe_events.EventStringAccountOutput(contractAddr)
+ eid := events.EventStringAccountOutput(contractAddr)
subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer unsubscribe(t, wsc, subId)
@@ -247,7 +246,7 @@ func TestWSCallCall(t *testing.T) {
receipt := txEnv.Tx.GenerateReceipt()
contractAddr1 := receipt.ContractAddress
// subscribe to the new contracts
- eid := evm_events.EventStringAccountCall(contractAddr1)
+ eid := events.EventStringAccountCall(contractAddr1)
subId := subscribeAndGetSubscriptionId(t, wsc, eid)
defer unsubscribe(t, wsc, subId)
@@ -285,7 +284,7 @@ func TestWSCallCall(t *testing.T) {
func TestSubscribe(t *testing.T) {
wsc := newWSClient()
var subId string
- subscribe(t, wsc, tm_types.EventNewBlock)
+ subscribe(t, wsc, tmTypes.EventNewBlock)
Subscribe:
for {
@@ -297,7 +296,7 @@ Subscribe:
require.Nil(t, response.Error)
res := new(rpc.ResultSubscribe)
require.NoError(t, json.Unmarshal(response.Result, res))
- assert.Equal(t, tm_types.EventNewBlock, res.EventID)
+ assert.Equal(t, tmTypes.EventNewBlock, res.EventID)
subId = res.SubscriptionID
break Subscribe
}
@@ -317,7 +316,7 @@ Subscribe:
case response := <-wsc.ResponsesCh:
require.Nil(t, response.Error)
- if response.ID == tm_client.EventResponseID(tm_types.EventNewBlock) {
+ if response.ID == tmClient.EventResponseID(tmTypes.EventNewBlock) {
res := new(rpc.ResultEvent)
json.Unmarshal(response.Result, res)
enb := res.Tendermint.EventDataNewBlock()
diff --git a/rpc/tm/integration/websocket_helpers.go b/rpc/tm/integration/websocket_helpers.go
index 785c9fd3afb2126eaf29741d09b2349e0c1bf9cc..6e19d8fee2f0c83328fe2c3b4cc361bc388ec010 100644
--- a/rpc/tm/integration/websocket_helpers.go
+++ b/rpc/tm/integration/websocket_helpers.go
@@ -250,7 +250,7 @@ func readResponse(r rpcTypes.RPCResponse) (*rpc.ResultEvent, error) {
//--------------------------------------------------------------------------------
func unmarshalValidateSend(amt uint64, toAddr crypto.Address, resultEvent *rpc.ResultEvent) error {
- data := resultEvent.EventDataTx
+ data := resultEvent.Execution.GetTx()
if data == nil {
return fmt.Errorf("event data %v is not EventDataTx", resultEvent)
}
@@ -274,7 +274,7 @@ func unmarshalValidateSend(amt uint64, toAddr crypto.Address, resultEvent *rpc.R
func unmarshalValidateTx(amt uint64, returnCode []byte) resultEventChecker {
return func(eventID string, resultEvent *rpc.ResultEvent) (bool, error) {
- data := resultEvent.EventDataTx
+ data := resultEvent.Execution.GetTx()
if data == nil {
return true, fmt.Errorf("event data %v is not EventDataTx", *resultEvent)
}
@@ -300,7 +300,7 @@ func unmarshalValidateTx(amt uint64, returnCode []byte) resultEventChecker {
func unmarshalValidateCall(origin crypto.Address, returnCode []byte, txid *[]byte) resultEventChecker {
return func(eventID string, resultEvent *rpc.ResultEvent) (bool, error) {
- data := resultEvent.EventDataCall
+ data := resultEvent.Execution.Call
if data == nil {
return true, fmt.Errorf("event data %v is not EventDataTx", *resultEvent)
}
@@ -314,9 +314,9 @@ func unmarshalValidateCall(origin crypto.Address, returnCode []byte, txid *[]byt
if !bytes.Equal(ret, returnCode) {
return true, fmt.Errorf("call did not return correctly. Got %x, expected %x", ret, returnCode)
}
- if !bytes.Equal(data.TxHash, *txid) {
+ if !bytes.Equal(resultEvent.Execution.Header.TxHash, *txid) {
return true, fmt.Errorf("TxIDs do not match up! Got %x, expected %x",
- data.TxHash, *txid)
+ resultEvent.Execution.Header.TxHash, *txid)
}
return true, nil
}
diff --git a/rpc/tm/methods.go b/rpc/tm/methods.go
index 25be7c08cfecd5006a83566f359d311ea6b02d02..6e892df8e645175fda3f3e5dd93f4fd57e963a6f 100644
--- a/rpc/tm/methods.go
+++ b/rpc/tm/methods.go
@@ -106,7 +106,7 @@ func GetRoutes(service *rpc.Service, logger *logging.Logger) map[string]*server.
ctx, cancel := context.WithTimeout(context.Background(), SubscriptionTimeout)
defer cancel()
- err = service.Subscribe(ctx, subscriptionID, eventID, func(resultEvent *rpc.ResultEvent) bool {
+ err = service.Subscribe(ctx, subscriptionID, eventID, func(resultEvent *rpc.ResultEvent) (stop bool) {
keepAlive := wsCtx.TryWriteRPCResponse(types.NewRPCSuccessResponse(
EventResponseID(wsCtx.Request.ID, eventID), resultEvent))
if !keepAlive {
@@ -114,7 +114,7 @@ func GetRoutes(service *rpc.Service, logger *logging.Logger) map[string]*server.
"subscription_id", subscriptionID,
"event_id", eventID)
}
- return keepAlive
+ return !keepAlive
})
if err != nil {
return nil, err
diff --git a/rpc/v0/client.go b/rpc/v0/client.go
index 5bf27c5ff14a27fd8da0456f96f5a6f8879980a2..f663a7993509daf900b8f1d4a4c7e25a4662783d 100644
--- a/rpc/v0/client.go
+++ b/rpc/v0/client.go
@@ -8,7 +8,7 @@ import (
"time"
"github.com/hyperledger/burrow/execution"
- "github.com/hyperledger/burrow/execution/evm/events"
+ "github.com/hyperledger/burrow/execution/events"
"github.com/hyperledger/burrow/rpc"
"github.com/hyperledger/burrow/txs"
)
diff --git a/rpc/v0/integration/main_test.go b/rpc/v0/integration/main_test.go
index 5a0375653533e0e49b14512aca4d1517115783fc..a83a08b5158c70bc5236c3a042e1e6ceab4eb827 100644
--- a/rpc/v0/integration/main_test.go
+++ b/rpc/v0/integration/main_test.go
@@ -28,12 +28,12 @@ import (
var privateAccounts = integration.MakePrivateAccounts(5) // make keys
var genesisDoc = integration.TestGenesisDoc(privateAccounts)
-var kernel *core.Kernel
+var kern *core.Kernel
// Needs to be in a _test.go file to be picked up
func TestMain(m *testing.M) {
- returnValue := integration.TestWrapper(privateAccounts, genesisDoc, func(kern *core.Kernel) int {
- kernel = kern
+ returnValue := integration.TestWrapper(privateAccounts, genesisDoc, func(k *core.Kernel) int {
+ kern = k
return m.Run()
})
diff --git a/rpc/v0/integration/strange_loop.go b/rpc/v0/integration/strange_loop.go
deleted file mode 100644
index f8137df9465c72ab725616c6463092a4006d9db0..0000000000000000000000000000000000000000
--- a/rpc/v0/integration/strange_loop.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package integration
-
-const strangeLoopBytecode = "60606040526017600055602260015560116002556001600360006101000a81548160ff021916908315150217905550341561003957600080fd5b6102c9806100486000396000f300606060405260043610610041576000357c0100000000000000000000000000000000000000000000000000000000900463ffffffff168063ebb384dd14610046575b600080fd5b341561005157600080fd5b61005961006f565b6040518082815260200191505060405180910390f35b60006002549050600360009054906101000a900460ff16156101cf57600154600254121561012e5760026000815480929190600101919050555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b151561011157600080fd5b5af1151561011e57600080fd5b50505060405180519050506101ca565b6000600360006101000a81548160ff02191690831515021790555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b15156101b157600080fd5b5af115156101be57600080fd5b50505060405180519050505b610299565b6000546002541315610273576002600081548092919060019003919050555060025490503073ffffffffffffffffffffffffffffffffffffffff1663ebb384dd6040518163ffffffff167c0100000000000000000000000000000000000000000000000000000000028152600401602060405180830381600087803b151561025657600080fd5b5af1151561026357600080fd5b5050506040518051905050610298565b6001600360006101000a81548160ff021916908315150217905550600254905061029a565b5b5b905600a165627a7a7230582071446a8de59540361bd59bb4f5a84f884006f53e50c1c89d2bfbdb72f92fd4700029"
diff --git a/rpc/v0/integration/strange_loop.sh b/rpc/v0/integration/strange_loop.sh
deleted file mode 100755
index d0cf04eecf86779b63ccdfb604aeee15792a52ec..0000000000000000000000000000000000000000
--- a/rpc/v0/integration/strange_loop.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
-
-echo -e "package integration\n\nconst strangeLoopBytecode = \"$(solc --bin rpc/v0/integration/strange_loop.sol | tail -1)\"" > "${script_dir}/strange_loop.go"
diff --git a/rpc/v0/integration/strange_loop.sol b/rpc/v0/integration/strange_loop.sol
deleted file mode 100644
index 2a3e07f242d5da224a6e5a9e502c8df38e308a39..0000000000000000000000000000000000000000
--- a/rpc/v0/integration/strange_loop.sol
+++ /dev/null
@@ -1,31 +0,0 @@
-pragma solidity ^0.4.16;
-
-contract StrangeLoop {
- int top = 23;
- int bottom = 34;
- int depth = 17;
- bool down = true;
-
- function UpsieDownsie() public returns (int i) {
- i = depth;
- if (down) {
- if (depth < bottom) {
- depth++;
- i = depth;
- this.UpsieDownsie();
- } else {
- down = false;
- i = depth;
- this.UpsieDownsie();
- }
- } else if (depth > top) {
- depth--;
- i = depth;
- this.UpsieDownsie();
- } else {
- down = true;
- i = depth;
- return;
- }
- }
-}
\ No newline at end of file
diff --git a/rpc/v0/integration/v0_test.go b/rpc/v0/integration/v0_test.go
index 55590ff15dde438b381f5f5ff2e203388e4257de..484e9dd9788c56347bcbb2db1f49ed39769609aa 100644
--- a/rpc/v0/integration/v0_test.go
+++ b/rpc/v0/integration/v0_test.go
@@ -18,19 +18,16 @@
package integration
import (
- "context"
"encoding/hex"
- "fmt"
"sync"
"testing"
"github.com/hyperledger/burrow/binary"
- "github.com/hyperledger/burrow/consensus/tendermint"
"github.com/hyperledger/burrow/execution/evm/abi"
+ "github.com/hyperledger/burrow/rpc/test"
"github.com/hyperledger/burrow/rpc/v0"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
- "github.com/tendermint/tendermint/types"
)
func TestTransactCallNoCode(t *testing.T) {
@@ -40,7 +37,7 @@ func TestTransactCallNoCode(t *testing.T) {
toAddress := privateAccounts[2].Address()
numCreates := 1000
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numCreates; i++ {
receipt, err := cli.Transact(v0.TransactParam{
InputAccount: inputAccount(i),
@@ -63,9 +60,9 @@ func TestTransactCreate(t *testing.T) {
wg.Add(numGoroutines)
cli := v0.NewV0Client("http://localhost:1337/rpc")
// Flip flops between sending private key and input address to test private key and address based signing
- bc, err := hex.DecodeString(strangeLoopBytecode)
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
require.NoError(t, err)
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numGoroutines; i++ {
go func() {
for j := 0; j < numCreates; j++ {
@@ -91,7 +88,7 @@ func TestTransactCreate(t *testing.T) {
func BenchmarkTransactCreateContract(b *testing.B) {
cli := v0.NewV0Client("http://localhost:1337/rpc")
- bc, err := hex.DecodeString(strangeLoopBytecode)
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
require.NoError(b, err)
for i := 0; i < b.N; i++ {
create, err := cli.Transact(v0.TransactParam{
@@ -108,12 +105,12 @@ func BenchmarkTransactCreateContract(b *testing.B) {
func TestTransactAndHold(t *testing.T) {
cli := v0.NewV0Client("http://localhost:1337/rpc")
- bc, err := hex.DecodeString(strangeLoopBytecode)
+ bc, err := hex.DecodeString(test.StrangeLoopByteCode)
require.NoError(t, err)
numGoroutines := 5
numRuns := 2
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numGoroutines; i++ {
for j := 0; j < numRuns; j++ {
create, err := cli.TransactAndHold(v0.TransactParam{
@@ -124,7 +121,7 @@ func TestTransactAndHold(t *testing.T) {
GasLimit: 10000,
})
require.NoError(t, err)
- assert.Equal(t, 0, create.StackDepth)
+ assert.Equal(t, uint64(0), create.StackDepth)
functionID := abi.FunctionID("UpsieDownsie()")
call, err := cli.TransactAndHold(v0.TransactParam{
InputAccount: inputAccount(i),
@@ -144,9 +141,8 @@ func TestTransactAndHold(t *testing.T) {
func TestSend(t *testing.T) {
cli := v0.NewV0Client("http://localhost:1337/rpc")
-
numSends := 1000
- countCh := committedTxCount(t)
+ countCh := test.CommittedTxCount(t, kern.Emitter)
for i := 0; i < numSends; i++ {
send, err := cli.Send(v0.SendParam{
InputAccount: inputAccount(i),
@@ -175,38 +171,6 @@ func TestSendAndHold(t *testing.T) {
// Helpers
-var committedTxCountIndex = 0
-
-func committedTxCount(t *testing.T) chan int {
- var numTxs int64
- emptyBlocks := 0
- maxEmptyBlocks := 2
- outCh := make(chan int)
- ch := make(chan *types.EventDataNewBlock)
- ctx := context.Background()
- subscriber := fmt.Sprintf("committedTxCount_%v", committedTxCountIndex)
- committedTxCountIndex++
- require.NoError(t, tendermint.SubscribeNewBlock(ctx, kernel.Emitter, subscriber, ch))
-
- go func() {
- for ed := range ch {
- if ed.Block.NumTxs == 0 {
- emptyBlocks++
- } else {
- emptyBlocks = 0
- }
- if emptyBlocks > maxEmptyBlocks {
- break
- }
- numTxs += ed.Block.NumTxs
- t.Logf("Total TXs committed at block %v: %v (+%v)\n", ed.Block.Height, numTxs, ed.Block.NumTxs)
- }
- require.NoError(t, kernel.Emitter.UnsubscribeAll(ctx, subscriber))
- outCh <- int(numTxs)
- }()
- return outCh
-}
-
var inputPrivateKey = privateAccounts[0].PrivateKey().RawBytes()
var inputAddress = privateAccounts[0].Address().Bytes()
diff --git a/rpc/v0/json_service.go b/rpc/v0/json_service.go
index 08459b7049a497636c9c96b819d9b618ae424927..bb4facea92691dd0acc07499673a955f310bf7dd 100644
--- a/rpc/v0/json_service.go
+++ b/rpc/v0/json_service.go
@@ -81,7 +81,7 @@ func (jrs *JsonRpcServer) handleFunc(c *gin.Context) {
type JSONService struct {
codec rpc.Codec
service *rpc.Service
- eventSubs *Subscriptions
+ eventSubs *rpc.Subscriptions
defaultHandlers map[string]RequestHandlerFunc
logger *logging.Logger
}
@@ -92,7 +92,7 @@ func NewJSONService(codec rpc.Codec, service *rpc.Service, logger *logging.Logge
tmhttps := &JSONService{
codec: codec,
service: service,
- eventSubs: NewSubscriptions(service),
+ eventSubs: rpc.NewSubscriptions(service),
logger: logger.WithScope("NewJSONService"),
}
diff --git a/rpc/v0/methods.go b/rpc/v0/methods.go
index 536a554f3614170b14cf91a18ad8a1763070cc15..224ce798ddc71357f2bda08322e03279ce712d9e 100644
--- a/rpc/v0/methods.go
+++ b/rpc/v0/methods.go
@@ -233,7 +233,8 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
return nil, rpc.INVALID_PARAMS, err
}
// Use mempool state so that transact can generate a run of sequence numbers when formulating transactions
- inputAccount, err := service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ inputAccount, err := service.MempoolAccounts().GetSequentialSigningAccount(param.InputAccount.Address,
+ param.InputAccount.PrivateKey)
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
@@ -253,7 +254,8 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
- inputAccount, err := service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ inputAccount, err := service.MempoolAccounts().GetSequentialSigningAccount(param.InputAccount.Address,
+ param.InputAccount.PrivateKey)
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
@@ -275,7 +277,8 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
return nil, rpc.INVALID_PARAMS, err
}
// Run Send against mempool state
- inputAccount, err := service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ inputAccount, err := service.MempoolAccounts().GetSequentialSigningAccount(param.InputAccount.Address,
+ param.InputAccount.PrivateKey)
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
@@ -296,7 +299,8 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
return nil, rpc.INVALID_PARAMS, err
}
// Run Send against mempool state
- inputAccount, err := service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ inputAccount, err := service.MempoolAccounts().GetSequentialSigningAccount(param.InputAccount.Address,
+ param.InputAccount.PrivateKey)
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
@@ -312,7 +316,8 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
- inputAccount, err := service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ inputAccount, err := service.MempoolAccounts().GetSequentialSigningAccount(param.InputAccount.Address,
+ param.InputAccount.PrivateKey)
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
diff --git a/rpc/v0/websocket_service.go b/rpc/v0/websocket_service.go
index ed75f1ce0cd0ce3bb22373468a6dcb59fbee2519..259a3f13d6e8a01900eb098cd24489503c30d616 100644
--- a/rpc/v0/websocket_service.go
+++ b/rpc/v0/websocket_service.go
@@ -137,9 +137,9 @@ func (ws *WebsocketService) EventSubscribe(request *rpc.RPCRequest,
return nil, rpc.INTERNAL_ERROR, err
}
- err = ws.service.Subscribe(context.Background(), subId, eventId, func(resultEvent *rpc.ResultEvent) bool {
+ err = ws.service.Subscribe(context.Background(), subId, eventId, func(resultEvent *rpc.ResultEvent) (stop bool) {
ws.writeResponse(subId, resultEvent, session)
- return true
+ return
})
if err != nil {
return nil, rpc.INTERNAL_ERROR, err
diff --git a/scripts/deps/bos.sh b/scripts/deps/bos.sh
index 83f969127237163fb89d6bcbe5ce09ea44940151..8adb3069550a8f745519ff95274dd962af560f93 100755
--- a/scripts/deps/bos.sh
+++ b/scripts/deps/bos.sh
@@ -2,4 +2,5 @@
# The git revision of Bosmarmot/bos we will build and install into ./bin/ for integration tests
-echo "4731b612c040e8b0ab7c6cbab3eb0b2fe0e49298"
+echo "ca5fda25977a5e445561aff2078ef398e9962cc0"
+
diff --git a/txs/amino_codec_test.go b/txs/amino_codec_test.go
index 86a90a5d028f36c57d39a6fc67adb860cda63f55..41c3e4885f691502c26641cbd907986075b76ada 100644
--- a/txs/amino_codec_test.go
+++ b/txs/amino_codec_test.go
@@ -3,8 +3,6 @@ package txs
import (
"testing"
- "fmt"
-
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/txs/payload"
@@ -80,6 +78,5 @@ func TestAminoTxEnvelope(t *testing.T) {
require.NoError(t, err)
txEnvOut, err := codec.DecodeTx(bs)
require.NoError(t, err)
- fmt.Println(txEnvOut)
assert.Equal(t, txEnv, txEnvOut)
}
diff --git a/txs/payload/payload.go b/txs/payload/payload.go
index e1c2433d621ad5576bcf775ff72d99355813defb..cc0c5e181466e3d76eeb33da2495fb0f4e0faedf 100644
--- a/txs/payload/payload.go
+++ b/txs/payload/payload.go
@@ -54,6 +54,27 @@ func init() {
}
}
+func TxTypeFromString(name string) Type {
+ return typeFromName[name]
+}
+
+func (typ Type) String() string {
+ name, ok := nameFromType[typ]
+ if ok {
+ return name
+ }
+ return "UnknownTx"
+}
+
+func (typ Type) MarshalText() ([]byte, error) {
+ return []byte(typ.String()), nil
+}
+
+func (typ *Type) UnmarshalText(data []byte) error {
+ *typ = TxTypeFromString(string(data))
+ return nil
+}
+
type Payload interface {
String() string
GetInputs() []*TxInput
@@ -77,24 +98,3 @@ func New(txType Type) Payload {
}
return nil
}
-
-func TxTypeFromString(name string) Type {
- return typeFromName[name]
-}
-
-func (typ Type) String() string {
- name, ok := nameFromType[typ]
- if ok {
- return name
- }
- return "UnknownTx"
-}
-
-func (typ Type) MarshalText() ([]byte, error) {
- return []byte(typ.String()), nil
-}
-
-func (typ *Type) UnmarshalText(data []byte) error {
- *typ = TxTypeFromString(string(data))
- return nil
-}
diff --git a/txs/tx.go b/txs/tx.go
index c80fac1a7fbe3df553521d8cd20610b2170b81d6..d099c892d1354f46c53d2c1ffd70bdcfd7d40b8d 100644
--- a/txs/tx.go
+++ b/txs/tx.go
@@ -34,12 +34,6 @@ type Tx struct {
// Wrap the Payload in Tx required for signing and serialisation
func NewTx(payload payload.Payload) *Tx {
- switch t := payload.(type) {
- case Tx:
- return &t
- case *Tx:
- return t
- }
return &Tx{
Payload: payload,
}
@@ -111,15 +105,32 @@ func (tx *Tx) UnmarshalJSON(data []byte) error {
return json.Unmarshal(w.Payload, tx.Payload)
}
+func (tx *Tx) Type() payload.Type {
+ if tx == nil {
+ return payload.TypeUnknown
+ }
+ return tx.Payload.Type()
+}
+
// Generate a Hash for this transaction based on the SignBytes. The hash is memoized over the lifetime
// of the Tx so repeated calls to Hash() are effectively free
func (tx *Tx) Hash() []byte {
+ if tx == nil {
+ return nil
+ }
if tx.txHash == nil {
return tx.Rehash()
}
return tx.txHash
}
+func (tx *Tx) String() string {
+ if tx == nil {
+ return "Tx{nil}"
+ }
+ return fmt.Sprintf("Tx{TxHash: %X; Payload: %v}", tx.Hash(), tx.Payload)
+}
+
// Regenerate the Tx hash if it has been mutated or as called by Hash() in first instance
func (tx *Tx) Rehash() []byte {
hasher := ripemd160.New()
diff --git a/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..e855b1f5c4abc0122d223e2c2705ea9a6d2d4899
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/protoc-gen-go/descriptor/descriptor.pb.go
@@ -0,0 +1,2812 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/descriptor.proto
+
+package descriptor // import "github.com/golang/protobuf/protoc-gen-go/descriptor"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type FieldDescriptorProto_Type int32
+
+const (
+ // 0 is reserved for errors.
+ // Order is weird for historical reasons.
+ FieldDescriptorProto_TYPE_DOUBLE FieldDescriptorProto_Type = 1
+ FieldDescriptorProto_TYPE_FLOAT FieldDescriptorProto_Type = 2
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT64 if
+ // negative values are likely.
+ FieldDescriptorProto_TYPE_INT64 FieldDescriptorProto_Type = 3
+ FieldDescriptorProto_TYPE_UINT64 FieldDescriptorProto_Type = 4
+ // Not ZigZag encoded. Negative numbers take 10 bytes. Use TYPE_SINT32 if
+ // negative values are likely.
+ FieldDescriptorProto_TYPE_INT32 FieldDescriptorProto_Type = 5
+ FieldDescriptorProto_TYPE_FIXED64 FieldDescriptorProto_Type = 6
+ FieldDescriptorProto_TYPE_FIXED32 FieldDescriptorProto_Type = 7
+ FieldDescriptorProto_TYPE_BOOL FieldDescriptorProto_Type = 8
+ FieldDescriptorProto_TYPE_STRING FieldDescriptorProto_Type = 9
+ // Tag-delimited aggregate.
+ // Group type is deprecated and not supported in proto3. However, Proto3
+ // implementations should still be able to parse the group wire format and
+ // treat group fields as unknown fields.
+ FieldDescriptorProto_TYPE_GROUP FieldDescriptorProto_Type = 10
+ FieldDescriptorProto_TYPE_MESSAGE FieldDescriptorProto_Type = 11
+ // New in version 2.
+ FieldDescriptorProto_TYPE_BYTES FieldDescriptorProto_Type = 12
+ FieldDescriptorProto_TYPE_UINT32 FieldDescriptorProto_Type = 13
+ FieldDescriptorProto_TYPE_ENUM FieldDescriptorProto_Type = 14
+ FieldDescriptorProto_TYPE_SFIXED32 FieldDescriptorProto_Type = 15
+ FieldDescriptorProto_TYPE_SFIXED64 FieldDescriptorProto_Type = 16
+ FieldDescriptorProto_TYPE_SINT32 FieldDescriptorProto_Type = 17
+ FieldDescriptorProto_TYPE_SINT64 FieldDescriptorProto_Type = 18
+)
+
+var FieldDescriptorProto_Type_name = map[int32]string{
+ 1: "TYPE_DOUBLE",
+ 2: "TYPE_FLOAT",
+ 3: "TYPE_INT64",
+ 4: "TYPE_UINT64",
+ 5: "TYPE_INT32",
+ 6: "TYPE_FIXED64",
+ 7: "TYPE_FIXED32",
+ 8: "TYPE_BOOL",
+ 9: "TYPE_STRING",
+ 10: "TYPE_GROUP",
+ 11: "TYPE_MESSAGE",
+ 12: "TYPE_BYTES",
+ 13: "TYPE_UINT32",
+ 14: "TYPE_ENUM",
+ 15: "TYPE_SFIXED32",
+ 16: "TYPE_SFIXED64",
+ 17: "TYPE_SINT32",
+ 18: "TYPE_SINT64",
+}
+var FieldDescriptorProto_Type_value = map[string]int32{
+ "TYPE_DOUBLE": 1,
+ "TYPE_FLOAT": 2,
+ "TYPE_INT64": 3,
+ "TYPE_UINT64": 4,
+ "TYPE_INT32": 5,
+ "TYPE_FIXED64": 6,
+ "TYPE_FIXED32": 7,
+ "TYPE_BOOL": 8,
+ "TYPE_STRING": 9,
+ "TYPE_GROUP": 10,
+ "TYPE_MESSAGE": 11,
+ "TYPE_BYTES": 12,
+ "TYPE_UINT32": 13,
+ "TYPE_ENUM": 14,
+ "TYPE_SFIXED32": 15,
+ "TYPE_SFIXED64": 16,
+ "TYPE_SINT32": 17,
+ "TYPE_SINT64": 18,
+}
+
+func (x FieldDescriptorProto_Type) Enum() *FieldDescriptorProto_Type {
+ p := new(FieldDescriptorProto_Type)
+ *p = x
+ return p
+}
+func (x FieldDescriptorProto_Type) String() string {
+ return proto.EnumName(FieldDescriptorProto_Type_name, int32(x))
+}
+func (x *FieldDescriptorProto_Type) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Type_value, data, "FieldDescriptorProto_Type")
+ if err != nil {
+ return err
+ }
+ *x = FieldDescriptorProto_Type(value)
+ return nil
+}
+func (FieldDescriptorProto_Type) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4, 0}
+}
+
+type FieldDescriptorProto_Label int32
+
+const (
+ // 0 is reserved for errors
+ FieldDescriptorProto_LABEL_OPTIONAL FieldDescriptorProto_Label = 1
+ FieldDescriptorProto_LABEL_REQUIRED FieldDescriptorProto_Label = 2
+ FieldDescriptorProto_LABEL_REPEATED FieldDescriptorProto_Label = 3
+)
+
+var FieldDescriptorProto_Label_name = map[int32]string{
+ 1: "LABEL_OPTIONAL",
+ 2: "LABEL_REQUIRED",
+ 3: "LABEL_REPEATED",
+}
+var FieldDescriptorProto_Label_value = map[string]int32{
+ "LABEL_OPTIONAL": 1,
+ "LABEL_REQUIRED": 2,
+ "LABEL_REPEATED": 3,
+}
+
+func (x FieldDescriptorProto_Label) Enum() *FieldDescriptorProto_Label {
+ p := new(FieldDescriptorProto_Label)
+ *p = x
+ return p
+}
+func (x FieldDescriptorProto_Label) String() string {
+ return proto.EnumName(FieldDescriptorProto_Label_name, int32(x))
+}
+func (x *FieldDescriptorProto_Label) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldDescriptorProto_Label_value, data, "FieldDescriptorProto_Label")
+ if err != nil {
+ return err
+ }
+ *x = FieldDescriptorProto_Label(value)
+ return nil
+}
+func (FieldDescriptorProto_Label) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4, 1}
+}
+
+// Generated classes can be optimized for speed or code size.
+type FileOptions_OptimizeMode int32
+
+const (
+ FileOptions_SPEED FileOptions_OptimizeMode = 1
+ // etc.
+ FileOptions_CODE_SIZE FileOptions_OptimizeMode = 2
+ FileOptions_LITE_RUNTIME FileOptions_OptimizeMode = 3
+)
+
+var FileOptions_OptimizeMode_name = map[int32]string{
+ 1: "SPEED",
+ 2: "CODE_SIZE",
+ 3: "LITE_RUNTIME",
+}
+var FileOptions_OptimizeMode_value = map[string]int32{
+ "SPEED": 1,
+ "CODE_SIZE": 2,
+ "LITE_RUNTIME": 3,
+}
+
+func (x FileOptions_OptimizeMode) Enum() *FileOptions_OptimizeMode {
+ p := new(FileOptions_OptimizeMode)
+ *p = x
+ return p
+}
+func (x FileOptions_OptimizeMode) String() string {
+ return proto.EnumName(FileOptions_OptimizeMode_name, int32(x))
+}
+func (x *FileOptions_OptimizeMode) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FileOptions_OptimizeMode_value, data, "FileOptions_OptimizeMode")
+ if err != nil {
+ return err
+ }
+ *x = FileOptions_OptimizeMode(value)
+ return nil
+}
+func (FileOptions_OptimizeMode) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{10, 0}
+}
+
+type FieldOptions_CType int32
+
+const (
+ // Default mode.
+ FieldOptions_STRING FieldOptions_CType = 0
+ FieldOptions_CORD FieldOptions_CType = 1
+ FieldOptions_STRING_PIECE FieldOptions_CType = 2
+)
+
+var FieldOptions_CType_name = map[int32]string{
+ 0: "STRING",
+ 1: "CORD",
+ 2: "STRING_PIECE",
+}
+var FieldOptions_CType_value = map[string]int32{
+ "STRING": 0,
+ "CORD": 1,
+ "STRING_PIECE": 2,
+}
+
+func (x FieldOptions_CType) Enum() *FieldOptions_CType {
+ p := new(FieldOptions_CType)
+ *p = x
+ return p
+}
+func (x FieldOptions_CType) String() string {
+ return proto.EnumName(FieldOptions_CType_name, int32(x))
+}
+func (x *FieldOptions_CType) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldOptions_CType_value, data, "FieldOptions_CType")
+ if err != nil {
+ return err
+ }
+ *x = FieldOptions_CType(value)
+ return nil
+}
+func (FieldOptions_CType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12, 0}
+}
+
+type FieldOptions_JSType int32
+
+const (
+ // Use the default type.
+ FieldOptions_JS_NORMAL FieldOptions_JSType = 0
+ // Use JavaScript strings.
+ FieldOptions_JS_STRING FieldOptions_JSType = 1
+ // Use JavaScript numbers.
+ FieldOptions_JS_NUMBER FieldOptions_JSType = 2
+)
+
+var FieldOptions_JSType_name = map[int32]string{
+ 0: "JS_NORMAL",
+ 1: "JS_STRING",
+ 2: "JS_NUMBER",
+}
+var FieldOptions_JSType_value = map[string]int32{
+ "JS_NORMAL": 0,
+ "JS_STRING": 1,
+ "JS_NUMBER": 2,
+}
+
+func (x FieldOptions_JSType) Enum() *FieldOptions_JSType {
+ p := new(FieldOptions_JSType)
+ *p = x
+ return p
+}
+func (x FieldOptions_JSType) String() string {
+ return proto.EnumName(FieldOptions_JSType_name, int32(x))
+}
+func (x *FieldOptions_JSType) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(FieldOptions_JSType_value, data, "FieldOptions_JSType")
+ if err != nil {
+ return err
+ }
+ *x = FieldOptions_JSType(value)
+ return nil
+}
+func (FieldOptions_JSType) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12, 1}
+}
+
+// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
+// or neither? HTTP based RPC implementation may choose GET verb for safe
+// methods, and PUT verb for idempotent methods instead of the default POST.
+type MethodOptions_IdempotencyLevel int32
+
+const (
+ MethodOptions_IDEMPOTENCY_UNKNOWN MethodOptions_IdempotencyLevel = 0
+ MethodOptions_NO_SIDE_EFFECTS MethodOptions_IdempotencyLevel = 1
+ MethodOptions_IDEMPOTENT MethodOptions_IdempotencyLevel = 2
+)
+
+var MethodOptions_IdempotencyLevel_name = map[int32]string{
+ 0: "IDEMPOTENCY_UNKNOWN",
+ 1: "NO_SIDE_EFFECTS",
+ 2: "IDEMPOTENT",
+}
+var MethodOptions_IdempotencyLevel_value = map[string]int32{
+ "IDEMPOTENCY_UNKNOWN": 0,
+ "NO_SIDE_EFFECTS": 1,
+ "IDEMPOTENT": 2,
+}
+
+func (x MethodOptions_IdempotencyLevel) Enum() *MethodOptions_IdempotencyLevel {
+ p := new(MethodOptions_IdempotencyLevel)
+ *p = x
+ return p
+}
+func (x MethodOptions_IdempotencyLevel) String() string {
+ return proto.EnumName(MethodOptions_IdempotencyLevel_name, int32(x))
+}
+func (x *MethodOptions_IdempotencyLevel) UnmarshalJSON(data []byte) error {
+ value, err := proto.UnmarshalJSONEnum(MethodOptions_IdempotencyLevel_value, data, "MethodOptions_IdempotencyLevel")
+ if err != nil {
+ return err
+ }
+ *x = MethodOptions_IdempotencyLevel(value)
+ return nil
+}
+func (MethodOptions_IdempotencyLevel) EnumDescriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{17, 0}
+}
+
+// The protocol compiler can output a FileDescriptorSet containing the .proto
+// files it parses.
+type FileDescriptorSet struct {
+ File []*FileDescriptorProto `protobuf:"bytes,1,rep,name=file" json:"file,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileDescriptorSet) Reset() { *m = FileDescriptorSet{} }
+func (m *FileDescriptorSet) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorSet) ProtoMessage() {}
+func (*FileDescriptorSet) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{0}
+}
+func (m *FileDescriptorSet) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileDescriptorSet.Unmarshal(m, b)
+}
+func (m *FileDescriptorSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileDescriptorSet.Marshal(b, m, deterministic)
+}
+func (dst *FileDescriptorSet) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileDescriptorSet.Merge(dst, src)
+}
+func (m *FileDescriptorSet) XXX_Size() int {
+ return xxx_messageInfo_FileDescriptorSet.Size(m)
+}
+func (m *FileDescriptorSet) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileDescriptorSet.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorSet proto.InternalMessageInfo
+
+func (m *FileDescriptorSet) GetFile() []*FileDescriptorProto {
+ if m != nil {
+ return m.File
+ }
+ return nil
+}
+
+// Describes a complete .proto file.
+type FileDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Package *string `protobuf:"bytes,2,opt,name=package" json:"package,omitempty"`
+ // Names of files imported by this file.
+ Dependency []string `protobuf:"bytes,3,rep,name=dependency" json:"dependency,omitempty"`
+ // Indexes of the public imported files in the dependency list above.
+ PublicDependency []int32 `protobuf:"varint,10,rep,name=public_dependency,json=publicDependency" json:"public_dependency,omitempty"`
+ // Indexes of the weak imported files in the dependency list.
+ // For Google-internal migration only. Do not use.
+ WeakDependency []int32 `protobuf:"varint,11,rep,name=weak_dependency,json=weakDependency" json:"weak_dependency,omitempty"`
+ // All top-level definitions in this file.
+ MessageType []*DescriptorProto `protobuf:"bytes,4,rep,name=message_type,json=messageType" json:"message_type,omitempty"`
+ EnumType []*EnumDescriptorProto `protobuf:"bytes,5,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+ Service []*ServiceDescriptorProto `protobuf:"bytes,6,rep,name=service" json:"service,omitempty"`
+ Extension []*FieldDescriptorProto `protobuf:"bytes,7,rep,name=extension" json:"extension,omitempty"`
+ Options *FileOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+ // This field contains optional information about the original source code.
+ // You may safely remove this entire field without harming runtime
+ // functionality of the descriptors -- the information is needed only by
+ // development tools.
+ SourceCodeInfo *SourceCodeInfo `protobuf:"bytes,9,opt,name=source_code_info,json=sourceCodeInfo" json:"source_code_info,omitempty"`
+ // The syntax of the proto file.
+ // The supported values are "proto2" and "proto3".
+ Syntax *string `protobuf:"bytes,12,opt,name=syntax" json:"syntax,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileDescriptorProto) Reset() { *m = FileDescriptorProto{} }
+func (m *FileDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorProto) ProtoMessage() {}
+func (*FileDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{1}
+}
+func (m *FileDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileDescriptorProto.Unmarshal(m, b)
+}
+func (m *FileDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *FileDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileDescriptorProto.Merge(dst, src)
+}
+func (m *FileDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_FileDescriptorProto.Size(m)
+}
+func (m *FileDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorProto proto.InternalMessageInfo
+
+func (m *FileDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *FileDescriptorProto) GetPackage() string {
+ if m != nil && m.Package != nil {
+ return *m.Package
+ }
+ return ""
+}
+
+func (m *FileDescriptorProto) GetDependency() []string {
+ if m != nil {
+ return m.Dependency
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetPublicDependency() []int32 {
+ if m != nil {
+ return m.PublicDependency
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetWeakDependency() []int32 {
+ if m != nil {
+ return m.WeakDependency
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetMessageType() []*DescriptorProto {
+ if m != nil {
+ return m.MessageType
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetEnumType() []*EnumDescriptorProto {
+ if m != nil {
+ return m.EnumType
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetService() []*ServiceDescriptorProto {
+ if m != nil {
+ return m.Service
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetExtension() []*FieldDescriptorProto {
+ if m != nil {
+ return m.Extension
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetOptions() *FileOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetSourceCodeInfo() *SourceCodeInfo {
+ if m != nil {
+ return m.SourceCodeInfo
+ }
+ return nil
+}
+
+func (m *FileDescriptorProto) GetSyntax() string {
+ if m != nil && m.Syntax != nil {
+ return *m.Syntax
+ }
+ return ""
+}
+
+// Describes a message type.
+type DescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Field []*FieldDescriptorProto `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
+ Extension []*FieldDescriptorProto `protobuf:"bytes,6,rep,name=extension" json:"extension,omitempty"`
+ NestedType []*DescriptorProto `protobuf:"bytes,3,rep,name=nested_type,json=nestedType" json:"nested_type,omitempty"`
+ EnumType []*EnumDescriptorProto `protobuf:"bytes,4,rep,name=enum_type,json=enumType" json:"enum_type,omitempty"`
+ ExtensionRange []*DescriptorProto_ExtensionRange `protobuf:"bytes,5,rep,name=extension_range,json=extensionRange" json:"extension_range,omitempty"`
+ OneofDecl []*OneofDescriptorProto `protobuf:"bytes,8,rep,name=oneof_decl,json=oneofDecl" json:"oneof_decl,omitempty"`
+ Options *MessageOptions `protobuf:"bytes,7,opt,name=options" json:"options,omitempty"`
+ ReservedRange []*DescriptorProto_ReservedRange `protobuf:"bytes,9,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+ // Reserved field names, which may not be used by fields in the same message.
+ // A given name may only be reserved once.
+ ReservedName []string `protobuf:"bytes,10,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DescriptorProto) Reset() { *m = DescriptorProto{} }
+func (m *DescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto) ProtoMessage() {}
+func (*DescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2}
+}
+func (m *DescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_DescriptorProto.Unmarshal(m, b)
+}
+func (m *DescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_DescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *DescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DescriptorProto.Merge(dst, src)
+}
+func (m *DescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_DescriptorProto.Size(m)
+}
+func (m *DescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_DescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto proto.InternalMessageInfo
+
+func (m *DescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *DescriptorProto) GetField() []*FieldDescriptorProto {
+ if m != nil {
+ return m.Field
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetExtension() []*FieldDescriptorProto {
+ if m != nil {
+ return m.Extension
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetNestedType() []*DescriptorProto {
+ if m != nil {
+ return m.NestedType
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetEnumType() []*EnumDescriptorProto {
+ if m != nil {
+ return m.EnumType
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetExtensionRange() []*DescriptorProto_ExtensionRange {
+ if m != nil {
+ return m.ExtensionRange
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetOneofDecl() []*OneofDescriptorProto {
+ if m != nil {
+ return m.OneofDecl
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetOptions() *MessageOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetReservedRange() []*DescriptorProto_ReservedRange {
+ if m != nil {
+ return m.ReservedRange
+ }
+ return nil
+}
+
+func (m *DescriptorProto) GetReservedName() []string {
+ if m != nil {
+ return m.ReservedName
+ }
+ return nil
+}
+
+type DescriptorProto_ExtensionRange struct {
+ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+ Options *ExtensionRangeOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DescriptorProto_ExtensionRange) Reset() { *m = DescriptorProto_ExtensionRange{} }
+func (m *DescriptorProto_ExtensionRange) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto_ExtensionRange) ProtoMessage() {}
+func (*DescriptorProto_ExtensionRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2, 0}
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_DescriptorProto_ExtensionRange.Unmarshal(m, b)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_DescriptorProto_ExtensionRange.Marshal(b, m, deterministic)
+}
+func (dst *DescriptorProto_ExtensionRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DescriptorProto_ExtensionRange.Merge(dst, src)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_Size() int {
+ return xxx_messageInfo_DescriptorProto_ExtensionRange.Size(m)
+}
+func (m *DescriptorProto_ExtensionRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_DescriptorProto_ExtensionRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto_ExtensionRange proto.InternalMessageInfo
+
+func (m *DescriptorProto_ExtensionRange) GetStart() int32 {
+ if m != nil && m.Start != nil {
+ return *m.Start
+ }
+ return 0
+}
+
+func (m *DescriptorProto_ExtensionRange) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+func (m *DescriptorProto_ExtensionRange) GetOptions() *ExtensionRangeOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Range of reserved tag numbers. Reserved tag numbers may not be used by
+// fields or extension ranges in the same message. Reserved ranges may
+// not overlap.
+type DescriptorProto_ReservedRange struct {
+ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *DescriptorProto_ReservedRange) Reset() { *m = DescriptorProto_ReservedRange{} }
+func (m *DescriptorProto_ReservedRange) String() string { return proto.CompactTextString(m) }
+func (*DescriptorProto_ReservedRange) ProtoMessage() {}
+func (*DescriptorProto_ReservedRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{2, 1}
+}
+func (m *DescriptorProto_ReservedRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_DescriptorProto_ReservedRange.Unmarshal(m, b)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_DescriptorProto_ReservedRange.Marshal(b, m, deterministic)
+}
+func (dst *DescriptorProto_ReservedRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DescriptorProto_ReservedRange.Merge(dst, src)
+}
+func (m *DescriptorProto_ReservedRange) XXX_Size() int {
+ return xxx_messageInfo_DescriptorProto_ReservedRange.Size(m)
+}
+func (m *DescriptorProto_ReservedRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_DescriptorProto_ReservedRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DescriptorProto_ReservedRange proto.InternalMessageInfo
+
+func (m *DescriptorProto_ReservedRange) GetStart() int32 {
+ if m != nil && m.Start != nil {
+ return *m.Start
+ }
+ return 0
+}
+
+func (m *DescriptorProto_ReservedRange) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+type ExtensionRangeOptions struct {
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExtensionRangeOptions) Reset() { *m = ExtensionRangeOptions{} }
+func (m *ExtensionRangeOptions) String() string { return proto.CompactTextString(m) }
+func (*ExtensionRangeOptions) ProtoMessage() {}
+func (*ExtensionRangeOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{3}
+}
+
+var extRange_ExtensionRangeOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*ExtensionRangeOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_ExtensionRangeOptions
+}
+func (m *ExtensionRangeOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExtensionRangeOptions.Unmarshal(m, b)
+}
+func (m *ExtensionRangeOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExtensionRangeOptions.Marshal(b, m, deterministic)
+}
+func (dst *ExtensionRangeOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExtensionRangeOptions.Merge(dst, src)
+}
+func (m *ExtensionRangeOptions) XXX_Size() int {
+ return xxx_messageInfo_ExtensionRangeOptions.Size(m)
+}
+func (m *ExtensionRangeOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExtensionRangeOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtensionRangeOptions proto.InternalMessageInfo
+
+func (m *ExtensionRangeOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+// Describes a field within a message.
+type FieldDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Number *int32 `protobuf:"varint,3,opt,name=number" json:"number,omitempty"`
+ Label *FieldDescriptorProto_Label `protobuf:"varint,4,opt,name=label,enum=google.protobuf.FieldDescriptorProto_Label" json:"label,omitempty"`
+ // If type_name is set, this need not be set. If both this and type_name
+ // are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
+ Type *FieldDescriptorProto_Type `protobuf:"varint,5,opt,name=type,enum=google.protobuf.FieldDescriptorProto_Type" json:"type,omitempty"`
+ // For message and enum types, this is the name of the type. If the name
+ // starts with a '.', it is fully-qualified. Otherwise, C++-like scoping
+ // rules are used to find the type (i.e. first the nested types within this
+ // message are searched, then within the parent, on up to the root
+ // namespace).
+ TypeName *string `protobuf:"bytes,6,opt,name=type_name,json=typeName" json:"type_name,omitempty"`
+ // For extensions, this is the name of the type being extended. It is
+ // resolved in the same manner as type_name.
+ Extendee *string `protobuf:"bytes,2,opt,name=extendee" json:"extendee,omitempty"`
+ // For numeric types, contains the original text representation of the value.
+ // For booleans, "true" or "false".
+ // For strings, contains the default text contents (not escaped in any way).
+ // For bytes, contains the C escaped value. All bytes >= 128 are escaped.
+ // TODO(kenton): Base-64 encode?
+ DefaultValue *string `protobuf:"bytes,7,opt,name=default_value,json=defaultValue" json:"default_value,omitempty"`
+ // If set, gives the index of a oneof in the containing type's oneof_decl
+ // list. This field is a member of that oneof.
+ OneofIndex *int32 `protobuf:"varint,9,opt,name=oneof_index,json=oneofIndex" json:"oneof_index,omitempty"`
+ // JSON name of this field. The value is set by protocol compiler. If the
+ // user has set a "json_name" option on this field, that option's value
+ // will be used. Otherwise, it's deduced from the field's name by converting
+ // it to camelCase.
+ JsonName *string `protobuf:"bytes,10,opt,name=json_name,json=jsonName" json:"json_name,omitempty"`
+ Options *FieldOptions `protobuf:"bytes,8,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FieldDescriptorProto) Reset() { *m = FieldDescriptorProto{} }
+func (m *FieldDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*FieldDescriptorProto) ProtoMessage() {}
+func (*FieldDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{4}
+}
+func (m *FieldDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FieldDescriptorProto.Unmarshal(m, b)
+}
+func (m *FieldDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FieldDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *FieldDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FieldDescriptorProto.Merge(dst, src)
+}
+func (m *FieldDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_FieldDescriptorProto.Size(m)
+}
+func (m *FieldDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_FieldDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldDescriptorProto proto.InternalMessageInfo
+
+func (m *FieldDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetNumber() int32 {
+ if m != nil && m.Number != nil {
+ return *m.Number
+ }
+ return 0
+}
+
+func (m *FieldDescriptorProto) GetLabel() FieldDescriptorProto_Label {
+ if m != nil && m.Label != nil {
+ return *m.Label
+ }
+ return FieldDescriptorProto_LABEL_OPTIONAL
+}
+
+func (m *FieldDescriptorProto) GetType() FieldDescriptorProto_Type {
+ if m != nil && m.Type != nil {
+ return *m.Type
+ }
+ return FieldDescriptorProto_TYPE_DOUBLE
+}
+
+func (m *FieldDescriptorProto) GetTypeName() string {
+ if m != nil && m.TypeName != nil {
+ return *m.TypeName
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetExtendee() string {
+ if m != nil && m.Extendee != nil {
+ return *m.Extendee
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetDefaultValue() string {
+ if m != nil && m.DefaultValue != nil {
+ return *m.DefaultValue
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetOneofIndex() int32 {
+ if m != nil && m.OneofIndex != nil {
+ return *m.OneofIndex
+ }
+ return 0
+}
+
+func (m *FieldDescriptorProto) GetJsonName() string {
+ if m != nil && m.JsonName != nil {
+ return *m.JsonName
+ }
+ return ""
+}
+
+func (m *FieldDescriptorProto) GetOptions() *FieldOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes a oneof.
+type OneofDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Options *OneofOptions `protobuf:"bytes,2,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *OneofDescriptorProto) Reset() { *m = OneofDescriptorProto{} }
+func (m *OneofDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*OneofDescriptorProto) ProtoMessage() {}
+func (*OneofDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{5}
+}
+func (m *OneofDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_OneofDescriptorProto.Unmarshal(m, b)
+}
+func (m *OneofDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_OneofDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *OneofDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_OneofDescriptorProto.Merge(dst, src)
+}
+func (m *OneofDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_OneofDescriptorProto.Size(m)
+}
+func (m *OneofDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_OneofDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OneofDescriptorProto proto.InternalMessageInfo
+
+func (m *OneofDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *OneofDescriptorProto) GetOptions() *OneofOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes an enum type.
+type EnumDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Value []*EnumValueDescriptorProto `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
+ Options *EnumOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ // Range of reserved numeric values. Reserved numeric values may not be used
+ // by enum values in the same enum declaration. Reserved ranges may not
+ // overlap.
+ ReservedRange []*EnumDescriptorProto_EnumReservedRange `protobuf:"bytes,4,rep,name=reserved_range,json=reservedRange" json:"reserved_range,omitempty"`
+ // Reserved enum value names, which may not be reused. A given name may only
+ // be reserved once.
+ ReservedName []string `protobuf:"bytes,5,rep,name=reserved_name,json=reservedName" json:"reserved_name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumDescriptorProto) Reset() { *m = EnumDescriptorProto{} }
+func (m *EnumDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*EnumDescriptorProto) ProtoMessage() {}
+func (*EnumDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{6}
+}
+func (m *EnumDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumDescriptorProto.Unmarshal(m, b)
+}
+func (m *EnumDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *EnumDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumDescriptorProto.Merge(dst, src)
+}
+func (m *EnumDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_EnumDescriptorProto.Size(m)
+}
+func (m *EnumDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumDescriptorProto proto.InternalMessageInfo
+
+func (m *EnumDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *EnumDescriptorProto) GetValue() []*EnumValueDescriptorProto {
+ if m != nil {
+ return m.Value
+ }
+ return nil
+}
+
+func (m *EnumDescriptorProto) GetOptions() *EnumOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *EnumDescriptorProto) GetReservedRange() []*EnumDescriptorProto_EnumReservedRange {
+ if m != nil {
+ return m.ReservedRange
+ }
+ return nil
+}
+
+func (m *EnumDescriptorProto) GetReservedName() []string {
+ if m != nil {
+ return m.ReservedName
+ }
+ return nil
+}
+
+// Range of reserved numeric values. Reserved values may not be used by
+// entries in the same enum. Reserved ranges may not overlap.
+//
+// Note that this is distinct from DescriptorProto.ReservedRange in that it
+// is inclusive such that it can appropriately represent the entire int32
+// domain.
+type EnumDescriptorProto_EnumReservedRange struct {
+ Start *int32 `protobuf:"varint,1,opt,name=start" json:"start,omitempty"`
+ End *int32 `protobuf:"varint,2,opt,name=end" json:"end,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) Reset() { *m = EnumDescriptorProto_EnumReservedRange{} }
+func (m *EnumDescriptorProto_EnumReservedRange) String() string { return proto.CompactTextString(m) }
+func (*EnumDescriptorProto_EnumReservedRange) ProtoMessage() {}
+func (*EnumDescriptorProto_EnumReservedRange) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{6, 0}
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Unmarshal(m, b)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Marshal(b, m, deterministic)
+}
+func (dst *EnumDescriptorProto_EnumReservedRange) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Merge(dst, src)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_Size() int {
+ return xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.Size(m)
+}
+func (m *EnumDescriptorProto_EnumReservedRange) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumDescriptorProto_EnumReservedRange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumDescriptorProto_EnumReservedRange proto.InternalMessageInfo
+
+func (m *EnumDescriptorProto_EnumReservedRange) GetStart() int32 {
+ if m != nil && m.Start != nil {
+ return *m.Start
+ }
+ return 0
+}
+
+func (m *EnumDescriptorProto_EnumReservedRange) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+// Describes a value within an enum.
+type EnumValueDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Number *int32 `protobuf:"varint,2,opt,name=number" json:"number,omitempty"`
+ Options *EnumValueOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumValueDescriptorProto) Reset() { *m = EnumValueDescriptorProto{} }
+func (m *EnumValueDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*EnumValueDescriptorProto) ProtoMessage() {}
+func (*EnumValueDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{7}
+}
+func (m *EnumValueDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumValueDescriptorProto.Unmarshal(m, b)
+}
+func (m *EnumValueDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumValueDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *EnumValueDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumValueDescriptorProto.Merge(dst, src)
+}
+func (m *EnumValueDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_EnumValueDescriptorProto.Size(m)
+}
+func (m *EnumValueDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumValueDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumValueDescriptorProto proto.InternalMessageInfo
+
+func (m *EnumValueDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *EnumValueDescriptorProto) GetNumber() int32 {
+ if m != nil && m.Number != nil {
+ return *m.Number
+ }
+ return 0
+}
+
+func (m *EnumValueDescriptorProto) GetOptions() *EnumValueOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes a service.
+type ServiceDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ Method []*MethodDescriptorProto `protobuf:"bytes,2,rep,name=method" json:"method,omitempty"`
+ Options *ServiceOptions `protobuf:"bytes,3,opt,name=options" json:"options,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServiceDescriptorProto) Reset() { *m = ServiceDescriptorProto{} }
+func (m *ServiceDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*ServiceDescriptorProto) ProtoMessage() {}
+func (*ServiceDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{8}
+}
+func (m *ServiceDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServiceDescriptorProto.Unmarshal(m, b)
+}
+func (m *ServiceDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServiceDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *ServiceDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServiceDescriptorProto.Merge(dst, src)
+}
+func (m *ServiceDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_ServiceDescriptorProto.Size(m)
+}
+func (m *ServiceDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServiceDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceDescriptorProto proto.InternalMessageInfo
+
+func (m *ServiceDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *ServiceDescriptorProto) GetMethod() []*MethodDescriptorProto {
+ if m != nil {
+ return m.Method
+ }
+ return nil
+}
+
+func (m *ServiceDescriptorProto) GetOptions() *ServiceOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+// Describes a method of a service.
+type MethodDescriptorProto struct {
+ Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ // Input and output type names. These are resolved in the same way as
+ // FieldDescriptorProto.type_name, but must refer to a message type.
+ InputType *string `protobuf:"bytes,2,opt,name=input_type,json=inputType" json:"input_type,omitempty"`
+ OutputType *string `protobuf:"bytes,3,opt,name=output_type,json=outputType" json:"output_type,omitempty"`
+ Options *MethodOptions `protobuf:"bytes,4,opt,name=options" json:"options,omitempty"`
+ // Identifies if client streams multiple client messages
+ ClientStreaming *bool `protobuf:"varint,5,opt,name=client_streaming,json=clientStreaming,def=0" json:"client_streaming,omitempty"`
+ // Identifies if server streams multiple server messages
+ ServerStreaming *bool `protobuf:"varint,6,opt,name=server_streaming,json=serverStreaming,def=0" json:"server_streaming,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MethodDescriptorProto) Reset() { *m = MethodDescriptorProto{} }
+func (m *MethodDescriptorProto) String() string { return proto.CompactTextString(m) }
+func (*MethodDescriptorProto) ProtoMessage() {}
+func (*MethodDescriptorProto) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{9}
+}
+func (m *MethodDescriptorProto) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MethodDescriptorProto.Unmarshal(m, b)
+}
+func (m *MethodDescriptorProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MethodDescriptorProto.Marshal(b, m, deterministic)
+}
+func (dst *MethodDescriptorProto) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MethodDescriptorProto.Merge(dst, src)
+}
+func (m *MethodDescriptorProto) XXX_Size() int {
+ return xxx_messageInfo_MethodDescriptorProto.Size(m)
+}
+func (m *MethodDescriptorProto) XXX_DiscardUnknown() {
+ xxx_messageInfo_MethodDescriptorProto.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MethodDescriptorProto proto.InternalMessageInfo
+
+const Default_MethodDescriptorProto_ClientStreaming bool = false
+const Default_MethodDescriptorProto_ServerStreaming bool = false
+
+func (m *MethodDescriptorProto) GetName() string {
+ if m != nil && m.Name != nil {
+ return *m.Name
+ }
+ return ""
+}
+
+func (m *MethodDescriptorProto) GetInputType() string {
+ if m != nil && m.InputType != nil {
+ return *m.InputType
+ }
+ return ""
+}
+
+func (m *MethodDescriptorProto) GetOutputType() string {
+ if m != nil && m.OutputType != nil {
+ return *m.OutputType
+ }
+ return ""
+}
+
+func (m *MethodDescriptorProto) GetOptions() *MethodOptions {
+ if m != nil {
+ return m.Options
+ }
+ return nil
+}
+
+func (m *MethodDescriptorProto) GetClientStreaming() bool {
+ if m != nil && m.ClientStreaming != nil {
+ return *m.ClientStreaming
+ }
+ return Default_MethodDescriptorProto_ClientStreaming
+}
+
+func (m *MethodDescriptorProto) GetServerStreaming() bool {
+ if m != nil && m.ServerStreaming != nil {
+ return *m.ServerStreaming
+ }
+ return Default_MethodDescriptorProto_ServerStreaming
+}
+
+type FileOptions struct {
+ // Sets the Java package where classes generated from this .proto will be
+ // placed. By default, the proto package is used, but this is often
+ // inappropriate because proto packages do not normally start with backwards
+ // domain names.
+ JavaPackage *string `protobuf:"bytes,1,opt,name=java_package,json=javaPackage" json:"java_package,omitempty"`
+ // If set, all the classes from the .proto file are wrapped in a single
+ // outer class with the given name. This applies to both Proto1
+ // (equivalent to the old "--one_java_file" option) and Proto2 (where
+ // a .proto always translates to a single class, but you may want to
+ // explicitly choose the class name).
+ JavaOuterClassname *string `protobuf:"bytes,8,opt,name=java_outer_classname,json=javaOuterClassname" json:"java_outer_classname,omitempty"`
+ // If set true, then the Java code generator will generate a separate .java
+ // file for each top-level message, enum, and service defined in the .proto
+ // file. Thus, these types will *not* be nested inside the outer class
+ // named by java_outer_classname. However, the outer class will still be
+ // generated to contain the file's getDescriptor() method as well as any
+ // top-level extensions defined in the file.
+ JavaMultipleFiles *bool `protobuf:"varint,10,opt,name=java_multiple_files,json=javaMultipleFiles,def=0" json:"java_multiple_files,omitempty"`
+ // This option does nothing.
+ JavaGenerateEqualsAndHash *bool `protobuf:"varint,20,opt,name=java_generate_equals_and_hash,json=javaGenerateEqualsAndHash" json:"java_generate_equals_and_hash,omitempty"` // Deprecated: Do not use.
+ // If set true, then the Java2 code generator will generate code that
+ // throws an exception whenever an attempt is made to assign a non-UTF-8
+ // byte sequence to a string field.
+ // Message reflection will do the same.
+ // However, an extension field still accepts non-UTF-8 byte sequences.
+ // This option has no effect on when used with the lite runtime.
+ JavaStringCheckUtf8 *bool `protobuf:"varint,27,opt,name=java_string_check_utf8,json=javaStringCheckUtf8,def=0" json:"java_string_check_utf8,omitempty"`
+ OptimizeFor *FileOptions_OptimizeMode `protobuf:"varint,9,opt,name=optimize_for,json=optimizeFor,enum=google.protobuf.FileOptions_OptimizeMode,def=1" json:"optimize_for,omitempty"`
+ // Sets the Go package where structs generated from this .proto will be
+ // placed. If omitted, the Go package will be derived from the following:
+ // - The basename of the package import path, if provided.
+ // - Otherwise, the package statement in the .proto file, if present.
+ // - Otherwise, the basename of the .proto file, without extension.
+ GoPackage *string `protobuf:"bytes,11,opt,name=go_package,json=goPackage" json:"go_package,omitempty"`
+ // Should generic services be generated in each language? "Generic" services
+ // are not specific to any particular RPC system. They are generated by the
+ // main code generators in each language (without additional plugins).
+ // Generic services were the only kind of service generation supported by
+ // early versions of google.protobuf.
+ //
+ // Generic services are now considered deprecated in favor of using plugins
+ // that generate code specific to your particular RPC system. Therefore,
+ // these default to false. Old code which depends on generic services should
+ // explicitly set them to true.
+ CcGenericServices *bool `protobuf:"varint,16,opt,name=cc_generic_services,json=ccGenericServices,def=0" json:"cc_generic_services,omitempty"`
+ JavaGenericServices *bool `protobuf:"varint,17,opt,name=java_generic_services,json=javaGenericServices,def=0" json:"java_generic_services,omitempty"`
+ PyGenericServices *bool `protobuf:"varint,18,opt,name=py_generic_services,json=pyGenericServices,def=0" json:"py_generic_services,omitempty"`
+ PhpGenericServices *bool `protobuf:"varint,42,opt,name=php_generic_services,json=phpGenericServices,def=0" json:"php_generic_services,omitempty"`
+ // Is this file deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for everything in the file, or it will be completely ignored; in the very
+ // least, this is a formalization for deprecating files.
+ Deprecated *bool `protobuf:"varint,23,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // Enables the use of arenas for the proto messages in this file. This applies
+ // only to generated classes for C++.
+ CcEnableArenas *bool `protobuf:"varint,31,opt,name=cc_enable_arenas,json=ccEnableArenas,def=0" json:"cc_enable_arenas,omitempty"`
+ // Sets the objective c class prefix which is prepended to all objective c
+ // generated classes from this .proto. There is no default.
+ ObjcClassPrefix *string `protobuf:"bytes,36,opt,name=objc_class_prefix,json=objcClassPrefix" json:"objc_class_prefix,omitempty"`
+ // Namespace for generated classes; defaults to the package.
+ CsharpNamespace *string `protobuf:"bytes,37,opt,name=csharp_namespace,json=csharpNamespace" json:"csharp_namespace,omitempty"`
+ // By default Swift generators will take the proto package and CamelCase it
+ // replacing '.' with underscore and use that to prefix the types/symbols
+ // defined. When this options is provided, they will use this value instead
+ // to prefix the types/symbols defined.
+ SwiftPrefix *string `protobuf:"bytes,39,opt,name=swift_prefix,json=swiftPrefix" json:"swift_prefix,omitempty"`
+ // Sets the php class prefix which is prepended to all php generated classes
+ // from this .proto. Default is empty.
+ PhpClassPrefix *string `protobuf:"bytes,40,opt,name=php_class_prefix,json=phpClassPrefix" json:"php_class_prefix,omitempty"`
+ // Use this option to change the namespace of php generated classes. Default
+ // is empty. When this option is empty, the package name will be used for
+ // determining the namespace.
+ PhpNamespace *string `protobuf:"bytes,41,opt,name=php_namespace,json=phpNamespace" json:"php_namespace,omitempty"`
+ // The parser stores options it doesn't recognize here.
+ // See the documentation for the "Options" section above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileOptions) Reset() { *m = FileOptions{} }
+func (m *FileOptions) String() string { return proto.CompactTextString(m) }
+func (*FileOptions) ProtoMessage() {}
+func (*FileOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{10}
+}
+
+var extRange_FileOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*FileOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_FileOptions
+}
+func (m *FileOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileOptions.Unmarshal(m, b)
+}
+func (m *FileOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileOptions.Marshal(b, m, deterministic)
+}
+func (dst *FileOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileOptions.Merge(dst, src)
+}
+func (m *FileOptions) XXX_Size() int {
+ return xxx_messageInfo_FileOptions.Size(m)
+}
+func (m *FileOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileOptions proto.InternalMessageInfo
+
+const Default_FileOptions_JavaMultipleFiles bool = false
+const Default_FileOptions_JavaStringCheckUtf8 bool = false
+const Default_FileOptions_OptimizeFor FileOptions_OptimizeMode = FileOptions_SPEED
+const Default_FileOptions_CcGenericServices bool = false
+const Default_FileOptions_JavaGenericServices bool = false
+const Default_FileOptions_PyGenericServices bool = false
+const Default_FileOptions_PhpGenericServices bool = false
+const Default_FileOptions_Deprecated bool = false
+const Default_FileOptions_CcEnableArenas bool = false
+
+func (m *FileOptions) GetJavaPackage() string {
+ if m != nil && m.JavaPackage != nil {
+ return *m.JavaPackage
+ }
+ return ""
+}
+
+func (m *FileOptions) GetJavaOuterClassname() string {
+ if m != nil && m.JavaOuterClassname != nil {
+ return *m.JavaOuterClassname
+ }
+ return ""
+}
+
+func (m *FileOptions) GetJavaMultipleFiles() bool {
+ if m != nil && m.JavaMultipleFiles != nil {
+ return *m.JavaMultipleFiles
+ }
+ return Default_FileOptions_JavaMultipleFiles
+}
+
+// Deprecated: Do not use.
+func (m *FileOptions) GetJavaGenerateEqualsAndHash() bool {
+ if m != nil && m.JavaGenerateEqualsAndHash != nil {
+ return *m.JavaGenerateEqualsAndHash
+ }
+ return false
+}
+
+func (m *FileOptions) GetJavaStringCheckUtf8() bool {
+ if m != nil && m.JavaStringCheckUtf8 != nil {
+ return *m.JavaStringCheckUtf8
+ }
+ return Default_FileOptions_JavaStringCheckUtf8
+}
+
+func (m *FileOptions) GetOptimizeFor() FileOptions_OptimizeMode {
+ if m != nil && m.OptimizeFor != nil {
+ return *m.OptimizeFor
+ }
+ return Default_FileOptions_OptimizeFor
+}
+
+func (m *FileOptions) GetGoPackage() string {
+ if m != nil && m.GoPackage != nil {
+ return *m.GoPackage
+ }
+ return ""
+}
+
+func (m *FileOptions) GetCcGenericServices() bool {
+ if m != nil && m.CcGenericServices != nil {
+ return *m.CcGenericServices
+ }
+ return Default_FileOptions_CcGenericServices
+}
+
+func (m *FileOptions) GetJavaGenericServices() bool {
+ if m != nil && m.JavaGenericServices != nil {
+ return *m.JavaGenericServices
+ }
+ return Default_FileOptions_JavaGenericServices
+}
+
+func (m *FileOptions) GetPyGenericServices() bool {
+ if m != nil && m.PyGenericServices != nil {
+ return *m.PyGenericServices
+ }
+ return Default_FileOptions_PyGenericServices
+}
+
+func (m *FileOptions) GetPhpGenericServices() bool {
+ if m != nil && m.PhpGenericServices != nil {
+ return *m.PhpGenericServices
+ }
+ return Default_FileOptions_PhpGenericServices
+}
+
+func (m *FileOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_FileOptions_Deprecated
+}
+
+func (m *FileOptions) GetCcEnableArenas() bool {
+ if m != nil && m.CcEnableArenas != nil {
+ return *m.CcEnableArenas
+ }
+ return Default_FileOptions_CcEnableArenas
+}
+
+func (m *FileOptions) GetObjcClassPrefix() string {
+ if m != nil && m.ObjcClassPrefix != nil {
+ return *m.ObjcClassPrefix
+ }
+ return ""
+}
+
+func (m *FileOptions) GetCsharpNamespace() string {
+ if m != nil && m.CsharpNamespace != nil {
+ return *m.CsharpNamespace
+ }
+ return ""
+}
+
+func (m *FileOptions) GetSwiftPrefix() string {
+ if m != nil && m.SwiftPrefix != nil {
+ return *m.SwiftPrefix
+ }
+ return ""
+}
+
+func (m *FileOptions) GetPhpClassPrefix() string {
+ if m != nil && m.PhpClassPrefix != nil {
+ return *m.PhpClassPrefix
+ }
+ return ""
+}
+
+func (m *FileOptions) GetPhpNamespace() string {
+ if m != nil && m.PhpNamespace != nil {
+ return *m.PhpNamespace
+ }
+ return ""
+}
+
+func (m *FileOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type MessageOptions struct {
+ // Set true to use the old proto1 MessageSet wire format for extensions.
+ // This is provided for backwards-compatibility with the MessageSet wire
+ // format. You should not use this for any other reason: It's less
+ // efficient, has fewer features, and is more complicated.
+ //
+ // The message must be defined exactly as follows:
+ // message Foo {
+ // option message_set_wire_format = true;
+ // extensions 4 to max;
+ // }
+ // Note that the message cannot have any defined fields; MessageSets only
+ // have extensions.
+ //
+ // All extensions of your type must be singular messages; e.g. they cannot
+ // be int32s, enums, or repeated messages.
+ //
+ // Because this is an option, the above two restrictions are not enforced by
+ // the protocol compiler.
+ MessageSetWireFormat *bool `protobuf:"varint,1,opt,name=message_set_wire_format,json=messageSetWireFormat,def=0" json:"message_set_wire_format,omitempty"`
+ // Disables the generation of the standard "descriptor()" accessor, which can
+ // conflict with a field of the same name. This is meant to make migration
+ // from proto1 easier; new code should avoid fields named "descriptor".
+ NoStandardDescriptorAccessor *bool `protobuf:"varint,2,opt,name=no_standard_descriptor_accessor,json=noStandardDescriptorAccessor,def=0" json:"no_standard_descriptor_accessor,omitempty"`
+ // Is this message deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the message, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating messages.
+ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // Whether the message is an automatically generated map entry type for the
+ // maps field.
+ //
+ // For maps fields:
+ // map<KeyType, ValueType> map_field = 1;
+ // The parsed descriptor looks like:
+ // message MapFieldEntry {
+ // option map_entry = true;
+ // optional KeyType key = 1;
+ // optional ValueType value = 2;
+ // }
+ // repeated MapFieldEntry map_field = 1;
+ //
+ // Implementations may choose not to generate the map_entry=true message, but
+ // use a native map in the target language to hold the keys and values.
+ // The reflection APIs in such implementions still need to work as
+ // if the field is a repeated message field.
+ //
+ // NOTE: Do not set the option in .proto files. Always use the maps syntax
+ // instead. The option should only be implicitly set by the proto compiler
+ // parser.
+ MapEntry *bool `protobuf:"varint,7,opt,name=map_entry,json=mapEntry" json:"map_entry,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MessageOptions) Reset() { *m = MessageOptions{} }
+func (m *MessageOptions) String() string { return proto.CompactTextString(m) }
+func (*MessageOptions) ProtoMessage() {}
+func (*MessageOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{11}
+}
+
+var extRange_MessageOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*MessageOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_MessageOptions
+}
+func (m *MessageOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MessageOptions.Unmarshal(m, b)
+}
+func (m *MessageOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MessageOptions.Marshal(b, m, deterministic)
+}
+func (dst *MessageOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MessageOptions.Merge(dst, src)
+}
+func (m *MessageOptions) XXX_Size() int {
+ return xxx_messageInfo_MessageOptions.Size(m)
+}
+func (m *MessageOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_MessageOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MessageOptions proto.InternalMessageInfo
+
+const Default_MessageOptions_MessageSetWireFormat bool = false
+const Default_MessageOptions_NoStandardDescriptorAccessor bool = false
+const Default_MessageOptions_Deprecated bool = false
+
+func (m *MessageOptions) GetMessageSetWireFormat() bool {
+ if m != nil && m.MessageSetWireFormat != nil {
+ return *m.MessageSetWireFormat
+ }
+ return Default_MessageOptions_MessageSetWireFormat
+}
+
+func (m *MessageOptions) GetNoStandardDescriptorAccessor() bool {
+ if m != nil && m.NoStandardDescriptorAccessor != nil {
+ return *m.NoStandardDescriptorAccessor
+ }
+ return Default_MessageOptions_NoStandardDescriptorAccessor
+}
+
+func (m *MessageOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_MessageOptions_Deprecated
+}
+
+func (m *MessageOptions) GetMapEntry() bool {
+ if m != nil && m.MapEntry != nil {
+ return *m.MapEntry
+ }
+ return false
+}
+
+func (m *MessageOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type FieldOptions struct {
+ // The ctype option instructs the C++ code generator to use a different
+ // representation of the field than it normally would. See the specific
+ // options below. This option is not yet implemented in the open source
+ // release -- sorry, we'll try to include it in a future version!
+ Ctype *FieldOptions_CType `protobuf:"varint,1,opt,name=ctype,enum=google.protobuf.FieldOptions_CType,def=0" json:"ctype,omitempty"`
+ // The packed option can be enabled for repeated primitive fields to enable
+ // a more efficient representation on the wire. Rather than repeatedly
+ // writing the tag and type for each element, the entire array is encoded as
+ // a single length-delimited blob. In proto3, only explicit setting it to
+ // false will avoid using packed encoding.
+ Packed *bool `protobuf:"varint,2,opt,name=packed" json:"packed,omitempty"`
+ // The jstype option determines the JavaScript type used for values of the
+ // field. The option is permitted only for 64 bit integral and fixed types
+ // (int64, uint64, sint64, fixed64, sfixed64). A field with jstype JS_STRING
+ // is represented as JavaScript string, which avoids loss of precision that
+ // can happen when a large value is converted to a floating point JavaScript.
+ // Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
+ // use the JavaScript "number" type. The behavior of the default option
+ // JS_NORMAL is implementation dependent.
+ //
+ // This option is an enum to permit additional types to be added, e.g.
+ // goog.math.Integer.
+ Jstype *FieldOptions_JSType `protobuf:"varint,6,opt,name=jstype,enum=google.protobuf.FieldOptions_JSType,def=0" json:"jstype,omitempty"`
+ // Should this field be parsed lazily? Lazy applies only to message-type
+ // fields. It means that when the outer message is initially parsed, the
+ // inner message's contents will not be parsed but instead stored in encoded
+ // form. The inner message will actually be parsed when it is first accessed.
+ //
+ // This is only a hint. Implementations are free to choose whether to use
+ // eager or lazy parsing regardless of the value of this option. However,
+ // setting this option true suggests that the protocol author believes that
+ // using lazy parsing on this field is worth the additional bookkeeping
+ // overhead typically needed to implement it.
+ //
+ // This option does not affect the public interface of any generated code;
+ // all method signatures remain the same. Furthermore, thread-safety of the
+ // interface is not affected by this option; const methods remain safe to
+ // call from multiple threads concurrently, while non-const methods continue
+ // to require exclusive access.
+ //
+ //
+ // Note that implementations may choose not to check required fields within
+ // a lazy sub-message. That is, calling IsInitialized() on the outer message
+ // may return true even if the inner message has missing required fields.
+ // This is necessary because otherwise the inner message would have to be
+ // parsed in order to perform the check, defeating the purpose of lazy
+ // parsing. An implementation which chooses not to check required fields
+ // must be consistent about it. That is, for any particular sub-message, the
+ // implementation must either *always* check its required fields, or *never*
+ // check its required fields, regardless of whether or not the message has
+ // been parsed.
+ Lazy *bool `protobuf:"varint,5,opt,name=lazy,def=0" json:"lazy,omitempty"`
+ // Is this field deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for accessors, or it will be completely ignored; in the very least, this
+ // is a formalization for deprecating fields.
+ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // For Google-internal migration only. Do not use.
+ Weak *bool `protobuf:"varint,10,opt,name=weak,def=0" json:"weak,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FieldOptions) Reset() { *m = FieldOptions{} }
+func (m *FieldOptions) String() string { return proto.CompactTextString(m) }
+func (*FieldOptions) ProtoMessage() {}
+func (*FieldOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{12}
+}
+
+var extRange_FieldOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*FieldOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_FieldOptions
+}
+func (m *FieldOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FieldOptions.Unmarshal(m, b)
+}
+func (m *FieldOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FieldOptions.Marshal(b, m, deterministic)
+}
+func (dst *FieldOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FieldOptions.Merge(dst, src)
+}
+func (m *FieldOptions) XXX_Size() int {
+ return xxx_messageInfo_FieldOptions.Size(m)
+}
+func (m *FieldOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_FieldOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldOptions proto.InternalMessageInfo
+
+const Default_FieldOptions_Ctype FieldOptions_CType = FieldOptions_STRING
+const Default_FieldOptions_Jstype FieldOptions_JSType = FieldOptions_JS_NORMAL
+const Default_FieldOptions_Lazy bool = false
+const Default_FieldOptions_Deprecated bool = false
+const Default_FieldOptions_Weak bool = false
+
+func (m *FieldOptions) GetCtype() FieldOptions_CType {
+ if m != nil && m.Ctype != nil {
+ return *m.Ctype
+ }
+ return Default_FieldOptions_Ctype
+}
+
+func (m *FieldOptions) GetPacked() bool {
+ if m != nil && m.Packed != nil {
+ return *m.Packed
+ }
+ return false
+}
+
+func (m *FieldOptions) GetJstype() FieldOptions_JSType {
+ if m != nil && m.Jstype != nil {
+ return *m.Jstype
+ }
+ return Default_FieldOptions_Jstype
+}
+
+func (m *FieldOptions) GetLazy() bool {
+ if m != nil && m.Lazy != nil {
+ return *m.Lazy
+ }
+ return Default_FieldOptions_Lazy
+}
+
+func (m *FieldOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_FieldOptions_Deprecated
+}
+
+func (m *FieldOptions) GetWeak() bool {
+ if m != nil && m.Weak != nil {
+ return *m.Weak
+ }
+ return Default_FieldOptions_Weak
+}
+
+func (m *FieldOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type OneofOptions struct {
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *OneofOptions) Reset() { *m = OneofOptions{} }
+func (m *OneofOptions) String() string { return proto.CompactTextString(m) }
+func (*OneofOptions) ProtoMessage() {}
+func (*OneofOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{13}
+}
+
+var extRange_OneofOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*OneofOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_OneofOptions
+}
+func (m *OneofOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_OneofOptions.Unmarshal(m, b)
+}
+func (m *OneofOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_OneofOptions.Marshal(b, m, deterministic)
+}
+func (dst *OneofOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_OneofOptions.Merge(dst, src)
+}
+func (m *OneofOptions) XXX_Size() int {
+ return xxx_messageInfo_OneofOptions.Size(m)
+}
+func (m *OneofOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_OneofOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_OneofOptions proto.InternalMessageInfo
+
+func (m *OneofOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type EnumOptions struct {
+ // Set this option to true to allow mapping different tag names to the same
+ // value.
+ AllowAlias *bool `protobuf:"varint,2,opt,name=allow_alias,json=allowAlias" json:"allow_alias,omitempty"`
+ // Is this enum deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the enum, or it will be completely ignored; in the very least, this
+ // is a formalization for deprecating enums.
+ Deprecated *bool `protobuf:"varint,3,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumOptions) Reset() { *m = EnumOptions{} }
+func (m *EnumOptions) String() string { return proto.CompactTextString(m) }
+func (*EnumOptions) ProtoMessage() {}
+func (*EnumOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{14}
+}
+
+var extRange_EnumOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*EnumOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_EnumOptions
+}
+func (m *EnumOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumOptions.Unmarshal(m, b)
+}
+func (m *EnumOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumOptions.Marshal(b, m, deterministic)
+}
+func (dst *EnumOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumOptions.Merge(dst, src)
+}
+func (m *EnumOptions) XXX_Size() int {
+ return xxx_messageInfo_EnumOptions.Size(m)
+}
+func (m *EnumOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumOptions proto.InternalMessageInfo
+
+const Default_EnumOptions_Deprecated bool = false
+
+func (m *EnumOptions) GetAllowAlias() bool {
+ if m != nil && m.AllowAlias != nil {
+ return *m.AllowAlias
+ }
+ return false
+}
+
+func (m *EnumOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_EnumOptions_Deprecated
+}
+
+func (m *EnumOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type EnumValueOptions struct {
+ // Is this enum value deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the enum value, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating enum values.
+ Deprecated *bool `protobuf:"varint,1,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *EnumValueOptions) Reset() { *m = EnumValueOptions{} }
+func (m *EnumValueOptions) String() string { return proto.CompactTextString(m) }
+func (*EnumValueOptions) ProtoMessage() {}
+func (*EnumValueOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{15}
+}
+
+var extRange_EnumValueOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*EnumValueOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_EnumValueOptions
+}
+func (m *EnumValueOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_EnumValueOptions.Unmarshal(m, b)
+}
+func (m *EnumValueOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_EnumValueOptions.Marshal(b, m, deterministic)
+}
+func (dst *EnumValueOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_EnumValueOptions.Merge(dst, src)
+}
+func (m *EnumValueOptions) XXX_Size() int {
+ return xxx_messageInfo_EnumValueOptions.Size(m)
+}
+func (m *EnumValueOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_EnumValueOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EnumValueOptions proto.InternalMessageInfo
+
+const Default_EnumValueOptions_Deprecated bool = false
+
+func (m *EnumValueOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_EnumValueOptions_Deprecated
+}
+
+func (m *EnumValueOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type ServiceOptions struct {
+ // Is this service deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the service, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating services.
+ Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServiceOptions) Reset() { *m = ServiceOptions{} }
+func (m *ServiceOptions) String() string { return proto.CompactTextString(m) }
+func (*ServiceOptions) ProtoMessage() {}
+func (*ServiceOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{16}
+}
+
+var extRange_ServiceOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*ServiceOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_ServiceOptions
+}
+func (m *ServiceOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServiceOptions.Unmarshal(m, b)
+}
+func (m *ServiceOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServiceOptions.Marshal(b, m, deterministic)
+}
+func (dst *ServiceOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServiceOptions.Merge(dst, src)
+}
+func (m *ServiceOptions) XXX_Size() int {
+ return xxx_messageInfo_ServiceOptions.Size(m)
+}
+func (m *ServiceOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServiceOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceOptions proto.InternalMessageInfo
+
+const Default_ServiceOptions_Deprecated bool = false
+
+func (m *ServiceOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_ServiceOptions_Deprecated
+}
+
+func (m *ServiceOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+type MethodOptions struct {
+ // Is this method deprecated?
+ // Depending on the target platform, this can emit Deprecated annotations
+ // for the method, or it will be completely ignored; in the very least,
+ // this is a formalization for deprecating methods.
+ Deprecated *bool `protobuf:"varint,33,opt,name=deprecated,def=0" json:"deprecated,omitempty"`
+ IdempotencyLevel *MethodOptions_IdempotencyLevel `protobuf:"varint,34,opt,name=idempotency_level,json=idempotencyLevel,enum=google.protobuf.MethodOptions_IdempotencyLevel,def=0" json:"idempotency_level,omitempty"`
+ // The parser stores options it doesn't recognize here. See above.
+ UninterpretedOption []*UninterpretedOption `protobuf:"bytes,999,rep,name=uninterpreted_option,json=uninterpretedOption" json:"uninterpreted_option,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ proto.XXX_InternalExtensions `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *MethodOptions) Reset() { *m = MethodOptions{} }
+func (m *MethodOptions) String() string { return proto.CompactTextString(m) }
+func (*MethodOptions) ProtoMessage() {}
+func (*MethodOptions) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{17}
+}
+
+var extRange_MethodOptions = []proto.ExtensionRange{
+ {Start: 1000, End: 536870911},
+}
+
+func (*MethodOptions) ExtensionRangeArray() []proto.ExtensionRange {
+ return extRange_MethodOptions
+}
+func (m *MethodOptions) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_MethodOptions.Unmarshal(m, b)
+}
+func (m *MethodOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_MethodOptions.Marshal(b, m, deterministic)
+}
+func (dst *MethodOptions) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MethodOptions.Merge(dst, src)
+}
+func (m *MethodOptions) XXX_Size() int {
+ return xxx_messageInfo_MethodOptions.Size(m)
+}
+func (m *MethodOptions) XXX_DiscardUnknown() {
+ xxx_messageInfo_MethodOptions.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MethodOptions proto.InternalMessageInfo
+
+const Default_MethodOptions_Deprecated bool = false
+const Default_MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel = MethodOptions_IDEMPOTENCY_UNKNOWN
+
+func (m *MethodOptions) GetDeprecated() bool {
+ if m != nil && m.Deprecated != nil {
+ return *m.Deprecated
+ }
+ return Default_MethodOptions_Deprecated
+}
+
+func (m *MethodOptions) GetIdempotencyLevel() MethodOptions_IdempotencyLevel {
+ if m != nil && m.IdempotencyLevel != nil {
+ return *m.IdempotencyLevel
+ }
+ return Default_MethodOptions_IdempotencyLevel
+}
+
+func (m *MethodOptions) GetUninterpretedOption() []*UninterpretedOption {
+ if m != nil {
+ return m.UninterpretedOption
+ }
+ return nil
+}
+
+// A message representing a option the parser does not recognize. This only
+// appears in options protos created by the compiler::Parser class.
+// DescriptorPool resolves these when building Descriptor objects. Therefore,
+// options protos in descriptor objects (e.g. returned by Descriptor::options(),
+// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
+// in them.
+type UninterpretedOption struct {
+ Name []*UninterpretedOption_NamePart `protobuf:"bytes,2,rep,name=name" json:"name,omitempty"`
+ // The value of the uninterpreted option, in whatever type the tokenizer
+ // identified it as during parsing. Exactly one of these should be set.
+ IdentifierValue *string `protobuf:"bytes,3,opt,name=identifier_value,json=identifierValue" json:"identifier_value,omitempty"`
+ PositiveIntValue *uint64 `protobuf:"varint,4,opt,name=positive_int_value,json=positiveIntValue" json:"positive_int_value,omitempty"`
+ NegativeIntValue *int64 `protobuf:"varint,5,opt,name=negative_int_value,json=negativeIntValue" json:"negative_int_value,omitempty"`
+ DoubleValue *float64 `protobuf:"fixed64,6,opt,name=double_value,json=doubleValue" json:"double_value,omitempty"`
+ StringValue []byte `protobuf:"bytes,7,opt,name=string_value,json=stringValue" json:"string_value,omitempty"`
+ AggregateValue *string `protobuf:"bytes,8,opt,name=aggregate_value,json=aggregateValue" json:"aggregate_value,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *UninterpretedOption) Reset() { *m = UninterpretedOption{} }
+func (m *UninterpretedOption) String() string { return proto.CompactTextString(m) }
+func (*UninterpretedOption) ProtoMessage() {}
+func (*UninterpretedOption) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{18}
+}
+func (m *UninterpretedOption) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_UninterpretedOption.Unmarshal(m, b)
+}
+func (m *UninterpretedOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_UninterpretedOption.Marshal(b, m, deterministic)
+}
+func (dst *UninterpretedOption) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UninterpretedOption.Merge(dst, src)
+}
+func (m *UninterpretedOption) XXX_Size() int {
+ return xxx_messageInfo_UninterpretedOption.Size(m)
+}
+func (m *UninterpretedOption) XXX_DiscardUnknown() {
+ xxx_messageInfo_UninterpretedOption.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UninterpretedOption proto.InternalMessageInfo
+
+func (m *UninterpretedOption) GetName() []*UninterpretedOption_NamePart {
+ if m != nil {
+ return m.Name
+ }
+ return nil
+}
+
+func (m *UninterpretedOption) GetIdentifierValue() string {
+ if m != nil && m.IdentifierValue != nil {
+ return *m.IdentifierValue
+ }
+ return ""
+}
+
+func (m *UninterpretedOption) GetPositiveIntValue() uint64 {
+ if m != nil && m.PositiveIntValue != nil {
+ return *m.PositiveIntValue
+ }
+ return 0
+}
+
+func (m *UninterpretedOption) GetNegativeIntValue() int64 {
+ if m != nil && m.NegativeIntValue != nil {
+ return *m.NegativeIntValue
+ }
+ return 0
+}
+
+func (m *UninterpretedOption) GetDoubleValue() float64 {
+ if m != nil && m.DoubleValue != nil {
+ return *m.DoubleValue
+ }
+ return 0
+}
+
+func (m *UninterpretedOption) GetStringValue() []byte {
+ if m != nil {
+ return m.StringValue
+ }
+ return nil
+}
+
+func (m *UninterpretedOption) GetAggregateValue() string {
+ if m != nil && m.AggregateValue != nil {
+ return *m.AggregateValue
+ }
+ return ""
+}
+
+// The name of the uninterpreted option. Each string represents a segment in
+// a dot-separated name. is_extension is true iff a segment represents an
+// extension (denoted with parentheses in options specs in .proto files).
+// E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
+// "foo.(bar.baz).qux".
+type UninterpretedOption_NamePart struct {
+ NamePart *string `protobuf:"bytes,1,req,name=name_part,json=namePart" json:"name_part,omitempty"`
+ IsExtension *bool `protobuf:"varint,2,req,name=is_extension,json=isExtension" json:"is_extension,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *UninterpretedOption_NamePart) Reset() { *m = UninterpretedOption_NamePart{} }
+func (m *UninterpretedOption_NamePart) String() string { return proto.CompactTextString(m) }
+func (*UninterpretedOption_NamePart) ProtoMessage() {}
+func (*UninterpretedOption_NamePart) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{18, 0}
+}
+func (m *UninterpretedOption_NamePart) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_UninterpretedOption_NamePart.Unmarshal(m, b)
+}
+func (m *UninterpretedOption_NamePart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_UninterpretedOption_NamePart.Marshal(b, m, deterministic)
+}
+func (dst *UninterpretedOption_NamePart) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_UninterpretedOption_NamePart.Merge(dst, src)
+}
+func (m *UninterpretedOption_NamePart) XXX_Size() int {
+ return xxx_messageInfo_UninterpretedOption_NamePart.Size(m)
+}
+func (m *UninterpretedOption_NamePart) XXX_DiscardUnknown() {
+ xxx_messageInfo_UninterpretedOption_NamePart.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UninterpretedOption_NamePart proto.InternalMessageInfo
+
+func (m *UninterpretedOption_NamePart) GetNamePart() string {
+ if m != nil && m.NamePart != nil {
+ return *m.NamePart
+ }
+ return ""
+}
+
+func (m *UninterpretedOption_NamePart) GetIsExtension() bool {
+ if m != nil && m.IsExtension != nil {
+ return *m.IsExtension
+ }
+ return false
+}
+
+// Encapsulates information about the original source file from which a
+// FileDescriptorProto was generated.
+type SourceCodeInfo struct {
+ // A Location identifies a piece of source code in a .proto file which
+ // corresponds to a particular definition. This information is intended
+ // to be useful to IDEs, code indexers, documentation generators, and similar
+ // tools.
+ //
+ // For example, say we have a file like:
+ // message Foo {
+ // optional string foo = 1;
+ // }
+ // Let's look at just the field definition:
+ // optional string foo = 1;
+ // ^ ^^ ^^ ^ ^^^
+ // a bc de f ghi
+ // We have the following locations:
+ // span path represents
+ // [a,i) [ 4, 0, 2, 0 ] The whole field definition.
+ // [a,b) [ 4, 0, 2, 0, 4 ] The label (optional).
+ // [c,d) [ 4, 0, 2, 0, 5 ] The type (string).
+ // [e,f) [ 4, 0, 2, 0, 1 ] The name (foo).
+ // [g,h) [ 4, 0, 2, 0, 3 ] The number (1).
+ //
+ // Notes:
+ // - A location may refer to a repeated field itself (i.e. not to any
+ // particular index within it). This is used whenever a set of elements are
+ // logically enclosed in a single code segment. For example, an entire
+ // extend block (possibly containing multiple extension definitions) will
+ // have an outer location whose path refers to the "extensions" repeated
+ // field without an index.
+ // - Multiple locations may have the same path. This happens when a single
+ // logical declaration is spread out across multiple places. The most
+ // obvious example is the "extend" block again -- there may be multiple
+ // extend blocks in the same scope, each of which will have the same path.
+ // - A location's span is not always a subset of its parent's span. For
+ // example, the "extendee" of an extension declaration appears at the
+ // beginning of the "extend" block and is shared by all extensions within
+ // the block.
+ // - Just because a location's span is a subset of some other location's span
+ // does not mean that it is a descendent. For example, a "group" defines
+ // both a type and a field in a single declaration. Thus, the locations
+ // corresponding to the type and field and their components will overlap.
+ // - Code which tries to interpret locations should probably be designed to
+ // ignore those that it doesn't understand, as more types of locations could
+ // be recorded in the future.
+ Location []*SourceCodeInfo_Location `protobuf:"bytes,1,rep,name=location" json:"location,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SourceCodeInfo) Reset() { *m = SourceCodeInfo{} }
+func (m *SourceCodeInfo) String() string { return proto.CompactTextString(m) }
+func (*SourceCodeInfo) ProtoMessage() {}
+func (*SourceCodeInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{19}
+}
+func (m *SourceCodeInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SourceCodeInfo.Unmarshal(m, b)
+}
+func (m *SourceCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SourceCodeInfo.Marshal(b, m, deterministic)
+}
+func (dst *SourceCodeInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SourceCodeInfo.Merge(dst, src)
+}
+func (m *SourceCodeInfo) XXX_Size() int {
+ return xxx_messageInfo_SourceCodeInfo.Size(m)
+}
+func (m *SourceCodeInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_SourceCodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SourceCodeInfo proto.InternalMessageInfo
+
+func (m *SourceCodeInfo) GetLocation() []*SourceCodeInfo_Location {
+ if m != nil {
+ return m.Location
+ }
+ return nil
+}
+
+type SourceCodeInfo_Location struct {
+ // Identifies which part of the FileDescriptorProto was defined at this
+ // location.
+ //
+ // Each element is a field number or an index. They form a path from
+ // the root FileDescriptorProto to the place where the definition. For
+ // example, this path:
+ // [ 4, 3, 2, 7, 1 ]
+ // refers to:
+ // file.message_type(3) // 4, 3
+ // .field(7) // 2, 7
+ // .name() // 1
+ // This is because FileDescriptorProto.message_type has field number 4:
+ // repeated DescriptorProto message_type = 4;
+ // and DescriptorProto.field has field number 2:
+ // repeated FieldDescriptorProto field = 2;
+ // and FieldDescriptorProto.name has field number 1:
+ // optional string name = 1;
+ //
+ // Thus, the above path gives the location of a field name. If we removed
+ // the last element:
+ // [ 4, 3, 2, 7 ]
+ // this path refers to the whole field declaration (from the beginning
+ // of the label to the terminating semicolon).
+ Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+ // Always has exactly three or four elements: start line, start column,
+ // end line (optional, otherwise assumed same as start line), end column.
+ // These are packed into a single field for efficiency. Note that line
+ // and column numbers are zero-based -- typically you will want to add
+ // 1 to each before displaying to a user.
+ Span []int32 `protobuf:"varint,2,rep,packed,name=span" json:"span,omitempty"`
+ // If this SourceCodeInfo represents a complete declaration, these are any
+ // comments appearing before and after the declaration which appear to be
+ // attached to the declaration.
+ //
+ // A series of line comments appearing on consecutive lines, with no other
+ // tokens appearing on those lines, will be treated as a single comment.
+ //
+ // leading_detached_comments will keep paragraphs of comments that appear
+ // before (but not connected to) the current element. Each paragraph,
+ // separated by empty lines, will be one comment element in the repeated
+ // field.
+ //
+ // Only the comment content is provided; comment markers (e.g. //) are
+ // stripped out. For block comments, leading whitespace and an asterisk
+ // will be stripped from the beginning of each line other than the first.
+ // Newlines are included in the output.
+ //
+ // Examples:
+ //
+ // optional int32 foo = 1; // Comment attached to foo.
+ // // Comment attached to bar.
+ // optional int32 bar = 2;
+ //
+ // optional string baz = 3;
+ // // Comment attached to baz.
+ // // Another line attached to baz.
+ //
+ // // Comment attached to qux.
+ // //
+ // // Another line attached to qux.
+ // optional double qux = 4;
+ //
+ // // Detached comment for corge. This is not leading or trailing comments
+ // // to qux or corge because there are blank lines separating it from
+ // // both.
+ //
+ // // Detached comment for corge paragraph 2.
+ //
+ // optional string corge = 5;
+ // /* Block comment attached
+ // * to corge. Leading asterisks
+ // * will be removed. */
+ // /* Block comment attached to
+ // * grault. */
+ // optional int32 grault = 6;
+ //
+ // // ignored detached comments.
+ LeadingComments *string `protobuf:"bytes,3,opt,name=leading_comments,json=leadingComments" json:"leading_comments,omitempty"`
+ TrailingComments *string `protobuf:"bytes,4,opt,name=trailing_comments,json=trailingComments" json:"trailing_comments,omitempty"`
+ LeadingDetachedComments []string `protobuf:"bytes,6,rep,name=leading_detached_comments,json=leadingDetachedComments" json:"leading_detached_comments,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *SourceCodeInfo_Location) Reset() { *m = SourceCodeInfo_Location{} }
+func (m *SourceCodeInfo_Location) String() string { return proto.CompactTextString(m) }
+func (*SourceCodeInfo_Location) ProtoMessage() {}
+func (*SourceCodeInfo_Location) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{19, 0}
+}
+func (m *SourceCodeInfo_Location) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_SourceCodeInfo_Location.Unmarshal(m, b)
+}
+func (m *SourceCodeInfo_Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_SourceCodeInfo_Location.Marshal(b, m, deterministic)
+}
+func (dst *SourceCodeInfo_Location) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_SourceCodeInfo_Location.Merge(dst, src)
+}
+func (m *SourceCodeInfo_Location) XXX_Size() int {
+ return xxx_messageInfo_SourceCodeInfo_Location.Size(m)
+}
+func (m *SourceCodeInfo_Location) XXX_DiscardUnknown() {
+ xxx_messageInfo_SourceCodeInfo_Location.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_SourceCodeInfo_Location proto.InternalMessageInfo
+
+func (m *SourceCodeInfo_Location) GetPath() []int32 {
+ if m != nil {
+ return m.Path
+ }
+ return nil
+}
+
+func (m *SourceCodeInfo_Location) GetSpan() []int32 {
+ if m != nil {
+ return m.Span
+ }
+ return nil
+}
+
+func (m *SourceCodeInfo_Location) GetLeadingComments() string {
+ if m != nil && m.LeadingComments != nil {
+ return *m.LeadingComments
+ }
+ return ""
+}
+
+func (m *SourceCodeInfo_Location) GetTrailingComments() string {
+ if m != nil && m.TrailingComments != nil {
+ return *m.TrailingComments
+ }
+ return ""
+}
+
+func (m *SourceCodeInfo_Location) GetLeadingDetachedComments() []string {
+ if m != nil {
+ return m.LeadingDetachedComments
+ }
+ return nil
+}
+
+// Describes the relationship between generated code and its original source
+// file. A GeneratedCodeInfo message is associated with only one generated
+// source file, but may contain references to different source .proto files.
+type GeneratedCodeInfo struct {
+ // An Annotation connects some span of text in generated code to an element
+ // of its generating .proto file.
+ Annotation []*GeneratedCodeInfo_Annotation `protobuf:"bytes,1,rep,name=annotation" json:"annotation,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GeneratedCodeInfo) Reset() { *m = GeneratedCodeInfo{} }
+func (m *GeneratedCodeInfo) String() string { return proto.CompactTextString(m) }
+func (*GeneratedCodeInfo) ProtoMessage() {}
+func (*GeneratedCodeInfo) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{20}
+}
+func (m *GeneratedCodeInfo) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GeneratedCodeInfo.Unmarshal(m, b)
+}
+func (m *GeneratedCodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GeneratedCodeInfo.Marshal(b, m, deterministic)
+}
+func (dst *GeneratedCodeInfo) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GeneratedCodeInfo.Merge(dst, src)
+}
+func (m *GeneratedCodeInfo) XXX_Size() int {
+ return xxx_messageInfo_GeneratedCodeInfo.Size(m)
+}
+func (m *GeneratedCodeInfo) XXX_DiscardUnknown() {
+ xxx_messageInfo_GeneratedCodeInfo.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneratedCodeInfo proto.InternalMessageInfo
+
+func (m *GeneratedCodeInfo) GetAnnotation() []*GeneratedCodeInfo_Annotation {
+ if m != nil {
+ return m.Annotation
+ }
+ return nil
+}
+
+type GeneratedCodeInfo_Annotation struct {
+ // Identifies the element in the original source .proto file. This field
+ // is formatted the same as SourceCodeInfo.Location.path.
+ Path []int32 `protobuf:"varint,1,rep,packed,name=path" json:"path,omitempty"`
+ // Identifies the filesystem path to the original source .proto.
+ SourceFile *string `protobuf:"bytes,2,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
+ // Identifies the starting offset in bytes in the generated code
+ // that relates to the identified object.
+ Begin *int32 `protobuf:"varint,3,opt,name=begin" json:"begin,omitempty"`
+ // Identifies the ending offset in bytes in the generated code that
+ // relates to the identified offset. The end offset should be one past
+ // the last relevant byte (so the length of the text = end - begin).
+ End *int32 `protobuf:"varint,4,opt,name=end" json:"end,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *GeneratedCodeInfo_Annotation) Reset() { *m = GeneratedCodeInfo_Annotation{} }
+func (m *GeneratedCodeInfo_Annotation) String() string { return proto.CompactTextString(m) }
+func (*GeneratedCodeInfo_Annotation) ProtoMessage() {}
+func (*GeneratedCodeInfo_Annotation) Descriptor() ([]byte, []int) {
+ return fileDescriptor_descriptor_4df4cb5f42392df6, []int{20, 0}
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_GeneratedCodeInfo_Annotation.Unmarshal(m, b)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_GeneratedCodeInfo_Annotation.Marshal(b, m, deterministic)
+}
+func (dst *GeneratedCodeInfo_Annotation) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GeneratedCodeInfo_Annotation.Merge(dst, src)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_Size() int {
+ return xxx_messageInfo_GeneratedCodeInfo_Annotation.Size(m)
+}
+func (m *GeneratedCodeInfo_Annotation) XXX_DiscardUnknown() {
+ xxx_messageInfo_GeneratedCodeInfo_Annotation.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GeneratedCodeInfo_Annotation proto.InternalMessageInfo
+
+func (m *GeneratedCodeInfo_Annotation) GetPath() []int32 {
+ if m != nil {
+ return m.Path
+ }
+ return nil
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetSourceFile() string {
+ if m != nil && m.SourceFile != nil {
+ return *m.SourceFile
+ }
+ return ""
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetBegin() int32 {
+ if m != nil && m.Begin != nil {
+ return *m.Begin
+ }
+ return 0
+}
+
+func (m *GeneratedCodeInfo_Annotation) GetEnd() int32 {
+ if m != nil && m.End != nil {
+ return *m.End
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*FileDescriptorSet)(nil), "google.protobuf.FileDescriptorSet")
+ proto.RegisterType((*FileDescriptorProto)(nil), "google.protobuf.FileDescriptorProto")
+ proto.RegisterType((*DescriptorProto)(nil), "google.protobuf.DescriptorProto")
+ proto.RegisterType((*DescriptorProto_ExtensionRange)(nil), "google.protobuf.DescriptorProto.ExtensionRange")
+ proto.RegisterType((*DescriptorProto_ReservedRange)(nil), "google.protobuf.DescriptorProto.ReservedRange")
+ proto.RegisterType((*ExtensionRangeOptions)(nil), "google.protobuf.ExtensionRangeOptions")
+ proto.RegisterType((*FieldDescriptorProto)(nil), "google.protobuf.FieldDescriptorProto")
+ proto.RegisterType((*OneofDescriptorProto)(nil), "google.protobuf.OneofDescriptorProto")
+ proto.RegisterType((*EnumDescriptorProto)(nil), "google.protobuf.EnumDescriptorProto")
+ proto.RegisterType((*EnumDescriptorProto_EnumReservedRange)(nil), "google.protobuf.EnumDescriptorProto.EnumReservedRange")
+ proto.RegisterType((*EnumValueDescriptorProto)(nil), "google.protobuf.EnumValueDescriptorProto")
+ proto.RegisterType((*ServiceDescriptorProto)(nil), "google.protobuf.ServiceDescriptorProto")
+ proto.RegisterType((*MethodDescriptorProto)(nil), "google.protobuf.MethodDescriptorProto")
+ proto.RegisterType((*FileOptions)(nil), "google.protobuf.FileOptions")
+ proto.RegisterType((*MessageOptions)(nil), "google.protobuf.MessageOptions")
+ proto.RegisterType((*FieldOptions)(nil), "google.protobuf.FieldOptions")
+ proto.RegisterType((*OneofOptions)(nil), "google.protobuf.OneofOptions")
+ proto.RegisterType((*EnumOptions)(nil), "google.protobuf.EnumOptions")
+ proto.RegisterType((*EnumValueOptions)(nil), "google.protobuf.EnumValueOptions")
+ proto.RegisterType((*ServiceOptions)(nil), "google.protobuf.ServiceOptions")
+ proto.RegisterType((*MethodOptions)(nil), "google.protobuf.MethodOptions")
+ proto.RegisterType((*UninterpretedOption)(nil), "google.protobuf.UninterpretedOption")
+ proto.RegisterType((*UninterpretedOption_NamePart)(nil), "google.protobuf.UninterpretedOption.NamePart")
+ proto.RegisterType((*SourceCodeInfo)(nil), "google.protobuf.SourceCodeInfo")
+ proto.RegisterType((*SourceCodeInfo_Location)(nil), "google.protobuf.SourceCodeInfo.Location")
+ proto.RegisterType((*GeneratedCodeInfo)(nil), "google.protobuf.GeneratedCodeInfo")
+ proto.RegisterType((*GeneratedCodeInfo_Annotation)(nil), "google.protobuf.GeneratedCodeInfo.Annotation")
+ proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Type", FieldDescriptorProto_Type_name, FieldDescriptorProto_Type_value)
+ proto.RegisterEnum("google.protobuf.FieldDescriptorProto_Label", FieldDescriptorProto_Label_name, FieldDescriptorProto_Label_value)
+ proto.RegisterEnum("google.protobuf.FileOptions_OptimizeMode", FileOptions_OptimizeMode_name, FileOptions_OptimizeMode_value)
+ proto.RegisterEnum("google.protobuf.FieldOptions_CType", FieldOptions_CType_name, FieldOptions_CType_value)
+ proto.RegisterEnum("google.protobuf.FieldOptions_JSType", FieldOptions_JSType_name, FieldOptions_JSType_value)
+ proto.RegisterEnum("google.protobuf.MethodOptions_IdempotencyLevel", MethodOptions_IdempotencyLevel_name, MethodOptions_IdempotencyLevel_value)
+}
+
+func init() {
+ proto.RegisterFile("google/protobuf/descriptor.proto", fileDescriptor_descriptor_4df4cb5f42392df6)
+}
+
+var fileDescriptor_descriptor_4df4cb5f42392df6 = []byte{
+ // 2555 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x59, 0xdd, 0x6e, 0x1b, 0xc7,
+ 0xf5, 0xcf, 0xf2, 0x4b, 0xe4, 0x21, 0x45, 0x8d, 0x46, 0x8a, 0xbd, 0x56, 0x3e, 0x2c, 0x33, 0x1f,
+ 0x96, 0x9d, 0x7f, 0xa8, 0xc0, 0xb1, 0x1d, 0x47, 0xfe, 0x23, 0x2d, 0x45, 0xae, 0x15, 0xaa, 0x12,
+ 0xc9, 0x2e, 0xa9, 0xe6, 0x03, 0x28, 0x16, 0xa3, 0xdd, 0x21, 0xb9, 0xf6, 0x72, 0x77, 0xb3, 0xbb,
+ 0xb4, 0xad, 0xa0, 0x17, 0x06, 0x7a, 0xd5, 0xab, 0xde, 0x16, 0x45, 0xd1, 0x8b, 0xde, 0x04, 0xe8,
+ 0x03, 0x14, 0xc8, 0x5d, 0x9f, 0xa0, 0x40, 0xde, 0xa0, 0x68, 0x0b, 0xb4, 0x8f, 0xd0, 0xcb, 0x62,
+ 0x66, 0x76, 0x97, 0xbb, 0x24, 0x15, 0x2b, 0x01, 0xe2, 0x5c, 0x91, 0xf3, 0x9b, 0xdf, 0x39, 0x73,
+ 0xe6, 0xcc, 0x99, 0x33, 0x67, 0x66, 0x61, 0x7b, 0xe4, 0x38, 0x23, 0x8b, 0xee, 0xba, 0x9e, 0x13,
+ 0x38, 0xa7, 0xd3, 0xe1, 0xae, 0x41, 0x7d, 0xdd, 0x33, 0xdd, 0xc0, 0xf1, 0xea, 0x1c, 0xc3, 0x6b,
+ 0x82, 0x51, 0x8f, 0x18, 0xb5, 0x63, 0x58, 0x7f, 0x60, 0x5a, 0xb4, 0x15, 0x13, 0xfb, 0x34, 0xc0,
+ 0xf7, 0x20, 0x37, 0x34, 0x2d, 0x2a, 0x4b, 0xdb, 0xd9, 0x9d, 0xf2, 0xad, 0x37, 0xeb, 0x73, 0x42,
+ 0xf5, 0xb4, 0x44, 0x8f, 0xc1, 0x2a, 0x97, 0xa8, 0xfd, 0x2b, 0x07, 0x1b, 0x4b, 0x7a, 0x31, 0x86,
+ 0x9c, 0x4d, 0x26, 0x4c, 0xa3, 0xb4, 0x53, 0x52, 0xf9, 0x7f, 0x2c, 0xc3, 0x8a, 0x4b, 0xf4, 0x47,
+ 0x64, 0x44, 0xe5, 0x0c, 0x87, 0xa3, 0x26, 0x7e, 0x1d, 0xc0, 0xa0, 0x2e, 0xb5, 0x0d, 0x6a, 0xeb,
+ 0x67, 0x72, 0x76, 0x3b, 0xbb, 0x53, 0x52, 0x13, 0x08, 0x7e, 0x07, 0xd6, 0xdd, 0xe9, 0xa9, 0x65,
+ 0xea, 0x5a, 0x82, 0x06, 0xdb, 0xd9, 0x9d, 0xbc, 0x8a, 0x44, 0x47, 0x6b, 0x46, 0xbe, 0x0e, 0x6b,
+ 0x4f, 0x28, 0x79, 0x94, 0xa4, 0x96, 0x39, 0xb5, 0xca, 0xe0, 0x04, 0xb1, 0x09, 0x95, 0x09, 0xf5,
+ 0x7d, 0x32, 0xa2, 0x5a, 0x70, 0xe6, 0x52, 0x39, 0xc7, 0x67, 0xbf, 0xbd, 0x30, 0xfb, 0xf9, 0x99,
+ 0x97, 0x43, 0xa9, 0xc1, 0x99, 0x4b, 0x71, 0x03, 0x4a, 0xd4, 0x9e, 0x4e, 0x84, 0x86, 0xfc, 0x39,
+ 0xfe, 0x53, 0xec, 0xe9, 0x64, 0x5e, 0x4b, 0x91, 0x89, 0x85, 0x2a, 0x56, 0x7c, 0xea, 0x3d, 0x36,
+ 0x75, 0x2a, 0x17, 0xb8, 0x82, 0xeb, 0x0b, 0x0a, 0xfa, 0xa2, 0x7f, 0x5e, 0x47, 0x24, 0x87, 0x9b,
+ 0x50, 0xa2, 0x4f, 0x03, 0x6a, 0xfb, 0xa6, 0x63, 0xcb, 0x2b, 0x5c, 0xc9, 0x5b, 0x4b, 0x56, 0x91,
+ 0x5a, 0xc6, 0xbc, 0x8a, 0x99, 0x1c, 0xbe, 0x0b, 0x2b, 0x8e, 0x1b, 0x98, 0x8e, 0xed, 0xcb, 0xc5,
+ 0x6d, 0x69, 0xa7, 0x7c, 0xeb, 0xd5, 0xa5, 0x81, 0xd0, 0x15, 0x1c, 0x35, 0x22, 0xe3, 0x36, 0x20,
+ 0xdf, 0x99, 0x7a, 0x3a, 0xd5, 0x74, 0xc7, 0xa0, 0x9a, 0x69, 0x0f, 0x1d, 0xb9, 0xc4, 0x15, 0x5c,
+ 0x5d, 0x9c, 0x08, 0x27, 0x36, 0x1d, 0x83, 0xb6, 0xed, 0xa1, 0xa3, 0x56, 0xfd, 0x54, 0x1b, 0x5f,
+ 0x82, 0x82, 0x7f, 0x66, 0x07, 0xe4, 0xa9, 0x5c, 0xe1, 0x11, 0x12, 0xb6, 0x6a, 0x5f, 0x17, 0x60,
+ 0xed, 0x22, 0x21, 0x76, 0x1f, 0xf2, 0x43, 0x36, 0x4b, 0x39, 0xf3, 0x5d, 0x7c, 0x20, 0x64, 0xd2,
+ 0x4e, 0x2c, 0x7c, 0x4f, 0x27, 0x36, 0xa0, 0x6c, 0x53, 0x3f, 0xa0, 0x86, 0x88, 0x88, 0xec, 0x05,
+ 0x63, 0x0a, 0x84, 0xd0, 0x62, 0x48, 0xe5, 0xbe, 0x57, 0x48, 0x7d, 0x0a, 0x6b, 0xb1, 0x49, 0x9a,
+ 0x47, 0xec, 0x51, 0x14, 0x9b, 0xbb, 0xcf, 0xb3, 0xa4, 0xae, 0x44, 0x72, 0x2a, 0x13, 0x53, 0xab,
+ 0x34, 0xd5, 0xc6, 0x2d, 0x00, 0xc7, 0xa6, 0xce, 0x50, 0x33, 0xa8, 0x6e, 0xc9, 0xc5, 0x73, 0xbc,
+ 0xd4, 0x65, 0x94, 0x05, 0x2f, 0x39, 0x02, 0xd5, 0x2d, 0xfc, 0xe1, 0x2c, 0xd4, 0x56, 0xce, 0x89,
+ 0x94, 0x63, 0xb1, 0xc9, 0x16, 0xa2, 0xed, 0x04, 0xaa, 0x1e, 0x65, 0x71, 0x4f, 0x8d, 0x70, 0x66,
+ 0x25, 0x6e, 0x44, 0xfd, 0xb9, 0x33, 0x53, 0x43, 0x31, 0x31, 0xb1, 0x55, 0x2f, 0xd9, 0xc4, 0x6f,
+ 0x40, 0x0c, 0x68, 0x3c, 0xac, 0x80, 0x67, 0xa1, 0x4a, 0x04, 0x76, 0xc8, 0x84, 0x6e, 0x7d, 0x09,
+ 0xd5, 0xb4, 0x7b, 0xf0, 0x26, 0xe4, 0xfd, 0x80, 0x78, 0x01, 0x8f, 0xc2, 0xbc, 0x2a, 0x1a, 0x18,
+ 0x41, 0x96, 0xda, 0x06, 0xcf, 0x72, 0x79, 0x95, 0xfd, 0xc5, 0x3f, 0x9d, 0x4d, 0x38, 0xcb, 0x27,
+ 0xfc, 0xf6, 0xe2, 0x8a, 0xa6, 0x34, 0xcf, 0xcf, 0x7b, 0xeb, 0x03, 0x58, 0x4d, 0x4d, 0xe0, 0xa2,
+ 0x43, 0xd7, 0x7e, 0x05, 0x2f, 0x2f, 0x55, 0x8d, 0x3f, 0x85, 0xcd, 0xa9, 0x6d, 0xda, 0x01, 0xf5,
+ 0x5c, 0x8f, 0xb2, 0x88, 0x15, 0x43, 0xc9, 0xff, 0x5e, 0x39, 0x27, 0xe6, 0x4e, 0x92, 0x6c, 0xa1,
+ 0x45, 0xdd, 0x98, 0x2e, 0x82, 0x37, 0x4b, 0xc5, 0xff, 0xac, 0xa0, 0x67, 0xcf, 0x9e, 0x3d, 0xcb,
+ 0xd4, 0x7e, 0x57, 0x80, 0xcd, 0x65, 0x7b, 0x66, 0xe9, 0xf6, 0xbd, 0x04, 0x05, 0x7b, 0x3a, 0x39,
+ 0xa5, 0x1e, 0x77, 0x52, 0x5e, 0x0d, 0x5b, 0xb8, 0x01, 0x79, 0x8b, 0x9c, 0x52, 0x4b, 0xce, 0x6d,
+ 0x4b, 0x3b, 0xd5, 0x5b, 0xef, 0x5c, 0x68, 0x57, 0xd6, 0x8f, 0x98, 0x88, 0x2a, 0x24, 0xf1, 0x47,
+ 0x90, 0x0b, 0x53, 0x34, 0xd3, 0x70, 0xf3, 0x62, 0x1a, 0xd8, 0x5e, 0x52, 0xb9, 0x1c, 0x7e, 0x05,
+ 0x4a, 0xec, 0x57, 0xc4, 0x46, 0x81, 0xdb, 0x5c, 0x64, 0x00, 0x8b, 0x0b, 0xbc, 0x05, 0x45, 0xbe,
+ 0x4d, 0x0c, 0x1a, 0x1d, 0x6d, 0x71, 0x9b, 0x05, 0x96, 0x41, 0x87, 0x64, 0x6a, 0x05, 0xda, 0x63,
+ 0x62, 0x4d, 0x29, 0x0f, 0xf8, 0x92, 0x5a, 0x09, 0xc1, 0x5f, 0x30, 0x0c, 0x5f, 0x85, 0xb2, 0xd8,
+ 0x55, 0xa6, 0x6d, 0xd0, 0xa7, 0x3c, 0x7b, 0xe6, 0x55, 0xb1, 0xd1, 0xda, 0x0c, 0x61, 0xc3, 0x3f,
+ 0xf4, 0x1d, 0x3b, 0x0a, 0x4d, 0x3e, 0x04, 0x03, 0xf8, 0xf0, 0x1f, 0xcc, 0x27, 0xee, 0xd7, 0x96,
+ 0x4f, 0x6f, 0x3e, 0xa6, 0x6a, 0x7f, 0xc9, 0x40, 0x8e, 0xe7, 0x8b, 0x35, 0x28, 0x0f, 0x3e, 0xeb,
+ 0x29, 0x5a, 0xab, 0x7b, 0xb2, 0x7f, 0xa4, 0x20, 0x09, 0x57, 0x01, 0x38, 0xf0, 0xe0, 0xa8, 0xdb,
+ 0x18, 0xa0, 0x4c, 0xdc, 0x6e, 0x77, 0x06, 0x77, 0x6f, 0xa3, 0x6c, 0x2c, 0x70, 0x22, 0x80, 0x5c,
+ 0x92, 0xf0, 0xfe, 0x2d, 0x94, 0xc7, 0x08, 0x2a, 0x42, 0x41, 0xfb, 0x53, 0xa5, 0x75, 0xf7, 0x36,
+ 0x2a, 0xa4, 0x91, 0xf7, 0x6f, 0xa1, 0x15, 0xbc, 0x0a, 0x25, 0x8e, 0xec, 0x77, 0xbb, 0x47, 0xa8,
+ 0x18, 0xeb, 0xec, 0x0f, 0xd4, 0x76, 0xe7, 0x00, 0x95, 0x62, 0x9d, 0x07, 0x6a, 0xf7, 0xa4, 0x87,
+ 0x20, 0xd6, 0x70, 0xac, 0xf4, 0xfb, 0x8d, 0x03, 0x05, 0x95, 0x63, 0xc6, 0xfe, 0x67, 0x03, 0xa5,
+ 0x8f, 0x2a, 0x29, 0xb3, 0xde, 0xbf, 0x85, 0x56, 0xe3, 0x21, 0x94, 0xce, 0xc9, 0x31, 0xaa, 0xe2,
+ 0x75, 0x58, 0x15, 0x43, 0x44, 0x46, 0xac, 0xcd, 0x41, 0x77, 0x6f, 0x23, 0x34, 0x33, 0x44, 0x68,
+ 0x59, 0x4f, 0x01, 0x77, 0x6f, 0x23, 0x5c, 0x6b, 0x42, 0x9e, 0x47, 0x17, 0xc6, 0x50, 0x3d, 0x6a,
+ 0xec, 0x2b, 0x47, 0x5a, 0xb7, 0x37, 0x68, 0x77, 0x3b, 0x8d, 0x23, 0x24, 0xcd, 0x30, 0x55, 0xf9,
+ 0xf9, 0x49, 0x5b, 0x55, 0x5a, 0x28, 0x93, 0xc4, 0x7a, 0x4a, 0x63, 0xa0, 0xb4, 0x50, 0xb6, 0xa6,
+ 0xc3, 0xe6, 0xb2, 0x3c, 0xb9, 0x74, 0x67, 0x24, 0x96, 0x38, 0x73, 0xce, 0x12, 0x73, 0x5d, 0x0b,
+ 0x4b, 0xfc, 0xcf, 0x0c, 0x6c, 0x2c, 0x39, 0x2b, 0x96, 0x0e, 0xf2, 0x13, 0xc8, 0x8b, 0x10, 0x15,
+ 0xa7, 0xe7, 0x8d, 0xa5, 0x87, 0x0e, 0x0f, 0xd8, 0x85, 0x13, 0x94, 0xcb, 0x25, 0x2b, 0x88, 0xec,
+ 0x39, 0x15, 0x04, 0x53, 0xb1, 0x90, 0xd3, 0x7f, 0xb9, 0x90, 0xd3, 0xc5, 0xb1, 0x77, 0xf7, 0x22,
+ 0xc7, 0x1e, 0xc7, 0xbe, 0x5b, 0x6e, 0xcf, 0x2f, 0xc9, 0xed, 0xf7, 0x61, 0x7d, 0x41, 0xd1, 0x85,
+ 0x73, 0xec, 0xaf, 0x25, 0x90, 0xcf, 0x73, 0xce, 0x73, 0x32, 0x5d, 0x26, 0x95, 0xe9, 0xee, 0xcf,
+ 0x7b, 0xf0, 0xda, 0xf9, 0x8b, 0xb0, 0xb0, 0xd6, 0x5f, 0x49, 0x70, 0x69, 0x79, 0xa5, 0xb8, 0xd4,
+ 0x86, 0x8f, 0xa0, 0x30, 0xa1, 0xc1, 0xd8, 0x89, 0xaa, 0xa5, 0xb7, 0x97, 0x9c, 0xc1, 0xac, 0x7b,
+ 0x7e, 0xb1, 0x43, 0xa9, 0xe4, 0x21, 0x9e, 0x3d, 0xaf, 0xdc, 0x13, 0xd6, 0x2c, 0x58, 0xfa, 0x9b,
+ 0x0c, 0xbc, 0xbc, 0x54, 0xf9, 0x52, 0x43, 0x5f, 0x03, 0x30, 0x6d, 0x77, 0x1a, 0x88, 0x8a, 0x48,
+ 0x24, 0xd8, 0x12, 0x47, 0x78, 0xf2, 0x62, 0xc9, 0x73, 0x1a, 0xc4, 0xfd, 0x59, 0xde, 0x0f, 0x02,
+ 0xe2, 0x84, 0x7b, 0x33, 0x43, 0x73, 0xdc, 0xd0, 0xd7, 0xcf, 0x99, 0xe9, 0x42, 0x60, 0xbe, 0x07,
+ 0x48, 0xb7, 0x4c, 0x6a, 0x07, 0x9a, 0x1f, 0x78, 0x94, 0x4c, 0x4c, 0x7b, 0xc4, 0x4f, 0x90, 0xe2,
+ 0x5e, 0x7e, 0x48, 0x2c, 0x9f, 0xaa, 0x6b, 0xa2, 0xbb, 0x1f, 0xf5, 0x32, 0x09, 0x1e, 0x40, 0x5e,
+ 0x42, 0xa2, 0x90, 0x92, 0x10, 0xdd, 0xb1, 0x44, 0xed, 0xeb, 0x22, 0x94, 0x13, 0x75, 0x35, 0xbe,
+ 0x06, 0x95, 0x87, 0xe4, 0x31, 0xd1, 0xa2, 0xbb, 0x92, 0xf0, 0x44, 0x99, 0x61, 0xbd, 0xf0, 0xbe,
+ 0xf4, 0x1e, 0x6c, 0x72, 0x8a, 0x33, 0x0d, 0xa8, 0xa7, 0xe9, 0x16, 0xf1, 0x7d, 0xee, 0xb4, 0x22,
+ 0xa7, 0x62, 0xd6, 0xd7, 0x65, 0x5d, 0xcd, 0xa8, 0x07, 0xdf, 0x81, 0x0d, 0x2e, 0x31, 0x99, 0x5a,
+ 0x81, 0xe9, 0x5a, 0x54, 0x63, 0xb7, 0x37, 0x9f, 0x9f, 0x24, 0xb1, 0x65, 0xeb, 0x8c, 0x71, 0x1c,
+ 0x12, 0x98, 0x45, 0x3e, 0x6e, 0xc1, 0x6b, 0x5c, 0x6c, 0x44, 0x6d, 0xea, 0x91, 0x80, 0x6a, 0xf4,
+ 0x8b, 0x29, 0xb1, 0x7c, 0x8d, 0xd8, 0x86, 0x36, 0x26, 0xfe, 0x58, 0xde, 0x64, 0x0a, 0xf6, 0x33,
+ 0xb2, 0xa4, 0x5e, 0x61, 0xc4, 0x83, 0x90, 0xa7, 0x70, 0x5a, 0xc3, 0x36, 0x3e, 0x26, 0xfe, 0x18,
+ 0xef, 0xc1, 0x25, 0xae, 0xc5, 0x0f, 0x3c, 0xd3, 0x1e, 0x69, 0xfa, 0x98, 0xea, 0x8f, 0xb4, 0x69,
+ 0x30, 0xbc, 0x27, 0xbf, 0x92, 0x1c, 0x9f, 0x5b, 0xd8, 0xe7, 0x9c, 0x26, 0xa3, 0x9c, 0x04, 0xc3,
+ 0x7b, 0xb8, 0x0f, 0x15, 0xb6, 0x18, 0x13, 0xf3, 0x4b, 0xaa, 0x0d, 0x1d, 0x8f, 0x1f, 0x8d, 0xd5,
+ 0x25, 0xa9, 0x29, 0xe1, 0xc1, 0x7a, 0x37, 0x14, 0x38, 0x76, 0x0c, 0xba, 0x97, 0xef, 0xf7, 0x14,
+ 0xa5, 0xa5, 0x96, 0x23, 0x2d, 0x0f, 0x1c, 0x8f, 0x05, 0xd4, 0xc8, 0x89, 0x1d, 0x5c, 0x16, 0x01,
+ 0x35, 0x72, 0x22, 0xf7, 0xde, 0x81, 0x0d, 0x5d, 0x17, 0x73, 0x36, 0x75, 0x2d, 0xbc, 0x63, 0xf9,
+ 0x32, 0x4a, 0x39, 0x4b, 0xd7, 0x0f, 0x04, 0x21, 0x8c, 0x71, 0x1f, 0x7f, 0x08, 0x2f, 0xcf, 0x9c,
+ 0x95, 0x14, 0x5c, 0x5f, 0x98, 0xe5, 0xbc, 0xe8, 0x1d, 0xd8, 0x70, 0xcf, 0x16, 0x05, 0x71, 0x6a,
+ 0x44, 0xf7, 0x6c, 0x5e, 0xec, 0x03, 0xd8, 0x74, 0xc7, 0xee, 0xa2, 0xdc, 0xcd, 0xa4, 0x1c, 0x76,
+ 0xc7, 0xee, 0xbc, 0xe0, 0x5b, 0xfc, 0xc2, 0xed, 0x51, 0x9d, 0x04, 0xd4, 0x90, 0x2f, 0x27, 0xe9,
+ 0x89, 0x0e, 0xbc, 0x0b, 0x48, 0xd7, 0x35, 0x6a, 0x93, 0x53, 0x8b, 0x6a, 0xc4, 0xa3, 0x36, 0xf1,
+ 0xe5, 0xab, 0x49, 0x72, 0x55, 0xd7, 0x15, 0xde, 0xdb, 0xe0, 0x9d, 0xf8, 0x26, 0xac, 0x3b, 0xa7,
+ 0x0f, 0x75, 0x11, 0x92, 0x9a, 0xeb, 0xd1, 0xa1, 0xf9, 0x54, 0x7e, 0x93, 0xfb, 0x77, 0x8d, 0x75,
+ 0xf0, 0x80, 0xec, 0x71, 0x18, 0xdf, 0x00, 0xa4, 0xfb, 0x63, 0xe2, 0xb9, 0x3c, 0x27, 0xfb, 0x2e,
+ 0xd1, 0xa9, 0xfc, 0x96, 0xa0, 0x0a, 0xbc, 0x13, 0xc1, 0x6c, 0x4b, 0xf8, 0x4f, 0xcc, 0x61, 0x10,
+ 0x69, 0xbc, 0x2e, 0xb6, 0x04, 0xc7, 0x42, 0x6d, 0x3b, 0x80, 0x98, 0x2b, 0x52, 0x03, 0xef, 0x70,
+ 0x5a, 0xd5, 0x1d, 0xbb, 0xc9, 0x71, 0xdf, 0x80, 0x55, 0xc6, 0x9c, 0x0d, 0x7a, 0x43, 0x14, 0x64,
+ 0xee, 0x38, 0x31, 0xe2, 0x0f, 0x56, 0x1b, 0xd7, 0xf6, 0xa0, 0x92, 0x8c, 0x4f, 0x5c, 0x02, 0x11,
+ 0xa1, 0x48, 0x62, 0xc5, 0x4a, 0xb3, 0xdb, 0x62, 0x65, 0xc6, 0xe7, 0x0a, 0xca, 0xb0, 0x72, 0xe7,
+ 0xa8, 0x3d, 0x50, 0x34, 0xf5, 0xa4, 0x33, 0x68, 0x1f, 0x2b, 0x28, 0x9b, 0xa8, 0xab, 0x0f, 0x73,
+ 0xc5, 0xb7, 0xd1, 0xf5, 0xda, 0x37, 0x19, 0xa8, 0xa6, 0x2f, 0x4a, 0xf8, 0xff, 0xe1, 0x72, 0xf4,
+ 0xaa, 0xe1, 0xd3, 0x40, 0x7b, 0x62, 0x7a, 0x7c, 0xe3, 0x4c, 0x88, 0x38, 0xc4, 0xe2, 0xa5, 0xdb,
+ 0x0c, 0x59, 0x7d, 0x1a, 0x7c, 0x62, 0x7a, 0x6c, 0x5b, 0x4c, 0x48, 0x80, 0x8f, 0xe0, 0xaa, 0xed,
+ 0x68, 0x7e, 0x40, 0x6c, 0x83, 0x78, 0x86, 0x36, 0x7b, 0x4f, 0xd2, 0x88, 0xae, 0x53, 0xdf, 0x77,
+ 0xc4, 0x81, 0x15, 0x6b, 0x79, 0xd5, 0x76, 0xfa, 0x21, 0x79, 0x96, 0xc9, 0x1b, 0x21, 0x75, 0x2e,
+ 0xcc, 0xb2, 0xe7, 0x85, 0xd9, 0x2b, 0x50, 0x9a, 0x10, 0x57, 0xa3, 0x76, 0xe0, 0x9d, 0xf1, 0xf2,
+ 0xb8, 0xa8, 0x16, 0x27, 0xc4, 0x55, 0x58, 0xfb, 0x85, 0xdc, 0x52, 0x0e, 0x73, 0xc5, 0x22, 0x2a,
+ 0x1d, 0xe6, 0x8a, 0x25, 0x04, 0xb5, 0x7f, 0x64, 0xa1, 0x92, 0x2c, 0x97, 0xd9, 0xed, 0x43, 0xe7,
+ 0x27, 0x8b, 0xc4, 0x73, 0xcf, 0x1b, 0xdf, 0x5a, 0x5c, 0xd7, 0x9b, 0xec, 0xc8, 0xd9, 0x2b, 0x88,
+ 0x22, 0x56, 0x15, 0x92, 0xec, 0xb8, 0x67, 0xd9, 0x86, 0x8a, 0xa2, 0xa1, 0xa8, 0x86, 0x2d, 0x7c,
+ 0x00, 0x85, 0x87, 0x3e, 0xd7, 0x5d, 0xe0, 0xba, 0xdf, 0xfc, 0x76, 0xdd, 0x87, 0x7d, 0xae, 0xbc,
+ 0x74, 0xd8, 0xd7, 0x3a, 0x5d, 0xf5, 0xb8, 0x71, 0xa4, 0x86, 0xe2, 0xf8, 0x0a, 0xe4, 0x2c, 0xf2,
+ 0xe5, 0x59, 0xfa, 0x70, 0xe2, 0xd0, 0x45, 0x17, 0xe1, 0x0a, 0xe4, 0x9e, 0x50, 0xf2, 0x28, 0x7d,
+ 0x24, 0x70, 0xe8, 0x07, 0xdc, 0x0c, 0xbb, 0x90, 0xe7, 0xfe, 0xc2, 0x00, 0xa1, 0xc7, 0xd0, 0x4b,
+ 0xb8, 0x08, 0xb9, 0x66, 0x57, 0x65, 0x1b, 0x02, 0x41, 0x45, 0xa0, 0x5a, 0xaf, 0xad, 0x34, 0x15,
+ 0x94, 0xa9, 0xdd, 0x81, 0x82, 0x70, 0x02, 0xdb, 0x2c, 0xb1, 0x1b, 0xd0, 0x4b, 0x61, 0x33, 0xd4,
+ 0x21, 0x45, 0xbd, 0x27, 0xc7, 0xfb, 0x8a, 0x8a, 0x32, 0xe9, 0xa5, 0xce, 0xa1, 0x7c, 0xcd, 0x87,
+ 0x4a, 0xb2, 0x5e, 0x7e, 0x31, 0x77, 0xe1, 0xbf, 0x4a, 0x50, 0x4e, 0xd4, 0xbf, 0xac, 0x70, 0x21,
+ 0x96, 0xe5, 0x3c, 0xd1, 0x88, 0x65, 0x12, 0x3f, 0x0c, 0x0d, 0xe0, 0x50, 0x83, 0x21, 0x17, 0x5d,
+ 0xba, 0x17, 0xb4, 0x45, 0xf2, 0xa8, 0x50, 0xfb, 0xa3, 0x04, 0x68, 0xbe, 0x00, 0x9d, 0x33, 0x53,
+ 0xfa, 0x31, 0xcd, 0xac, 0xfd, 0x41, 0x82, 0x6a, 0xba, 0xea, 0x9c, 0x33, 0xef, 0xda, 0x8f, 0x6a,
+ 0xde, 0xdf, 0x33, 0xb0, 0x9a, 0xaa, 0x35, 0x2f, 0x6a, 0xdd, 0x17, 0xb0, 0x6e, 0x1a, 0x74, 0xe2,
+ 0x3a, 0x01, 0xb5, 0xf5, 0x33, 0xcd, 0xa2, 0x8f, 0xa9, 0x25, 0xd7, 0x78, 0xd2, 0xd8, 0xfd, 0xf6,
+ 0x6a, 0xb6, 0xde, 0x9e, 0xc9, 0x1d, 0x31, 0xb1, 0xbd, 0x8d, 0x76, 0x4b, 0x39, 0xee, 0x75, 0x07,
+ 0x4a, 0xa7, 0xf9, 0x99, 0x76, 0xd2, 0xf9, 0x59, 0xa7, 0xfb, 0x49, 0x47, 0x45, 0xe6, 0x1c, 0xed,
+ 0x07, 0xdc, 0xf6, 0x3d, 0x40, 0xf3, 0x46, 0xe1, 0xcb, 0xb0, 0xcc, 0x2c, 0xf4, 0x12, 0xde, 0x80,
+ 0xb5, 0x4e, 0x57, 0xeb, 0xb7, 0x5b, 0x8a, 0xa6, 0x3c, 0x78, 0xa0, 0x34, 0x07, 0x7d, 0xf1, 0x3e,
+ 0x11, 0xb3, 0x07, 0xa9, 0x0d, 0x5e, 0xfb, 0x7d, 0x16, 0x36, 0x96, 0x58, 0x82, 0x1b, 0xe1, 0xcd,
+ 0x42, 0x5c, 0x76, 0xde, 0xbd, 0x88, 0xf5, 0x75, 0x56, 0x10, 0xf4, 0x88, 0x17, 0x84, 0x17, 0x91,
+ 0x1b, 0xc0, 0xbc, 0x64, 0x07, 0xe6, 0xd0, 0xa4, 0x5e, 0xf8, 0x9c, 0x23, 0xae, 0x1b, 0x6b, 0x33,
+ 0x5c, 0xbc, 0xe8, 0xfc, 0x1f, 0x60, 0xd7, 0xf1, 0xcd, 0xc0, 0x7c, 0x4c, 0x35, 0xd3, 0x8e, 0xde,
+ 0x7e, 0xd8, 0xf5, 0x23, 0xa7, 0xa2, 0xa8, 0xa7, 0x6d, 0x07, 0x31, 0xdb, 0xa6, 0x23, 0x32, 0xc7,
+ 0x66, 0xc9, 0x3c, 0xab, 0xa2, 0xa8, 0x27, 0x66, 0x5f, 0x83, 0x8a, 0xe1, 0x4c, 0x59, 0x4d, 0x26,
+ 0x78, 0xec, 0xec, 0x90, 0xd4, 0xb2, 0xc0, 0x62, 0x4a, 0x58, 0x6d, 0xcf, 0x1e, 0x9d, 0x2a, 0x6a,
+ 0x59, 0x60, 0x82, 0x72, 0x1d, 0xd6, 0xc8, 0x68, 0xe4, 0x31, 0xe5, 0x91, 0x22, 0x71, 0x7f, 0xa8,
+ 0xc6, 0x30, 0x27, 0x6e, 0x1d, 0x42, 0x31, 0xf2, 0x03, 0x3b, 0xaa, 0x99, 0x27, 0x34, 0x57, 0x5c,
+ 0x8a, 0x33, 0x3b, 0x25, 0xb5, 0x68, 0x47, 0x9d, 0xd7, 0xa0, 0x62, 0xfa, 0xda, 0xec, 0x0d, 0x3d,
+ 0xb3, 0x9d, 0xd9, 0x29, 0xaa, 0x65, 0xd3, 0x8f, 0xdf, 0x1f, 0x6b, 0x5f, 0x65, 0xa0, 0x9a, 0xfe,
+ 0x06, 0x80, 0x5b, 0x50, 0xb4, 0x1c, 0x9d, 0xf0, 0xd0, 0x12, 0x1f, 0xa0, 0x76, 0x9e, 0xf3, 0xd9,
+ 0xa0, 0x7e, 0x14, 0xf2, 0xd5, 0x58, 0x72, 0xeb, 0x6f, 0x12, 0x14, 0x23, 0x18, 0x5f, 0x82, 0x9c,
+ 0x4b, 0x82, 0x31, 0x57, 0x97, 0xdf, 0xcf, 0x20, 0x49, 0xe5, 0x6d, 0x86, 0xfb, 0x2e, 0xb1, 0x79,
+ 0x08, 0x84, 0x38, 0x6b, 0xb3, 0x75, 0xb5, 0x28, 0x31, 0xf8, 0xe5, 0xc4, 0x99, 0x4c, 0xa8, 0x1d,
+ 0xf8, 0xd1, 0xba, 0x86, 0x78, 0x33, 0x84, 0xf1, 0x3b, 0xb0, 0x1e, 0x78, 0xc4, 0xb4, 0x52, 0xdc,
+ 0x1c, 0xe7, 0xa2, 0xa8, 0x23, 0x26, 0xef, 0xc1, 0x95, 0x48, 0xaf, 0x41, 0x03, 0xa2, 0x8f, 0xa9,
+ 0x31, 0x13, 0x2a, 0xf0, 0x47, 0x88, 0xcb, 0x21, 0xa1, 0x15, 0xf6, 0x47, 0xb2, 0xb5, 0x6f, 0x24,
+ 0x58, 0x8f, 0xae, 0x53, 0x46, 0xec, 0xac, 0x63, 0x00, 0x62, 0xdb, 0x4e, 0x90, 0x74, 0xd7, 0x62,
+ 0x28, 0x2f, 0xc8, 0xd5, 0x1b, 0xb1, 0x90, 0x9a, 0x50, 0xb0, 0x35, 0x01, 0x98, 0xf5, 0x9c, 0xeb,
+ 0xb6, 0xab, 0x50, 0x0e, 0x3f, 0xf0, 0xf0, 0xaf, 0x84, 0xe2, 0x02, 0x0e, 0x02, 0x62, 0xf7, 0x2e,
+ 0xbc, 0x09, 0xf9, 0x53, 0x3a, 0x32, 0xed, 0xf0, 0xd9, 0x56, 0x34, 0xa2, 0x67, 0x92, 0x5c, 0xfc,
+ 0x4c, 0xb2, 0xff, 0x5b, 0x09, 0x36, 0x74, 0x67, 0x32, 0x6f, 0xef, 0x3e, 0x9a, 0x7b, 0x05, 0xf0,
+ 0x3f, 0x96, 0x3e, 0xff, 0x68, 0x64, 0x06, 0xe3, 0xe9, 0x69, 0x5d, 0x77, 0x26, 0xbb, 0x23, 0xc7,
+ 0x22, 0xf6, 0x68, 0xf6, 0x99, 0x93, 0xff, 0xd1, 0xdf, 0x1d, 0x51, 0xfb, 0xdd, 0x91, 0x93, 0xf8,
+ 0xe8, 0x79, 0x7f, 0xf6, 0xf7, 0xbf, 0x92, 0xf4, 0xa7, 0x4c, 0xf6, 0xa0, 0xb7, 0xff, 0xe7, 0xcc,
+ 0xd6, 0x81, 0x18, 0xae, 0x17, 0xb9, 0x47, 0xa5, 0x43, 0x8b, 0xea, 0x6c, 0xca, 0xff, 0x0b, 0x00,
+ 0x00, 0xff, 0xff, 0x1a, 0x28, 0x25, 0x79, 0x42, 0x1d, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/grpc/reflection/grpc_reflection_v1alpha/reflection.pb.go b/vendor/google.golang.org/grpc/reflection/grpc_reflection_v1alpha/reflection.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..ab5b18893799483c543f1fddb40319d2f8b302e5
--- /dev/null
+++ b/vendor/google.golang.org/grpc/reflection/grpc_reflection_v1alpha/reflection.pb.go
@@ -0,0 +1,925 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: grpc_reflection_v1alpha/reflection.proto
+
+package grpc_reflection_v1alpha
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+ context "golang.org/x/net/context"
+ grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// The message sent by the client when calling ServerReflectionInfo method.
+type ServerReflectionRequest struct {
+ Host string `protobuf:"bytes,1,opt,name=host" json:"host,omitempty"`
+ // To use reflection service, the client should set one of the following
+ // fields in message_request. The server distinguishes requests by their
+ // defined field and then handles them using corresponding methods.
+ //
+ // Types that are valid to be assigned to MessageRequest:
+ // *ServerReflectionRequest_FileByFilename
+ // *ServerReflectionRequest_FileContainingSymbol
+ // *ServerReflectionRequest_FileContainingExtension
+ // *ServerReflectionRequest_AllExtensionNumbersOfType
+ // *ServerReflectionRequest_ListServices
+ MessageRequest isServerReflectionRequest_MessageRequest `protobuf_oneof:"message_request"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServerReflectionRequest) Reset() { *m = ServerReflectionRequest{} }
+func (m *ServerReflectionRequest) String() string { return proto.CompactTextString(m) }
+func (*ServerReflectionRequest) ProtoMessage() {}
+func (*ServerReflectionRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{0}
+}
+func (m *ServerReflectionRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServerReflectionRequest.Unmarshal(m, b)
+}
+func (m *ServerReflectionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServerReflectionRequest.Marshal(b, m, deterministic)
+}
+func (dst *ServerReflectionRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServerReflectionRequest.Merge(dst, src)
+}
+func (m *ServerReflectionRequest) XXX_Size() int {
+ return xxx_messageInfo_ServerReflectionRequest.Size(m)
+}
+func (m *ServerReflectionRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServerReflectionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServerReflectionRequest proto.InternalMessageInfo
+
+type isServerReflectionRequest_MessageRequest interface {
+ isServerReflectionRequest_MessageRequest()
+}
+
+type ServerReflectionRequest_FileByFilename struct {
+ FileByFilename string `protobuf:"bytes,3,opt,name=file_by_filename,json=fileByFilename,oneof"`
+}
+type ServerReflectionRequest_FileContainingSymbol struct {
+ FileContainingSymbol string `protobuf:"bytes,4,opt,name=file_containing_symbol,json=fileContainingSymbol,oneof"`
+}
+type ServerReflectionRequest_FileContainingExtension struct {
+ FileContainingExtension *ExtensionRequest `protobuf:"bytes,5,opt,name=file_containing_extension,json=fileContainingExtension,oneof"`
+}
+type ServerReflectionRequest_AllExtensionNumbersOfType struct {
+ AllExtensionNumbersOfType string `protobuf:"bytes,6,opt,name=all_extension_numbers_of_type,json=allExtensionNumbersOfType,oneof"`
+}
+type ServerReflectionRequest_ListServices struct {
+ ListServices string `protobuf:"bytes,7,opt,name=list_services,json=listServices,oneof"`
+}
+
+func (*ServerReflectionRequest_FileByFilename) isServerReflectionRequest_MessageRequest() {}
+func (*ServerReflectionRequest_FileContainingSymbol) isServerReflectionRequest_MessageRequest() {}
+func (*ServerReflectionRequest_FileContainingExtension) isServerReflectionRequest_MessageRequest() {}
+func (*ServerReflectionRequest_AllExtensionNumbersOfType) isServerReflectionRequest_MessageRequest() {}
+func (*ServerReflectionRequest_ListServices) isServerReflectionRequest_MessageRequest() {}
+
+func (m *ServerReflectionRequest) GetMessageRequest() isServerReflectionRequest_MessageRequest {
+ if m != nil {
+ return m.MessageRequest
+ }
+ return nil
+}
+
+func (m *ServerReflectionRequest) GetHost() string {
+ if m != nil {
+ return m.Host
+ }
+ return ""
+}
+
+func (m *ServerReflectionRequest) GetFileByFilename() string {
+ if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_FileByFilename); ok {
+ return x.FileByFilename
+ }
+ return ""
+}
+
+func (m *ServerReflectionRequest) GetFileContainingSymbol() string {
+ if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_FileContainingSymbol); ok {
+ return x.FileContainingSymbol
+ }
+ return ""
+}
+
+func (m *ServerReflectionRequest) GetFileContainingExtension() *ExtensionRequest {
+ if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_FileContainingExtension); ok {
+ return x.FileContainingExtension
+ }
+ return nil
+}
+
+func (m *ServerReflectionRequest) GetAllExtensionNumbersOfType() string {
+ if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_AllExtensionNumbersOfType); ok {
+ return x.AllExtensionNumbersOfType
+ }
+ return ""
+}
+
+func (m *ServerReflectionRequest) GetListServices() string {
+ if x, ok := m.GetMessageRequest().(*ServerReflectionRequest_ListServices); ok {
+ return x.ListServices
+ }
+ return ""
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ServerReflectionRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _ServerReflectionRequest_OneofMarshaler, _ServerReflectionRequest_OneofUnmarshaler, _ServerReflectionRequest_OneofSizer, []interface{}{
+ (*ServerReflectionRequest_FileByFilename)(nil),
+ (*ServerReflectionRequest_FileContainingSymbol)(nil),
+ (*ServerReflectionRequest_FileContainingExtension)(nil),
+ (*ServerReflectionRequest_AllExtensionNumbersOfType)(nil),
+ (*ServerReflectionRequest_ListServices)(nil),
+ }
+}
+
+func _ServerReflectionRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*ServerReflectionRequest)
+ // message_request
+ switch x := m.MessageRequest.(type) {
+ case *ServerReflectionRequest_FileByFilename:
+ b.EncodeVarint(3<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.FileByFilename)
+ case *ServerReflectionRequest_FileContainingSymbol:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.FileContainingSymbol)
+ case *ServerReflectionRequest_FileContainingExtension:
+ b.EncodeVarint(5<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.FileContainingExtension); err != nil {
+ return err
+ }
+ case *ServerReflectionRequest_AllExtensionNumbersOfType:
+ b.EncodeVarint(6<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.AllExtensionNumbersOfType)
+ case *ServerReflectionRequest_ListServices:
+ b.EncodeVarint(7<<3 | proto.WireBytes)
+ b.EncodeStringBytes(x.ListServices)
+ case nil:
+ default:
+ return fmt.Errorf("ServerReflectionRequest.MessageRequest has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _ServerReflectionRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*ServerReflectionRequest)
+ switch tag {
+ case 3: // message_request.file_by_filename
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.MessageRequest = &ServerReflectionRequest_FileByFilename{x}
+ return true, err
+ case 4: // message_request.file_containing_symbol
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.MessageRequest = &ServerReflectionRequest_FileContainingSymbol{x}
+ return true, err
+ case 5: // message_request.file_containing_extension
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ExtensionRequest)
+ err := b.DecodeMessage(msg)
+ m.MessageRequest = &ServerReflectionRequest_FileContainingExtension{msg}
+ return true, err
+ case 6: // message_request.all_extension_numbers_of_type
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.MessageRequest = &ServerReflectionRequest_AllExtensionNumbersOfType{x}
+ return true, err
+ case 7: // message_request.list_services
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ x, err := b.DecodeStringBytes()
+ m.MessageRequest = &ServerReflectionRequest_ListServices{x}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _ServerReflectionRequest_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*ServerReflectionRequest)
+ // message_request
+ switch x := m.MessageRequest.(type) {
+ case *ServerReflectionRequest_FileByFilename:
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(len(x.FileByFilename)))
+ n += len(x.FileByFilename)
+ case *ServerReflectionRequest_FileContainingSymbol:
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(len(x.FileContainingSymbol)))
+ n += len(x.FileContainingSymbol)
+ case *ServerReflectionRequest_FileContainingExtension:
+ s := proto.Size(x.FileContainingExtension)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *ServerReflectionRequest_AllExtensionNumbersOfType:
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(len(x.AllExtensionNumbersOfType)))
+ n += len(x.AllExtensionNumbersOfType)
+ case *ServerReflectionRequest_ListServices:
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(len(x.ListServices)))
+ n += len(x.ListServices)
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// The type name and extension number sent by the client when requesting
+// file_containing_extension.
+type ExtensionRequest struct {
+ // Fully-qualified type name. The format should be <package>.<type>
+ ContainingType string `protobuf:"bytes,1,opt,name=containing_type,json=containingType" json:"containing_type,omitempty"`
+ ExtensionNumber int32 `protobuf:"varint,2,opt,name=extension_number,json=extensionNumber" json:"extension_number,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExtensionRequest) Reset() { *m = ExtensionRequest{} }
+func (m *ExtensionRequest) String() string { return proto.CompactTextString(m) }
+func (*ExtensionRequest) ProtoMessage() {}
+func (*ExtensionRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{1}
+}
+func (m *ExtensionRequest) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExtensionRequest.Unmarshal(m, b)
+}
+func (m *ExtensionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExtensionRequest.Marshal(b, m, deterministic)
+}
+func (dst *ExtensionRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExtensionRequest.Merge(dst, src)
+}
+func (m *ExtensionRequest) XXX_Size() int {
+ return xxx_messageInfo_ExtensionRequest.Size(m)
+}
+func (m *ExtensionRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExtensionRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtensionRequest proto.InternalMessageInfo
+
+func (m *ExtensionRequest) GetContainingType() string {
+ if m != nil {
+ return m.ContainingType
+ }
+ return ""
+}
+
+func (m *ExtensionRequest) GetExtensionNumber() int32 {
+ if m != nil {
+ return m.ExtensionNumber
+ }
+ return 0
+}
+
+// The message sent by the server to answer ServerReflectionInfo method.
+type ServerReflectionResponse struct {
+ ValidHost string `protobuf:"bytes,1,opt,name=valid_host,json=validHost" json:"valid_host,omitempty"`
+ OriginalRequest *ServerReflectionRequest `protobuf:"bytes,2,opt,name=original_request,json=originalRequest" json:"original_request,omitempty"`
+ // The server sets one of the following fields according to the
+ // message_request in the request.
+ //
+ // Types that are valid to be assigned to MessageResponse:
+ // *ServerReflectionResponse_FileDescriptorResponse
+ // *ServerReflectionResponse_AllExtensionNumbersResponse
+ // *ServerReflectionResponse_ListServicesResponse
+ // *ServerReflectionResponse_ErrorResponse
+ MessageResponse isServerReflectionResponse_MessageResponse `protobuf_oneof:"message_response"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServerReflectionResponse) Reset() { *m = ServerReflectionResponse{} }
+func (m *ServerReflectionResponse) String() string { return proto.CompactTextString(m) }
+func (*ServerReflectionResponse) ProtoMessage() {}
+func (*ServerReflectionResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{2}
+}
+func (m *ServerReflectionResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServerReflectionResponse.Unmarshal(m, b)
+}
+func (m *ServerReflectionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServerReflectionResponse.Marshal(b, m, deterministic)
+}
+func (dst *ServerReflectionResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServerReflectionResponse.Merge(dst, src)
+}
+func (m *ServerReflectionResponse) XXX_Size() int {
+ return xxx_messageInfo_ServerReflectionResponse.Size(m)
+}
+func (m *ServerReflectionResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServerReflectionResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServerReflectionResponse proto.InternalMessageInfo
+
+type isServerReflectionResponse_MessageResponse interface {
+ isServerReflectionResponse_MessageResponse()
+}
+
+type ServerReflectionResponse_FileDescriptorResponse struct {
+ FileDescriptorResponse *FileDescriptorResponse `protobuf:"bytes,4,opt,name=file_descriptor_response,json=fileDescriptorResponse,oneof"`
+}
+type ServerReflectionResponse_AllExtensionNumbersResponse struct {
+ AllExtensionNumbersResponse *ExtensionNumberResponse `protobuf:"bytes,5,opt,name=all_extension_numbers_response,json=allExtensionNumbersResponse,oneof"`
+}
+type ServerReflectionResponse_ListServicesResponse struct {
+ ListServicesResponse *ListServiceResponse `protobuf:"bytes,6,opt,name=list_services_response,json=listServicesResponse,oneof"`
+}
+type ServerReflectionResponse_ErrorResponse struct {
+ ErrorResponse *ErrorResponse `protobuf:"bytes,7,opt,name=error_response,json=errorResponse,oneof"`
+}
+
+func (*ServerReflectionResponse_FileDescriptorResponse) isServerReflectionResponse_MessageResponse() {}
+func (*ServerReflectionResponse_AllExtensionNumbersResponse) isServerReflectionResponse_MessageResponse() {
+}
+func (*ServerReflectionResponse_ListServicesResponse) isServerReflectionResponse_MessageResponse() {}
+func (*ServerReflectionResponse_ErrorResponse) isServerReflectionResponse_MessageResponse() {}
+
+func (m *ServerReflectionResponse) GetMessageResponse() isServerReflectionResponse_MessageResponse {
+ if m != nil {
+ return m.MessageResponse
+ }
+ return nil
+}
+
+func (m *ServerReflectionResponse) GetValidHost() string {
+ if m != nil {
+ return m.ValidHost
+ }
+ return ""
+}
+
+func (m *ServerReflectionResponse) GetOriginalRequest() *ServerReflectionRequest {
+ if m != nil {
+ return m.OriginalRequest
+ }
+ return nil
+}
+
+func (m *ServerReflectionResponse) GetFileDescriptorResponse() *FileDescriptorResponse {
+ if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_FileDescriptorResponse); ok {
+ return x.FileDescriptorResponse
+ }
+ return nil
+}
+
+func (m *ServerReflectionResponse) GetAllExtensionNumbersResponse() *ExtensionNumberResponse {
+ if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_AllExtensionNumbersResponse); ok {
+ return x.AllExtensionNumbersResponse
+ }
+ return nil
+}
+
+func (m *ServerReflectionResponse) GetListServicesResponse() *ListServiceResponse {
+ if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_ListServicesResponse); ok {
+ return x.ListServicesResponse
+ }
+ return nil
+}
+
+func (m *ServerReflectionResponse) GetErrorResponse() *ErrorResponse {
+ if x, ok := m.GetMessageResponse().(*ServerReflectionResponse_ErrorResponse); ok {
+ return x.ErrorResponse
+ }
+ return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ServerReflectionResponse) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+ return _ServerReflectionResponse_OneofMarshaler, _ServerReflectionResponse_OneofUnmarshaler, _ServerReflectionResponse_OneofSizer, []interface{}{
+ (*ServerReflectionResponse_FileDescriptorResponse)(nil),
+ (*ServerReflectionResponse_AllExtensionNumbersResponse)(nil),
+ (*ServerReflectionResponse_ListServicesResponse)(nil),
+ (*ServerReflectionResponse_ErrorResponse)(nil),
+ }
+}
+
+func _ServerReflectionResponse_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+ m := msg.(*ServerReflectionResponse)
+ // message_response
+ switch x := m.MessageResponse.(type) {
+ case *ServerReflectionResponse_FileDescriptorResponse:
+ b.EncodeVarint(4<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.FileDescriptorResponse); err != nil {
+ return err
+ }
+ case *ServerReflectionResponse_AllExtensionNumbersResponse:
+ b.EncodeVarint(5<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.AllExtensionNumbersResponse); err != nil {
+ return err
+ }
+ case *ServerReflectionResponse_ListServicesResponse:
+ b.EncodeVarint(6<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.ListServicesResponse); err != nil {
+ return err
+ }
+ case *ServerReflectionResponse_ErrorResponse:
+ b.EncodeVarint(7<<3 | proto.WireBytes)
+ if err := b.EncodeMessage(x.ErrorResponse); err != nil {
+ return err
+ }
+ case nil:
+ default:
+ return fmt.Errorf("ServerReflectionResponse.MessageResponse has unexpected type %T", x)
+ }
+ return nil
+}
+
+func _ServerReflectionResponse_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+ m := msg.(*ServerReflectionResponse)
+ switch tag {
+ case 4: // message_response.file_descriptor_response
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(FileDescriptorResponse)
+ err := b.DecodeMessage(msg)
+ m.MessageResponse = &ServerReflectionResponse_FileDescriptorResponse{msg}
+ return true, err
+ case 5: // message_response.all_extension_numbers_response
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ExtensionNumberResponse)
+ err := b.DecodeMessage(msg)
+ m.MessageResponse = &ServerReflectionResponse_AllExtensionNumbersResponse{msg}
+ return true, err
+ case 6: // message_response.list_services_response
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ListServiceResponse)
+ err := b.DecodeMessage(msg)
+ m.MessageResponse = &ServerReflectionResponse_ListServicesResponse{msg}
+ return true, err
+ case 7: // message_response.error_response
+ if wire != proto.WireBytes {
+ return true, proto.ErrInternalBadWireType
+ }
+ msg := new(ErrorResponse)
+ err := b.DecodeMessage(msg)
+ m.MessageResponse = &ServerReflectionResponse_ErrorResponse{msg}
+ return true, err
+ default:
+ return false, nil
+ }
+}
+
+func _ServerReflectionResponse_OneofSizer(msg proto.Message) (n int) {
+ m := msg.(*ServerReflectionResponse)
+ // message_response
+ switch x := m.MessageResponse.(type) {
+ case *ServerReflectionResponse_FileDescriptorResponse:
+ s := proto.Size(x.FileDescriptorResponse)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *ServerReflectionResponse_AllExtensionNumbersResponse:
+ s := proto.Size(x.AllExtensionNumbersResponse)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *ServerReflectionResponse_ListServicesResponse:
+ s := proto.Size(x.ListServicesResponse)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case *ServerReflectionResponse_ErrorResponse:
+ s := proto.Size(x.ErrorResponse)
+ n += 1 // tag and wire
+ n += proto.SizeVarint(uint64(s))
+ n += s
+ case nil:
+ default:
+ panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+ }
+ return n
+}
+
+// Serialized FileDescriptorProto messages sent by the server answering
+// a file_by_filename, file_containing_symbol, or file_containing_extension
+// request.
+type FileDescriptorResponse struct {
+ // Serialized FileDescriptorProto messages. We avoid taking a dependency on
+ // descriptor.proto, which uses proto2 only features, by making them opaque
+ // bytes instead.
+ FileDescriptorProto [][]byte `protobuf:"bytes,1,rep,name=file_descriptor_proto,json=fileDescriptorProto,proto3" json:"file_descriptor_proto,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *FileDescriptorResponse) Reset() { *m = FileDescriptorResponse{} }
+func (m *FileDescriptorResponse) String() string { return proto.CompactTextString(m) }
+func (*FileDescriptorResponse) ProtoMessage() {}
+func (*FileDescriptorResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{3}
+}
+func (m *FileDescriptorResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_FileDescriptorResponse.Unmarshal(m, b)
+}
+func (m *FileDescriptorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_FileDescriptorResponse.Marshal(b, m, deterministic)
+}
+func (dst *FileDescriptorResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_FileDescriptorResponse.Merge(dst, src)
+}
+func (m *FileDescriptorResponse) XXX_Size() int {
+ return xxx_messageInfo_FileDescriptorResponse.Size(m)
+}
+func (m *FileDescriptorResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_FileDescriptorResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FileDescriptorResponse proto.InternalMessageInfo
+
+func (m *FileDescriptorResponse) GetFileDescriptorProto() [][]byte {
+ if m != nil {
+ return m.FileDescriptorProto
+ }
+ return nil
+}
+
+// A list of extension numbers sent by the server answering
+// all_extension_numbers_of_type request.
+type ExtensionNumberResponse struct {
+ // Full name of the base type, including the package name. The format
+ // is <package>.<type>
+ BaseTypeName string `protobuf:"bytes,1,opt,name=base_type_name,json=baseTypeName" json:"base_type_name,omitempty"`
+ ExtensionNumber []int32 `protobuf:"varint,2,rep,packed,name=extension_number,json=extensionNumber" json:"extension_number,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ExtensionNumberResponse) Reset() { *m = ExtensionNumberResponse{} }
+func (m *ExtensionNumberResponse) String() string { return proto.CompactTextString(m) }
+func (*ExtensionNumberResponse) ProtoMessage() {}
+func (*ExtensionNumberResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{4}
+}
+func (m *ExtensionNumberResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ExtensionNumberResponse.Unmarshal(m, b)
+}
+func (m *ExtensionNumberResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ExtensionNumberResponse.Marshal(b, m, deterministic)
+}
+func (dst *ExtensionNumberResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ExtensionNumberResponse.Merge(dst, src)
+}
+func (m *ExtensionNumberResponse) XXX_Size() int {
+ return xxx_messageInfo_ExtensionNumberResponse.Size(m)
+}
+func (m *ExtensionNumberResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ExtensionNumberResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ExtensionNumberResponse proto.InternalMessageInfo
+
+func (m *ExtensionNumberResponse) GetBaseTypeName() string {
+ if m != nil {
+ return m.BaseTypeName
+ }
+ return ""
+}
+
+func (m *ExtensionNumberResponse) GetExtensionNumber() []int32 {
+ if m != nil {
+ return m.ExtensionNumber
+ }
+ return nil
+}
+
+// A list of ServiceResponse sent by the server answering list_services request.
+type ListServiceResponse struct {
+ // The information of each service may be expanded in the future, so we use
+ // ServiceResponse message to encapsulate it.
+ Service []*ServiceResponse `protobuf:"bytes,1,rep,name=service" json:"service,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ListServiceResponse) Reset() { *m = ListServiceResponse{} }
+func (m *ListServiceResponse) String() string { return proto.CompactTextString(m) }
+func (*ListServiceResponse) ProtoMessage() {}
+func (*ListServiceResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{5}
+}
+func (m *ListServiceResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ListServiceResponse.Unmarshal(m, b)
+}
+func (m *ListServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ListServiceResponse.Marshal(b, m, deterministic)
+}
+func (dst *ListServiceResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ListServiceResponse.Merge(dst, src)
+}
+func (m *ListServiceResponse) XXX_Size() int {
+ return xxx_messageInfo_ListServiceResponse.Size(m)
+}
+func (m *ListServiceResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ListServiceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ListServiceResponse proto.InternalMessageInfo
+
+func (m *ListServiceResponse) GetService() []*ServiceResponse {
+ if m != nil {
+ return m.Service
+ }
+ return nil
+}
+
+// The information of a single service used by ListServiceResponse to answer
+// list_services request.
+type ServiceResponse struct {
+ // Full name of a registered service, including its package name. The format
+ // is <package>.<service>
+ Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ServiceResponse) Reset() { *m = ServiceResponse{} }
+func (m *ServiceResponse) String() string { return proto.CompactTextString(m) }
+func (*ServiceResponse) ProtoMessage() {}
+func (*ServiceResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{6}
+}
+func (m *ServiceResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ServiceResponse.Unmarshal(m, b)
+}
+func (m *ServiceResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ServiceResponse.Marshal(b, m, deterministic)
+}
+func (dst *ServiceResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ServiceResponse.Merge(dst, src)
+}
+func (m *ServiceResponse) XXX_Size() int {
+ return xxx_messageInfo_ServiceResponse.Size(m)
+}
+func (m *ServiceResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ServiceResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ServiceResponse proto.InternalMessageInfo
+
+func (m *ServiceResponse) GetName() string {
+ if m != nil {
+ return m.Name
+ }
+ return ""
+}
+
+// The error code and error message sent by the server when an error occurs.
+type ErrorResponse struct {
+ // This field uses the error codes defined in grpc::StatusCode.
+ ErrorCode int32 `protobuf:"varint,1,opt,name=error_code,json=errorCode" json:"error_code,omitempty"`
+ ErrorMessage string `protobuf:"bytes,2,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
+ XXX_NoUnkeyedLiteral struct{} `json:"-"`
+ XXX_unrecognized []byte `json:"-"`
+ XXX_sizecache int32 `json:"-"`
+}
+
+func (m *ErrorResponse) Reset() { *m = ErrorResponse{} }
+func (m *ErrorResponse) String() string { return proto.CompactTextString(m) }
+func (*ErrorResponse) ProtoMessage() {}
+func (*ErrorResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_reflection_178bd1e101bf8b63, []int{7}
+}
+func (m *ErrorResponse) XXX_Unmarshal(b []byte) error {
+ return xxx_messageInfo_ErrorResponse.Unmarshal(m, b)
+}
+func (m *ErrorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ return xxx_messageInfo_ErrorResponse.Marshal(b, m, deterministic)
+}
+func (dst *ErrorResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_ErrorResponse.Merge(dst, src)
+}
+func (m *ErrorResponse) XXX_Size() int {
+ return xxx_messageInfo_ErrorResponse.Size(m)
+}
+func (m *ErrorResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_ErrorResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ErrorResponse proto.InternalMessageInfo
+
+func (m *ErrorResponse) GetErrorCode() int32 {
+ if m != nil {
+ return m.ErrorCode
+ }
+ return 0
+}
+
+func (m *ErrorResponse) GetErrorMessage() string {
+ if m != nil {
+ return m.ErrorMessage
+ }
+ return ""
+}
+
+func init() {
+ proto.RegisterType((*ServerReflectionRequest)(nil), "grpc.reflection.v1alpha.ServerReflectionRequest")
+ proto.RegisterType((*ExtensionRequest)(nil), "grpc.reflection.v1alpha.ExtensionRequest")
+ proto.RegisterType((*ServerReflectionResponse)(nil), "grpc.reflection.v1alpha.ServerReflectionResponse")
+ proto.RegisterType((*FileDescriptorResponse)(nil), "grpc.reflection.v1alpha.FileDescriptorResponse")
+ proto.RegisterType((*ExtensionNumberResponse)(nil), "grpc.reflection.v1alpha.ExtensionNumberResponse")
+ proto.RegisterType((*ListServiceResponse)(nil), "grpc.reflection.v1alpha.ListServiceResponse")
+ proto.RegisterType((*ServiceResponse)(nil), "grpc.reflection.v1alpha.ServiceResponse")
+ proto.RegisterType((*ErrorResponse)(nil), "grpc.reflection.v1alpha.ErrorResponse")
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for ServerReflection service
+
+type ServerReflectionClient interface {
+ // The reflection service is structured as a bidirectional stream, ensuring
+ // all related requests go to a single server.
+ ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error)
+}
+
+type serverReflectionClient struct {
+ cc *grpc.ClientConn
+}
+
+func NewServerReflectionClient(cc *grpc.ClientConn) ServerReflectionClient {
+ return &serverReflectionClient{cc}
+}
+
+func (c *serverReflectionClient) ServerReflectionInfo(ctx context.Context, opts ...grpc.CallOption) (ServerReflection_ServerReflectionInfoClient, error) {
+ stream, err := grpc.NewClientStream(ctx, &_ServerReflection_serviceDesc.Streams[0], c.cc, "/grpc.reflection.v1alpha.ServerReflection/ServerReflectionInfo", opts...)
+ if err != nil {
+ return nil, err
+ }
+ x := &serverReflectionServerReflectionInfoClient{stream}
+ return x, nil
+}
+
+type ServerReflection_ServerReflectionInfoClient interface {
+ Send(*ServerReflectionRequest) error
+ Recv() (*ServerReflectionResponse, error)
+ grpc.ClientStream
+}
+
+type serverReflectionServerReflectionInfoClient struct {
+ grpc.ClientStream
+}
+
+func (x *serverReflectionServerReflectionInfoClient) Send(m *ServerReflectionRequest) error {
+ return x.ClientStream.SendMsg(m)
+}
+
+func (x *serverReflectionServerReflectionInfoClient) Recv() (*ServerReflectionResponse, error) {
+ m := new(ServerReflectionResponse)
+ if err := x.ClientStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+// Server API for ServerReflection service
+
+type ServerReflectionServer interface {
+ // The reflection service is structured as a bidirectional stream, ensuring
+ // all related requests go to a single server.
+ ServerReflectionInfo(ServerReflection_ServerReflectionInfoServer) error
+}
+
+func RegisterServerReflectionServer(s *grpc.Server, srv ServerReflectionServer) {
+ s.RegisterService(&_ServerReflection_serviceDesc, srv)
+}
+
+func _ServerReflection_ServerReflectionInfo_Handler(srv interface{}, stream grpc.ServerStream) error {
+ return srv.(ServerReflectionServer).ServerReflectionInfo(&serverReflectionServerReflectionInfoServer{stream})
+}
+
+type ServerReflection_ServerReflectionInfoServer interface {
+ Send(*ServerReflectionResponse) error
+ Recv() (*ServerReflectionRequest, error)
+ grpc.ServerStream
+}
+
+type serverReflectionServerReflectionInfoServer struct {
+ grpc.ServerStream
+}
+
+func (x *serverReflectionServerReflectionInfoServer) Send(m *ServerReflectionResponse) error {
+ return x.ServerStream.SendMsg(m)
+}
+
+func (x *serverReflectionServerReflectionInfoServer) Recv() (*ServerReflectionRequest, error) {
+ m := new(ServerReflectionRequest)
+ if err := x.ServerStream.RecvMsg(m); err != nil {
+ return nil, err
+ }
+ return m, nil
+}
+
+var _ServerReflection_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "grpc.reflection.v1alpha.ServerReflection",
+ HandlerType: (*ServerReflectionServer)(nil),
+ Methods: []grpc.MethodDesc{},
+ Streams: []grpc.StreamDesc{
+ {
+ StreamName: "ServerReflectionInfo",
+ Handler: _ServerReflection_ServerReflectionInfo_Handler,
+ ServerStreams: true,
+ ClientStreams: true,
+ },
+ },
+ Metadata: "grpc_reflection_v1alpha/reflection.proto",
+}
+
+func init() {
+ proto.RegisterFile("grpc_reflection_v1alpha/reflection.proto", fileDescriptor_reflection_178bd1e101bf8b63)
+}
+
+var fileDescriptor_reflection_178bd1e101bf8b63 = []byte{
+ // 656 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0x51, 0x73, 0xd2, 0x40,
+ 0x10, 0x6e, 0x5a, 0x68, 0x87, 0x85, 0x02, 0x5e, 0x2b, 0xa4, 0x3a, 0x75, 0x98, 0x68, 0x35, 0x75,
+ 0x1c, 0xda, 0xe2, 0x8c, 0x3f, 0x80, 0xaa, 0x83, 0x33, 0xb5, 0x75, 0x0e, 0x5f, 0x1c, 0x1f, 0x6e,
+ 0x02, 0x2c, 0x34, 0x1a, 0x72, 0xf1, 0x2e, 0x45, 0x79, 0xf2, 0x47, 0xf8, 0xa3, 0xfc, 0x4b, 0x3e,
+ 0x3a, 0x77, 0x09, 0x21, 0xa4, 0x44, 0xa7, 0x4f, 0x30, 0xdf, 0xee, 0xde, 0xb7, 0xbb, 0xdf, 0xb7,
+ 0x01, 0x7b, 0x22, 0x82, 0x21, 0x13, 0x38, 0xf6, 0x70, 0x18, 0xba, 0xdc, 0x67, 0xb3, 0x33, 0xc7,
+ 0x0b, 0xae, 0x9d, 0x93, 0x25, 0xd4, 0x0e, 0x04, 0x0f, 0x39, 0x69, 0xaa, 0xcc, 0x76, 0x0a, 0x8e,
+ 0x33, 0xad, 0x3f, 0x9b, 0xd0, 0xec, 0xa3, 0x98, 0xa1, 0xa0, 0x49, 0x90, 0xe2, 0xb7, 0x1b, 0x94,
+ 0x21, 0x21, 0x50, 0xb8, 0xe6, 0x32, 0x34, 0x8d, 0x96, 0x61, 0x97, 0xa8, 0xfe, 0x4f, 0x9e, 0x43,
+ 0x7d, 0xec, 0x7a, 0xc8, 0x06, 0x73, 0xa6, 0x7e, 0x7d, 0x67, 0x8a, 0xe6, 0x96, 0x8a, 0xf7, 0x36,
+ 0x68, 0x55, 0x21, 0xdd, 0xf9, 0xdb, 0x18, 0x27, 0xaf, 0xa0, 0xa1, 0x73, 0x87, 0xdc, 0x0f, 0x1d,
+ 0xd7, 0x77, 0xfd, 0x09, 0x93, 0xf3, 0xe9, 0x80, 0x7b, 0x66, 0x21, 0xae, 0xd8, 0x57, 0xf1, 0xf3,
+ 0x24, 0xdc, 0xd7, 0x51, 0x32, 0x81, 0x83, 0x6c, 0x1d, 0xfe, 0x08, 0xd1, 0x97, 0x2e, 0xf7, 0xcd,
+ 0x62, 0xcb, 0xb0, 0xcb, 0x9d, 0xe3, 0x76, 0xce, 0x40, 0xed, 0x37, 0x8b, 0xcc, 0x78, 0x8a, 0xde,
+ 0x06, 0x6d, 0xae, 0xb2, 0x24, 0x19, 0xa4, 0x0b, 0x87, 0x8e, 0xe7, 0x2d, 0x1f, 0x67, 0xfe, 0xcd,
+ 0x74, 0x80, 0x42, 0x32, 0x3e, 0x66, 0xe1, 0x3c, 0x40, 0x73, 0x3b, 0xee, 0xf3, 0xc0, 0xf1, 0xbc,
+ 0xa4, 0xec, 0x32, 0x4a, 0xba, 0x1a, 0x7f, 0x9c, 0x07, 0x48, 0x8e, 0x60, 0xd7, 0x73, 0x65, 0xc8,
+ 0x24, 0x8a, 0x99, 0x3b, 0x44, 0x69, 0xee, 0xc4, 0x35, 0x15, 0x05, 0xf7, 0x63, 0xb4, 0x7b, 0x0f,
+ 0x6a, 0x53, 0x94, 0xd2, 0x99, 0x20, 0x13, 0x51, 0x63, 0xd6, 0x18, 0xea, 0xd9, 0x66, 0xc9, 0x33,
+ 0xa8, 0xa5, 0xa6, 0xd6, 0x3d, 0x44, 0xdb, 0xaf, 0x2e, 0x61, 0x4d, 0x7b, 0x0c, 0xf5, 0x6c, 0xdb,
+ 0xe6, 0x66, 0xcb, 0xb0, 0x8b, 0xb4, 0x86, 0xab, 0x8d, 0x5a, 0xbf, 0x0b, 0x60, 0xde, 0x96, 0x58,
+ 0x06, 0xdc, 0x97, 0x48, 0x0e, 0x01, 0x66, 0x8e, 0xe7, 0x8e, 0x58, 0x4a, 0xe9, 0x92, 0x46, 0x7a,
+ 0x4a, 0xee, 0xcf, 0x50, 0xe7, 0xc2, 0x9d, 0xb8, 0xbe, 0xe3, 0x2d, 0xfa, 0xd6, 0x34, 0xe5, 0xce,
+ 0x69, 0xae, 0x02, 0x39, 0x76, 0xa2, 0xb5, 0xc5, 0x4b, 0x8b, 0x61, 0xbf, 0x82, 0xa9, 0x75, 0x1e,
+ 0xa1, 0x1c, 0x0a, 0x37, 0x08, 0xb9, 0x60, 0x22, 0xee, 0x4b, 0x3b, 0xa4, 0xdc, 0x39, 0xc9, 0x25,
+ 0x51, 0x26, 0x7b, 0x9d, 0xd4, 0x2d, 0xc6, 0xe9, 0x6d, 0x50, 0x6d, 0xb9, 0xdb, 0x11, 0xf2, 0x1d,
+ 0x1e, 0xad, 0xd7, 0x3a, 0xa1, 0x2c, 0xfe, 0x67, 0xae, 0x8c, 0x01, 0x52, 0x9c, 0x0f, 0xd7, 0xd8,
+ 0x23, 0x21, 0x1e, 0x41, 0x63, 0xc5, 0x20, 0x4b, 0xc2, 0x6d, 0x4d, 0xf8, 0x22, 0x97, 0xf0, 0x62,
+ 0x69, 0xa0, 0x14, 0xd9, 0x7e, 0xda, 0x57, 0x09, 0xcb, 0x15, 0x54, 0x51, 0x88, 0xf4, 0x06, 0x77,
+ 0xf4, 0xeb, 0x4f, 0xf3, 0xc7, 0x51, 0xe9, 0xa9, 0x77, 0x77, 0x31, 0x0d, 0x74, 0x09, 0xd4, 0x97,
+ 0x86, 0x8d, 0x30, 0xeb, 0x02, 0x1a, 0xeb, 0xf7, 0x4e, 0x3a, 0x70, 0x3f, 0x2b, 0xa5, 0xfe, 0xf0,
+ 0x98, 0x46, 0x6b, 0xcb, 0xae, 0xd0, 0xbd, 0x55, 0x51, 0x3e, 0xa8, 0x90, 0xf5, 0x05, 0x9a, 0x39,
+ 0x2b, 0x25, 0x4f, 0xa0, 0x3a, 0x70, 0x24, 0xea, 0x03, 0x60, 0xfa, 0x1b, 0x13, 0x39, 0xb3, 0xa2,
+ 0x50, 0xe5, 0xff, 0x4b, 0xf5, 0x7d, 0x59, 0x7f, 0x03, 0x5b, 0xeb, 0x6e, 0xe0, 0x13, 0xec, 0xad,
+ 0xd9, 0x26, 0xe9, 0xc2, 0x4e, 0x2c, 0x8b, 0x6e, 0xb4, 0xdc, 0xb1, 0xff, 0xe9, 0xea, 0x54, 0x29,
+ 0x5d, 0x14, 0x5a, 0x47, 0x50, 0xcb, 0x3e, 0x4b, 0xa0, 0x90, 0x6a, 0x5a, 0xff, 0xb7, 0xfa, 0xb0,
+ 0xbb, 0xb2, 0x71, 0x75, 0x79, 0x91, 0x62, 0x43, 0x3e, 0x8a, 0x52, 0x8b, 0xb4, 0xa4, 0x91, 0x73,
+ 0x3e, 0x42, 0xf2, 0x18, 0x22, 0x41, 0x58, 0xac, 0x82, 0x3e, 0xbb, 0x12, 0xad, 0x68, 0xf0, 0x7d,
+ 0x84, 0x75, 0x7e, 0x19, 0x50, 0xcf, 0x9e, 0x1b, 0xf9, 0x09, 0xfb, 0x59, 0xec, 0x9d, 0x3f, 0xe6,
+ 0xe4, 0xce, 0x17, 0xfb, 0xe0, 0xec, 0x0e, 0x15, 0xd1, 0x54, 0xb6, 0x71, 0x6a, 0x0c, 0xb6, 0xb5,
+ 0xf4, 0x2f, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x85, 0x02, 0x09, 0x9d, 0x9f, 0x06, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/grpc/reflection/serverreflection.go b/vendor/google.golang.org/grpc/reflection/serverreflection.go
new file mode 100644
index 0000000000000000000000000000000000000000..dd22a2da78496cd3b14ac45483ecc4c1ac094a80
--- /dev/null
+++ b/vendor/google.golang.org/grpc/reflection/serverreflection.go
@@ -0,0 +1,454 @@
+/*
+ *
+ * Copyright 2016 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+//go:generate protoc --go_out=plugins=grpc:. grpc_reflection_v1alpha/reflection.proto
+
+/*
+Package reflection implements server reflection service.
+
+The service implemented is defined in:
+https://github.com/grpc/grpc/blob/master/src/proto/grpc/reflection/v1alpha/reflection.proto.
+
+To register server reflection on a gRPC server:
+ import "google.golang.org/grpc/reflection"
+
+ s := grpc.NewServer()
+ pb.RegisterYourOwnServer(s, &server{})
+
+ // Register reflection service on gRPC server.
+ reflection.Register(s)
+
+ s.Serve(lis)
+
+*/
+package reflection // import "google.golang.org/grpc/reflection"
+
+import (
+ "bytes"
+ "compress/gzip"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "reflect"
+ "sort"
+ "sync"
+
+ "github.com/golang/protobuf/proto"
+ dpb "github.com/golang/protobuf/protoc-gen-go/descriptor"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/codes"
+ rpb "google.golang.org/grpc/reflection/grpc_reflection_v1alpha"
+ "google.golang.org/grpc/status"
+)
+
+type serverReflectionServer struct {
+ s *grpc.Server
+
+ initSymbols sync.Once
+ serviceNames []string
+ symbols map[string]*dpb.FileDescriptorProto // map of fully-qualified names to files
+}
+
+// Register registers the server reflection service on the given gRPC server.
+func Register(s *grpc.Server) {
+ rpb.RegisterServerReflectionServer(s, &serverReflectionServer{
+ s: s,
+ })
+}
+
+// protoMessage is used for type assertion on proto messages.
+// Generated proto message implements function Descriptor(), but Descriptor()
+// is not part of interface proto.Message. This interface is needed to
+// call Descriptor().
+type protoMessage interface {
+ Descriptor() ([]byte, []int)
+}
+
+func (s *serverReflectionServer) getSymbols() (svcNames []string, symbolIndex map[string]*dpb.FileDescriptorProto) {
+ s.initSymbols.Do(func() {
+ serviceInfo := s.s.GetServiceInfo()
+
+ s.symbols = map[string]*dpb.FileDescriptorProto{}
+ s.serviceNames = make([]string, 0, len(serviceInfo))
+ processed := map[string]struct{}{}
+ for svc, info := range serviceInfo {
+ s.serviceNames = append(s.serviceNames, svc)
+ fdenc, ok := parseMetadata(info.Metadata)
+ if !ok {
+ continue
+ }
+ fd, err := decodeFileDesc(fdenc)
+ if err != nil {
+ continue
+ }
+ s.processFile(fd, processed)
+ }
+ sort.Strings(s.serviceNames)
+ })
+
+ return s.serviceNames, s.symbols
+}
+
+func (s *serverReflectionServer) processFile(fd *dpb.FileDescriptorProto, processed map[string]struct{}) {
+ filename := fd.GetName()
+ if _, ok := processed[filename]; ok {
+ return
+ }
+ processed[filename] = struct{}{}
+
+ prefix := fd.GetPackage()
+
+ for _, msg := range fd.MessageType {
+ s.processMessage(fd, prefix, msg)
+ }
+ for _, en := range fd.EnumType {
+ s.processEnum(fd, prefix, en)
+ }
+ for _, ext := range fd.Extension {
+ s.processField(fd, prefix, ext)
+ }
+ for _, svc := range fd.Service {
+ svcName := fqn(prefix, svc.GetName())
+ s.symbols[svcName] = fd
+ for _, meth := range svc.Method {
+ name := fqn(svcName, meth.GetName())
+ s.symbols[name] = fd
+ }
+ }
+
+ for _, dep := range fd.Dependency {
+ fdenc := proto.FileDescriptor(dep)
+ fdDep, err := decodeFileDesc(fdenc)
+ if err != nil {
+ continue
+ }
+ s.processFile(fdDep, processed)
+ }
+}
+
+func (s *serverReflectionServer) processMessage(fd *dpb.FileDescriptorProto, prefix string, msg *dpb.DescriptorProto) {
+ msgName := fqn(prefix, msg.GetName())
+ s.symbols[msgName] = fd
+
+ for _, nested := range msg.NestedType {
+ s.processMessage(fd, msgName, nested)
+ }
+ for _, en := range msg.EnumType {
+ s.processEnum(fd, msgName, en)
+ }
+ for _, ext := range msg.Extension {
+ s.processField(fd, msgName, ext)
+ }
+ for _, fld := range msg.Field {
+ s.processField(fd, msgName, fld)
+ }
+ for _, oneof := range msg.OneofDecl {
+ oneofName := fqn(msgName, oneof.GetName())
+ s.symbols[oneofName] = fd
+ }
+}
+
+func (s *serverReflectionServer) processEnum(fd *dpb.FileDescriptorProto, prefix string, en *dpb.EnumDescriptorProto) {
+ enName := fqn(prefix, en.GetName())
+ s.symbols[enName] = fd
+
+ for _, val := range en.Value {
+ valName := fqn(enName, val.GetName())
+ s.symbols[valName] = fd
+ }
+}
+
+func (s *serverReflectionServer) processField(fd *dpb.FileDescriptorProto, prefix string, fld *dpb.FieldDescriptorProto) {
+ fldName := fqn(prefix, fld.GetName())
+ s.symbols[fldName] = fd
+}
+
+func fqn(prefix, name string) string {
+ if prefix == "" {
+ return name
+ }
+ return prefix + "." + name
+}
+
+// fileDescForType gets the file descriptor for the given type.
+// The given type should be a proto message.
+func (s *serverReflectionServer) fileDescForType(st reflect.Type) (*dpb.FileDescriptorProto, error) {
+ m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(protoMessage)
+ if !ok {
+ return nil, fmt.Errorf("failed to create message from type: %v", st)
+ }
+ enc, _ := m.Descriptor()
+
+ return decodeFileDesc(enc)
+}
+
+// decodeFileDesc does decompression and unmarshalling on the given
+// file descriptor byte slice.
+func decodeFileDesc(enc []byte) (*dpb.FileDescriptorProto, error) {
+ raw, err := decompress(enc)
+ if err != nil {
+ return nil, fmt.Errorf("failed to decompress enc: %v", err)
+ }
+
+ fd := new(dpb.FileDescriptorProto)
+ if err := proto.Unmarshal(raw, fd); err != nil {
+ return nil, fmt.Errorf("bad descriptor: %v", err)
+ }
+ return fd, nil
+}
+
+// decompress does gzip decompression.
+func decompress(b []byte) ([]byte, error) {
+ r, err := gzip.NewReader(bytes.NewReader(b))
+ if err != nil {
+ return nil, fmt.Errorf("bad gzipped descriptor: %v", err)
+ }
+ out, err := ioutil.ReadAll(r)
+ if err != nil {
+ return nil, fmt.Errorf("bad gzipped descriptor: %v", err)
+ }
+ return out, nil
+}
+
+func typeForName(name string) (reflect.Type, error) {
+ pt := proto.MessageType(name)
+ if pt == nil {
+ return nil, fmt.Errorf("unknown type: %q", name)
+ }
+ st := pt.Elem()
+
+ return st, nil
+}
+
+func fileDescContainingExtension(st reflect.Type, ext int32) (*dpb.FileDescriptorProto, error) {
+ m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(proto.Message)
+ if !ok {
+ return nil, fmt.Errorf("failed to create message from type: %v", st)
+ }
+
+ var extDesc *proto.ExtensionDesc
+ for id, desc := range proto.RegisteredExtensions(m) {
+ if id == ext {
+ extDesc = desc
+ break
+ }
+ }
+
+ if extDesc == nil {
+ return nil, fmt.Errorf("failed to find registered extension for extension number %v", ext)
+ }
+
+ return decodeFileDesc(proto.FileDescriptor(extDesc.Filename))
+}
+
+func (s *serverReflectionServer) allExtensionNumbersForType(st reflect.Type) ([]int32, error) {
+ m, ok := reflect.Zero(reflect.PtrTo(st)).Interface().(proto.Message)
+ if !ok {
+ return nil, fmt.Errorf("failed to create message from type: %v", st)
+ }
+
+ exts := proto.RegisteredExtensions(m)
+ out := make([]int32, 0, len(exts))
+ for id := range exts {
+ out = append(out, id)
+ }
+ return out, nil
+}
+
+// fileDescEncodingByFilename finds the file descriptor for given filename,
+// does marshalling on it and returns the marshalled result.
+func (s *serverReflectionServer) fileDescEncodingByFilename(name string) ([]byte, error) {
+ enc := proto.FileDescriptor(name)
+ if enc == nil {
+ return nil, fmt.Errorf("unknown file: %v", name)
+ }
+ fd, err := decodeFileDesc(enc)
+ if err != nil {
+ return nil, err
+ }
+ return proto.Marshal(fd)
+}
+
+// parseMetadata finds the file descriptor bytes specified meta.
+// For SupportPackageIsVersion4, m is the name of the proto file, we
+// call proto.FileDescriptor to get the byte slice.
+// For SupportPackageIsVersion3, m is a byte slice itself.
+func parseMetadata(meta interface{}) ([]byte, bool) {
+ // Check if meta is the file name.
+ if fileNameForMeta, ok := meta.(string); ok {
+ return proto.FileDescriptor(fileNameForMeta), true
+ }
+
+ // Check if meta is the byte slice.
+ if enc, ok := meta.([]byte); ok {
+ return enc, true
+ }
+
+ return nil, false
+}
+
+// fileDescEncodingContainingSymbol finds the file descriptor containing the given symbol,
+// does marshalling on it and returns the marshalled result.
+// The given symbol can be a type, a service or a method.
+func (s *serverReflectionServer) fileDescEncodingContainingSymbol(name string) ([]byte, error) {
+ _, symbols := s.getSymbols()
+ fd := symbols[name]
+ if fd == nil {
+ // Check if it's a type name that was not present in the
+ // transitive dependencies of the registered services.
+ if st, err := typeForName(name); err == nil {
+ fd, err = s.fileDescForType(st)
+ if err != nil {
+ return nil, err
+ }
+ }
+ }
+
+ if fd == nil {
+ return nil, fmt.Errorf("unknown symbol: %v", name)
+ }
+
+ return proto.Marshal(fd)
+}
+
+// fileDescEncodingContainingExtension finds the file descriptor containing given extension,
+// does marshalling on it and returns the marshalled result.
+func (s *serverReflectionServer) fileDescEncodingContainingExtension(typeName string, extNum int32) ([]byte, error) {
+ st, err := typeForName(typeName)
+ if err != nil {
+ return nil, err
+ }
+ fd, err := fileDescContainingExtension(st, extNum)
+ if err != nil {
+ return nil, err
+ }
+ return proto.Marshal(fd)
+}
+
+// allExtensionNumbersForTypeName returns all extension numbers for the given type.
+func (s *serverReflectionServer) allExtensionNumbersForTypeName(name string) ([]int32, error) {
+ st, err := typeForName(name)
+ if err != nil {
+ return nil, err
+ }
+ extNums, err := s.allExtensionNumbersForType(st)
+ if err != nil {
+ return nil, err
+ }
+ return extNums, nil
+}
+
+// ServerReflectionInfo is the reflection service handler.
+func (s *serverReflectionServer) ServerReflectionInfo(stream rpb.ServerReflection_ServerReflectionInfoServer) error {
+ for {
+ in, err := stream.Recv()
+ if err == io.EOF {
+ return nil
+ }
+ if err != nil {
+ return err
+ }
+
+ out := &rpb.ServerReflectionResponse{
+ ValidHost: in.Host,
+ OriginalRequest: in,
+ }
+ switch req := in.MessageRequest.(type) {
+ case *rpb.ServerReflectionRequest_FileByFilename:
+ b, err := s.fileDescEncodingByFilename(req.FileByFilename)
+ if err != nil {
+ out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
+ ErrorResponse: &rpb.ErrorResponse{
+ ErrorCode: int32(codes.NotFound),
+ ErrorMessage: err.Error(),
+ },
+ }
+ } else {
+ out.MessageResponse = &rpb.ServerReflectionResponse_FileDescriptorResponse{
+ FileDescriptorResponse: &rpb.FileDescriptorResponse{FileDescriptorProto: [][]byte{b}},
+ }
+ }
+ case *rpb.ServerReflectionRequest_FileContainingSymbol:
+ b, err := s.fileDescEncodingContainingSymbol(req.FileContainingSymbol)
+ if err != nil {
+ out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
+ ErrorResponse: &rpb.ErrorResponse{
+ ErrorCode: int32(codes.NotFound),
+ ErrorMessage: err.Error(),
+ },
+ }
+ } else {
+ out.MessageResponse = &rpb.ServerReflectionResponse_FileDescriptorResponse{
+ FileDescriptorResponse: &rpb.FileDescriptorResponse{FileDescriptorProto: [][]byte{b}},
+ }
+ }
+ case *rpb.ServerReflectionRequest_FileContainingExtension:
+ typeName := req.FileContainingExtension.ContainingType
+ extNum := req.FileContainingExtension.ExtensionNumber
+ b, err := s.fileDescEncodingContainingExtension(typeName, extNum)
+ if err != nil {
+ out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
+ ErrorResponse: &rpb.ErrorResponse{
+ ErrorCode: int32(codes.NotFound),
+ ErrorMessage: err.Error(),
+ },
+ }
+ } else {
+ out.MessageResponse = &rpb.ServerReflectionResponse_FileDescriptorResponse{
+ FileDescriptorResponse: &rpb.FileDescriptorResponse{FileDescriptorProto: [][]byte{b}},
+ }
+ }
+ case *rpb.ServerReflectionRequest_AllExtensionNumbersOfType:
+ extNums, err := s.allExtensionNumbersForTypeName(req.AllExtensionNumbersOfType)
+ if err != nil {
+ out.MessageResponse = &rpb.ServerReflectionResponse_ErrorResponse{
+ ErrorResponse: &rpb.ErrorResponse{
+ ErrorCode: int32(codes.NotFound),
+ ErrorMessage: err.Error(),
+ },
+ }
+ } else {
+ out.MessageResponse = &rpb.ServerReflectionResponse_AllExtensionNumbersResponse{
+ AllExtensionNumbersResponse: &rpb.ExtensionNumberResponse{
+ BaseTypeName: req.AllExtensionNumbersOfType,
+ ExtensionNumber: extNums,
+ },
+ }
+ }
+ case *rpb.ServerReflectionRequest_ListServices:
+ svcNames, _ := s.getSymbols()
+ serviceResponses := make([]*rpb.ServiceResponse, len(svcNames))
+ for i, n := range svcNames {
+ serviceResponses[i] = &rpb.ServiceResponse{
+ Name: n,
+ }
+ }
+ out.MessageResponse = &rpb.ServerReflectionResponse_ListServicesResponse{
+ ListServicesResponse: &rpb.ListServiceResponse{
+ Service: serviceResponses,
+ },
+ }
+ default:
+ return status.Errorf(codes.InvalidArgument, "invalid MessageRequest: %v", in.MessageRequest)
+ }
+
+ if err := stream.Send(out); err != nil {
+ return err
+ }
+ }
+}