exec.pb.go

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

package exec

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	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.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// This message exists purely for framing []StreamEvent
type StreamEvents struct {
	StreamEvents         []*StreamEvent `protobuf:"bytes,1,rep,name=StreamEvents,proto3" json:"StreamEvents,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_StreamEvents proto.InternalMessageInfo

func (m *StreamEvents) GetStreamEvents() []*StreamEvent {
	if m != nil {
		return m.StreamEvents
	}
	return nil
}

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

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{1}
}
func (m *StreamEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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"
}

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) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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 TxExecutionKey struct {
	// The block height
	Height uint64 `protobuf:"varint,1,opt,name=Height,proto3" json:"Height,omitempty"`
	// The offset of the TxExecution in bytes
	Offset               uint64   `protobuf:"varint,2,opt,name=Offset,proto3" json:"Offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_TxExecutionKey proto.InternalMessageInfo

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

func (m *TxExecutionKey) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

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

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{9}
}
func (m *TxExecution) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TxExecution) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{10}
}
func (m *Origin) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Origin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{11}
}
func (m *Header) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{12}
}
func (m *Event) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{13}
}
func (m *Result) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Result) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{14}
}
func (m *LogEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *LogEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{15}
}
func (m *CallEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CallEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{16}
}
func (m *GovernAccountEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GovernAccountEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{17}
}
func (m *InputEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *InputEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{18}
}
func (m *OutputEvent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutputEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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{19}
}
func (m *CallData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CallData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	b = b[:cap(b)]
	n, err := m.MarshalToSizedBuffer(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((*StreamEvents)(nil), "exec.StreamEvents")
	golang_proto.RegisterType((*StreamEvents)(nil), "exec.StreamEvents")
	proto.RegisterType((*StreamEvent)(nil), "exec.StreamEvent")
	golang_proto.RegisterType((*StreamEvent)(nil), "exec.StreamEvent")
	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((*TxExecutionKey)(nil), "exec.TxExecutionKey")
	golang_proto.RegisterType((*TxExecutionKey)(nil), "exec.TxExecutionKey")
	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{
	// 1275 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x56, 0xcf, 0x93, 0x13, 0xc5,
	0x17, 0x67, 0x92, 0xc9, 0xaf, 0x4e, 0x96, 0x2f, 0x74, 0xf1, 0xa5, 0x52, 0x1c, 0x12, 0x1c, 0x14,
	0x11, 0x61, 0x42, 0xad, 0xa2, 0x16, 0x56, 0x59, 0x12, 0x36, 0xc2, 0x0a, 0x82, 0x36, 0x01, 0x4b,
	0x4b, 0x0f, 0x93, 0x99, 0x66, 0x32, 0x45, 0x32, 0x33, 0x35, 0xd3, 0xc1, 0xc9, 0x3f, 0xe0, 0xc1,
	0xf2, 0xa0, 0x37, 0xbc, 0x58, 0xfc, 0x1f, 0x5e, 0x3c, 0xee, 0x4d, 0x8e, 0x16, 0x87, 0x68, 0x2d,
	0x7f, 0x81, 0xe5, 0xc9, 0x3d, 0x59, 0xdd, 0xfd, 0x7a, 0xd2, 0x23, 0xcb, 0x2e, 0x65, 0xf6, 0xe0,
	0x25, 0xd5, 0xef, 0xbd, 0x4f, 0xbf, 0xbc, 0x7e, 0xef, 0xf3, 0xde, 0x1b, 0x84, 0x68, 0x46, 0x5d,
	0x3b, 0x4e, 0x22, 0x16, 0x61, 0x93, 0x9f, 0x4f, 0x9c, 0xf7, 0x03, 0x36, 0x9e, 0x8d, 0x6c, 0x37,
	0x9a, 0xf6, 0xfc, 0xc8, 0x8f, 0x7a, 0xc2, 0x38, 0x9a, 0xdd, 0x13, 0x92, 0x10, 0xc4, 0x49, 0x5e,
	0x3a, 0xf1, 0xb6, 0x06, 0x67, 0x34, 0xf4, 0x68, 0x32, 0x0d, 0x42, 0xa6, 0x1f, 0x9d, 0x91, 0x1b,
	0xf4, 0xd8, 0x3c, 0xa6, 0xa9, 0xfc, 0x85, 0x8b, 0x5d, 0x3f, 0x8a, 0xfc, 0x09, 0x5d, 0xba, 0x67,
	0xc1, 0x94, 0xa6, 0xcc, 0x99, 0xc6, 0x00, 0x68, 0xd1, 0x24, 0x89, 0x12, 0x05, 0x6f, 0x86, 0xce,
	0x34, 0xbf, 0xdb, 0x60, 0x99, 0x3a, 0x1e, 0x89, 0xf9, 0xdf, 0xa4, 0x69, 0x10, 0x85, 0xa0, 0x41,
	0x69, 0xac, 0x9e, 0x64, 0x0d, 0x50, 0xeb, 0x36, 0x4b, 0xa8, 0x33, 0x1d, 0x3c, 0xa0, 0x21, 0x4b,
	0xf1, 0xc5, 0xa2, 0xdc, 0x36, 0x4e, 0x96, 0xcf, 0x34, 0xd7, 0x8f, 0xda, 0x22, 0x0b, 0x9a, 0x85,
	0x14, 0x60, 0xd6, 0x4f, 0x25, 0xd4, 0xd4, 0x14, 0xf8, 0x02, 0x42, 0x7d, 0xea, 0x07, 0x61, 0x7f,
	0x12, 0xb9, 0xf7, 0xdb, 0xc6, 0x49, 0xe3, 0x4c, 0x73, 0xfd, 0x88, 0x74, 0xb2, 0xd4, 0x13, 0x0d,
	0x83, 0x5f, 0x45, 0x35, 0x21, 0x0d, 0xb3, 0x76, 0x49, 0xc0, 0xd7, 0x34, 0xf8, 0x30, 0x23, 0xca,
	0x8a, 0x3f, 0x43, 0xf5, 0x41, 0xf8, 0x80, 0x4e, 0xa2, 0x98, 0xb6, 0xcb, 0x80, 0xe4, 0xaf, 0x55,
	0xca, 0xbe, 0xfd, 0x64, 0xd1, 0x3d, 0xab, 0x25, 0x7d, 0x3c, 0x8f, 0x69, 0x32, 0xa1, 0x9e, 0x4f,
	0x93, 0xde, 0x68, 0x96, 0x24, 0xd1, 0x57, 0x3d, 0x1d, 0x4f, 0x72, 0x77, 0xf8, 0x25, 0x54, 0x11,
	0xe1, 0xb7, 0x4d, 0xe1, 0xb7, 0x29, 0x23, 0x90, 0xef, 0x95, 0x16, 0x01, 0x09, 0xbd, 0x61, 0xd6,
	0xae, 0x14, 0x20, 0x5c, 0x45, 0xa4, 0x05, 0x9f, 0xe5, 0x01, 0x7a, 0xf2, 0xe5, 0x55, 0x81, 0x3a,
	0x9c, 0xa3, 0xe4, 0xbb, 0x73, 0xfb, 0x25, 0x73, 0xeb, 0x51, 0xd7, 0xb0, 0xae, 0xeb, 0xd9, 0xc2,
	0xc7, 0x51, 0xf5, 0x1a, 0x0d, 0xfc, 0x31, 0x13, 0x79, 0x33, 0x09, 0x48, 0xf8, 0x15, 0xae, 0x77,
	0x3c, 0x9a, 0xe4, 0x09, 0x92, 0x6c, 0x91, 0x4a, 0x02, 0x46, 0xcb, 0x5a, 0xfe, 0xfd, 0xf3, 0x5c,
	0x59, 0xdf, 0x1a, 0x79, 0xb6, 0x79, 0xb8, 0xc3, 0x0c, 0x1c, 0x1b, 0x7a, 0xb8, 0x4a, 0x4b, 0x72,
	0x3b, 0x7e, 0x19, 0x55, 0x09, 0x4d, 0x67, 0x13, 0x06, 0x21, 0xb4, 0x24, 0x52, 0xea, 0x08, 0xd8,
	0x70, 0x0f, 0x35, 0x06, 0x99, 0x4b, 0x63, 0x16, 0x44, 0x21, 0xa4, 0xf2, 0xa8, 0x0d, 0x5c, 0xcd,
	0x0d, 0x64, 0x89, 0xb1, 0xee, 0x42, 0x52, 0xf1, 0x47, 0xa8, 0x3a, 0xcc, 0xae, 0x39, 0xe9, 0x58,
	0x54, 0xb6, 0xd5, 0xbf, 0xb8, 0xb5, 0xe8, 0x1e, 0x7a, 0xb2, 0xe8, 0x9e, 0xdf, 0xbb, 0x9c, 0xa3,
	0x20, 0x74, 0x92, 0xb9, 0x7d, 0x8d, 0x66, 0xfd, 0x39, 0xa3, 0x29, 0x01, 0x27, 0xd6, 0x5f, 0xc6,
	0xf2, 0x6d, 0xf8, 0x43, 0xee, 0x7b, 0x38, 0x8f, 0xa9, 0x78, 0xe5, 0x5a, 0x7f, 0x7d, 0x67, 0xd1,
	0xb5, 0xf7, 0xa5, 0x49, 0x2f, 0x76, 0xe6, 0x93, 0xc8, 0xf1, 0x6c, 0x7e, 0x93, 0x80, 0x07, 0x2d,
	0xce, 0xd2, 0x01, 0xc4, 0xa9, 0x95, 0xa9, 0x5c, 0xa8, 0xf8, 0x31, 0x54, 0xd9, 0x0c, 0x3d, 0x9a,
	0x89, 0x24, 0x9a, 0x44, 0x0a, 0xbc, 0x08, 0xb7, 0x92, 0xc0, 0x0f, 0x42, 0xe0, 0x20, 0x14, 0x41,
	0xea, 0x08, 0xd8, 0xac, 0xaf, 0x0d, 0x74, 0x58, 0x90, 0x60, 0x90, 0x51, 0x77, 0xc6, 0xd3, 0xbc,
	0x22, 0xb1, 0xf8, 0x68, 0x18, 0x66, 0xb9, 0xb7, 0xb4, 0x5d, 0xd6, 0x47, 0x83, 0x66, 0x21, 0x05,
	0x98, 0xf5, 0x3e, 0x3a, 0xac, 0xc9, 0xd7, 0xe9, 0xfc, 0xb9, 0x71, 0x1c, 0x47, 0xd5, 0x5b, 0xf7,
	0xee, 0xa5, 0x54, 0xb2, 0xcb, 0x24, 0x20, 0x59, 0x7f, 0x94, 0x50, 0x53, 0x73, 0x81, 0xcf, 0xe5,
	0xf1, 0xee, 0xca, 0xd7, 0xbe, 0xf9, 0x78, 0xd1, 0x35, 0xf2, 0xb0, 0xf5, 0x79, 0x51, 0x3d, 0xd8,
	0x79, 0x71, 0x0a, 0x55, 0x61, 0x4c, 0xd6, 0x44, 0x2e, 0x0a, 0x03, 0x03, 0x4c, 0x5a, 0xcf, 0xd4,
	0xf7, 0xe8, 0x99, 0xd3, 0xa8, 0x46, 0xa8, 0x4b, 0x83, 0x98, 0xb5, 0x1b, 0x00, 0xe3, 0x7f, 0x0a,
	0x3a, 0xa2, 0x8c, 0xc5, 0xde, 0x42, 0xfb, 0xf7, 0xd6, 0x33, 0x55, 0x6b, 0xbe, 0x58, 0xd5, 0xbe,
	0x31, 0x14, 0xcb, 0x70, 0x1b, 0xd5, 0xae, 0x8c, 0x9d, 0x20, 0xdc, 0xdc, 0x10, 0xf9, 0x6e, 0x10,
	0x25, 0x6a, 0x85, 0x2c, 0xed, 0xce, 0xdb, 0xb2, 0xce, 0xdb, 0x77, 0x90, 0x39, 0x0c, 0xa6, 0x14,
	0x26, 0xc2, 0x09, 0x5b, 0xae, 0x37, 0x5b, 0xad, 0x37, 0x7b, 0xa8, 0xd6, 0x5b, 0xbf, 0xce, 0xdb,
	0xe9, 0xbb, 0xdf, 0xba, 0x06, 0x11, 0x37, 0xac, 0x5f, 0x4a, 0xaa, 0xe2, 0xff, 0xe5, 0x2e, 0x7e,
	0x1d, 0x35, 0x44, 0xc9, 0x45, 0x74, 0x65, 0x11, 0xdd, 0xda, 0xce, 0xa2, 0xbb, 0x54, 0x92, 0xe5,
	0x91, 0x27, 0x55, 0x08, 0x9b, 0x1b, 0x22, 0x1f, 0x0d, 0xa2, 0x44, 0x2d, 0xa9, 0x95, 0xdd, 0x93,
	0x5a, 0xd5, 0x93, 0x5a, 0xe0, 0x43, 0x6d, 0x7f, 0x3e, 0x5c, 0x32, 0x1f, 0x3e, 0xea, 0x1e, 0xb2,
	0xbe, 0x2f, 0xc1, 0xaa, 0xe3, 0xf4, 0x2c, 0x34, 0x13, 0xd0, 0xf3, 0x1f, 0xbd, 0x7f, 0x9a, 0xff,
	0x79, 0x3c, 0x53, 0x73, 0x1f, 0x56, 0xb9, 0x50, 0xc1, 0x7a, 0x14, 0x67, 0xfc, 0x1a, 0xaa, 0xde,
	0x9a, 0x31, 0x0e, 0x2c, 0xab, 0x58, 0xc4, 0x6c, 0x12, 0x3a, 0xe8, 0x0b, 0x29, 0xe0, 0x53, 0xc8,
	0xbc, 0xe2, 0x4c, 0x26, 0x40, 0x87, 0xff, 0x49, 0x20, 0xd7, 0x48, 0x98, 0x30, 0xe2, 0x93, 0xa8,
	0x7c, 0x23, 0xf2, 0x61, 0xd0, 0x41, 0x9f, 0xdf, 0x88, 0x7c, 0x09, 0xe1, 0x26, 0xfc, 0x1e, 0x5a,
	0xbb, 0x1a, 0x3d, 0xa0, 0x49, 0x78, 0xd9, 0x75, 0xa3, 0x59, 0xc8, 0xa0, 0xc7, 0xdb, 0x12, 0x5b,
	0x30, 0xc9, 0x5b, 0x45, 0xf8, 0xa5, 0x3a, 0xcf, 0x87, 0xd8, 0xc2, 0x0f, 0x0d, 0xd5, 0xa9, 0xbc,
	0x06, 0x84, 0xb2, 0x59, 0x12, 0x8a, 0xa4, 0xb4, 0x08, 0x48, 0xbc, 0x6a, 0x57, 0x9d, 0xf4, 0x4e,
	0x4a, 0x3d, 0x60, 0xbc, 0x12, 0xf1, 0x59, 0xd4, 0xb8, 0xe9, 0x4c, 0xe9, 0x20, 0x64, 0xc9, 0x1c,
	0xde, 0xde, 0xb2, 0xe5, 0x17, 0x99, 0xd0, 0x91, 0xa5, 0x19, 0x5f, 0x40, 0xf5, 0x8f, 0x69, 0x32,
	0xbd, 0x9c, 0xf8, 0x29, 0xbc, 0xfe, 0x98, 0xad, 0x7d, 0xa4, 0x29, 0x1b, 0xc9, 0x51, 0xd6, 0x9f,
	0x06, 0xaa, 0xab, 0x67, 0xe3, 0x9b, 0xa8, 0x76, 0xd9, 0xf3, 0x12, 0x9a, 0xa6, 0x32, 0xba, 0xfe,
	0x9b, 0xc0, 0xdb, 0x73, 0x7b, 0xf3, 0xd6, 0x4d, 0xe6, 0x31, 0x8b, 0x6c, 0xb8, 0x4b, 0x94, 0x13,
	0xbc, 0x89, 0xcc, 0x0d, 0x87, 0x39, 0xab, 0x35, 0x81, 0x70, 0x81, 0x6f, 0xa0, 0xea, 0x30, 0x8a,
	0x03, 0x57, 0x2e, 0x87, 0x17, 0x8e, 0x0c, 0x9c, 0x7d, 0x1a, 0x25, 0xde, 0xfa, 0xc5, 0xb7, 0x08,
	0xf8, 0xb0, 0x7e, 0x2c, 0xa1, 0x46, 0x4e, 0x08, 0x7c, 0x06, 0xd5, 0xb9, 0x20, 0xba, 0xab, 0x22,
	0xba, 0xab, 0xb5, 0xb3, 0xe8, 0xe6, 0x3a, 0x92, 0x9f, 0xf8, 0x17, 0x0d, 0x3f, 0x8b, 0x47, 0x15,
	0x36, 0x84, 0xd2, 0x92, 0xdc, 0xce, 0x23, 0x86, 0x65, 0x5a, 0x5a, 0x21, 0x97, 0x6a, 0x54, 0x76,
	0x10, 0xba, 0xcd, 0x1c, 0xf7, 0xfe, 0x06, 0x8d, 0xd9, 0x18, 0xa6, 0x9f, 0xa6, 0xe1, 0x13, 0x07,
	0x78, 0x65, 0xae, 0x34, 0x71, 0xa4, 0x13, 0xeb, 0x13, 0x84, 0x9f, 0x25, 0x38, 0x7e, 0x17, 0xad,
	0x81, 0x7c, 0x27, 0xf6, 0x1c, 0x46, 0x21, 0x07, 0xff, 0xb7, 0xc5, 0x67, 0xff, 0x90, 0x4e, 0xe3,
	0x89, 0xc3, 0x28, 0x40, 0x48, 0x11, 0x6b, 0x7d, 0x81, 0xd0, 0xb2, 0xab, 0x0f, 0x9a, 0x6a, 0xd6,
	0x97, 0xa8, 0xa9, 0x8d, 0x82, 0x03, 0x77, 0xff, 0x43, 0x09, 0x15, 0x2a, 0xcb, 0xcf, 0x30, 0xd8,
	0xfe, 0x75, 0x65, 0xa5, 0x8f, 0xdc, 0x1b, 0x5d, 0x8d, 0x27, 0xd2, 0x47, 0xde, 0x72, 0xe5, 0xd5,
	0x5b, 0xee, 0x18, 0xaa, 0xdc, 0x75, 0x26, 0x33, 0xaa, 0xbe, 0x11, 0x85, 0x80, 0x8f, 0xa0, 0xf2,
	0x55, 0x27, 0x85, 0x0d, 0xc2, 0x8f, 0xfd, 0x0f, 0xb6, 0xb6, 0x3b, 0xc6, 0xe3, 0xed, 0x8e, 0xf1,
	0xeb, 0x76, 0xc7, 0xf8, 0x7d, 0xbb, 0x63, 0xfc, 0xfc, 0xb4, 0x63, 0x6c, 0x3d, 0xed, 0x18, 0x9f,
	0xef, 0xf3, 0x04, 0xaa, 0x3e, 0x0a, 0xc4, 0x69, 0x54, 0x15, 0xfb, 0xfa, 0x8d, 0xbf, 0x03, 0x00,
	0x00, 0xff, 0xff, 0xf5, 0x7c, 0x70, 0x97, 0x18, 0x0f, 0x00, 0x00,
}

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

func (m *StreamEvents) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StreamEvents) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.StreamEvents) > 0 {
		for iNdEx := len(m.StreamEvents) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StreamEvents[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExec(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *StreamEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StreamEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.EndBlock != nil {
		{
			size, err := m.EndBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.EndTx != nil {
		{
			size, err := m.EndTx.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Event != nil {
		{
			size, err := m.Event.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Envelope != nil {
		{
			size := m.Envelope.Size()
			i -= size
			if _, err := m.Envelope.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.BeginTx != nil {
		{
			size, err := m.BeginTx.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.BeginBlock != nil {
		{
			size, err := m.BeginBlock.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BeginBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *EndBlock) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BeginTx) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BeginTx) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Exception != nil {
		{
			size, err := m.Exception.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.TxHeader != nil {
		{
			size, err := m.TxHeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EndTx) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *TxHeader) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *BlockExecution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *BlockExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.TxExecutions) > 0 {
		for iNdEx := len(m.TxExecutions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TxExecutions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExec(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Header != nil {
		{
			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Height != 0 {
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TxExecutionKey) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TxExecutionKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Offset != 0 {
		i = encodeVarintExec(dAtA, i, uint64(m.Offset))
		i--
		dAtA[i] = 0x10
	}
	if m.Height != 0 {
		i = encodeVarintExec(dAtA, i, uint64(m.Height))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TxExecution) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TxExecution) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.TxExecutions) > 0 {
		for iNdEx := len(m.TxExecutions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.TxExecutions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExec(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x5a
		}
	}
	if m.Exception != nil {
		{
			size, err := m.Exception.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.Receipt != nil {
		{
			size, err := m.Receipt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.Events) > 0 {
		for iNdEx := len(m.Events) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Events[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintExec(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Envelope != nil {
		{
			size := m.Envelope.Size()
			i -= size
			if _, err := m.Envelope.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.TxHeader != nil {
		{
			size, err := m.TxHeader.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Origin) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *Header) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *Event) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.GovernAccount != nil {
		{
			size, err := m.GovernAccount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Log != nil {
		{
			size, err := m.Log.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Call != nil {
		{
			size, err := m.Call.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Output != nil {
		{
			size, err := m.Output.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Input != nil {
		{
			size, err := m.Input.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Header != nil {
		{
			size, err := m.Header.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintExec(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Result) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *LogEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LogEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Topics) > 0 {
		for iNdEx := len(m.Topics) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.Topics[iNdEx].Size()
				i -= size
				if _, err := m.Topics[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintExec(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size := m.Data.Size()
		i -= size
		if _, err := m.Data.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExec(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.Address.Size()
		i -= size
		if _, err := m.Address.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintExec(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *CallEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *GovernAccountEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *InputEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *OutputEvent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *CallData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func encodeVarintExec(dAtA []byte, offset int, v uint64) int {
	offset -= sovExec(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *StreamEvents) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.StreamEvents) > 0 {
		for _, e := range m.StreamEvents {
			l = e.Size()
			n += 1 + l + sovExec(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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 *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 *TxExecutionKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Height != 0 {
		n += 1 + sovExec(uint64(m.Height))
	}
	if m.Offset != 0 {
		n += 1 + sovExec(uint64(m.Offset))
	}
	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) {
	return (math_bits.Len64(x|1) + 6) / 7
}
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 *StreamEvents) 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: StreamEvents: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamEvents: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StreamEvents", 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.StreamEvents = append(m.StreamEvents, &StreamEvent{})
			if err := m.StreamEvents[len(m.StreamEvents)-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 *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 *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 *TxExecutionKey) 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: TxExecutionKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TxExecutionKey: 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 Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowExec
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Offset |= 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 *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
	depth := 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
				}
			}
		case 1:
			iNdEx += 8
		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
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupExec
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthExec
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthExec        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowExec          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupExec = fmt.Errorf("proto: unexpected end of group")
)