github.com/datachainlab/burrow@v0.25.0/execution/exec/exec.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: exec.proto

package exec

import (
	fmt "fmt"
	io "io"
	math "math"
	time "time"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	golang_proto "github.com/golang/protobuf/proto"
	_ "github.com/golang/protobuf/ptypes/timestamp"
	github_com_hyperledger_burrow_binary "github.com/hyperledger/burrow/binary"
	github_com_hyperledger_burrow_crypto "github.com/hyperledger/burrow/crypto"
	errors "github.com/hyperledger/burrow/execution/errors"
	names "github.com/hyperledger/burrow/execution/names"
	spec "github.com/hyperledger/burrow/genesis/spec"
	permission "github.com/hyperledger/burrow/permission"
	github_com_hyperledger_burrow_txs "github.com/hyperledger/burrow/txs"
	txs "github.com/hyperledger/burrow/txs"
	github_com_hyperledger_burrow_txs_payload "github.com/hyperledger/burrow/txs/payload"
	types "github.com/tendermint/tendermint/abci/types"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = golang_proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
var _ = time.Kitchen

// 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.GoGoProtoPackageIsVersion2 // please upgrade the proto package

type StreamEvent struct {
	BeginBlock           *BeginBlock                                 `protobuf:"bytes,1,opt,name=BeginBlock,proto3" json:"BeginBlock,omitempty"`
	BeginTx              *BeginTx                                    `protobuf:"bytes,2,opt,name=BeginTx,proto3" json:"BeginTx,omitempty"`
	Envelope             *github_com_hyperledger_burrow_txs.Envelope `protobuf:"bytes,3,opt,name=Envelope,proto3,customtype=github.com/hyperledger/burrow/txs.Envelope" json:"Envelope,omitempty"`
	Event                *Event                                      `protobuf:"bytes,4,opt,name=Event,proto3" json:"Event,omitempty"`
	EndTx                *EndTx                                      `protobuf:"bytes,5,opt,name=EndTx,proto3" json:"EndTx,omitempty"`
	EndBlock             *EndBlock                                   `protobuf:"bytes,6,opt,name=EndBlock,proto3" json:"EndBlock,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                    `json:"-"`
	XXX_unrecognized     []byte                                      `json:"-"`
	XXX_sizecache        int32                                       `json:"-"`
}

func (m *StreamEvent) Reset()         { *m = StreamEvent{} }
func (m *StreamEvent) String() string { return proto.CompactTextString(m) }
func (*StreamEvent) ProtoMessage()    {}
func (*StreamEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{0}
}
func (m *StreamEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StreamEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamEvent.Merge(m, src)
}
func (m *StreamEvent) XXX_Size() int {
	return m.Size()
}
func (m *StreamEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamEvent.DiscardUnknown(m)
}

var xxx_messageInfo_StreamEvent proto.InternalMessageInfo

func (m *StreamEvent) GetBeginBlock() *BeginBlock {
	if m != nil {
		return m.BeginBlock
	}
	return nil
}

func (m *StreamEvent) GetBeginTx() *BeginTx {
	if m != nil {
		return m.BeginTx
	}
	return nil
}

func (m *StreamEvent) GetEvent() *Event {
	if m != nil {
		return m.Event
	}
	return nil
}

func (m *StreamEvent) GetEndTx() *EndTx {
	if m != nil {
		return m.EndTx
	}
	return nil
}

func (m *StreamEvent) GetEndBlock() *EndBlock {
	if m != nil {
		return m.EndBlock
	}
	return nil
}

func (*StreamEvent) XXX_MessageName() string {
	return "exec.StreamEvent"
}

// A key to a stream event
type StreamKey struct {
	// The block height
	Height uint64 `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	// The index of the StreamEvent amongst other StreamEvents at the same height
	Index                uint64   `protobuf:"varint,2,opt,name=Index,proto3" json:"Index,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *StreamKey) Reset()         { *m = StreamKey{} }
func (m *StreamKey) String() string { return proto.CompactTextString(m) }
func (*StreamKey) ProtoMessage()    {}
func (*StreamKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{1}
}
func (m *StreamKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamKey.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *StreamKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamKey.Merge(m, src)
}
func (m *StreamKey) XXX_Size() int {
	return m.Size()
}
func (m *StreamKey) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamKey.DiscardUnknown(m)
}

var xxx_messageInfo_StreamKey proto.InternalMessageInfo

func (m *StreamKey) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *StreamKey) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (*StreamKey) XXX_MessageName() string {
	return "exec.StreamKey"
}

type BeginBlock struct {
	// The height of this block
	Height               uint64        `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	Header               *types.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 *BeginBlock) Reset()         { *m = BeginBlock{} }
func (m *BeginBlock) String() string { return proto.CompactTextString(m) }
func (*BeginBlock) ProtoMessage()    {}
func (*BeginBlock) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{2}
}
func (m *BeginBlock) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BeginBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BeginBlock.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BeginBlock) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BeginBlock.Merge(m, src)
}
func (m *BeginBlock) XXX_Size() int {
	return m.Size()
}
func (m *BeginBlock) XXX_DiscardUnknown() {
	xxx_messageInfo_BeginBlock.DiscardUnknown(m)
}

var xxx_messageInfo_BeginBlock proto.InternalMessageInfo

func (m *BeginBlock) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *BeginBlock) GetHeader() *types.Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (*BeginBlock) XXX_MessageName() string {
	return "exec.BeginBlock"
}

type EndBlock 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 *EndBlock) Reset()         { *m = EndBlock{} }
func (m *EndBlock) String() string { return proto.CompactTextString(m) }
func (*EndBlock) ProtoMessage()    {}
func (*EndBlock) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{3}
}
func (m *EndBlock) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EndBlock) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EndBlock.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EndBlock) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndBlock.Merge(m, src)
}
func (m *EndBlock) XXX_Size() int {
	return m.Size()
}
func (m *EndBlock) XXX_DiscardUnknown() {
	xxx_messageInfo_EndBlock.DiscardUnknown(m)
}

var xxx_messageInfo_EndBlock proto.InternalMessageInfo

func (m *EndBlock) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (*EndBlock) XXX_MessageName() string {
	return "exec.EndBlock"
}

type BeginTx struct {
	TxHeader *TxHeader `protobuf:"bytes,1,opt,name=TxHeader,proto3" json:"TxHeader,omitempty"`
	// Result of tx execution
	Result *Result `protobuf:"bytes,2,opt,name=Result,proto3" json:"Result,omitempty"`
	// If tx execution was an exception
	Exception            *errors.Exception `protobuf:"bytes,4,opt,name=Exception,proto3" json:"Exception,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *BeginTx) Reset()         { *m = BeginTx{} }
func (m *BeginTx) String() string { return proto.CompactTextString(m) }
func (*BeginTx) ProtoMessage()    {}
func (*BeginTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{4}
}
func (m *BeginTx) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BeginTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BeginTx.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BeginTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BeginTx.Merge(m, src)
}
func (m *BeginTx) XXX_Size() int {
	return m.Size()
}
func (m *BeginTx) XXX_DiscardUnknown() {
	xxx_messageInfo_BeginTx.DiscardUnknown(m)
}

var xxx_messageInfo_BeginTx proto.InternalMessageInfo

func (m *BeginTx) GetTxHeader() *TxHeader {
	if m != nil {
		return m.TxHeader
	}
	return nil
}

func (m *BeginTx) GetResult() *Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *BeginTx) GetException() *errors.Exception {
	if m != nil {
		return m.Exception
	}
	return nil
}

func (*BeginTx) XXX_MessageName() string {
	return "exec.BeginTx"
}

type EndTx struct {
	// The hash of the transaction that caused this event to be generated
	TxHash               github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,3,opt,name=TxHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"TxHash"`
	XXX_NoUnkeyedLiteral struct{}                                      `json:"-"`
	XXX_unrecognized     []byte                                        `json:"-"`
	XXX_sizecache        int32                                         `json:"-"`
}

func (m *EndTx) Reset()         { *m = EndTx{} }
func (m *EndTx) String() string { return proto.CompactTextString(m) }
func (*EndTx) ProtoMessage()    {}
func (*EndTx) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{5}
}
func (m *EndTx) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EndTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EndTx.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *EndTx) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EndTx.Merge(m, src)
}
func (m *EndTx) XXX_Size() int {
	return m.Size()
}
func (m *EndTx) XXX_DiscardUnknown() {
	xxx_messageInfo_EndTx.DiscardUnknown(m)
}

