// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: hyperlane/core/post_dispatch/v1/events.proto

package types

import (
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	github_com_bcp_innovations_hyperlane_cosmos_util "github.com/bcp-innovations/hyperlane-cosmos/util"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// EventCreateMerkleTreeHook ...
type EventCreateMerkleTreeHook struct {
	// id ...
	MerkleTreeHookId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=merkle_tree_hook_id,json=merkleTreeHookId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"merkle_tree_hook_id"`
	// mailbox_id ...
	MailboxId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=mailbox_id,json=mailboxId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"mailbox_id"`
	Owner     string                                                      `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
}

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

var xxx_messageInfo_EventCreateMerkleTreeHook proto.InternalMessageInfo

func (m *EventCreateMerkleTreeHook) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// EventInsertedIntoTree ...
type EventInsertedIntoTree struct {
	// message_id ...
	MessageId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"message_id"`
	// index ...
	Index uint32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
	// merkle_tree_hook_id ...
	MerkleTreeHookId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,3,opt,name=merkle_tree_hook_id,json=merkleTreeHookId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"merkle_tree_hook_id"`
}

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

var xxx_messageInfo_EventInsertedIntoTree proto.InternalMessageInfo

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

// EventGasPayment ...
type EventGasPayment struct {
	// message_id ...
	MessageId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"message_id"`
	// destination ...
	Destination uint32 `protobuf:"varint,2,opt,name=destination,proto3" json:"destination,omitempty"`
	// gas_amount ...
	GasAmount string `protobuf:"bytes,3,opt,name=gas_amount,json=gasAmount,proto3" json:"gas_amount,omitempty"`
	// payment ...
	Payment string `protobuf:"bytes,4,opt,name=payment,proto3" json:"payment,omitempty"`
	// igp_id ...
	IgpId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,5,opt,name=igp_id,json=igpId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"igp_id"`
}

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

var xxx_messageInfo_EventGasPayment proto.InternalMessageInfo

func (m *EventGasPayment) GetDestination() uint32 {
	if m != nil {
		return m.Destination
	}
	return 0
}

func (m *EventGasPayment) GetGasAmount() string {
	if m != nil {
		return m.GasAmount
	}
	return ""
}

func (m *EventGasPayment) GetPayment() string {
	if m != nil {
		return m.Payment
	}
	return ""
}

// EventCreateNoopHook ...
type EventCreateNoopHook struct {
	// id ...
	NoopHookId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=noop_hook_id,json=noopHookId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"noop_hook_id"`
	// owner ...
	Owner string `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
}

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

var xxx_messageInfo_EventCreateNoopHook proto.InternalMessageInfo

func (m *EventCreateNoopHook) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

// EventCreateIgp ...
type EventCreateIgp struct {
	IgpId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=igp_id,json=igpId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"igp_id"`
	Owner string                                                      `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	Denom string                                                      `protobuf:"bytes,3,opt,name=denom,proto3" json:"denom,omitempty"`
}

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

var xxx_messageInfo_EventCreateIgp proto.InternalMessageInfo

func (m *EventCreateIgp) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *EventCreateIgp) GetDenom() string {
	if m != nil {
		return m.Denom
	}
	return ""
}

// EventSetIgp ...
type EventSetIgp struct {
	IgpId             github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=igp_id,json=igpId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"igp_id"`
	Owner             string                                                      `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	NewOwner          string                                                      `protobuf:"bytes,3,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"`
	RenounceOwnership bool                                                        `protobuf:"varint,4,opt,name=renounce_ownership,json=renounceOwnership,proto3" json:"renounce_ownership,omitempty"`
}

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

var xxx_messageInfo_EventSetIgp proto.InternalMessageInfo

func (m *EventSetIgp) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *EventSetIgp) GetNewOwner() string {
	if m != nil {
		return m.NewOwner
	}
	return ""
}

func (m *EventSetIgp) GetRenounceOwnership() bool {
	if m != nil {
		return m.RenounceOwnership
	}
	return false
}

// EventSetDestinationGasConfig ...
type EventSetDestinationGasConfig struct {
	IgpId             github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=igp_id,json=igpId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"igp_id"`
	Owner             string                                                      `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	RemoteDomain      uint32                                                      `protobuf:"varint,4,opt,name=remote_domain,json=remoteDomain,proto3" json:"remote_domain,omitempty"`
	GasOverhead       cosmossdk_io_math.Int                                       `protobuf:"bytes,5,opt,name=gas_overhead,json=gasOverhead,proto3,customtype=cosmossdk.io/math.Int" json:"gas_overhead"`
	GasPrice          cosmossdk_io_math.Int                                       `protobuf:"bytes,6,opt,name=gas_price,json=gasPrice,proto3,customtype=cosmossdk.io/math.Int" json:"gas_price"`
	TokenExchangeRate cosmossdk_io_math.Int                                       `protobuf:"bytes,7,opt,name=token_exchange_rate,json=tokenExchangeRate,proto3,customtype=cosmossdk.io/math.Int" json:"token_exchange_rate"`
}

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

var xxx_messageInfo_EventSetDestinationGasConfig proto.InternalMessageInfo

func (m *EventSetDestinationGasConfig) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *EventSetDestinationGasConfig) GetRemoteDomain() uint32 {
	if m != nil {
		return m.RemoteDomain
	}
	return 0
}

// EventClaimIgp ...
type EventClaimIgp struct {
	IgpId  github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=igp_id,json=igpId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"igp_id"`
	Owner  string                                                      `protobuf:"bytes,2,opt,name=owner,proto3" json:"owner,omitempty"`
	Amount string                                                      `protobuf:"bytes,3,opt,name=amount,proto3" json:"amount,omitempty"`
}

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

var xxx_messageInfo_EventClaimIgp proto.InternalMessageInfo

func (m *EventClaimIgp) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *EventClaimIgp) GetAmount() string {
	if m != nil {
		return m.Amount
	}
	return ""
}

