diff --git a/Gopkg.lock b/Gopkg.lock
index e65882cd76c3a48613ec63e066c7468b9dab7a0a..c3b36efb1f38397ec3ce4ad435d39e8c70902e52 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -332,8 +332,7 @@
"db",
"flowrate",
"log",
- "merkle",
- "test"
+ "merkle"
]
revision = "692f1d86a6e2c0efa698fd1e4541b68c74ffaf38"
version = "v0.8.4"
@@ -485,6 +484,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
- inputs-digest = "766fecea2ba1613d7d686ddae1228a47ee1d5e62e93e6ab6fe9dc5812207c071"
+ inputs-digest = "65c36d346ec9b2591985beee41737b31df479ef48759f4ff4ac165c0108f5296"
solver-name = "gps-cdcl"
solver-version = 1
diff --git a/Makefile b/Makefile
index 9ebc4982f16910ecfa71e009fdaacc66ba49c814..11614f0d08e67081d8596ab3a49fefecbe38efe3 100644
--- a/Makefile
+++ b/Makefile
@@ -70,8 +70,8 @@ protobuf_deps:
keys/pbkeys/keys.pb.go: keys/pbkeys/keys.proto
@protoc -I ./keys/pbkeys keys/pbkeys/keys.proto --go_out=plugins=grpc:keys/pbkeys
-rpc/grpc/burrow.pb.go: rpc/burrow
- @protoc -I ./rpc/grpc rpc/grpc/burrow.proto --go_out=plugins=grpc:rpc/grpc
+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
# erase vendor wipes the full vendor directory
@@ -160,7 +160,7 @@ docker_build: check commit_hash
# test burrow
.PHONY: test
-test: check
+test: fix
@go test ${PACKAGES_NOVENDOR}
.PHONY: test_keys
@@ -169,6 +169,7 @@ test_keys: build_db
.PHONY: test_integration
test_integration: test_keys
+ @go test -tags integration ./rpc/burrow/integration
@go test -tags integration ./rpc/v0/integration
@go test -tags integration ./rpc/tm/integration
diff --git a/account/account.go b/account/account.go
index 98053e91c768668cf5bcd671b759e0f15469e523..a708bb673157bc53a46e3d73459bf2c5d8689e8c 100644
--- a/account/account.go
+++ b/account/account.go
@@ -15,15 +15,13 @@
package account
import (
- "bytes"
"encoding/json"
"fmt"
- "encoding/gob"
-
"github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
ptypes "github.com/hyperledger/burrow/permission/types"
+ "github.com/tendermint/go-amino"
)
var GlobalPermissionsAddress = crypto.Address(binary.Zero160)
@@ -302,14 +300,10 @@ func (caw concreteAccountWrapper) Copy() MutableAccount {
// concreteAccount Wrapper
//----------------------------------------------
// Encoding/decoding
+var cdc = amino.NewCodec()
func (acc *ConcreteAccount) Encode() ([]byte, error) {
- buf := new(bytes.Buffer)
- err := gob.NewEncoder(buf).Encode(acc)
- if err != nil {
- return nil, err
- }
- return buf.Bytes(), nil
+ return cdc.MarshalBinary(acc)
}
func Decode(accBytes []byte) (Account, error) {
@@ -322,8 +316,7 @@ func Decode(accBytes []byte) (Account, error) {
func DecodeConcrete(accBytes []byte) (*ConcreteAccount, error) {
ca := new(ConcreteAccount)
- buf := bytes.NewBuffer(accBytes)
- err := gob.NewDecoder(buf).Decode(ca)
+ err := cdc.UnmarshalBinary(accBytes, ca)
if err != nil {
return nil, fmt.Errorf("could not convert decoded account to *ConcreteAccount: %v", err)
}
diff --git a/consensus/tendermint/abci/app.go b/consensus/tendermint/abci/app.go
index 77ca81f230458460e0843934258308e06ecb0ad7..6cca22aef6580d1feeeb653adb3516be3a3827b9 100644
--- a/consensus/tendermint/abci/app.go
+++ b/consensus/tendermint/abci/app.go
@@ -37,15 +37,13 @@ type App struct {
var _ abciTypes.Application = &App{}
-func NewApp(blockchain *bcm.Blockchain,
- checker execution.BatchExecutor,
- committer execution.BatchCommitter,
- logger *logging.Logger) *App {
+func NewApp(blockchain *bcm.Blockchain, checker execution.BatchExecutor, committer execution.BatchCommitter,
+ txDecoder txs.Decoder, logger *logging.Logger) *App {
return &App{
blockchain: blockchain,
checker: checker,
committer: committer,
- txDecoder: txs.NewJSONCodec(),
+ txDecoder: txDecoder,
logger: logger.WithScope("abci.NewApp").With(structure.ComponentKey, "ABCI_App"),
}
}
diff --git a/consensus/tendermint/tendermint.go b/consensus/tendermint/tendermint.go
index 00e2ce065f984815d65c9cfb0864b5d3ed42f2de..175cbab85273ca972dbc4434d0e8ef6b51f63f75 100644
--- a/consensus/tendermint/tendermint.go
+++ b/consensus/tendermint/tendermint.go
@@ -13,6 +13,7 @@ import (
"github.com/hyperledger/burrow/genesis"
"github.com/hyperledger/burrow/logging"
"github.com/hyperledger/burrow/logging/structure"
+ "github.com/hyperledger/burrow/txs"
tm_crypto "github.com/tendermint/go-crypto"
"github.com/tendermint/tendermint/config"
"github.com/tendermint/tendermint/node"
@@ -46,14 +47,9 @@ func (n *Node) Close() {
}
}
-func NewNode(
- conf *config.Config,
- privValidator tm_types.PrivValidator,
- genesisDoc *tm_types.GenesisDoc,
- blockchain *bcm.Blockchain,
- checker execution.BatchExecutor,
- committer execution.BatchCommitter,
- logger *logging.Logger) (*Node, error) {
+func NewNode(conf *config.Config, privValidator tm_types.PrivValidator, genesisDoc *tm_types.GenesisDoc,
+ blockchain *bcm.Blockchain, checker execution.BatchExecutor, committer execution.BatchCommitter,
+ txDecoder txs.Decoder, logger *logging.Logger) (*Node, error) {
var err error
// disable Tendermint's RPC
@@ -65,7 +61,7 @@ func NewNode(
}
nde := &Node{}
- app := abci.NewApp(blockchain, checker, committer, logger)
+ app := abci.NewApp(blockchain, checker, committer, txDecoder, logger)
conf.NodeKeyFile()
nde.Node, err = node.NewNode(conf, privValidator,
proxy.NewLocalClientCreator(app),
diff --git a/execution/names/names.go b/execution/names/names.go
index 1eea378b17d12a53c3cde4a1bb19b7b4661e2ee1..96cd2f1dae4cdd85e07d4ccedcf36495901d0c7c 100644
--- a/execution/names/names.go
+++ b/execution/names/names.go
@@ -15,10 +15,8 @@
package names
import (
- "bytes"
- "encoding/gob"
-
"github.com/hyperledger/burrow/crypto"
+ "github.com/tendermint/go-amino"
)
var (
@@ -49,19 +47,15 @@ type Entry struct {
Expires uint64
}
+var cdc = amino.NewCodec()
+
func (e *Entry) Encode() ([]byte, error) {
- buf := new(bytes.Buffer)
- err := gob.NewEncoder(buf).Encode(e)
- if err != nil {
- return nil, err
- }
- return buf.Bytes(), nil
+ return cdc.MarshalBinary(e)
}
func DecodeEntry(entryBytes []byte) (*Entry, error) {
entry := new(Entry)
- buf := bytes.NewBuffer(entryBytes)
- err := gob.NewDecoder(buf).Decode(entry)
+ err := cdc.UnmarshalBinary(entryBytes, entry)
if err != nil {
return nil, err
}
diff --git a/execution/transactor.go b/execution/transactor.go
index de732e5d0b959e179be13e2df2df14db65144f8f..6401bd28d8f2ad72435f94bfb6c39cc96ed08267 100644
--- a/execution/transactor.go
+++ b/execution/transactor.go
@@ -73,21 +73,21 @@ func NewTransactor(tip *blockchain.Tip, eventEmitter event.Emitter,
// Run a contract's code on an isolated and unpersisted state
// Cannot be used to create new contracts
-func (trans *Transactor) Call(reader state.Reader, fromAddress, toAddress crypto.Address,
+func (trans *Transactor) Call(reader state.Reader, fromAddress, address crypto.Address,
data []byte) (call *Call, err error) {
- if evm.IsRegisteredNativeContract(toAddress.Word256()) {
+ if evm.IsRegisteredNativeContract(address.Word256()) {
return nil, fmt.Errorf("attempt to call native contract at address "+
"%X, but native contracts can not be called directly. Use a deployed "+
- "contract that calls the native function instead", toAddress)
+ "contract that calls the native function instead", address)
}
// This was being run against CheckTx cache, need to understand the reasoning
- callee, err := state.GetMutableAccount(reader, toAddress)
+ callee, err := state.GetMutableAccount(reader, address)
if err != nil {
return nil, err
}
if callee == nil {
- return nil, fmt.Errorf("account %s does not exist", toAddress)
+ return nil, fmt.Errorf("account %s does not exist", address)
}
caller := acm.ConcreteAccount{Address: fromAddress}.MutableAccount()
txCache := state.NewCache(reader)
@@ -203,20 +203,15 @@ func (trans *Transactor) Transact(sequentialSigningAccount *SequentialSigningAcc
}
defer unlock()
- callTx, err := trans.formulateCallTx(inputAccount, address, data, gasLimit, fee)
+ txEnv, err := trans.formulateCallTx(inputAccount, address, data, gasLimit, fee)
if err != nil {
return nil, err
}
- // Got ourselves a tx.
- err = callTx.Sign(inputAccount)
- if err != nil {
- return nil, err
- }
- return trans.BroadcastTx(callTx)
+ return trans.BroadcastTx(txEnv)
}
-func (trans *Transactor) TransactAndHold(sequentialSigningAccount *SequentialSigningAccount, address *crypto.Address, data []byte, gasLimit,
- fee uint64) (*evm_events.EventDataCall, error) {
+func (trans *Transactor) TransactAndHold(ctx context.Context, sequentialSigningAccount *SequentialSigningAccount,
+ address *crypto.Address, data []byte, gasLimit, fee uint64) (*evm_events.EventDataCall, error) {
inputAccount, unlock, err := sequentialSigningAccount.Lock()
if err != nil {
@@ -261,6 +256,8 @@ func (trans *Transactor) TransactAndHold(sequentialSigningAccount *SequentialSig
defer timer.Stop()
select {
+ case <-ctx.Done():
+ return nil, ctx.Err()
case <-timer.C:
return nil, fmt.Errorf("transaction timed out TxHash: %X", expectedReceipt.TxHash)
case eventDataCall := <-ch:
@@ -313,8 +310,8 @@ func (trans *Transactor) Send(sequentialSigningAccount *SequentialSigningAccount
return trans.BroadcastTx(sendTxEnv)
}
-func (trans *Transactor) SendAndHold(sequentialSigningAccount *SequentialSigningAccount, toAddress crypto.Address,
- amount uint64) (*txs.Receipt, error) {
+func (trans *Transactor) SendAndHold(ctx context.Context, sequentialSigningAccount *SequentialSigningAccount,
+ toAddress crypto.Address, amount uint64) (*txs.Receipt, error) {
inputAccount, unlock, err := sequentialSigningAccount.Lock()
if err != nil {
@@ -354,6 +351,8 @@ func (trans *Transactor) SendAndHold(sequentialSigningAccount *SequentialSigning
defer timer.Stop()
select {
+ case <-ctx.Done():
+ return nil, ctx.Err()
case <-timer.C:
return nil, fmt.Errorf("transaction timed out TxHash: %X", expectedReceipt.TxHash)
case sendTx := <-wc:
diff --git a/rpc/burrow/burrow.pb.go b/rpc/burrow/burrow.pb.go
new file mode 100644
index 0000000000000000000000000000000000000000..37ec3405d0336144b4a771168c965602c264aecc
--- /dev/null
+++ b/rpc/burrow/burrow.pb.go
@@ -0,0 +1,4842 @@
+// 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/burrow.proto b/rpc/burrow/burrow.proto
index 969fac4e70394b796535fa6a54ae78d7ee41be9c..24f7333d289c606b7f584860d599d4d44a1c12eb 100644
--- a/rpc/burrow/burrow.proto
+++ b/rpc/burrow/burrow.proto
@@ -33,9 +33,7 @@ message TxReceipt {
// This is here because it is used in both the Account Service (GenPrivAccount)
// And in the transaction service (SignTx)
message PrivateAccount {
- bytes Address = 1;
- bytes PublicKey = 2;
- bytes PrivateKey = 3;
+ bytes PrivateKey = 1;
}
// This is hear because it is used by both the Events service (Poll) and the
diff --git a/rpc/burrow/transaction_server.go b/rpc/burrow/transaction_server.go
index 73deeabc2e5b48788b2ae548e76836438c4e5ace..e8cd83475f3add3f420566482d64873fbcbe9dbf 100644
--- a/rpc/burrow/transaction_server.go
+++ b/rpc/burrow/transaction_server.go
@@ -1,6 +1,8 @@
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/evm/events"
"github.com/hyperledger/burrow/rpc"
@@ -10,10 +12,16 @@ import (
type transactionServer struct {
service *rpc.Service
+ txCodec txs.Codec
+ reader state.Reader
}
-func NewTransactionServer(service *rpc.Service) TransactionServer {
- return &transactionServer{service}
+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) {
@@ -24,12 +32,32 @@ func (ts *transactionServer) BroadcastTx(ctx context.Context, param *TxParam) (*
return txReceipt(receipt), nil
}
-func (ts *transactionServer) Call(context.Context, *CallParam) (*CallResult, error) {
- panic("implement me")
+func (ts *transactionServer) Call(ctx context.Context, param *CallParam) (*CallResult, error) {
+ fromAddress, err := crypto.AddressFromBytes(param.From)
+ if err != nil {
+ return nil, err
+ }
+ address, err := crypto.AddressFromBytes(param.Address)
+ if err != nil {
+ return nil, err
+ }
+ call, err := ts.service.Transactor().Call(ts.reader, fromAddress, address, param.Data)
+ return &CallResult{
+ Return: call.Return,
+ GasUsed: call.GasUsed,
+ }, nil
}
-func (ts *transactionServer) CallCode(context.Context, *CallCodeParam) (*CallResult, error) {
- panic("implement me")
+func (ts *transactionServer) CallCode(ctx context.Context, param *CallCodeParam) (*CallResult, error) {
+ fromAddress, err := crypto.AddressFromBytes(param.From)
+ if err != nil {
+ return nil, err
+ }
+ call, err := ts.service.Transactor().CallCode(ts.reader, fromAddress, param.Code, param.Data)
+ return &CallResult{
+ Return: call.Return,
+ GasUsed: call.GasUsed,
+ }, nil
}
func (ts *transactionServer) Transact(ctx context.Context, param *TransactParam) (*TxReceipt, error) {
@@ -57,23 +85,65 @@ func (ts *transactionServer) TransactAndHold(ctx context.Context, param *Transac
if err != nil {
return nil, err
}
- edt, err := ts.service.Transactor().TransactAndHold(inputAccount, address, param.Data, param.GasLimit, param.Fee)
+ edt, err := ts.service.Transactor().TransactAndHold(ctx, inputAccount, address, param.Data, param.GasLimit, param.Fee)
if err != nil {
return nil, err
}
return eventDataCall(edt), nil
}
-func (ts *transactionServer) Send(context.Context, *SendParam) (*TxReceipt, error) {
- panic("implement me")
+func (ts *transactionServer) Send(ctx context.Context, param *SendParam) (*TxReceipt, error) {
+ inputAccount, err := ts.service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ if err != nil {
+ return nil, err
+ }
+ toAddress, err := crypto.AddressFromBytes(param.ToAddress)
+ if err != nil {
+ return nil, err
+ }
+ receipt, err := ts.service.Transactor().Send(inputAccount, toAddress, param.Amount)
+ if err != nil {
+ return nil, err
+ }
+ return txReceipt(receipt), nil
}
-func (ts *transactionServer) SendAndHold(context.Context, *SendParam) (*TxReceipt, error) {
- panic("implement me")
+func (ts *transactionServer) SendAndHold(ctx context.Context, param *SendParam) (*TxReceipt, error) {
+ inputAccount, err := ts.service.SigningAccount(param.InputAccount.Address, param.InputAccount.PrivateKey)
+ if err != nil {
+ return nil, err
+ }
+ toAddress, err := crypto.AddressFromBytes(param.ToAddress)
+ if err != nil {
+ return nil, err
+ }
+ receipt, err := ts.service.Transactor().SendAndHold(ctx, inputAccount, toAddress, param.Amount)
+ if err != nil {
+ return nil, err
+ }
+ return txReceipt(receipt), nil
}
-func (ts *transactionServer) SignTx(context.Context, *SignTxParam) (*SignedTx, error) {
- panic("implement me")
+func (ts *transactionServer) SignTx(ctx context.Context, param *SignTxParam) (*SignedTx, error) {
+ txEnv, err := ts.txCodec.DecodeTx(param.Tx)
+ if err != nil {
+ return nil, err
+ }
+ signers, err := signersFromPrivateAccounts(param.PrivateAccounts)
+ 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 eventDataCall(edt *events.EventDataCall) *EventDataCall {
@@ -102,3 +172,28 @@ func txReceipt(receipt *txs.Receipt) *TxReceipt {
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/result.go b/rpc/result.go
index 4dc921fc20bbf8a63c6d7970e743599285cc912f..05ab9a853b6f11b1bb1566e035daac72ae56fa4d 100644
--- a/rpc/result.go
+++ b/rpc/result.go
@@ -19,6 +19,7 @@ import (
"fmt"
acm "github.com/hyperledger/burrow/account"
+ "github.com/hyperledger/burrow/binary"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/execution"
exeEvents "github.com/hyperledger/burrow/execution/events"
@@ -43,8 +44,8 @@ func init() {
}
type ResultGetStorage struct {
- Key []byte
- Value []byte
+ Key binary.HexBytes
+ Value binary.HexBytes
}
type ResultCall struct {
@@ -65,13 +66,13 @@ type ResultListAccounts struct {
}
type ResultDumpStorage struct {
- StorageRoot []byte
+ StorageRoot binary.HexBytes
StorageItems []StorageItem
}
type StorageItem struct {
- Key []byte
- Value []byte
+ Key binary.HexBytes
+ Value binary.HexBytes
}
type ResultListBlocks struct {
@@ -111,9 +112,9 @@ func (b *Block) UnmarshalJSON(data []byte) (err error) {
type ResultStatus struct {
NodeInfo p2p.NodeInfo
- GenesisHash []byte
+ GenesisHash binary.HexBytes
PubKey crypto.PublicKey
- LatestBlockHash []byte
+ LatestBlockHash binary.HexBytes
LatestBlockHeight uint64
LatestBlockTime int64
NodeVersion string
@@ -122,7 +123,7 @@ type ResultStatus struct {
type ResultChainId struct {
ChainName string
ChainId string
- GenesisHash []byte
+ GenesisHash binary.HexBytes
}
type ResultSubscribe struct {
diff --git a/rpc/result_test.go b/rpc/result_test.go
index 5de3f3eb949ee2808b9fc9c2a7747b58cd2145ea..62ea5b510fd0c4404108091e5ae8b16460194b9d 100644
--- a/rpc/result_test.go
+++ b/rpc/result_test.go
@@ -57,7 +57,7 @@ func TestListUnconfirmedTxs(t *testing.T) {
}
bs, err := json.Marshal(res)
require.NoError(t, err)
- assert.Equal(t, "{\"NumTxs\":3,\"Txs\":[{\"Signatories\":null,\"Tx\":{\"ChainID\":\"testChain\",\"Type\":\"CallTx\",\"Payload\":{\"Input\":null,\"Address\":\"0100000000000000000000000000000000000000\",\"GasLimit\":0,\"Fee\":0,\"Data\":null}}}]}",
+ assert.Equal(t, "{\"NumTxs\":3,\"Txs\":[{\"Signatories\":null,\"Tx\":{\"ChainID\":\"testChain\",\"Type\":\"CallTx\",\"Payload\":{\"Input\":null,\"Address\":\"0100000000000000000000000000000000000000\",\"GasLimit\":0,\"Fee\":0}}}]}",
string(bs))
}
diff --git a/rpc/v0/methods.go b/rpc/v0/methods.go
index e2c2aca1bd73fe450dcd9ff48c90a7256166a182..536a554f3614170b14cf91a18ad8a1763070cc15 100644
--- a/rpc/v0/methods.go
+++ b/rpc/v0/methods.go
@@ -15,6 +15,8 @@
package v0
import (
+ "context"
+
acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/execution/names"
@@ -255,7 +257,8 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
- eventDataCall, err := service.Transactor().TransactAndHold(inputAccount, address, param.Data, param.GasLimit, param.Fee)
+ eventDataCall, err := service.Transactor().TransactAndHold(context.Background(), inputAccount, address,
+ param.Data, param.GasLimit, param.Fee)
if err != nil {
return nil, rpc.INTERNAL_ERROR, err
}
@@ -297,7 +300,7 @@ func GetMethods(codec rpc.Codec, service *rpc.Service, logger *logging.Logger) m
if err != nil {
return nil, rpc.INVALID_PARAMS, err
}
- rec, err := service.Transactor().SendAndHold(inputAccount, toAddress, param.Amount)
+ rec, err := service.Transactor().SendAndHold(context.Background(), inputAccount, toAddress, param.Amount)
if err != nil {
return nil, rpc.INTERNAL_ERROR, err
}
diff --git a/txs/amino_codec_test.go b/txs/amino_codec_test.go
index 2cc87ad689bf62b19fa86f035911bcf4a31d04b5..86a90a5d028f36c57d39a6fc67adb860cda63f55 100644
--- a/txs/amino_codec_test.go
+++ b/txs/amino_codec_test.go
@@ -3,7 +3,9 @@ package txs
import (
"testing"
- "github.com/hyperledger/burrow/account"
+ "fmt"
+
+ acm "github.com/hyperledger/burrow/account"
"github.com/hyperledger/burrow/crypto"
"github.com/hyperledger/burrow/txs/payload"
"github.com/stretchr/testify/assert"
@@ -39,7 +41,7 @@ func TestAminoEncodeTxDecodeTx(t *testing.T) {
func TestAminoEncodeTxDecodeTx_CallTx(t *testing.T) {
codec := NewAminoCodec()
- inputAccount := account.GeneratePrivateAccountFromSecret("fooo")
+ inputAccount := acm.GeneratePrivateAccountFromSecret("fooo")
amount := uint64(2)
sequence := uint64(3)
tx := &payload.CallTx{
@@ -63,3 +65,21 @@ func TestAminoEncodeTxDecodeTx_CallTx(t *testing.T) {
assert.NoError(t, err, "DecodeTx error")
assert.Equal(t, txEnv, txEnvOut)
}
+
+func TestAminoTxEnvelope(t *testing.T) {
+ codec := NewAminoCodec()
+ privAccFrom := acm.GeneratePrivateAccountFromSecret("foo")
+ privAccTo := acm.GeneratePrivateAccountFromSecret("bar")
+ toAddress := privAccTo.Address()
+ txEnv := Enclose("testChain", payload.NewCallTxWithSequence(privAccFrom.PublicKey(), &toAddress,
+ []byte{3, 4, 5, 5}, 343, 2323, 12, 3))
+ err := txEnv.Sign(privAccFrom)
+ require.NoError(t, err)
+
+ bs, err := codec.EncodeTx(txEnv)
+ 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/envelope.go b/txs/envelope.go
index 222867eacd2c481cae94d66a203bcb5eeee489db..107c7a6770a853de5a34e992ab39dd983653a071 100644
--- a/txs/envelope.go
+++ b/txs/envelope.go
@@ -9,6 +9,11 @@ import (
"github.com/hyperledger/burrow/txs/payload"
)
+type Codec interface {
+ Encoder
+ Decoder
+}
+
type Encoder interface {
EncodeTx(envelope *Envelope) ([]byte, error)
}
diff --git a/txs/json_codec.go b/txs/json_codec.go
index ccfbfe8ceb2d0e6e1b96fa8e4963e13f8c0cb9bd..af33f1193e4452e171f6ec693d7e60e4df4e4346 100644
--- a/txs/json_codec.go
+++ b/txs/json_codec.go
@@ -15,10 +15,10 @@ func (gwc *jsonCodec) EncodeTx(env *Envelope) ([]byte, error) {
}
func (gwc *jsonCodec) DecodeTx(txBytes []byte) (*Envelope, error) {
- env := new(Envelope)
- err := json.Unmarshal(txBytes, env)
+ txEnv := new(Envelope)
+ err := json.Unmarshal(txBytes, txEnv)
if err != nil {
return nil, err
}
- return env, nil
+ return txEnv, nil
}
diff --git a/txs/json_codec_test.go b/txs/json_codec_test.go
index 76c907e01a043aa188190d5ad13e49bb514cae05..f0056290c55d5efa285733fcb5831ad1138b936b 100644
--- a/txs/json_codec_test.go
+++ b/txs/json_codec_test.go
@@ -63,3 +63,30 @@ func TestJSONEncodeTxDecodeTx_CallTx(t *testing.T) {
assert.NoError(t, err, "DecodeTx error")
assert.Equal(t, txEnv, txEnvOut)
}
+
+func TestJSONEncodeTxDecodeTx_CallTxNoData(t *testing.T) {
+ codec := NewJSONCodec()
+ inputAccount := account.GeneratePrivateAccountFromSecret("fooo")
+ amount := uint64(2)
+ sequence := uint64(3)
+ tx := &payload.CallTx{
+ Input: &payload.TxInput{
+ Address: inputAccount.Address(),
+ Amount: amount,
+ Sequence: sequence,
+ },
+ GasLimit: 233,
+ Fee: 2,
+ Address: nil,
+ Data: nil,
+ }
+ txEnv := Enclose(chainID, tx)
+ require.NoError(t, txEnv.Sign(inputAccount))
+ txBytes, err := codec.EncodeTx(txEnv)
+ if err != nil {
+ t.Fatal(err)
+ }
+ txEnvOut, err := codec.DecodeTx(txBytes)
+ assert.NoError(t, err, "DecodeTx error")
+ assert.Equal(t, txEnv, txEnvOut)
+}
diff --git a/txs/payload/call_tx.go b/txs/payload/call_tx.go
index b3c1270bf10da692fb23e3b9238980d67e3ff3c4..40037d69f475051d0ae048dbd8c607f25ec62611 100644
--- a/txs/payload/call_tx.go
+++ b/txs/payload/call_tx.go
@@ -13,7 +13,8 @@ type CallTx struct {
Address *crypto.Address
GasLimit uint64
Fee uint64
- Data []byte
+ // Signing normalisation needs omitempty
+ Data []byte `json:",omitempty"`
}
func NewCallTx(st state.AccountGetter, from crypto.PublicKey, to *crypto.Address, data []byte,
diff --git a/txs/payload/governance_tx.go b/txs/payload/governance_tx.go
index bf145470beb75eb2d29279be677de8dd91d05fa0..24c0cb48ad0a060d960345561057d4c39a55ac92 100644
--- a/txs/payload/governance_tx.go
+++ b/txs/payload/governance_tx.go
@@ -36,6 +36,10 @@ func NewGovTxWithSequence(from crypto.Address, sequence uint64, accounts []spec.
}
}
+func (tx *GovernanceTx) Type() Type {
+ return TypeGovernance
+}
+
func (tx *GovernanceTx) GetInputs() []*TxInput {
return []*TxInput{tx.Input}
}
diff --git a/vendor/github.com/tendermint/tmlibs/test/assert.go b/vendor/github.com/tendermint/tmlibs/test/assert.go
deleted file mode 100644
index a6ffed0cec39bb8079a9d698645a876640fea7a6..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/tmlibs/test/assert.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package test
-
-import (
- "testing"
-)
-
-func AssertPanics(t *testing.T, msg string, f func()) {
- defer func() {
- if err := recover(); err == nil {
- t.Errorf("Should have panic'd, but didn't: %v", msg)
- }
- }()
- f()
-}
diff --git a/vendor/github.com/tendermint/tmlibs/test/mutate.go b/vendor/github.com/tendermint/tmlibs/test/mutate.go
deleted file mode 100644
index 76534e8b1874bf4c5e0a7c84a2472c46f6f9df33..0000000000000000000000000000000000000000
--- a/vendor/github.com/tendermint/tmlibs/test/mutate.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package test
-
-import (
- cmn "github.com/tendermint/tmlibs/common"
-)
-
-// Contract: !bytes.Equal(input, output) && len(input) >= len(output)
-func MutateByteSlice(bytez []byte) []byte {
- // If bytez is empty, panic
- if len(bytez) == 0 {
- panic("Cannot mutate an empty bytez")
- }
-
- // Copy bytez
- mBytez := make([]byte, len(bytez))
- copy(mBytez, bytez)
- bytez = mBytez
-
- // Try a random mutation
- switch cmn.RandInt() % 2 {
- case 0: // Mutate a single byte
- bytez[cmn.RandInt()%len(bytez)] += byte(cmn.RandInt()%255 + 1)
- case 1: // Remove an arbitrary byte
- pos := cmn.RandInt() % len(bytez)
- bytez = append(bytez[:pos], bytez[pos+1:]...)
- }
- return bytez
-}