var xxx_messageInfo_EndTx proto.InternalMessageInfo

func (*EndTx) XXX_MessageName() string {
	return "exec.EndTx"
}

type TxHeader struct {
	// Transaction type
	TxType github_com_hyperledger_burrow_txs_payload.Type `protobuf:"varint,1,opt,name=TxType,proto3,casttype=github.com/hyperledger/burrow/txs/payload.Type" json:"TxType,omitempty"`
	// The hash of the transaction that caused this event to be generated
	TxHash github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,2,opt,name=TxHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"TxHash"`
	// The block height at which this Tx was included
	Height uint64 `protobuf:"varint,3,opt,name=Height,proto3" json:"Height,omitempty"`
	// The index of this transaction within the block
	Index uint64 `protobuf:"varint,4,opt,name=Index,proto3" json:"Index,omitempty"`
	// The origin information from the chain on which this tx was originally committed (if restored or otherwise imported)
	Origin               *Origin  `protobuf:"bytes,5,opt,name=Origin,proto3" json:"Origin,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TxHeader) Reset()         { *m = TxHeader{} }
func (m *TxHeader) String() string { return proto.CompactTextString(m) }
func (*TxHeader) ProtoMessage()    {}
func (*TxHeader) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{6}
}
func (m *TxHeader) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TxHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TxHeader.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TxHeader) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TxHeader.Merge(m, src)
}
func (m *TxHeader) XXX_Size() int {
	return m.Size()
}
func (m *TxHeader) XXX_DiscardUnknown() {
	xxx_messageInfo_TxHeader.DiscardUnknown(m)
}

var xxx_messageInfo_TxHeader proto.InternalMessageInfo

func (m *TxHeader) GetTxType() github_com_hyperledger_burrow_txs_payload.Type {
	if m != nil {
		return m.TxType
	}
	return 0
}

func (m *TxHeader) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *TxHeader) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *TxHeader) GetOrigin() *Origin {
	if m != nil {
		return m.Origin
	}
	return nil
}

func (*TxHeader) XXX_MessageName() string {
	return "exec.TxHeader"
}

type BlockExecution struct {
	// The height of this block
	Height               uint64         `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	Header               *types.Header  `protobuf:"bytes,2,opt,name=Header,proto3" json:"Header,omitempty"`
	TxExecutions         []*TxExecution `protobuf:"bytes,3,rep,name=TxExecutions,proto3" json:"TxExecutions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *BlockExecution) Reset()         { *m = BlockExecution{} }
func (m *BlockExecution) String() string { return proto.CompactTextString(m) }
func (*BlockExecution) ProtoMessage()    {}
func (*BlockExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{7}
}
func (m *BlockExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BlockExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BlockExecution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *BlockExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BlockExecution.Merge(m, src)
}
func (m *BlockExecution) XXX_Size() int {
	return m.Size()
}
func (m *BlockExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_BlockExecution.DiscardUnknown(m)
}

var xxx_messageInfo_BlockExecution proto.InternalMessageInfo

func (m *BlockExecution) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *BlockExecution) GetHeader() *types.Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *BlockExecution) GetTxExecutions() []*TxExecution {
	if m != nil {
		return m.TxExecutions
	}
	return nil
}

func (*BlockExecution) XXX_MessageName() string {
	return "exec.BlockExecution"
}

type TxExecution struct {
	*TxHeader `protobuf:"bytes,1,opt,name=Header,proto3,embedded=Header" json:"Header,omitempty"`
	// Signed Tx that triggered this execution
	Envelope *github_com_hyperledger_burrow_txs.Envelope `protobuf:"bytes,6,opt,name=Envelope,proto3,customtype=github.com/hyperledger/burrow/txs.Envelope" json:"Envelope,omitempty"`
	// Execution events
	Events []*Event `protobuf:"bytes,7,rep,name=Events,proto3" json:"Events,omitempty"`
	// The execution results
	Result *Result `protobuf:"bytes,8,opt,name=Result,proto3" json:"Result,omitempty"`
	// The transaction receipt
	Receipt *txs.Receipt `protobuf:"bytes,9,opt,name=Receipt,proto3" json:"Receipt,omitempty"`
	// If execution was an exception
	Exception *errors.Exception `protobuf:"bytes,10,opt,name=Exception,proto3" json:"Exception,omitempty"`
	// A proposal may contain other transactions
	TxExecutions         []*TxExecution `protobuf:"bytes,11,rep,name=TxExecutions,proto3" json:"TxExecutions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *TxExecution) Reset()         { *m = TxExecution{} }
func (m *TxExecution) String() string { return proto.CompactTextString(m) }
func (*TxExecution) ProtoMessage()    {}
func (*TxExecution) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{8}
}
func (m *TxExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TxExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TxExecution.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *TxExecution) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TxExecution.Merge(m, src)
}
func (m *TxExecution) XXX_Size() int {
	return m.Size()
}
func (m *TxExecution) XXX_DiscardUnknown() {
	xxx_messageInfo_TxExecution.DiscardUnknown(m)
}

var xxx_messageInfo_TxExecution proto.InternalMessageInfo

func (m *TxExecution) GetEvents() []*Event {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *TxExecution) GetResult() *Result {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *TxExecution) GetReceipt() *txs.Receipt {
	if m != nil {
		return m.Receipt
	}
	return nil
}

func (m *TxExecution) GetException() *errors.Exception {
	if m != nil {
		return m.Exception
	}
	return nil
}

func (m *TxExecution) GetTxExecutions() []*TxExecution {
	if m != nil {
		return m.TxExecutions
	}
	return nil
}

func (*TxExecution) XXX_MessageName() string {
	return "exec.TxExecution"
}

type Origin struct {
	// The original ChainID from for this transaction
	ChainID string `protobuf:"bytes,1,opt,name=ChainID,proto3" json:"ChainID,omitempty"`
	// The original height at which this transaction was committed
	Height uint64 `protobuf:"varint,2,opt,name=Height,proto3" json:"Height,omitempty"`
	// The original index in the block
	Index uint64 `protobuf:"varint,3,opt,name=Index,proto3" json:"Index,omitempty"`
	// The original block time for this transaction
	Time                 time.Time `protobuf:"bytes,4,opt,name=Time,proto3,stdtime" json:"Time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *Origin) Reset()         { *m = Origin{} }
func (m *Origin) String() string { return proto.CompactTextString(m) }
func (*Origin) ProtoMessage()    {}
func (*Origin) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{9}
}
func (m *Origin) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Origin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Origin.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Origin) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Origin.Merge(m, src)
}
func (m *Origin) XXX_Size() int {
	return m.Size()
}
func (m *Origin) XXX_DiscardUnknown() {
	xxx_messageInfo_Origin.DiscardUnknown(m)
}

var xxx_messageInfo_Origin proto.InternalMessageInfo

func (m *Origin) GetChainID() string {
	if m != nil {
		return m.ChainID
	}
	return ""
}

func (m *Origin) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Origin) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *Origin) GetTime() time.Time {
	if m != nil {
		return m.Time
	}
	return time.Time{}
}

func (*Origin) XXX_MessageName() string {
	return "exec.Origin"
}

type Header struct {
	// Transaction type
	TxType github_com_hyperledger_burrow_txs_payload.Type `protobuf:"varint,1,opt,name=TxType,proto3,casttype=github.com/hyperledger/burrow/txs/payload.Type" json:"TxType,omitempty"`
	// The hash of the transaction that caused this event to be generated
	TxHash github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,2,opt,name=TxHash,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"TxHash"`
	// The type of event
	EventType EventType `protobuf:"varint,3,opt,name=EventType,proto3,casttype=EventType" json:"EventType,omitempty"`
	// EventID published with event
	EventID string `protobuf:"bytes,4,opt,name=EventID,proto3" json:"EventID,omitempty"`
	// The block height at which this event was emitted
	Height uint64 `protobuf:"varint,5,opt,name=Height,proto3" json:"Height,omitempty"`
	// The index of this event relative to other events generated by the same transaction
	Index uint64 `protobuf:"varint,6,opt,name=Index,proto3" json:"Index,omitempty"`
	// If event is exception
	Exception            *errors.Exception `protobuf:"bytes,7,opt,name=Exception,proto3" json:"Exception,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Header) Reset()      { *m = Header{} }
func (*Header) ProtoMessage() {}
func (*Header) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{10}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Header.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Header) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Header.Merge(m, src)
}
func (m *Header) XXX_Size() int {
	return m.Size()
}
func (m *Header) XXX_DiscardUnknown() {
	xxx_messageInfo_Header.DiscardUnknown(m)
}