func init() {
	proto.RegisterType((*EventCreateMerkleTreeHook)(nil), "hyperlane.core.post_dispatch.v1.EventCreateMerkleTreeHook")
	proto.RegisterType((*EventInsertedIntoTree)(nil), "hyperlane.core.post_dispatch.v1.EventInsertedIntoTree")
	proto.RegisterType((*EventGasPayment)(nil), "hyperlane.core.post_dispatch.v1.EventGasPayment")
	proto.RegisterType((*EventCreateNoopHook)(nil), "hyperlane.core.post_dispatch.v1.EventCreateNoopHook")
	proto.RegisterType((*EventCreateIgp)(nil), "hyperlane.core.post_dispatch.v1.EventCreateIgp")
	proto.RegisterType((*EventSetIgp)(nil), "hyperlane.core.post_dispatch.v1.EventSetIgp")
	proto.RegisterType((*EventSetDestinationGasConfig)(nil), "hyperlane.core.post_dispatch.v1.EventSetDestinationGasConfig")
	proto.RegisterType((*EventClaimIgp)(nil), "hyperlane.core.post_dispatch.v1.EventClaimIgp")
}

func init() {
	proto.RegisterFile("hyperlane/core/post_dispatch/v1/events.proto", fileDescriptor_158483b25b83c3db)
}

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