var xxx_messageInfo_Header proto.InternalMessageInfo

func (m *Header) GetTxType() github_com_hyperledger_burrow_txs_payload.Type {
	if m != nil {
		return m.TxType
	}
	return 0
}

func (m *Header) GetEventType() EventType {
	if m != nil {
		return m.EventType
	}
	return 0
}

func (m *Header) GetEventID() string {
	if m != nil {
		return m.EventID
	}
	return ""
}

func (m *Header) GetHeight() uint64 {
	if m != nil {
		return m.Height
	}
	return 0
}

func (m *Header) GetIndex() uint64 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *Header) GetException() *errors.Exception {
	if m != nil {
		return m.Exception
	}
	return nil
}

func (*Header) XXX_MessageName() string {
	return "exec.Header"
}

type Event struct {
	Header               *Header             `protobuf:"bytes,1,opt,name=Header,proto3" json:"Header,omitempty"`
	Input                *InputEvent         `protobuf:"bytes,2,opt,name=Input,proto3" json:"Input,omitempty"`
	Output               *OutputEvent        `protobuf:"bytes,3,opt,name=Output,proto3" json:"Output,omitempty"`
	Call                 *CallEvent          `protobuf:"bytes,4,opt,name=Call,proto3" json:"Call,omitempty"`
	Log                  *LogEvent           `protobuf:"bytes,5,opt,name=Log,proto3" json:"Log,omitempty"`
	GovernAccount        *GovernAccountEvent `protobuf:"bytes,6,opt,name=GovernAccount,proto3" json:"GovernAccount,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *Event) Reset()      { *m = Event{} }
func (*Event) ProtoMessage() {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{11}
}
func (m *Event) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Event.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Event) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Event.Merge(m, src)
}
func (m *Event) XXX_Size() int {
	return m.Size()
}
func (m *Event) XXX_DiscardUnknown() {
	xxx_messageInfo_Event.DiscardUnknown(m)
}

var xxx_messageInfo_Event proto.InternalMessageInfo

func (m *Event) GetHeader() *Header {
	if m != nil {
		return m.Header
	}
	return nil
}

func (m *Event) GetInput() *InputEvent {
	if m != nil {
		return m.Input
	}
	return nil
}

func (m *Event) GetOutput() *OutputEvent {
	if m != nil {
		return m.Output
	}
	return nil
}

func (m *Event) GetCall() *CallEvent {
	if m != nil {
		return m.Call
	}
	return nil
}

func (m *Event) GetLog() *LogEvent {
	if m != nil {
		return m.Log
	}
	return nil
}

func (m *Event) GetGovernAccount() *GovernAccountEvent {
	if m != nil {
		return m.GovernAccount
	}
	return nil
}

func (*Event) XXX_MessageName() string {
	return "exec.Event"
}

// Could structure this further if needed - sum type of various results relevant to different transaction types
type Result struct {
	// EVM execution return
	Return []byte `protobuf:"bytes,1,opt,name=Return,proto3" json:"Return,omitempty"`
	// Gas used in computation
	GasUsed uint64 `protobuf:"varint,2,opt,name=GasUsed,proto3" json:"GasUsed,omitempty"`
	// Name entry created
	NameEntry *names.Entry `protobuf:"bytes,3,opt,name=NameEntry,proto3" json:"NameEntry,omitempty"`
	// Permission update performed
	PermArgs             *permission.PermArgs `protobuf:"bytes,4,opt,name=PermArgs,proto3" json:"PermArgs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Result) Reset()         { *m = Result{} }
func (m *Result) String() string { return proto.CompactTextString(m) }
func (*Result) ProtoMessage()    {}
func (*Result) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{12}
}
func (m *Result) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Result.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Result) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Result.Merge(m, src)
}
func (m *Result) XXX_Size() int {
	return m.Size()
}
func (m *Result) XXX_DiscardUnknown() {
	xxx_messageInfo_Result.DiscardUnknown(m)
}

var xxx_messageInfo_Result proto.InternalMessageInfo

func (m *Result) GetReturn() []byte {
	if m != nil {
		return m.Return
	}
	return nil
}

func (m *Result) GetGasUsed() uint64 {
	if m != nil {
		return m.GasUsed
	}
	return 0
}

func (m *Result) GetNameEntry() *names.Entry {
	if m != nil {
		return m.NameEntry
	}
	return nil
}

func (m *Result) GetPermArgs() *permission.PermArgs {
	if m != nil {
		return m.PermArgs
	}
	return nil
}

func (*Result) XXX_MessageName() string {
	return "exec.Result"
}

type LogEvent struct {
	Address              github_com_hyperledger_burrow_crypto.Address   `protobuf:"bytes,1,opt,name=Address,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address"`
	Data                 github_com_hyperledger_burrow_binary.HexBytes  `protobuf:"bytes,2,opt,name=Data,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"Data"`
	Topics               []github_com_hyperledger_burrow_binary.Word256 `protobuf:"bytes,3,rep,name=Topics,proto3,customtype=github.com/hyperledger/burrow/binary.Word256" json:"Topics"`
	XXX_NoUnkeyedLiteral struct{}                                       `json:"-"`
	XXX_unrecognized     []byte                                         `json:"-"`
	XXX_sizecache        int32                                          `json:"-"`
}

func (m *LogEvent) Reset()         { *m = LogEvent{} }
func (m *LogEvent) String() string { return proto.CompactTextString(m) }
func (*LogEvent) ProtoMessage()    {}
func (*LogEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{13}
}
func (m *LogEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_LogEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *LogEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_LogEvent.Merge(m, src)
}
func (m *LogEvent) XXX_Size() int {
	return m.Size()
}
func (m *LogEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_LogEvent.DiscardUnknown(m)
}

var xxx_messageInfo_LogEvent proto.InternalMessageInfo

func (*LogEvent) XXX_MessageName() string {
	return "exec.LogEvent"
}

type CallEvent struct {
	CallType             CallType                                      `protobuf:"varint,5,opt,name=CallType,proto3,casttype=CallType" json:"CallType,omitempty"`
	CallData             *CallData                                     `protobuf:"bytes,1,opt,name=CallData,proto3" json:"CallData,omitempty"`
	Origin               github_com_hyperledger_burrow_crypto.Address  `protobuf:"bytes,2,opt,name=Origin,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Origin"`
	StackDepth           uint64                                        `protobuf:"varint,3,opt,name=StackDepth,proto3" json:"StackDepth,omitempty"`
	Return               github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,4,opt,name=Return,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"Return"`
	XXX_NoUnkeyedLiteral struct{}                                      `json:"-"`
	XXX_unrecognized     []byte                                        `json:"-"`
	XXX_sizecache        int32                                         `json:"-"`
}

func (m *CallEvent) Reset()         { *m = CallEvent{} }
func (m *CallEvent) String() string { return proto.CompactTextString(m) }
func (*CallEvent) ProtoMessage()    {}
func (*CallEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{14}
}
func (m *CallEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CallEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CallEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CallEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CallEvent.Merge(m, src)
}
func (m *CallEvent) XXX_Size() int {
	return m.Size()
}
func (m *CallEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_CallEvent.DiscardUnknown(m)
}

var xxx_messageInfo_CallEvent proto.InternalMessageInfo

func (m *CallEvent) GetCallType() CallType {
	if m != nil {
		return m.CallType
	}
	return 0
}

func (m *CallEvent) GetCallData() *CallData {
	if m != nil {
		return m.CallData
	}
	return nil
}

func (m *CallEvent) GetStackDepth() uint64 {
	if m != nil {
		return m.StackDepth
	}
	return 0
}

func (*CallEvent) XXX_MessageName() string {
	return "exec.CallEvent"
}

type GovernAccountEvent struct {
	AccountUpdate        *spec.TemplateAccount `protobuf:"bytes,1,opt,name=AccountUpdate,proto3" json:"AccountUpdate,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *GovernAccountEvent) Reset()         { *m = GovernAccountEvent{} }
func (m *GovernAccountEvent) String() string { return proto.CompactTextString(m) }
func (*GovernAccountEvent) ProtoMessage()    {}
func (*GovernAccountEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{15}
}
func (m *GovernAccountEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GovernAccountEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GovernAccountEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GovernAccountEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GovernAccountEvent.Merge(m, src)
}
func (m *GovernAccountEvent) XXX_Size() int {
	return m.Size()
}
func (m *GovernAccountEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_GovernAccountEvent.DiscardUnknown(m)
}

var xxx_messageInfo_GovernAccountEvent proto.InternalMessageInfo

func (m *GovernAccountEvent) GetAccountUpdate() *spec.TemplateAccount {
	if m != nil {
		return m.AccountUpdate
	}
	return nil
}

func (*GovernAccountEvent) XXX_MessageName() string {
	return "exec.GovernAccountEvent"
}

type InputEvent struct {
	Address              github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,1,opt,name=Address,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}

func (m *InputEvent) Reset()         { *m = InputEvent{} }
func (m *InputEvent) String() string { return proto.CompactTextString(m) }
func (*InputEvent) ProtoMessage()    {}
func (*InputEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{16}
}
func (m *InputEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InputEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_InputEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *InputEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InputEvent.Merge(m, src)
}
func (m *InputEvent) XXX_Size() int {
	return m.Size()
}
func (m *InputEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_InputEvent.DiscardUnknown(m)
}

var xxx_messageInfo_InputEvent proto.InternalMessageInfo

func (*InputEvent) XXX_MessageName() string {
	return "exec.InputEvent"
}

type OutputEvent struct {
	Address              github_com_hyperledger_burrow_crypto.Address `protobuf:"bytes,1,opt,name=Address,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Address"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}

func (m *OutputEvent) Reset()         { *m = OutputEvent{} }
func (m *OutputEvent) String() string { return proto.CompactTextString(m) }
func (*OutputEvent) ProtoMessage()    {}
func (*OutputEvent) Descriptor() ([]byte, []int) {
	return fileDescriptor_4d737c7315c25422, []int{17}
}
func (m *OutputEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutputEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutputEvent.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutputEvent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutputEvent.Merge(m, src)
}
func (m *OutputEvent) XXX_Size() int {
	return m.Size()
}
func (m *OutputEvent) XXX_DiscardUnknown() {
	xxx_messageInfo_OutputEvent.DiscardUnknown(m)
}

var xxx_messageInfo_OutputEvent proto.InternalMessageInfo

func (*OutputEvent) XXX_MessageName() string {
	return "exec.OutputEvent"
}

type CallData struct {
	Caller               github_com_hyperledger_burrow_crypto.Address  `protobuf:"bytes,1,opt,name=Caller,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Caller"`
	Callee               github_com_hyperledger_burrow_crypto.Address  `protobuf:"bytes,2,opt,name=Callee,proto3,customtype=github.com/hyperledger/burrow/crypto.Address" json:"Callee"`
	Data                 github_com_hyperledger_burrow_binary.HexBytes `protobuf:"bytes,3,opt,name=Data,proto3,customtype=github.com/hyperledger/burrow/binary.HexBytes" json:"Data"`
	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_4d737c7315c25422, []int{18}
}
func (m *CallData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CallData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CallData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CallData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CallData.Merge(m, src)
}
func (m *CallData) XXX_Size() int {
	return m.Size()
}
func (m *CallData) XXX_DiscardUnknown() {
	xxx_messageInfo_CallData.DiscardUnknown(m)
}

var xxx_messageInfo_CallData proto.InternalMessageInfo

func (m *CallData) GetValue() uint64 {
	if m != nil {
		return m.Value
	}
	return 0
}

func (m *CallData) GetGas() uint64 {
	if m != nil {
		return m.Gas
	}
	return 0
}

func (*CallData) XXX_MessageName() string {
	return "exec.CallData"
}
func init() {
	proto.RegisterType((*StreamEvent)(nil), "exec.StreamEvent")
	golang_proto.RegisterType((*StreamEvent)(nil), "exec.StreamEvent")
	proto.RegisterType((*StreamKey)(nil), "exec.StreamKey")
	golang_proto.RegisterType((*StreamKey)(nil), "exec.StreamKey")
	proto.RegisterType((*BeginBlock)(nil), "exec.BeginBlock")
	golang_proto.RegisterType((*BeginBlock)(nil), "exec.BeginBlock")
	proto.RegisterType((*EndBlock)(nil), "exec.EndBlock")
	golang_proto.RegisterType((*EndBlock)(nil), "exec.EndBlock")
	proto.RegisterType((*BeginTx)(nil), "exec.BeginTx")
	golang_proto.RegisterType((*BeginTx)(nil), "exec.BeginTx")
	proto.RegisterType((*EndTx)(nil), "exec.EndTx")
	golang_proto.RegisterType((*EndTx)(nil), "exec.EndTx")
	proto.RegisterType((*TxHeader)(nil), "exec.TxHeader")
	golang_proto.RegisterType((*TxHeader)(nil), "exec.TxHeader")
	proto.RegisterType((*BlockExecution)(nil), "exec.BlockExecution")
	golang_proto.RegisterType((*BlockExecution)(nil), "exec.BlockExecution")
	proto.RegisterType((*TxExecution)(nil), "exec.TxExecution")
	golang_proto.RegisterType((*TxExecution)(nil), "exec.TxExecution")
	proto.RegisterType((*Origin)(nil), "exec.Origin")
	golang_proto.RegisterType((*Origin)(nil), "exec.Origin")
	proto.RegisterType((*Header)(nil), "exec.Header")
	golang_proto.RegisterType((*Header)(nil), "exec.Header")
	proto.RegisterType((*Event)(nil), "exec.Event")
	golang_proto.RegisterType((*Event)(nil), "exec.Event")
	proto.RegisterType((*Result)(nil), "exec.Result")
	golang_proto.RegisterType((*Result)(nil), "exec.Result")
	proto.RegisterType((*LogEvent)(nil), "exec.LogEvent")
	golang_proto.RegisterType((*LogEvent)(nil), "exec.LogEvent")
	proto.RegisterType((*CallEvent)(nil), "exec.CallEvent")
	golang_proto.RegisterType((*CallEvent)(nil), "exec.CallEvent")
	proto.RegisterType((*GovernAccountEvent)(nil), "exec.GovernAccountEvent")
	golang_proto.RegisterType((*GovernAccountEvent)(nil), "exec.GovernAccountEvent")
	proto.RegisterType((*InputEvent)(nil), "exec.InputEvent")
	golang_proto.RegisterType((*InputEvent)(nil), "exec.InputEvent")
	proto.RegisterType((*OutputEvent)(nil), "exec.OutputEvent")
	golang_proto.RegisterType((*OutputEvent)(nil), "exec.OutputEvent")
	proto.RegisterType((*CallData)(nil), "exec.CallData")
	golang_proto.RegisterType((*CallData)(nil), "exec.CallData")
}

func init() { proto.RegisterFile("exec.proto", fileDescriptor_4d737c7315c25422) }
func init() { golang_proto.RegisterFile("exec.proto", fileDescriptor_4d737c7315c25422) }

var fileDescriptor_4d737c7315c25422 = []byte{
	// 1242 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0x4f, 0x8f, 0xdb, 0x44,
	0x14, 0xaf, 0x13, 0xe7, 0xdf, 0x4b, 0xb6, 0x94, 0x51, 0x41, 0x51, 0x0f, 0x49, 0x71, 0xa1, 0x94,
	0xd2, 0x3a, 0x55, 0xa1, 0xfc, 0x29, 0x12, 0xd2, 0xa6, 0xbb, 0xda, 0x5d, 0xba, 0xb4, 0x30, 0x4d,
	0x8b, 0x40, 0x70, 0x70, 0xec, 0xc1, 0xb1, 0x9a, 0xd8, 0x96, 0x3d, 0x59, 0x92, 0x2f, 0xc0, 0x01,
	0x71, 0x80, 0x5b, 0xb9, 0xa0, 0x7e, 0x0f, 0x2e, 0x1c, 0xf7, 0x46, 0xcf, 0x3d, 0x04, 0xb4, 0xfd,
	0x04, 0x88, 0x13, 0x7b, 0x42, 0x33, 0xf3, 0xc6, 0x71, 0xe8, 0x76, 0xb7, 0x22, 0x7b, 0xe0, 0x12,
	0xcd, 0x7b, 0xef, 0x37, 0x2f, 0xef, 0xcf, 0xef, 0xbd, 0x31, 0x00, 0x9b, 0x30, 0xd7, 0x8e, 0x93,
	0x88, 0x47, 0xc4, 0x14, 0xe7, 0x33, 0x97, 0xfd, 0x80, 0x0f, 0xc6, 0x7d, 0xdb, 0x8d, 0x46, 0x1d,
	0x3f, 0xf2, 0xa3, 0x8e, 0x34, 0xf6, 0xc7, 0x5f, 0x4b, 0x49, 0x0a, 0xf2, 0xa4, 0x2e, 0x9d, 0x79,
	0x37, 0x07, 0xe7, 0x2c, 0xf4, 0x58, 0x32, 0x0a, 0x42, 0x9e, 0x3f, 0x3a, 0x7d, 0x37, 0xe8, 0xf0,
	0x69, 0xcc, 0x52, 0xf5, 0x8b, 0x17, 0xdb, 0x7e, 0x14, 0xf9, 0x43, 0x36, 0x77, 0xcf, 0x83, 0x11,
	0x4b, 0xb9, 0x33, 0x8a, 0x11, 0xd0, 0x60, 0x49, 0x12, 0x25, 0x1a, 0x5e, 0x0f, 0x9d, 0x51, 0x76,
	0xb7, 0xc6, 0x27, 0xfa, 0x78, 0x2a, 0x16, 0x7f, 0x93, 0xa6, 0x41, 0x14, 0xa2, 0x06, 0xd2, 0x58,
	0xa7, 0x64, 0xfd, 0x52, 0x80, 0xfa, 0x1d, 0x9e, 0x30, 0x67, 0xb4, 0xbe, 0xc3, 0x42, 0x4e, 0xae,
	0x00, 0x74, 0x99, 0x1f, 0x84, 0xdd, 0x61, 0xe4, 0xde, 0x6f, 0x1a, 0x67, 0x8d, 0x0b, 0xf5, 0xab,
	0xa7, 0x6c, 0x59, 0x83, 0xb9, 0x9e, 0xe6, 0x30, 0xe4, 0x75, 0xa8, 0x48, 0xa9, 0x37, 0x69, 0x16,
	0x24, 0x7c, 0x25, 0x07, 0xef, 0x4d, 0xa8, 0xb6, 0x92, 0xcf, 0xa1, 0xba, 0x1e, 0xee, 0xb0, 0x61,
	0x14, 0xb3, 0x66, 0x11, 0x91, 0x22, 0x4c, 0xad, 0xec, 0xda, 0x8f, 0x67, 0xed, 0x8b, 0xb9, 0x6a,
	0x0d, 0xa6, 0x31, 0x4b, 0x86, 0xcc, 0xf3, 0x59, 0xd2, 0xe9, 0x8f, 0x93, 0x24, 0xfa, 0xa6, 0x93,
	0xc7, 0xd3, 0xcc, 0x1d, 0x79, 0x05, 0x4a, 0x32, 0xfc, 0xa6, 0x29, 0xfd, 0xd6, 0x55, 0x04, 0x52,
	0x45, 0x95, 0x45, 0x42, 0x42, 0xaf, 0x37, 0x69, 0x96, 0x16, 0x20, 0x42, 0x45, 0x95, 0x85, 0x5c,
	0x14, 0x01, 0x7a, 0x2a, 0xf3, 0xb2, 0x44, 0x9d, 0xcc, 0x50, 0x2a, 0xef, 0xcc, 0x7e, 0xdd, 0xdc,
	0x7d, 0xd8, 0x36, 0xac, 0xf7, 0xa1, 0xa6, 0x8a, 0x77, 0x93, 0x4d, 0xc9, 0xcb, 0x50, 0xde, 0x64,
	0x81, 0x3f, 0xe0, 0xb2, 0x6c, 0x26, 0x45, 0x89, 0x9c, 0x86, 0xd2, 0x56, 0xe8, 0x31, 0x55, 0x1e,
	0x93, 0x2a, 0xc1, 0xba, 0x99, 0x2f, 0xf4, 0x33, 0xef, 0xbe, 0x26, 0xf4, 0x8e, 0xc7, 0x92, 0xac,
	0xb6, 0x8a, 0x21, 0x4a, 0x49, 0xd1, 0x68, 0x59, 0xf3, 0xc8, 0x9f, 0xe5, 0xca, 0xfa, 0xde, 0xc8,
	0x1a, 0x25, 0x32, 0xed, 0x4d, 0xd0, 0xb1, 0x91, 0xcf, 0x54, 0x6b, 0x69, 0x66, 0x27, 0xaf, 0x42,
	0x99, 0xb2, 0x74, 0x3c, 0xe4, 0x18, 0x42, 0x43, 0x21, 0x95, 0x8e, 0xa2, 0x8d, 0x74, 0xa0, 0xb6,
	0x3e, 0x71, 0x59, 0xcc, 0x83, 0x28, 0xc4, 0x2e, 0xbc, 0x68, 0x23, 0x3f, 0x33, 0x03, 0x9d, 0x63,
	0xac, 0x7b, 0xd8, 0x0f, 0xf2, 0x31, 0x94, 0x7b, 0x93, 0x4d, 0x27, 0x1d, 0x48, 0x52, 0x34, 0xba,
	0xd7, 0x76, 0x67, 0xed, 0x13, 0x8f, 0x67, 0xed, 0xcb, 0x87, 0x33, 0xa1, 0x1f, 0x84, 0x4e, 0x32,
	0xb5, 0x37, 0xd9, 0xa4, 0x3b, 0xe5, 0x2c, 0xa5, 0xe8, 0xc4, 0xfa, 0xdb, 0x98, 0xe7, 0x46, 0x3e,
	0x12, 0xbe, 0x7b, 0xd3, 0x98, 0xc9, 0x2c, 0x57, 0xba, 0x57, 0xf7, 0x67, 0x6d, 0xfb, 0x48, 0x86,
	0x75, 0x62, 0x67, 0x3a, 0x8c, 0x1c, 0xcf, 0x16, 0x37, 0x29, 0x7a, 0xc8, 0xc5, 0x59, 0x38, 0x86,
	0x38, 0x73, 0x6d, 0x2a, 0x1e, 0xcc, 0x16, 0x33, 0xc7, 0x16, 0xd1, 0x84, 0xdb, 0x49, 0xe0, 0x07,
	0x21, 0xd2, 0x17, 0x9b, 0xa0, 0x74, 0x14, 0x6d, 0xd6, 0xb7, 0x06, 0x9c, 0x94, 0x24, 0x58, 0x9f,
	0x30, 0x77, 0x2c, 0xca, 0xbc, 0x24, 0xb1, 0xc8, 0x35, 0x68, 0xf4, 0x26, 0x99, 0xb7, 0xb4, 0x59,
	0x3c, 0x5b, 0x54, 0x9d, 0x55, 0x64, 0xc9, 0x2c, 0x74, 0x01, 0x66, 0xfd, 0x59, 0x80, 0x7a, 0x4e,
	0x41, 0x2e, 0x65, 0xff, 0x76, 0x20, 0xdb, 0xba, 0xe6, 0xa3, 0x59, 0xdb, 0xc8, 0xfe, 0x34, 0xbf,
	0x28, 0xca, 0xc7, 0xbb, 0x28, 0xce, 0x41, 0x59, 0xae, 0x83, 0xb4, 0x59, 0x91, 0x99, 0x2c, 0x6c,
	0x0a, 0x34, 0xe5, 0x18, 0x5f, 0x3d, 0x84, 0xf1, 0xe7, 0xa1, 0x42, 0x99, 0xcb, 0x82, 0x98, 0x37,
	0x6b, 0x08, 0x13, 0x7f, 0x8a, 0x3a, 0xaa, 0x8d, 0x8b, 0x93, 0x01, 0x47, 0x4f, 0xc6, 0x53, 0x35,
	0xaf, 0x3f, 0x5f, 0xcd, 0xbf, 0x33, 0x34, 0x47, 0x48, 0x13, 0x2a, 0x37, 0x06, 0x4e, 0x10, 0x6e,
	0xad, 0xc9, 0x7a, 0xd7, 0xa8, 0x16, 0x73, 0x74, 0x28, 0x1c, 0xcc, 0xba, 0x62, 0x9e, 0x75, 0xef,
	0x81, 0xd9, 0x0b, 0x46, 0x0c, 0xe7, 0xf9, 0x8c, 0xad, 0x1e, 0x24, 0x5b, 0x3f, 0x48, 0x76, 0x4f,
	0x3f, 0x48, 0xdd, 0xaa, 0x18, 0x86, 0x1f, 0x7e, 0x6f, 0x1b, 0x54, 0xde, 0xb0, 0x7e, 0x2b, 0xe8,
	0x8e, 0xff, 0x9f, 0x67, 0xf0, 0x4d, 0xa8, 0xc9, 0x96, 0xcb, 0xe8, 0x8a, 0x32, 0xba, 0x95, 0xfd,
	0x59, 0x7b, 0xae, 0xa4, 0xf3, 0xa3, 0x28, 0xaa, 0x14, 0xb6, 0xd6, 0x64, 0x3d, 0x6a, 0x54, 0x8b,
	0xb9, 0xa2, 0x96, 0x0e, 0x2e, 0x6a, 0x39, 0x5f, 0xd4, 0x05, 0x3e, 0x54, 0x8e, 0xe6, 0xc3, 0x75,
	0xf3, 0xc1, 0xc3, 0xf6, 0x09, 0xeb, 0xc7, 0x02, 0xbe, 0x71, 0x82, 0x9e, 0x0b, 0xc3, 0x84, 0xf4,
	0xfc, 0xd7, 0xe4, 0x9e, 0x17, 0x7f, 0x1e, 0x8f, 0xf5, 0xd6, 0xc6, 0x37, 0x5c, 0xaa, 0xf0, 0x5d,
	0x94, 0x67, 0xf2, 0x06, 0x94, 0x6f, 0x8f, 0xb9, 0x00, 0x16, 0x75, 0x2c, 0x72, 0xb3, 0x48, 0x1d,
	0xce, 0x85, 0x12, 0xc8, 0x39, 0x30, 0x6f, 0x38, 0xc3, 0x21, 0xd2, 0xe1, 0x05, 0x05, 0x14, 0x1a,
	0x05, 0x93, 0x46, 0x72, 0x16, 0x8a, 0xdb, 0x91, 0x8f, 0x6b, 0x0a, 0xe7, 0x7c, 0x3b, 0xf2, 0x15,
	0x44, 0x98, 0xc8, 0x87, 0xb0, 0xb2, 0x11, 0xed, 0xb0, 0x24, 0x5c, 0x75, 0xdd, 0x68, 0x1c, 0x72,
	0x9c, 0xf1, 0xa6, 0xc2, 0x2e, 0x98, 0xd4, 0xad, 0x45, 0xf8, 0xf5, 0xaa, 0xa8, 0x87, 0x7c, 0x7e,
	0x1f, 0x18, 0x7a, 0x52, 0x45, 0x0f, 0x28, 0xe3, 0xe3, 0x24, 0x94, 0x45, 0x69, 0x50, 0x94, 0x44,
	0xd7, 0x36, 0x9c, 0xf4, 0x6e, 0xca, 0x3c, 0x64, 0xbc, 0x16, 0xc9, 0x45, 0xa8, 0xdd, 0x72, 0x46,
	0x6c, 0x3d, 0xe4, 0xc9, 0x14, 0x73, 0x6f, 0xd8, 0xea, 0x1b, 0x4a, 0xea, 0xe8, 0xdc, 0x4c, 0xae,
	0x40, 0xf5, 0x13, 0x96, 0x8c, 0x56, 0x13, 0x3f, 0xc5, 0xec, 0x4f, 0xdb, 0xb9, 0xcf, 0x2a, 0x6d,
	0xa3, 0x19, 0xca, 0xfa, 0xcb, 0x80, 0xaa, 0x4e, 0x9b, 0xdc, 0x82, 0xca, 0xaa, 0xe7, 0x25, 0x2c,
	0x4d, 0x55, 0x74, 0xdd, 0xb7, 0x91, 0xb7, 0x97, 0x0e, 0xe7, 0xad, 0x9b, 0x4c, 0x63, 0x1e, 0xd9,
	0x78, 0x97, 0x6a, 0x27, 0x64, 0x0b, 0xcc, 0x35, 0x87, 0x3b, 0xcb, 0x0d, 0x81, 0x74, 0x41, 0xb6,
	0xa1, 0xdc, 0x8b, 0xe2, 0xc0, 0x55, 0xab, 0xfd, 0xb9, 0x23, 0x43, 0x67, 0x9f, 0x45, 0x89, 0x77,
	0xf5, 0xda, 0x3b, 0x14, 0x7d, 0x58, 0x3f, 0x17, 0xa0, 0x96, 0x11, 0x82, 0x5c, 0x80, 0xaa, 0x10,
	0xe4, 0x74, 0x95, 0xe4, 0x74, 0x35, 0xf6, 0x67, 0xed, 0x4c, 0x47, 0xb3, 0x93, 0xf8, 0x1e, 0x11,
	0x67, 0x99, 0xd4, 0xc2, 0x0b, 0xa1, 0xb5, 0x34, 0xb3, 0x8b, 0x88, 0xf1, 0x29, 0x2c, 0x2c, 0x51,
	0x4b, 0xbd, 0x2a, 0x5b, 0x00, 0x77, 0xb8, 0xe3, 0xde, 0x5f, 0x63, 0x31, 0x1f, 0xe0, 0xf6, 0xcb,
	0x69, 0xc4, 0xc6, 0x41, 0x5e, 0x99, 0x4b, 0x6d, 0x1c, 0xe5, 0xc4, 0xfa, 0x14, 0xc8, 0xd3, 0x04,
	0x27, 0x1f, 0xc0, 0x0a, 0xca, 0x77, 0x63, 0xcf, 0xe1, 0x0c, 0x6b, 0xf0, 0x92, 0x2d, 0x3f, 0xd4,
	0x7b, 0x6c, 0x14, 0x0f, 0x1d, 0xce, 0x10, 0x42, 0x17, 0xb1, 0xd6, 0x97, 0x00, 0xf3, 0xa9, 0x3e,
	0x6e, 0xaa, 0x59, 0x5f, 0x41, 0x3d, 0xb7, 0x0a, 0x8e, 0xdd, 0xfd, 0x4f, 0x05, 0x58, 0xe8, 0xac,
	0x38, 0xe3, 0x62, 0xfb, 0xcf, 0x9d, 0x55, 0x3e, 0x32, 0x6f, 0x6c, 0x39, 0x9e, 0x28, 0x1f, 0xd9,
	0xc8, 0x15, 0x97, 0x1f, 0xb9, 0xd3, 0x50, 0xba, 0xe7, 0x0c, 0xc7, 0x4c, 0x7f, 0xe1, 0x49, 0x81,
	0x9c, 0x82, 0xe2, 0x86, 0x93, 0xe2, 0x0b, 0x22, 0x8e, 0xdd, 0xee, 0xee, 0x5e, 0xcb, 0x78, 0xb4,
	0xd7, 0x32, 0xfe, 0xd8, 0x6b, 0x19, 0xbf, 0x3e, 0x69, 0x19, 0xbb, 0x4f, 0x5a, 0xc6, 0x17, 0x47,
	0x84, 0xcf, 0xf4, 0x07, 0x81, 0x3c, 0xf5, 0xcb, 0xf2, 0xad, 0x7e, 0xeb, 0x9f, 0x00, 0x00, 0x00,
	0xff, 0xff, 0x3e, 0x40, 0x8d, 0xe4, 0xc6, 0x0e, 0x00, 0x00,
}

func (m *StreamEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StreamEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.BeginBlock != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.BeginBlock.Size()))
		n1, err := m.BeginBlock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.BeginTx != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.BeginTx.Size()))
		n2, err := m.BeginTx.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Envelope != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Envelope.Size()))
		n3, err := m.Envelope.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.Event != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Event.Size()))
		n4, err := m.Event.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.EndTx != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.EndTx.Size()))
		n5, err := m.EndTx.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.EndBlock != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.EndBlock.Size()))
		n6, err := m.EndBlock.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *StreamKey) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *StreamKey) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.Index != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BeginBlock) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BeginBlock) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.Header != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Header.Size()))
		n7, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EndBlock) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndBlock) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BeginTx) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BeginTx) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TxHeader != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.TxHeader.Size()))
		n8, err := m.TxHeader.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.Result != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Result.Size()))
		n9, err := m.Result.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.Exception != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Exception.Size()))
		n10, err := m.Exception.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *EndTx) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *EndTx) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0x1a
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.TxHash.Size()))
	n11, err := m.TxHash.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n11
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TxHeader) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TxHeader) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TxType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.TxType))
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.TxHash.Size()))
	n12, err := m.TxHash.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n12
	if m.Height != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.Index != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Index))
	}
	if m.Origin != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Origin.Size()))
		n13, err := m.Origin.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *BlockExecution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *BlockExecution) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Height != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.Header != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Header.Size()))
		n14, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if len(m.TxExecutions) > 0 {
		for _, msg := range m.TxExecutions {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintExec(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *TxExecution) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *TxExecution) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TxHeader != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.TxHeader.Size()))
		n15, err := m.TxHeader.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	if m.Envelope != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Envelope.Size()))
		n16, err := m.Envelope.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	if len(m.Events) > 0 {
		for _, msg := range m.Events {
			dAtA[i] = 0x3a
			i++
			i = encodeVarintExec(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.Result != nil {
		dAtA[i] = 0x42
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Result.Size()))
		n17, err := m.Result.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	if m.Receipt != nil {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Receipt.Size()))
		n18, err := m.Receipt.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.Exception != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Exception.Size()))
		n19, err := m.Exception.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if len(m.TxExecutions) > 0 {
		for _, msg := range m.TxExecutions {
			dAtA[i] = 0x5a
			i++
			i = encodeVarintExec(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Origin) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Origin) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ChainID) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(len(m.ChainID)))
		i += copy(dAtA[i:], m.ChainID)
	}
	if m.Height != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.Index != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Index))
	}
	dAtA[i] = 0x22
	i++
	i = encodeVarintExec(dAtA, i, uint64(github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)))
	n20, err := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Time, dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n20
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Header) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Header) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.TxType != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.TxType))
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.TxHash.Size()))
	n21, err := m.TxHash.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n21
	if m.EventType != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.EventType))
	}
	if len(m.EventID) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExec(dAtA, i, uint64(len(m.EventID)))
		i += copy(dAtA[i:], m.EventID)
	}
	if m.Height != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
	}
	if m.Index != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Index))
	}
	if m.Exception != nil {
		dAtA[i] = 0x3a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Exception.Size()))
		n22, err := m.Exception.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Event) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Event) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Header != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Header.Size()))
		n23, err := m.Header.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	if m.Input != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Input.Size()))
		n24, err := m.Input.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	if m.Output != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Output.Size()))
		n25, err := m.Output.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	if m.Call != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Call.Size()))
		n26, err := m.Call.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	if m.Log != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Log.Size()))
		n27, err := m.Log.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	if m.GovernAccount != nil {
		dAtA[i] = 0x32
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.GovernAccount.Size()))
		n28, err := m.GovernAccount.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n28
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *Result) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Result) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Return) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(len(m.Return)))
		i += copy(dAtA[i:], m.Return)
	}
	if m.GasUsed != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.GasUsed))
	}
	if m.NameEntry != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.NameEntry.Size()))
		n29, err := m.NameEntry.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	if m.PermArgs != nil {
		dAtA[i] = 0x22
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.PermArgs.Size()))
		n30, err := m.PermArgs.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *LogEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *LogEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Address.Size()))
	n31, err := m.Address.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n31
	dAtA[i] = 0x12
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Data.Size()))
	n32, err := m.Data.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n32
	if len(m.Topics) > 0 {
		for _, msg := range m.Topics {
			dAtA[i] = 0x1a
			i++
			i = encodeVarintExec(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CallEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CallEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.CallData != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.CallData.Size()))
		n33, err := m.CallData.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n33
	}
	dAtA[i] = 0x12
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Origin.Size()))
	n34, err := m.Origin.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n34
	if m.StackDepth != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.StackDepth))
	}
	dAtA[i] = 0x22
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Return.Size()))
	n35, err := m.Return.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n35
	if m.CallType != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.CallType))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *GovernAccountEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GovernAccountEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.AccountUpdate != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.AccountUpdate.Size()))
		n36, err := m.AccountUpdate.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n36
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *InputEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *InputEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Address.Size()))
	n37, err := m.Address.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n37
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *OutputEvent) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutputEvent) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Address.Size()))
	n38, err := m.Address.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n38
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func (m *CallData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *CallData) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	dAtA[i] = 0xa
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Caller.Size()))
	n39, err := m.Caller.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n39
	dAtA[i] = 0x12
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Callee.Size()))
	n40, err := m.Callee.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n40
	dAtA[i] = 0x1a
	i++
	i = encodeVarintExec(dAtA, i, uint64(m.Data.Size()))
	n41, err := m.Data.MarshalTo(dAtA[i:])
	if err != nil {
		return 0, err
	}
	i += n41
	if m.Value != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Value))
	}
	if m.Gas != 0 {
		dAtA[i] = 0x28
		i++
		i = encodeVarintExec(dAtA, i, uint64(m.Gas))
	}
	if m.XXX_unrecognized != nil {
		i += copy(dAtA[i:], m.XXX_unrecognized)
	}
	return i, nil
}

func encodeVarintExec(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *StreamEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.BeginBlock != nil {
		l = m.BeginBlock.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.BeginTx != nil {
		l = m.BeginTx.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Envelope != nil {
		l = m.Envelope.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Event != nil {
		l = m.Event.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.EndTx != nil {
		l = m.EndTx.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.EndBlock != nil {
		l = m.EndBlock.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StreamKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Index != 0 {
		n += 1 + sovExec(uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BeginBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EndBlock) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BeginTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TxHeader != nil {
		l = m.TxHeader.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Exception != nil {
		l = m.Exception.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EndTx) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TxHash.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxHeader) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TxType != 0 {
		n += 1 + sovExec(uint64(m.TxType))
	}
	l = m.TxHash.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Index != 0 {
		n += 1 + sovExec(uint64(m.Index))
	}
	if m.Origin != nil {
		l = m.Origin.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BlockExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if len(m.TxExecutions) > 0 {
		for _, e := range m.TxExecutions {
			l = e.Size()
			n += 1 + l + sovExec(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TxExecution) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TxHeader != nil {
		l = m.TxHeader.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Envelope != nil {
		l = m.Envelope.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if len(m.Events) > 0 {
		for _, e := range m.Events {
			l = e.Size()
			n += 1 + l + sovExec(uint64(l))
		}
	}
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Receipt != nil {
		l = m.Receipt.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Exception != nil {
		l = m.Exception.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if len(m.TxExecutions) > 0 {
		for _, e := range m.TxExecutions {
			l = e.Size()
			n += 1 + l + sovExec(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Origin) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChainID)
	if l > 0 {
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Index != 0 {
		n += 1 + sovExec(uint64(m.Index))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Time)
	n += 1 + l + sovExec(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Header) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TxType != 0 {
		n += 1 + sovExec(uint64(m.TxType))
	}
	l = m.TxHash.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.EventType != 0 {
		n += 1 + sovExec(uint64(m.EventType))
	}
	l = len(m.EventID)
	if l > 0 {
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Index != 0 {
		n += 1 + sovExec(uint64(m.Index))
	}
	if m.Exception != nil {
		l = m.Exception.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Header != nil {
		l = m.Header.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Input != nil {
		l = m.Input.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Output != nil {
		l = m.Output.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Call != nil {
		l = m.Call.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.Log != nil {
		l = m.Log.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.GovernAccount != nil {
		l = m.GovernAccount.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Result) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Return)
	if l > 0 {
		n += 1 + l + sovExec(uint64(l))
	}
	if m.GasUsed != 0 {
		n += 1 + sovExec(uint64(m.GasUsed))
	}
	if m.NameEntry != nil {
		l = m.NameEntry.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.PermArgs != nil {
		l = m.PermArgs.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LogEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Address.Size()
	n += 1 + l + sovExec(uint64(l))
	l = m.Data.Size()
	n += 1 + l + sovExec(uint64(l))
	if len(m.Topics) > 0 {
		for _, e := range m.Topics {
			l = e.Size()
			n += 1 + l + sovExec(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CallEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CallData != nil {
		l = m.CallData.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	l = m.Origin.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.StackDepth != 0 {
		n += 1 + sovExec(uint64(m.StackDepth))
	}
	l = m.Return.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.CallType != 0 {
		n += 1 + sovExec(uint64(m.CallType))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GovernAccountEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AccountUpdate != nil {
		l = m.AccountUpdate.Size()
		n += 1 + l + sovExec(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *InputEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Address.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutputEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Address.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CallData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Caller.Size()
	n += 1 + l + sovExec(uint64(l))
	l = m.Callee.Size()
	n += 1 + l + sovExec(uint64(l))
	l = m.Data.Size()
	n += 1 + l + sovExec(uint64(l))
	if m.Value != 0 {
		n += 1 + sovExec(uint64(m.Value))
	}
	if m.Gas != 0 {
		n += 1 + sovExec(uint64(m.Gas))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovExec(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozExec(x uint64) (n int) {
	return sovExec(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *StreamEvent) GetValue() interface{} {
	if this.BeginBlock != nil {
		return this.BeginBlock
	}
	if this.BeginTx != nil {
		return this.BeginTx
	}
	if this.Envelope != nil {
		return this.Envelope
	}
	if this.Event != nil {
		return this.Event
	}
	if this.EndTx != nil {
		return this.EndTx
	}
	if this.EndBlock != nil {
		return this.EndBlock
	}
	return nil
}

func (this *StreamEvent) SetValue(value interface{}) bool {
	switch vt := value.(type) {
	case *BeginBlock:
		this.BeginBlock = vt
	case *BeginTx:
		this.BeginTx = vt
	case *github_com_hyperledger_burrow_txs.Envelope:
		this.Envelope = vt
	case *Event:
		this.Event = vt
	case *EndTx:
		this.EndTx = vt
	case *EndBlock:
		this.EndBlock = vt
	default:
		this.Event = new(Event)
		if set := this.Event.SetValue(value); set {
			return true
		}
		this.Event = nil
		return false
	}
	return true
}
func (this *Event) GetValue() interface{} {
	if this.Header != nil {
		return this.Header
	}
	if this.Input != nil {
		return this.Input
	}
	if this.Output != nil {
		return this.Output
	}
	if this.Call != nil {
		return this.Call
	}
	if this.Log != nil {
		return this.Log
	}
	if this.GovernAccount != nil {
		return this.GovernAccount
	}
	return nil
}

func (this *Event) SetValue(value interface{}) bool {
	switch vt := value.(type) {
	case *Header:
		this.Header = vt
	case *InputEvent:
		this.Input = vt
	case *OutputEvent:
		this.Output = vt
	case *CallEvent:
		this.Call = vt
	case *LogEvent:
		this.Log = vt
	case *GovernAccountEvent:
		this.GovernAccount = vt
	default:
		return false
	}
	return true
}
func (m *StreamEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StreamEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BeginBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BeginBlock == nil {
				m.BeginBlock = &BeginBlock{}
			}
			if err := m.BeginBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BeginTx", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BeginTx == nil {
				m.BeginTx = &BeginTx{}
			}
			if err := m.BeginTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Envelope", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Envelope == nil {
				m.Envelope = &github_com_hyperledger_burrow_txs.Envelope{}
			}
			if err := m.Envelope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Event", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Event == nil {
				m.Event = &Event{}
			}
			if err := m.Event.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndTx", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndTx == nil {
				m.EndTx = &EndTx{}
			}
			if err := m.EndTx.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndBlock", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EndBlock == nil {
				m.EndBlock = &EndBlock{}
			}
			if err := m.EndBlock.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StreamKey) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: StreamKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BeginBlock) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BeginBlock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BeginBlock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &types.Header{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndBlock) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndBlock: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndBlock: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BeginTx) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BeginTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BeginTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TxHeader == nil {
				m.TxHeader = &TxHeader{}
			}
			if err := m.TxHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &Result{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Exception == nil {
				m.Exception = &errors.Exception{}
			}
			if err := m.Exception.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EndTx) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: EndTx: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EndTx: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxHeader) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TxHeader: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxHeader: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxType", wireType)
			}
			m.TxType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxType |= github_com_hyperledger_burrow_txs_payload.Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Origin", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Origin == nil {
				m.Origin = &Origin{}
			}
			if err := m.Origin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BlockExecution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: BlockExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BlockExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &types.Header{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxExecutions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxExecutions = append(m.TxExecutions, &TxExecution{})
			if err := m.TxExecutions[len(m.TxExecutions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TxExecution) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: TxExecution: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxExecution: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHeader", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TxHeader == nil {
				m.TxHeader = &TxHeader{}
			}
			if err := m.TxHeader.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Envelope", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Envelope == nil {
				m.Envelope = &github_com_hyperledger_burrow_txs.Envelope{}
			}
			if err := m.Envelope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Events = append(m.Events, &Event{})
			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &Result{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receipt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Receipt == nil {
				m.Receipt = &txs.Receipt{}
			}
			if err := m.Receipt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Exception == nil {
				m.Exception = &errors.Exception{}
			}
			if err := m.Exception.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxExecutions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TxExecutions = append(m.TxExecutions, &TxExecution{})
			if err := m.TxExecutions[len(m.TxExecutions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Origin) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Origin: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Origin: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Time, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Header) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Header: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Header: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxType", wireType)
			}
			m.TxType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TxType |= github_com_hyperledger_burrow_txs_payload.Type(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventType", wireType)
			}
			m.EventType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EventType |= EventType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EventID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EventID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Height", wireType)
			}
			m.Height = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Height |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Exception", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Exception == nil {
				m.Exception = &errors.Exception{}
			}
			if err := m.Exception.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Event) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Event: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Header == nil {
				m.Header = &Header{}
			}
			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Input == nil {
				m.Input = &InputEvent{}
			}
			if err := m.Input.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Output == nil {
				m.Output = &OutputEvent{}
			}
			if err := m.Output.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Call", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Call == nil {
				m.Call = &CallEvent{}
			}
			if err := m.Call.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Log", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Log == nil {
				m.Log = &LogEvent{}
			}
			if err := m.Log.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GovernAccount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GovernAccount == nil {
				m.GovernAccount = &GovernAccountEvent{}
			}
			if err := m.GovernAccount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Result) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Result: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Result: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Return", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Return = append(m.Return[:0], dAtA[iNdEx:postIndex]...)
			if m.Return == nil {
				m.Return = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasUsed", wireType)
			}
			m.GasUsed = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GasUsed |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NameEntry", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NameEntry == nil {
				m.NameEntry = &names.Entry{}
			}
			if err := m.NameEntry.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PermArgs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PermArgs == nil {
				m.PermArgs = &permission.PermArgs{}
			}
			if err := m.PermArgs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LogEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LogEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LogEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Topics", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_hyperledger_burrow_binary.Word256
			m.Topics = append(m.Topics, v)
			if err := m.Topics[len(m.Topics)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CallEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CallEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CallEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallData", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CallData == nil {
				m.CallData = &CallData{}
			}
			if err := m.CallData.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Origin", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Origin.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StackDepth", wireType)
			}
			m.StackDepth = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StackDepth |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Return", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Return.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CallType", wireType)
			}
			m.CallType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CallType |= CallType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GovernAccountEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GovernAccountEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GovernAccountEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountUpdate", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AccountUpdate == nil {
				m.AccountUpdate = &spec.TemplateAccount{}
			}
			if err := m.AccountUpdate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *InputEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: InputEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: InputEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutputEvent) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutputEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutputEvent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Address.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CallData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowExec
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CallData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CallData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Caller", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Caller.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Callee", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Callee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthExec
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthExec
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			m.Value = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Value |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Gas", wireType)
			}
			m.Gas = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Gas |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipExec(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthExec
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipExec(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowExec
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowExec
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowExec
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthExec
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthExec
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowExec
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipExec(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthExec
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthExec = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExec   = fmt.Errorf("proto: integer overflow")
)