func (m *EventCreateMerkleTreeHook) 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 *EventCreateMerkleTreeHook) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventCreateMerkleTreeHook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.MailboxId.Size()
		i -= size
		if _, err := m.MailboxId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.MerkleTreeHookId.Size()
		i -= size
		if _, err := m.MerkleTreeHookId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventInsertedIntoTree) 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 *EventInsertedIntoTree) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventInsertedIntoTree) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MerkleTreeHookId.Size()
		i -= size
		if _, err := m.MerkleTreeHookId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if m.Index != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	{
		size := m.MessageId.Size()
		i -= size
		if _, err := m.MessageId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventGasPayment) 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 *EventGasPayment) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventGasPayment) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.IgpId.Size()
		i -= size
		if _, err := m.IgpId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Payment) > 0 {
		i -= len(m.Payment)
		copy(dAtA[i:], m.Payment)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Payment)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.GasAmount) > 0 {
		i -= len(m.GasAmount)
		copy(dAtA[i:], m.GasAmount)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.GasAmount)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Destination != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.Destination))
		i--
		dAtA[i] = 0x10
	}
	{
		size := m.MessageId.Size()
		i -= size
		if _, err := m.MessageId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventCreateNoopHook) 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 *EventCreateNoopHook) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventCreateNoopHook) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.NoopHookId.Size()
		i -= size
		if _, err := m.NoopHookId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventCreateIgp) 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 *EventCreateIgp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventCreateIgp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.IgpId.Size()
		i -= size
		if _, err := m.IgpId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventSetIgp) 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 *EventSetIgp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSetIgp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RenounceOwnership {
		i--
		if m.RenounceOwnership {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if len(m.NewOwner) > 0 {
		i -= len(m.NewOwner)
		copy(dAtA[i:], m.NewOwner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.NewOwner)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.IgpId.Size()
		i -= size
		if _, err := m.IgpId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventSetDestinationGasConfig) 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 *EventSetDestinationGasConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventSetDestinationGasConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.TokenExchangeRate.Size()
		i -= size
		if _, err := m.TokenExchangeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size := m.GasPrice.Size()
		i -= size
		if _, err := m.GasPrice.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	{
		size := m.GasOverhead.Size()
		i -= size
		if _, err := m.GasOverhead.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if m.RemoteDomain != 0 {
		i = encodeVarintEvents(dAtA, i, uint64(m.RemoteDomain))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.IgpId.Size()
		i -= size
		if _, err := m.IgpId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func (m *EventClaimIgp) 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 *EventClaimIgp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventClaimIgp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Amount) > 0 {
		i -= len(m.Amount)
		copy(dAtA[i:], m.Amount)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Amount)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintEvents(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.IgpId.Size()
		i -= size
		if _, err := m.IgpId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintEvents(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

func encodeVarintEvents(dAtA []byte, offset int, v uint64) int {
	offset -= sovEvents(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *EventCreateMerkleTreeHook) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MerkleTreeHookId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.MailboxId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventInsertedIntoTree) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MessageId.Size()
	n += 1 + l + sovEvents(uint64(l))
	if m.Index != 0 {
		n += 1 + sovEvents(uint64(m.Index))
	}
	l = m.MerkleTreeHookId.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventGasPayment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MessageId.Size()
	n += 1 + l + sovEvents(uint64(l))
	if m.Destination != 0 {
		n += 1 + sovEvents(uint64(m.Destination))
	}
	l = len(m.GasAmount)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Payment)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = m.IgpId.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventCreateNoopHook) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.NoopHookId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventCreateIgp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.IgpId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Denom)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func (m *EventSetIgp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.IgpId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.NewOwner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.RenounceOwnership {
		n += 2
	}
	return n
}

func (m *EventSetDestinationGasConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.IgpId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	if m.RemoteDomain != 0 {
		n += 1 + sovEvents(uint64(m.RemoteDomain))
	}
	l = m.GasOverhead.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.GasPrice.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = m.TokenExchangeRate.Size()
	n += 1 + l + sovEvents(uint64(l))
	return n
}

func (m *EventClaimIgp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.IgpId.Size()
	n += 1 + l + sovEvents(uint64(l))
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	l = len(m.Amount)
	if l > 0 {
		n += 1 + l + sovEvents(uint64(l))
	}
	return n
}

func sovEvents(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEvents(x uint64) (n int) {
	return sovEvents(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *EventCreateMerkleTreeHook) 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 ErrIntOverflowEvents
			}
			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: EventCreateMerkleTreeHook: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventCreateMerkleTreeHook: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MerkleTreeHookId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MerkleTreeHookId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MailboxId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MailboxId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventInsertedIntoTree) 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 ErrIntOverflowEvents
			}
			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: EventInsertedIntoTree: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventInsertedIntoTree: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MessageId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MerkleTreeHookId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MerkleTreeHookId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventGasPayment) 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 ErrIntOverflowEvents
			}
			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: EventGasPayment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventGasPayment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MessageId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MessageId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Destination", wireType)
			}
			m.Destination = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Destination |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasAmount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GasAmount = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payment", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payment = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgpId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IgpId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventCreateNoopHook) 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 ErrIntOverflowEvents
			}
			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: EventCreateNoopHook: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventCreateNoopHook: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NoopHookId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NoopHookId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventCreateIgp) 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 ErrIntOverflowEvents
			}
			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: EventCreateIgp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventCreateIgp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgpId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IgpId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSetIgp) 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 ErrIntOverflowEvents
			}
			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: EventSetIgp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventSetIgp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgpId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IgpId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewOwner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewOwner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RenounceOwnership", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.RenounceOwnership = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventSetDestinationGasConfig) 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 ErrIntOverflowEvents
			}
			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: EventSetDestinationGasConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventSetDestinationGasConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgpId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IgpId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RemoteDomain", wireType)
			}
			m.RemoteDomain = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RemoteDomain |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasOverhead", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GasOverhead.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasPrice", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GasPrice.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenExchangeRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TokenExchangeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventClaimIgp) 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 ErrIntOverflowEvents
			}
			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: EventClaimIgp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventClaimIgp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field IgpId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.IgpId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEvents
				}
				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 ErrInvalidLengthEvents
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEvents
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEvents(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthEvents
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipEvents(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, ErrIntOverflowEvents
			}
			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, ErrIntOverflowEvents
				}
				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, ErrIntOverflowEvents
				}
				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, ErrInvalidLengthEvents
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupEvents
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthEvents
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthEvents        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvents          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvents = fmt.Errorf("proto: unexpected end of group")
)
