types.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: axelar/evm/v1beta1/types.proto

package types

import (
	fmt "fmt"
	_ "github.com/axelarnetwork/axelar-core/x/multisig/exported"
	github_com_axelarnetwork_axelar_core_x_multisig_exported "github.com/axelarnetwork/axelar-core/x/multisig/exported"
	_ "github.com/axelarnetwork/axelar-core/x/nexus/exported"
	github_com_axelarnetwork_axelar_core_x_nexus_exported "github.com/axelarnetwork/axelar-core/x/nexus/exported"
	types "github.com/cosmos/cosmos-sdk/codec/types"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/regen-network/cosmos-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

type Status int32

const (
	// these enum values are used for bitwise operations, therefore they need to
	// be powers of 2
	NonExistent Status = 0
	Initialized Status = 1
	Pending     Status = 2
	Confirmed   Status = 4
)

var Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_INITIALIZED",
	2: "STATUS_PENDING",
	4: "STATUS_CONFIRMED",
}

var Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"STATUS_INITIALIZED": 1,
	"STATUS_PENDING":     2,
	"STATUS_CONFIRMED":   4,
}

func (x Status) String() string {
	return proto.EnumName(Status_name, int32(x))
}

func (Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{0}
}

type CommandType int32

const (
	COMMAND_TYPE_UNSPECIFIED                     CommandType = 0
	COMMAND_TYPE_MINT_TOKEN                      CommandType = 1
	COMMAND_TYPE_DEPLOY_TOKEN                    CommandType = 2
	COMMAND_TYPE_BURN_TOKEN                      CommandType = 3
	COMMAND_TYPE_TRANSFER_OPERATORSHIP           CommandType = 4
	COMMAND_TYPE_APPROVE_CONTRACT_CALL_WITH_MINT CommandType = 5
	COMMAND_TYPE_APPROVE_CONTRACT_CALL           CommandType = 6
)

var CommandType_name = map[int32]string{
	0: "COMMAND_TYPE_UNSPECIFIED",
	1: "COMMAND_TYPE_MINT_TOKEN",
	2: "COMMAND_TYPE_DEPLOY_TOKEN",
	3: "COMMAND_TYPE_BURN_TOKEN",
	4: "COMMAND_TYPE_TRANSFER_OPERATORSHIP",
	5: "COMMAND_TYPE_APPROVE_CONTRACT_CALL_WITH_MINT",
	6: "COMMAND_TYPE_APPROVE_CONTRACT_CALL",
}

var CommandType_value = map[string]int32{
	"COMMAND_TYPE_UNSPECIFIED":                     0,
	"COMMAND_TYPE_MINT_TOKEN":                      1,
	"COMMAND_TYPE_DEPLOY_TOKEN":                    2,
	"COMMAND_TYPE_BURN_TOKEN":                      3,
	"COMMAND_TYPE_TRANSFER_OPERATORSHIP":           4,
	"COMMAND_TYPE_APPROVE_CONTRACT_CALL_WITH_MINT": 5,
	"COMMAND_TYPE_APPROVE_CONTRACT_CALL":           6,
}

func (CommandType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{1}
}

type BatchedCommandsStatus int32

const (
	BatchNonExistent BatchedCommandsStatus = 0
	BatchSigning     BatchedCommandsStatus = 1
	BatchAborted     BatchedCommandsStatus = 2
	BatchSigned      BatchedCommandsStatus = 3
)

var BatchedCommandsStatus_name = map[int32]string{
	0: "BATCHED_COMMANDS_STATUS_UNSPECIFIED",
	1: "BATCHED_COMMANDS_STATUS_SIGNING",
	2: "BATCHED_COMMANDS_STATUS_ABORTED",
	3: "BATCHED_COMMANDS_STATUS_SIGNED",
}

var BatchedCommandsStatus_value = map[string]int32{
	"BATCHED_COMMANDS_STATUS_UNSPECIFIED": 0,
	"BATCHED_COMMANDS_STATUS_SIGNING":     1,
	"BATCHED_COMMANDS_STATUS_ABORTED":     2,
	"BATCHED_COMMANDS_STATUS_SIGNED":      3,
}

func (x BatchedCommandsStatus) String() string {
	return proto.EnumName(BatchedCommandsStatus_name, int32(x))
}

func (BatchedCommandsStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{2}
}

type SigType int32

const (
	None       SigType = 0
	SigTx      SigType = 1
	SigCommand SigType = 2
)

var SigType_name = map[int32]string{
	0: "SIG_TYPE_UNSPECIFIED",
	1: "SIG_TYPE_TX",
	2: "SIG_TYPE_COMMAND",
}

var SigType_value = map[string]int32{
	"SIG_TYPE_UNSPECIFIED": 0,
	"SIG_TYPE_TX":          1,
	"SIG_TYPE_COMMAND":     2,
}

func (x SigType) String() string {
	return proto.EnumName(SigType_name, int32(x))
}

func (SigType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{3}
}

type DepositStatus int32

const (
	DepositStatus_None      DepositStatus = 0
	DepositStatus_Pending   DepositStatus = 1
	DepositStatus_Confirmed DepositStatus = 2
	DepositStatus_Burned    DepositStatus = 3
)

var DepositStatus_name = map[int32]string{
	0: "DEPOSIT_STATUS_UNSPECIFIED",
	1: "DEPOSIT_STATUS_PENDING",
	2: "DEPOSIT_STATUS_CONFIRMED",
	3: "DEPOSIT_STATUS_BURNED",
}

var DepositStatus_value = map[string]int32{
	"DEPOSIT_STATUS_UNSPECIFIED": 0,
	"DEPOSIT_STATUS_PENDING":     1,
	"DEPOSIT_STATUS_CONFIRMED":   2,
	"DEPOSIT_STATUS_BURNED":      3,
}

func (x DepositStatus) String() string {
	return proto.EnumName(DepositStatus_name, int32(x))
}

func (DepositStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{4}
}

type Event_Status int32

const (
	EventNonExistent Event_Status = 0
	EventConfirmed   Event_Status = 1
	EventCompleted   Event_Status = 2
	EventFailed      Event_Status = 3
)

var Event_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_CONFIRMED",
	2: "STATUS_COMPLETED",
	3: "STATUS_FAILED",
}

var Event_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"STATUS_CONFIRMED":   1,
	"STATUS_COMPLETED":   2,
	"STATUS_FAILED":      3,
}

func (x Event_Status) String() string {
	return proto.EnumName(Event_Status_name, int32(x))
}

func (Event_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{1, 0}
}

type VoteEvents struct {
	Chain  github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,1,opt,name=chain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"chain,omitempty"`
	Events []Event                                                         `protobuf:"bytes,2,rep,name=events,proto3" json:"events"`
}

func (m *VoteEvents) Reset()         { *m = VoteEvents{} }
func (m *VoteEvents) String() string { return proto.CompactTextString(m) }
func (*VoteEvents) ProtoMessage()    {}
func (*VoteEvents) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{0}
}
func (m *VoteEvents) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *VoteEvents) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_VoteEvents.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 *VoteEvents) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VoteEvents.Merge(m, src)
}
func (m *VoteEvents) XXX_Size() int {
	return m.Size()
}
func (m *VoteEvents) XXX_DiscardUnknown() {
	xxx_messageInfo_VoteEvents.DiscardUnknown(m)
}

var xxx_messageInfo_VoteEvents proto.InternalMessageInfo

type Event struct {
	Chain  github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,1,opt,name=chain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"chain,omitempty"`
	TxID   Hash                                                            `protobuf:"bytes,2,opt,name=tx_id,json=txId,proto3,customtype=Hash" json:"tx_id"`
	Index  uint64                                                          `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
	Status Event_Status                                                    `protobuf:"varint,4,opt,name=status,proto3,enum=axelar.evm.v1beta1.Event_Status" json:"status,omitempty"`
	// Types that are valid to be assigned to Event:
	//	*Event_TokenSent
	//	*Event_ContractCall
	//	*Event_ContractCallWithToken
	//	*Event_Transfer
	//	*Event_TokenDeployed
	//	*Event_MultisigOwnershipTransferred
	//	*Event_MultisigOperatorshipTransferred
	Event isEvent_Event `protobuf_oneof:"event"`
}

func (m *Event) Reset()         { *m = Event{} }
func (m *Event) String() string { return proto.CompactTextString(m) }
func (*Event) ProtoMessage()    {}
func (*Event) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{1}
}
func (m *Event) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Event) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Event.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.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

type isEvent_Event interface {
	isEvent_Event()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Event_TokenSent struct {
	TokenSent *EventTokenSent `protobuf:"bytes,5,opt,name=token_sent,json=tokenSent,proto3,oneof" json:"token_sent,omitempty"`
}
type Event_ContractCall struct {
	ContractCall *EventContractCall `protobuf:"bytes,6,opt,name=contract_call,json=contractCall,proto3,oneof" json:"contract_call,omitempty"`
}
type Event_ContractCallWithToken struct {
	ContractCallWithToken *EventContractCallWithToken `protobuf:"bytes,7,opt,name=contract_call_with_token,json=contractCallWithToken,proto3,oneof" json:"contract_call_with_token,omitempty"`
}
type Event_Transfer struct {
	Transfer *EventTransfer `protobuf:"bytes,8,opt,name=transfer,proto3,oneof" json:"transfer,omitempty"`
}
type Event_TokenDeployed struct {
	TokenDeployed *EventTokenDeployed `protobuf:"bytes,9,opt,name=token_deployed,json=tokenDeployed,proto3,oneof" json:"token_deployed,omitempty"`
}
type Event_MultisigOwnershipTransferred struct {
	MultisigOwnershipTransferred *EventMultisigOwnershipTransferred `protobuf:"bytes,10,opt,name=multisig_ownership_transferred,json=multisigOwnershipTransferred,proto3,oneof" json:"multisig_ownership_transferred,omitempty"`
}
type Event_MultisigOperatorshipTransferred struct {
	MultisigOperatorshipTransferred *EventMultisigOperatorshipTransferred `protobuf:"bytes,11,opt,name=multisig_operatorship_transferred,json=multisigOperatorshipTransferred,proto3,oneof" json:"multisig_operatorship_transferred,omitempty"`
}

func (*Event_TokenSent) isEvent_Event()                       {}
func (*Event_ContractCall) isEvent_Event()                    {}
func (*Event_ContractCallWithToken) isEvent_Event()           {}
func (*Event_Transfer) isEvent_Event()                        {}
func (*Event_TokenDeployed) isEvent_Event()                   {}
func (*Event_MultisigOwnershipTransferred) isEvent_Event()    {}
func (*Event_MultisigOperatorshipTransferred) isEvent_Event() {}

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

func (m *Event) GetTokenSent() *EventTokenSent {
	if x, ok := m.GetEvent().(*Event_TokenSent); ok {
		return x.TokenSent
	}
	return nil
}

func (m *Event) GetContractCall() *EventContractCall {
	if x, ok := m.GetEvent().(*Event_ContractCall); ok {
		return x.ContractCall
	}
	return nil
}

func (m *Event) GetContractCallWithToken() *EventContractCallWithToken {
	if x, ok := m.GetEvent().(*Event_ContractCallWithToken); ok {
		return x.ContractCallWithToken
	}
	return nil
}

func (m *Event) GetTransfer() *EventTransfer {
	if x, ok := m.GetEvent().(*Event_Transfer); ok {
		return x.Transfer
	}
	return nil
}

func (m *Event) GetTokenDeployed() *EventTokenDeployed {
	if x, ok := m.GetEvent().(*Event_TokenDeployed); ok {
		return x.TokenDeployed
	}
	return nil
}

// Deprecated: Do not use.
func (m *Event) GetMultisigOwnershipTransferred() *EventMultisigOwnershipTransferred {
	if x, ok := m.GetEvent().(*Event_MultisigOwnershipTransferred); ok {
		return x.MultisigOwnershipTransferred
	}
	return nil
}

func (m *Event) GetMultisigOperatorshipTransferred() *EventMultisigOperatorshipTransferred {
	if x, ok := m.GetEvent().(*Event_MultisigOperatorshipTransferred); ok {
		return x.MultisigOperatorshipTransferred
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Event) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Event_TokenSent)(nil),
		(*Event_ContractCall)(nil),
		(*Event_ContractCallWithToken)(nil),
		(*Event_Transfer)(nil),
		(*Event_TokenDeployed)(nil),
		(*Event_MultisigOwnershipTransferred)(nil),
		(*Event_MultisigOperatorshipTransferred)(nil),
	}
}

type EventTokenSent struct {
	Sender             Address                                                         `protobuf:"bytes,1,opt,name=sender,proto3,customtype=Address" json:"sender"`
	DestinationChain   github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,2,opt,name=destination_chain,json=destinationChain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"destination_chain,omitempty"`
	DestinationAddress string                                                          `protobuf:"bytes,3,opt,name=destination_address,json=destinationAddress,proto3" json:"destination_address,omitempty"`
	Symbol             string                                                          `protobuf:"bytes,4,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Amount             github_com_cosmos_cosmos_sdk_types.Uint                         `protobuf:"bytes,5,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"`
}

func (m *EventTokenSent) Reset()         { *m = EventTokenSent{} }
func (m *EventTokenSent) String() string { return proto.CompactTextString(m) }
func (*EventTokenSent) ProtoMessage()    {}
func (*EventTokenSent) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{2}
}
func (m *EventTokenSent) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventTokenSent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventTokenSent.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 *EventTokenSent) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventTokenSent.Merge(m, src)
}
func (m *EventTokenSent) XXX_Size() int {
	return m.Size()
}
func (m *EventTokenSent) XXX_DiscardUnknown() {
	xxx_messageInfo_EventTokenSent.DiscardUnknown(m)
}

var xxx_messageInfo_EventTokenSent proto.InternalMessageInfo

type EventContractCall struct {
	Sender           Address                                                         `protobuf:"bytes,1,opt,name=sender,proto3,customtype=Address" json:"sender"`
	DestinationChain github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,2,opt,name=destination_chain,json=destinationChain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"destination_chain,omitempty"`
	ContractAddress  string                                                          `protobuf:"bytes,3,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
	PayloadHash      Hash                                                            `protobuf:"bytes,4,opt,name=payload_hash,json=payloadHash,proto3,customtype=Hash" json:"payload_hash"`
}

func (m *EventContractCall) Reset()         { *m = EventContractCall{} }
func (m *EventContractCall) String() string { return proto.CompactTextString(m) }
func (*EventContractCall) ProtoMessage()    {}
func (*EventContractCall) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{3}
}
func (m *EventContractCall) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventContractCall) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventContractCall.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 *EventContractCall) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventContractCall.Merge(m, src)
}
func (m *EventContractCall) XXX_Size() int {
	return m.Size()
}
func (m *EventContractCall) XXX_DiscardUnknown() {
	xxx_messageInfo_EventContractCall.DiscardUnknown(m)
}

var xxx_messageInfo_EventContractCall proto.InternalMessageInfo

type EventContractCallWithToken struct {
	Sender           Address                                                         `protobuf:"bytes,1,opt,name=sender,proto3,customtype=Address" json:"sender"`
	DestinationChain github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,2,opt,name=destination_chain,json=destinationChain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"destination_chain,omitempty"`
	ContractAddress  string                                                          `protobuf:"bytes,3,opt,name=contract_address,json=contractAddress,proto3" json:"contract_address,omitempty"`
	PayloadHash      Hash                                                            `protobuf:"bytes,4,opt,name=payload_hash,json=payloadHash,proto3,customtype=Hash" json:"payload_hash"`
	Symbol           string                                                          `protobuf:"bytes,5,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Amount           github_com_cosmos_cosmos_sdk_types.Uint                         `protobuf:"bytes,6,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"`
}

func (m *EventContractCallWithToken) Reset()         { *m = EventContractCallWithToken{} }
func (m *EventContractCallWithToken) String() string { return proto.CompactTextString(m) }
func (*EventContractCallWithToken) ProtoMessage()    {}
func (*EventContractCallWithToken) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{4}
}
func (m *EventContractCallWithToken) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventContractCallWithToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventContractCallWithToken.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 *EventContractCallWithToken) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventContractCallWithToken.Merge(m, src)
}
func (m *EventContractCallWithToken) XXX_Size() int {
	return m.Size()
}
func (m *EventContractCallWithToken) XXX_DiscardUnknown() {
	xxx_messageInfo_EventContractCallWithToken.DiscardUnknown(m)
}

var xxx_messageInfo_EventContractCallWithToken proto.InternalMessageInfo

type EventTransfer struct {
	To     Address                                 `protobuf:"bytes,1,opt,name=to,proto3,customtype=Address" json:"to"`
	Amount github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"`
}

func (m *EventTransfer) Reset()         { *m = EventTransfer{} }
func (m *EventTransfer) String() string { return proto.CompactTextString(m) }
func (*EventTransfer) ProtoMessage()    {}
func (*EventTransfer) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{5}
}
func (m *EventTransfer) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventTransfer) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventTransfer.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 *EventTransfer) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventTransfer.Merge(m, src)
}
func (m *EventTransfer) XXX_Size() int {
	return m.Size()
}
func (m *EventTransfer) XXX_DiscardUnknown() {
	xxx_messageInfo_EventTransfer.DiscardUnknown(m)
}

var xxx_messageInfo_EventTransfer proto.InternalMessageInfo

type EventTokenDeployed struct {
	Symbol       string  `protobuf:"bytes,1,opt,name=symbol,proto3" json:"symbol,omitempty"`
	TokenAddress Address `protobuf:"bytes,2,opt,name=token_address,json=tokenAddress,proto3,customtype=Address" json:"token_address"`
}

func (m *EventTokenDeployed) Reset()         { *m = EventTokenDeployed{} }
func (m *EventTokenDeployed) String() string { return proto.CompactTextString(m) }
func (*EventTokenDeployed) ProtoMessage()    {}
func (*EventTokenDeployed) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{6}
}
func (m *EventTokenDeployed) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventTokenDeployed) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventTokenDeployed.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 *EventTokenDeployed) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventTokenDeployed.Merge(m, src)
}
func (m *EventTokenDeployed) XXX_Size() int {
	return m.Size()
}
func (m *EventTokenDeployed) XXX_DiscardUnknown() {
	xxx_messageInfo_EventTokenDeployed.DiscardUnknown(m)
}

var xxx_messageInfo_EventTokenDeployed proto.InternalMessageInfo

// Deprecated: Do not use.
type EventMultisigOwnershipTransferred struct {
	PreOwners     []Address                               `protobuf:"bytes,1,rep,name=pre_owners,json=preOwners,proto3,customtype=Address" json:"pre_owners"`
	PrevThreshold github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,2,opt,name=prev_threshold,json=prevThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"prev_threshold"`
	NewOwners     []Address                               `protobuf:"bytes,3,rep,name=new_owners,json=newOwners,proto3,customtype=Address" json:"new_owners"`
	NewThreshold  github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,4,opt,name=new_threshold,json=newThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"new_threshold"`
}

func (m *EventMultisigOwnershipTransferred) Reset()         { *m = EventMultisigOwnershipTransferred{} }
func (m *EventMultisigOwnershipTransferred) String() string { return proto.CompactTextString(m) }
func (*EventMultisigOwnershipTransferred) ProtoMessage()    {}
func (*EventMultisigOwnershipTransferred) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{7}
}
func (m *EventMultisigOwnershipTransferred) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventMultisigOwnershipTransferred) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventMultisigOwnershipTransferred.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 *EventMultisigOwnershipTransferred) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventMultisigOwnershipTransferred.Merge(m, src)
}
func (m *EventMultisigOwnershipTransferred) XXX_Size() int {
	return m.Size()
}
func (m *EventMultisigOwnershipTransferred) XXX_DiscardUnknown() {
	xxx_messageInfo_EventMultisigOwnershipTransferred.DiscardUnknown(m)
}

var xxx_messageInfo_EventMultisigOwnershipTransferred proto.InternalMessageInfo

type EventMultisigOperatorshipTransferred struct {
	NewOperators []Address                                 `protobuf:"bytes,3,rep,name=new_operators,json=newOperators,proto3,customtype=Address" json:"new_operators"`
	NewThreshold github_com_cosmos_cosmos_sdk_types.Uint   `protobuf:"bytes,4,opt,name=new_threshold,json=newThreshold,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"new_threshold"`
	NewWeights   []github_com_cosmos_cosmos_sdk_types.Uint `protobuf:"bytes,5,rep,name=new_weights,json=newWeights,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"new_weights"`
}

func (m *EventMultisigOperatorshipTransferred) Reset()         { *m = EventMultisigOperatorshipTransferred{} }
func (m *EventMultisigOperatorshipTransferred) String() string { return proto.CompactTextString(m) }
func (*EventMultisigOperatorshipTransferred) ProtoMessage()    {}
func (*EventMultisigOperatorshipTransferred) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{8}
}
func (m *EventMultisigOperatorshipTransferred) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *EventMultisigOperatorshipTransferred) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_EventMultisigOperatorshipTransferred.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 *EventMultisigOperatorshipTransferred) XXX_Merge(src proto.Message) {
	xxx_messageInfo_EventMultisigOperatorshipTransferred.Merge(m, src)
}
func (m *EventMultisigOperatorshipTransferred) XXX_Size() int {
	return m.Size()
}
func (m *EventMultisigOperatorshipTransferred) XXX_DiscardUnknown() {
	xxx_messageInfo_EventMultisigOperatorshipTransferred.DiscardUnknown(m)
}

var xxx_messageInfo_EventMultisigOperatorshipTransferred proto.InternalMessageInfo

// NetworkInfo describes information about a network
type NetworkInfo struct {
	Name string                                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Id   github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=id,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"id"`
}

func (m *NetworkInfo) Reset()         { *m = NetworkInfo{} }
func (m *NetworkInfo) String() string { return proto.CompactTextString(m) }
func (*NetworkInfo) ProtoMessage()    {}
func (*NetworkInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{9}
}
func (m *NetworkInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NetworkInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NetworkInfo.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 *NetworkInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NetworkInfo.Merge(m, src)
}
func (m *NetworkInfo) XXX_Size() int {
	return m.Size()
}
func (m *NetworkInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_NetworkInfo.DiscardUnknown(m)
}

var xxx_messageInfo_NetworkInfo proto.InternalMessageInfo

// BurnerInfo describes information required to burn token at an burner address
// that is deposited by an user
type BurnerInfo struct {
	BurnerAddress    Address                                                         `protobuf:"bytes,1,opt,name=burner_address,json=burnerAddress,proto3,customtype=Address" json:"burner_address"`
	TokenAddress     Address                                                         `protobuf:"bytes,2,opt,name=token_address,json=tokenAddress,proto3,customtype=Address" json:"token_address"`
	DestinationChain github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,3,opt,name=destination_chain,json=destinationChain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"destination_chain,omitempty"`
	Symbol           string                                                          `protobuf:"bytes,4,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Asset            string                                                          `protobuf:"bytes,5,opt,name=asset,proto3" json:"asset,omitempty"`
	Salt             Hash                                                            `protobuf:"bytes,6,opt,name=salt,proto3,customtype=Hash" json:"salt"`
}

func (m *BurnerInfo) Reset()         { *m = BurnerInfo{} }
func (m *BurnerInfo) String() string { return proto.CompactTextString(m) }
func (*BurnerInfo) ProtoMessage()    {}
func (*BurnerInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{10}
}
func (m *BurnerInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *BurnerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_BurnerInfo.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 *BurnerInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BurnerInfo.Merge(m, src)
}
func (m *BurnerInfo) XXX_Size() int {
	return m.Size()
}
func (m *BurnerInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_BurnerInfo.DiscardUnknown(m)
}

var xxx_messageInfo_BurnerInfo proto.InternalMessageInfo

// ERC20Deposit contains information for an ERC20 deposit
type ERC20Deposit struct {
	TxID             Hash                                                            `protobuf:"bytes,1,opt,name=tx_id,json=txId,proto3,customtype=Hash" json:"tx_id"`
	Amount           github_com_cosmos_cosmos_sdk_types.Uint                         `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"amount"`
	Asset            string                                                          `protobuf:"bytes,3,opt,name=asset,proto3" json:"asset,omitempty"`
	DestinationChain github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,4,opt,name=destination_chain,json=destinationChain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"destination_chain,omitempty"`
	BurnerAddress    Address                                                         `protobuf:"bytes,5,opt,name=burner_address,json=burnerAddress,proto3,customtype=Address" json:"burner_address"`
	LogIndex         uint64                                                          `protobuf:"varint,6,opt,name=log_index,json=logIndex,proto3" json:"log_index,omitempty"`
}

func (m *ERC20Deposit) Reset()         { *m = ERC20Deposit{} }
func (m *ERC20Deposit) String() string { return proto.CompactTextString(m) }
func (*ERC20Deposit) ProtoMessage()    {}
func (*ERC20Deposit) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{11}
}
func (m *ERC20Deposit) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ERC20Deposit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ERC20Deposit.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 *ERC20Deposit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20Deposit.Merge(m, src)
}
func (m *ERC20Deposit) XXX_Size() int {
	return m.Size()
}
func (m *ERC20Deposit) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20Deposit.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20Deposit proto.InternalMessageInfo

// ERC20TokenMetadata describes information about an ERC20 token
type ERC20TokenMetadata struct {
	Asset        string                                 `protobuf:"bytes,1,opt,name=asset,proto3" json:"asset,omitempty"`
	ChainID      github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=chain_id,json=chainId,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"chain_id"`
	Details      TokenDetails                           `protobuf:"bytes,3,opt,name=details,proto3" json:"details"`
	TokenAddress Address                                `protobuf:"bytes,4,opt,name=token_address,json=tokenAddress,proto3,customtype=Address" json:"token_address"`
	TxHash       Hash                                   `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3,customtype=Hash" json:"tx_hash"`
	Status       Status                                 `protobuf:"varint,7,opt,name=status,proto3,enum=axelar.evm.v1beta1.Status" json:"status,omitempty"`
	IsExternal   bool                                   `protobuf:"varint,8,opt,name=is_external,json=isExternal,proto3" json:"is_external,omitempty"`
	BurnerCode   []byte                                 `protobuf:"bytes,9,opt,name=burner_code,json=burnerCode,proto3" json:"burner_code,omitempty"`
}

func (m *ERC20TokenMetadata) Reset()         { *m = ERC20TokenMetadata{} }
func (m *ERC20TokenMetadata) String() string { return proto.CompactTextString(m) }
func (*ERC20TokenMetadata) ProtoMessage()    {}
func (*ERC20TokenMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{12}
}
func (m *ERC20TokenMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ERC20TokenMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ERC20TokenMetadata.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 *ERC20TokenMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ERC20TokenMetadata.Merge(m, src)
}
func (m *ERC20TokenMetadata) XXX_Size() int {
	return m.Size()
}
func (m *ERC20TokenMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_ERC20TokenMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_ERC20TokenMetadata proto.InternalMessageInfo

type TransactionMetadata struct {
	RawTX  []byte `protobuf:"bytes,1,opt,name=raw_tx,json=rawTx,proto3" json:"raw_tx,omitempty"`
	PubKey []byte `protobuf:"bytes,2,opt,name=pub_key,json=pubKey,proto3" json:"pub_key,omitempty"`
}

func (m *TransactionMetadata) Reset()         { *m = TransactionMetadata{} }
func (m *TransactionMetadata) String() string { return proto.CompactTextString(m) }
func (*TransactionMetadata) ProtoMessage()    {}
func (*TransactionMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{13}
}
func (m *TransactionMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransactionMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransactionMetadata.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 *TransactionMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransactionMetadata.Merge(m, src)
}
func (m *TransactionMetadata) XXX_Size() int {
	return m.Size()
}
func (m *TransactionMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_TransactionMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_TransactionMetadata proto.InternalMessageInfo

type Command struct {
	ID         CommandID                                                      `protobuf:"bytes,1,opt,name=id,proto3,customtype=CommandID" json:"id"`
	Command    string                                                         `protobuf:"bytes,2,opt,name=command,proto3" json:"command,omitempty"` // Deprecated: Do not use.
	Params     []byte                                                         `protobuf:"bytes,3,opt,name=params,proto3" json:"params,omitempty"`
	KeyID      github_com_axelarnetwork_axelar_core_x_multisig_exported.KeyID `protobuf:"bytes,4,opt,name=key_id,json=keyId,proto3,casttype=github.com/axelarnetwork/axelar-core/x/multisig/exported.KeyID" json:"key_id,omitempty"`
	MaxGasCost uint32                                                         `protobuf:"varint,5,opt,name=max_gas_cost,json=maxGasCost,proto3" json:"max_gas_cost,omitempty"`
	Type       CommandType                                                    `protobuf:"varint,6,opt,name=type,proto3,enum=axelar.evm.v1beta1.CommandType" json:"type,omitempty"`
}

func (m *Command) Reset()         { *m = Command{} }
func (m *Command) String() string { return proto.CompactTextString(m) }
func (*Command) ProtoMessage()    {}
func (*Command) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{14}
}
func (m *Command) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Command) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Command.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 *Command) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Command.Merge(m, src)
}
func (m *Command) XXX_Size() int {
	return m.Size()
}
func (m *Command) XXX_DiscardUnknown() {
	xxx_messageInfo_Command.DiscardUnknown(m)
}

var xxx_messageInfo_Command proto.InternalMessageInfo

type CommandBatchMetadata struct {
	ID                    []byte                                                         `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CommandIDs            []CommandID                                                    `protobuf:"bytes,2,rep,name=command_ids,json=commandIds,proto3,customtype=CommandID" json:"command_ids"`
	Data                  []byte                                                         `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	SigHash               Hash                                                           `protobuf:"bytes,4,opt,name=sig_hash,json=sigHash,proto3,customtype=Hash" json:"sig_hash"`
	Status                BatchedCommandsStatus                                          `protobuf:"varint,5,opt,name=status,proto3,enum=axelar.evm.v1beta1.BatchedCommandsStatus" json:"status,omitempty"`
	KeyID                 github_com_axelarnetwork_axelar_core_x_multisig_exported.KeyID `protobuf:"bytes,6,opt,name=key_id,json=keyId,proto3,casttype=github.com/axelarnetwork/axelar-core/x/multisig/exported.KeyID" json:"key_id,omitempty"`
	PrevBatchedCommandsID []byte                                                         `protobuf:"bytes,7,opt,name=prev_batched_commands_id,json=prevBatchedCommandsId,proto3" json:"prev_batched_commands_id,omitempty"`
	Signature             *types.Any                                                     `protobuf:"bytes,8,opt,name=signature,proto3" json:"signature,omitempty"`
}

func (m *CommandBatchMetadata) Reset()         { *m = CommandBatchMetadata{} }
func (m *CommandBatchMetadata) String() string { return proto.CompactTextString(m) }
func (*CommandBatchMetadata) ProtoMessage()    {}
func (*CommandBatchMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{15}
}
func (m *CommandBatchMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CommandBatchMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CommandBatchMetadata.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 *CommandBatchMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CommandBatchMetadata.Merge(m, src)
}
func (m *CommandBatchMetadata) XXX_Size() int {
	return m.Size()
}
func (m *CommandBatchMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_CommandBatchMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_CommandBatchMetadata proto.InternalMessageInfo

// SigMetadata stores necessary information for external apps to map signature
// results to evm relay transaction types
type SigMetadata struct {
	Type           SigType                                                         `protobuf:"varint,1,opt,name=type,proto3,enum=axelar.evm.v1beta1.SigType" json:"type,omitempty"`
	Chain          github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,2,opt,name=chain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"chain,omitempty"`
	CommandBatchID []byte                                                          `protobuf:"bytes,3,opt,name=command_batch_id,json=commandBatchId,proto3" json:"command_batch_id,omitempty"`
}

func (m *SigMetadata) Reset()         { *m = SigMetadata{} }
func (m *SigMetadata) String() string { return proto.CompactTextString(m) }
func (*SigMetadata) ProtoMessage()    {}
func (*SigMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{16}
}
func (m *SigMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SigMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SigMetadata.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 *SigMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SigMetadata.Merge(m, src)
}
func (m *SigMetadata) XXX_Size() int {
	return m.Size()
}
func (m *SigMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_SigMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_SigMetadata proto.InternalMessageInfo

// TransferKey contains information for a transfer operatorship
type TransferKey struct {
	TxID      Hash                                                           `protobuf:"bytes,1,opt,name=tx_id,json=txId,proto3,customtype=Hash" json:"tx_id"`
	NextKeyID github_com_axelarnetwork_axelar_core_x_multisig_exported.KeyID `protobuf:"bytes,3,opt,name=next_key_id,json=nextKeyId,proto3,casttype=github.com/axelarnetwork/axelar-core/x/multisig/exported.KeyID" json:"next_key_id,omitempty"`
}

func (m *TransferKey) Reset()         { *m = TransferKey{} }
func (m *TransferKey) String() string { return proto.CompactTextString(m) }
func (*TransferKey) ProtoMessage()    {}
func (*TransferKey) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{17}
}
func (m *TransferKey) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TransferKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TransferKey.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 *TransferKey) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransferKey.Merge(m, src)
}
func (m *TransferKey) XXX_Size() int {
	return m.Size()
}
func (m *TransferKey) XXX_DiscardUnknown() {
	xxx_messageInfo_TransferKey.DiscardUnknown(m)
}

var xxx_messageInfo_TransferKey proto.InternalMessageInfo

type Asset struct {
	Chain github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,1,opt,name=chain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"chain,omitempty"`
	Name  string                                                          `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
}

func (m *Asset) Reset()         { *m = Asset{} }
func (m *Asset) String() string { return proto.CompactTextString(m) }
func (*Asset) ProtoMessage()    {}
func (*Asset) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{18}
}
func (m *Asset) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Asset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Asset.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 *Asset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Asset.Merge(m, src)
}
func (m *Asset) XXX_Size() int {
	return m.Size()
}
func (m *Asset) XXX_DiscardUnknown() {
	xxx_messageInfo_Asset.DiscardUnknown(m)
}

var xxx_messageInfo_Asset proto.InternalMessageInfo

type TokenDetails struct {
	TokenName string                                 `protobuf:"bytes,1,opt,name=token_name,json=tokenName,proto3" json:"token_name,omitempty"`
	Symbol    string                                 `protobuf:"bytes,2,opt,name=symbol,proto3" json:"symbol,omitempty"`
	Decimals  uint8                                  `protobuf:"varint,3,opt,name=decimals,proto3,casttype=uint8" json:"decimals,omitempty"`
	Capacity  github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=capacity,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"capacity"`
}

func (m *TokenDetails) Reset()         { *m = TokenDetails{} }
func (m *TokenDetails) String() string { return proto.CompactTextString(m) }
func (*TokenDetails) ProtoMessage()    {}
func (*TokenDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{19}
}
func (m *TokenDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TokenDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TokenDetails.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 *TokenDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TokenDetails.Merge(m, src)
}
func (m *TokenDetails) XXX_Size() int {
	return m.Size()
}
func (m *TokenDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_TokenDetails.DiscardUnknown(m)
}

var xxx_messageInfo_TokenDetails proto.InternalMessageInfo

type Gateway struct {
	Address Address `protobuf:"bytes,1,opt,name=address,proto3,customtype=Address" json:"address"`
}

func (m *Gateway) Reset()         { *m = Gateway{} }
func (m *Gateway) String() string { return proto.CompactTextString(m) }
func (*Gateway) ProtoMessage()    {}
func (*Gateway) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{20}
}
func (m *Gateway) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Gateway) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Gateway.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 *Gateway) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Gateway.Merge(m, src)
}
func (m *Gateway) XXX_Size() int {
	return m.Size()
}
func (m *Gateway) XXX_DiscardUnknown() {
	xxx_messageInfo_Gateway.DiscardUnknown(m)
}

var xxx_messageInfo_Gateway proto.InternalMessageInfo

type PollMetadata struct {
	Chain github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName `protobuf:"bytes,1,opt,name=chain,proto3,casttype=github.com/axelarnetwork/axelar-core/x/nexus/exported.ChainName" json:"chain,omitempty"`
	TxID  Hash                                                            `protobuf:"bytes,2,opt,name=tx_id,json=txId,proto3,customtype=Hash" json:"tx_id"`
}

func (m *PollMetadata) Reset()         { *m = PollMetadata{} }
func (m *PollMetadata) String() string { return proto.CompactTextString(m) }
func (*PollMetadata) ProtoMessage()    {}
func (*PollMetadata) Descriptor() ([]byte, []int) {
	return fileDescriptor_ea224848ef0a2f28, []int{21}
}
func (m *PollMetadata) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PollMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PollMetadata.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 *PollMetadata) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PollMetadata.Merge(m, src)
}
func (m *PollMetadata) XXX_Size() int {
	return m.Size()
}
func (m *PollMetadata) XXX_DiscardUnknown() {
	xxx_messageInfo_PollMetadata.DiscardUnknown(m)
}

var xxx_messageInfo_PollMetadata proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("axelar.evm.v1beta1.Status", Status_name, Status_value)
	proto.RegisterEnum("axelar.evm.v1beta1.CommandType", CommandType_name, CommandType_value)
	proto.RegisterEnum("axelar.evm.v1beta1.BatchedCommandsStatus", BatchedCommandsStatus_name, BatchedCommandsStatus_value)
	proto.RegisterEnum("axelar.evm.v1beta1.SigType", SigType_name, SigType_value)
	proto.RegisterEnum("axelar.evm.v1beta1.DepositStatus", DepositStatus_name, DepositStatus_value)
	proto.RegisterEnum("axelar.evm.v1beta1.Event_Status", Event_Status_name, Event_Status_value)
	proto.RegisterType((*VoteEvents)(nil), "axelar.evm.v1beta1.VoteEvents")
	proto.RegisterType((*Event)(nil), "axelar.evm.v1beta1.Event")
	proto.RegisterType((*EventTokenSent)(nil), "axelar.evm.v1beta1.EventTokenSent")
	proto.RegisterType((*EventContractCall)(nil), "axelar.evm.v1beta1.EventContractCall")
	proto.RegisterType((*EventContractCallWithToken)(nil), "axelar.evm.v1beta1.EventContractCallWithToken")
	proto.RegisterType((*EventTransfer)(nil), "axelar.evm.v1beta1.EventTransfer")
	proto.RegisterType((*EventTokenDeployed)(nil), "axelar.evm.v1beta1.EventTokenDeployed")
	proto.RegisterType((*EventMultisigOwnershipTransferred)(nil), "axelar.evm.v1beta1.EventMultisigOwnershipTransferred")
	proto.RegisterType((*EventMultisigOperatorshipTransferred)(nil), "axelar.evm.v1beta1.EventMultisigOperatorshipTransferred")
	proto.RegisterType((*NetworkInfo)(nil), "axelar.evm.v1beta1.NetworkInfo")
	proto.RegisterType((*BurnerInfo)(nil), "axelar.evm.v1beta1.BurnerInfo")
	proto.RegisterType((*ERC20Deposit)(nil), "axelar.evm.v1beta1.ERC20Deposit")
	proto.RegisterType((*ERC20TokenMetadata)(nil), "axelar.evm.v1beta1.ERC20TokenMetadata")
	proto.RegisterType((*TransactionMetadata)(nil), "axelar.evm.v1beta1.TransactionMetadata")
	proto.RegisterType((*Command)(nil), "axelar.evm.v1beta1.Command")
	proto.RegisterType((*CommandBatchMetadata)(nil), "axelar.evm.v1beta1.CommandBatchMetadata")
	proto.RegisterType((*SigMetadata)(nil), "axelar.evm.v1beta1.SigMetadata")
	proto.RegisterType((*TransferKey)(nil), "axelar.evm.v1beta1.TransferKey")
	proto.RegisterType((*Asset)(nil), "axelar.evm.v1beta1.Asset")
	proto.RegisterType((*TokenDetails)(nil), "axelar.evm.v1beta1.TokenDetails")
	proto.RegisterType((*Gateway)(nil), "axelar.evm.v1beta1.Gateway")
	proto.RegisterType((*PollMetadata)(nil), "axelar.evm.v1beta1.PollMetadata")
}

func init() { proto.RegisterFile("axelar/evm/v1beta1/types.proto", fileDescriptor_ea224848ef0a2f28) }

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

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

func (m *VoteEvents) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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 = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0xa
	}
	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.Event != nil {
		{
			size := m.Event.Size()
			i -= size
			if _, err := m.Event.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if m.Status != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if m.Index != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.TxID.Size()
		i -= size
		if _, err := m.TxID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Event_TokenSent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TokenSent != nil {
		{
			size, err := m.TokenSent.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	return len(dAtA) - i, nil
}
func (m *Event_ContractCall) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event_ContractCall) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ContractCall != nil {
		{
			size, err := m.ContractCall.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *Event_ContractCallWithToken) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event_ContractCallWithToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.ContractCallWithToken != nil {
		{
			size, err := m.ContractCallWithToken.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	return len(dAtA) - i, nil
}
func (m *Event_Transfer) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event_Transfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Transfer != nil {
		{
			size, err := m.Transfer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	return len(dAtA) - i, nil
}
func (m *Event_TokenDeployed) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event_TokenDeployed) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.TokenDeployed != nil {
		{
			size, err := m.TokenDeployed.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	return len(dAtA) - i, nil
}
func (m *Event_MultisigOwnershipTransferred) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event_MultisigOwnershipTransferred) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MultisigOwnershipTransferred != nil {
		{
			size, err := m.MultisigOwnershipTransferred.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *Event_MultisigOperatorshipTransferred) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Event_MultisigOperatorshipTransferred) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.MultisigOperatorshipTransferred != nil {
		{
			size, err := m.MultisigOperatorshipTransferred.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	return len(dAtA) - i, nil
}
func (m *EventTokenSent) 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 *EventTokenSent) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EventTokenSent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DestinationAddress) > 0 {
		i -= len(m.DestinationAddress)
		copy(dAtA[i:], m.DestinationAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DestinationAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DestinationChain) > 0 {
		i -= len(m.DestinationChain)
		copy(dAtA[i:], m.DestinationChain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DestinationChain)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Sender.Size()
		i -= size
		if _, err := m.Sender.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EventContractCall) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.PayloadHash.Size()
		i -= size
		if _, err := m.PayloadHash.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.ContractAddress) > 0 {
		i -= len(m.ContractAddress)
		copy(dAtA[i:], m.ContractAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ContractAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DestinationChain) > 0 {
		i -= len(m.DestinationChain)
		copy(dAtA[i:], m.DestinationChain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DestinationChain)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Sender.Size()
		i -= size
		if _, err := m.Sender.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EventContractCallWithToken) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0x2a
	}
	{
		size := m.PayloadHash.Size()
		i -= size
		if _, err := m.PayloadHash.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.ContractAddress) > 0 {
		i -= len(m.ContractAddress)
		copy(dAtA[i:], m.ContractAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ContractAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DestinationChain) > 0 {
		i -= len(m.DestinationChain)
		copy(dAtA[i:], m.DestinationChain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DestinationChain)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.Sender.Size()
		i -= size
		if _, err := m.Sender.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EventTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.To.Size()
		i -= size
		if _, err := m.To.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *EventMultisigOwnershipTransferred) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.NewThreshold.Size()
		i -= size
		if _, err := m.NewThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.NewOwners) > 0 {
		for iNdEx := len(m.NewOwners) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.NewOwners[iNdEx].Size()
				i -= size
				if _, err := m.NewOwners[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size := m.PrevThreshold.Size()
		i -= size
		if _, err := m.PrevThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.PreOwners) > 0 {
		for iNdEx := len(m.PreOwners) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.PreOwners[iNdEx].Size()
				i -= size
				if _, err := m.PreOwners[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *EventMultisigOperatorshipTransferred) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NewWeights) > 0 {
		for iNdEx := len(m.NewWeights) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.NewWeights[iNdEx].Size()
				i -= size
				if _, err := m.NewWeights[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	{
		size := m.NewThreshold.Size()
		i -= size
		if _, err := m.NewThreshold.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.NewOperators) > 0 {
		for iNdEx := len(m.NewOperators) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.NewOperators[iNdEx].Size()
				i -= size
				if _, err := m.NewOperators[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *BurnerInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Salt.Size()
		i -= size
		if _, err := m.Salt.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if len(m.Asset) > 0 {
		i -= len(m.Asset)
		copy(dAtA[i:], m.Asset)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Asset)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.DestinationChain) > 0 {
		i -= len(m.DestinationChain)
		copy(dAtA[i:], m.DestinationChain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DestinationChain)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.TokenAddress.Size()
		i -= size
		if _, err := m.TokenAddress.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.BurnerAddress.Size()
		i -= size
		if _, err := m.BurnerAddress.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ERC20Deposit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.LogIndex != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.LogIndex))
		i--
		dAtA[i] = 0x30
	}
	{
		size := m.BurnerAddress.Size()
		i -= size
		if _, err := m.BurnerAddress.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.DestinationChain) > 0 {
		i -= len(m.DestinationChain)
		copy(dAtA[i:], m.DestinationChain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.DestinationChain)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Asset) > 0 {
		i -= len(m.Asset)
		copy(dAtA[i:], m.Asset)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Asset)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size := m.TxID.Size()
		i -= size
		if _, err := m.TxID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ERC20TokenMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BurnerCode) > 0 {
		i -= len(m.BurnerCode)
		copy(dAtA[i:], m.BurnerCode)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.BurnerCode)))
		i--
		dAtA[i] = 0x4a
	}
	if m.IsExternal {
		i--
		if m.IsExternal {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x40
	}
	if m.Status != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x38
	}
	{
		size := m.TxHash.Size()
		i -= size
		if _, err := m.TxHash.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.TokenAddress.Size()
		i -= size
		if _, err := m.TokenAddress.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size := m.ChainID.Size()
		i -= size
		if _, err := m.ChainID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Asset) > 0 {
		i -= len(m.Asset)
		copy(dAtA[i:], m.Asset)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Asset)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TransactionMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.PubKey) > 0 {
		i -= len(m.PubKey)
		copy(dAtA[i:], m.PubKey)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.PubKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RawTX) > 0 {
		i -= len(m.RawTX)
		copy(dAtA[i:], m.RawTX)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.RawTX)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Command) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Type != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x30
	}
	if m.MaxGasCost != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.MaxGasCost))
		i--
		dAtA[i] = 0x28
	}
	if len(m.KeyID) > 0 {
		i -= len(m.KeyID)
		copy(dAtA[i:], m.KeyID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.KeyID)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Params) > 0 {
		i -= len(m.Params)
		copy(dAtA[i:], m.Params)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Params)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Command) > 0 {
		i -= len(m.Command)
		copy(dAtA[i:], m.Command)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Command)))
		i--
		dAtA[i] = 0x12
	}
	{
		size := m.ID.Size()
		i -= size
		if _, err := m.ID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *CommandBatchMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Signature != nil {
		{
			size, err := m.Signature.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.PrevBatchedCommandsID) > 0 {
		i -= len(m.PrevBatchedCommandsID)
		copy(dAtA[i:], m.PrevBatchedCommandsID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.PrevBatchedCommandsID)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.KeyID) > 0 {
		i -= len(m.KeyID)
		copy(dAtA[i:], m.KeyID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.KeyID)))
		i--
		dAtA[i] = 0x32
	}
	if m.Status != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x28
	}
	{
		size := m.SigHash.Size()
		i -= size
		if _, err := m.SigHash.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Data) > 0 {
		i -= len(m.Data)
		copy(dAtA[i:], m.Data)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Data)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.CommandIDs) > 0 {
		for iNdEx := len(m.CommandIDs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size := m.CommandIDs[iNdEx].Size()
				i -= size
				if _, err := m.CommandIDs[iNdEx].MarshalTo(dAtA[i:]); err != nil {
					return 0, err
				}
				i = encodeVarintTypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SigMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CommandBatchID) > 0 {
		i -= len(m.CommandBatchID)
		copy(dAtA[i:], m.CommandBatchID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.CommandBatchID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TransferKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NextKeyID) > 0 {
		i -= len(m.NextKeyID)
		copy(dAtA[i:], m.NextKeyID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.NextKeyID)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size := m.TxID.Size()
		i -= size
		if _, err := m.TxID.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Asset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Chain) > 0 {
		i -= len(m.Chain)
		copy(dAtA[i:], m.Chain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Chain)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TokenDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.Capacity.Size()
		i -= size
		if _, err := m.Capacity.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.Decimals != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Decimals))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Symbol) > 0 {
		i -= len(m.Symbol)
		copy(dAtA[i:], m.Symbol)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Symbol)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.TokenName) > 0 {
		i -= len(m.TokenName)
		copy(dAtA[i:], m.TokenName)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.TokenName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *Event) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.TxID.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.Index != 0 {
		n += 1 + sovTypes(uint64(m.Index))
	}
	if m.Status != 0 {
		n += 1 + sovTypes(uint64(m.Status))
	}
	if m.Event != nil {
		n += m.Event.Size()
	}
	return n
}

func (m *Event_TokenSent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TokenSent != nil {
		l = m.TokenSent.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Event_ContractCall) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContractCall != nil {
		l = m.ContractCall.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Event_ContractCallWithToken) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ContractCallWithToken != nil {
		l = m.ContractCallWithToken.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Event_Transfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Transfer != nil {
		l = m.Transfer.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Event_TokenDeployed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TokenDeployed != nil {
		l = m.TokenDeployed.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Event_MultisigOwnershipTransferred) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MultisigOwnershipTransferred != nil {
		l = m.MultisigOwnershipTransferred.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *Event_MultisigOperatorshipTransferred) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MultisigOperatorshipTransferred != nil {
		l = m.MultisigOperatorshipTransferred.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}
func (m *EventTokenSent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Sender.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.DestinationChain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.DestinationAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *EventContractCall) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Sender.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.DestinationChain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.PayloadHash.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *EventContractCallWithToken) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Sender.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.DestinationChain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ContractAddress)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.PayloadHash.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *EventTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.To.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Amount.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *EventTokenDeployed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.TokenAddress.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *EventMultisigOwnershipTransferred) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.PreOwners) > 0 {
		for _, e := range m.PreOwners {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	l = m.PrevThreshold.Size()
	n += 1 + l + sovTypes(uint64(l))
	if len(m.NewOwners) > 0 {
		for _, e := range m.NewOwners {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	l = m.NewThreshold.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *EventMultisigOperatorshipTransferred) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.NewOperators) > 0 {
		for _, e := range m.NewOperators {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	l = m.NewThreshold.Size()
	n += 1 + l + sovTypes(uint64(l))
	if len(m.NewWeights) > 0 {
		for _, e := range m.NewWeights {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	return n
}

func (m *NetworkInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Id.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *BurnerInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BurnerAddress.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.TokenAddress.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.DestinationChain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Asset)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.Salt.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *ERC20Deposit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TxID.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Amount.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.Asset)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.DestinationChain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.BurnerAddress.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.LogIndex != 0 {
		n += 1 + sovTypes(uint64(m.LogIndex))
	}
	return n
}

func (m *ERC20TokenMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Asset)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.ChainID.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Details.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.TokenAddress.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.TxHash.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.Status != 0 {
		n += 1 + sovTypes(uint64(m.Status))
	}
	if m.IsExternal {
		n += 2
	}
	l = len(m.BurnerCode)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *TransactionMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RawTX)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.PubKey)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *Command) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ID.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.Command)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Params)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.KeyID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.MaxGasCost != 0 {
		n += 1 + sovTypes(uint64(m.MaxGasCost))
	}
	if m.Type != 0 {
		n += 1 + sovTypes(uint64(m.Type))
	}
	return n
}

func (m *CommandBatchMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if len(m.CommandIDs) > 0 {
		for _, e := range m.CommandIDs {
			l = e.Size()
			n += 1 + l + sovTypes(uint64(l))
		}
	}
	l = len(m.Data)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.SigHash.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.Status != 0 {
		n += 1 + sovTypes(uint64(m.Status))
	}
	l = len(m.KeyID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.PrevBatchedCommandsID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Signature != nil {
		l = m.Signature.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *SigMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovTypes(uint64(m.Type))
	}
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.CommandBatchID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *TransferKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TxID.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.NextKeyID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *Asset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

func (m *TokenDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TokenName)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.Symbol)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Decimals != 0 {
		n += 1 + sovTypes(uint64(m.Decimals))
	}
	l = m.Capacity.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *Gateway) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Address.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func (m *PollMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Chain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.TxID.Size()
	n += 1 + l + sovTypes(uint64(l))
	return n
}

func sovTypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTypes(x uint64) (n int) {
	return sovTypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *VoteEvents) 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 ErrIntOverflowTypes
			}
			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: VoteEvents: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VoteEvents: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			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 ErrIntOverflowTypes
			}
			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 Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= Event_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenSent", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventTokenSent{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_TokenSent{v}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractCall", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventContractCall{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_ContractCall{v}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractCallWithToken", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventContractCallWithToken{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_ContractCallWithToken{v}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Transfer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventTransfer{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_Transfer{v}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenDeployed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventTokenDeployed{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_TokenDeployed{v}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultisigOwnershipTransferred", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventMultisigOwnershipTransferred{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_MultisigOwnershipTransferred{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MultisigOperatorshipTransferred", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &EventMultisigOperatorshipTransferred{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Event = &Event_MultisigOperatorshipTransferred{v}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventTokenSent) 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 ErrIntOverflowTypes
			}
			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: EventTokenSent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTokenSent: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Sender.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventContractCall) 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 ErrIntOverflowTypes
			}
			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: EventContractCall: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventContractCall: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Sender.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PayloadHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventContractCallWithToken) 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 ErrIntOverflowTypes
			}
			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: EventContractCallWithToken: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventContractCallWithToken: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Sender.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PayloadHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventTransfer) 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 ErrIntOverflowTypes
			}
			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: EventTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMultisigOwnershipTransferred) 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 ErrIntOverflowTypes
			}
			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: EventMultisigOwnershipTransferred: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventMultisigOwnershipTransferred: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PreOwners", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v Address
			m.PreOwners = append(m.PreOwners, v)
			if err := m.PreOwners[len(m.PreOwners)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevThreshold", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.PrevThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewOwners", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v Address
			m.NewOwners = append(m.NewOwners, v)
			if err := m.NewOwners[len(m.NewOwners)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewThreshold", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NewThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *EventMultisigOperatorshipTransferred) 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 ErrIntOverflowTypes
			}
			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: EventMultisigOperatorshipTransferred: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EventMultisigOperatorshipTransferred: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewOperators", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v Address
			m.NewOperators = append(m.NewOperators, v)
			if err := m.NewOperators[len(m.NewOperators)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewThreshold", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.NewThreshold.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewWeights", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_cosmos_cosmos_sdk_types.Uint
			m.NewWeights = append(m.NewWeights, v)
			if err := m.NewWeights[len(m.NewWeights)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *BurnerInfo) 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 ErrIntOverflowTypes
			}
			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: BurnerInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BurnerInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BurnerAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BurnerAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TokenAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Asset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Salt", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Salt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ERC20Deposit) 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 ErrIntOverflowTypes
			}
			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: ERC20Deposit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20Deposit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Asset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BurnerAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BurnerAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogIndex", wireType)
			}
			m.LogIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ERC20TokenMetadata) 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 ErrIntOverflowTypes
			}
			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: ERC20TokenMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ERC20TokenMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Asset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChainID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ChainID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TokenAddress.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxHash", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsExternal", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.IsExternal = bool(v != 0)
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BurnerCode", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BurnerCode = append(m.BurnerCode[:0], dAtA[iNdEx:postIndex]...)
			if m.BurnerCode == nil {
				m.BurnerCode = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionMetadata) 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 ErrIntOverflowTypes
			}
			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: TransactionMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RawTX", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RawTX = append(m.RawTX[:0], dAtA[iNdEx:postIndex]...)
			if m.RawTX == nil {
				m.RawTX = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PubKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PubKey = append(m.PubKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PubKey == nil {
				m.PubKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Command) 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 ErrIntOverflowTypes
			}
			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: Command: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Command: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Command = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Params = append(m.Params[:0], dAtA[iNdEx:postIndex]...)
			if m.Params == nil {
				m.Params = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyID = github_com_axelarnetwork_axelar_core_x_multisig_exported.KeyID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxGasCost", wireType)
			}
			m.MaxGasCost = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxGasCost |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= CommandType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CommandBatchMetadata) 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 ErrIntOverflowTypes
			}
			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: CommandBatchMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommandBatchMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = append(m.ID[:0], dAtA[iNdEx:postIndex]...)
			if m.ID == nil {
				m.ID = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommandIDs", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v CommandID
			m.CommandIDs = append(m.CommandIDs, v)
			if err := m.CommandIDs[len(m.CommandIDs)-1].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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
			if m.Data == nil {
				m.Data = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigHash", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SigHash.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= BatchedCommandsStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KeyID = github_com_axelarnetwork_axelar_core_x_multisig_exported.KeyID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PrevBatchedCommandsID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PrevBatchedCommandsID = append(m.PrevBatchedCommandsID[:0], dAtA[iNdEx:postIndex]...)
			if m.PrevBatchedCommandsID == nil {
				m.PrevBatchedCommandsID = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signature", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Signature == nil {
				m.Signature = &types.Any{}
			}
			if err := m.Signature.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SigMetadata) 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 ErrIntOverflowTypes
			}
			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: SigMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SigMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= SigType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CommandBatchID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CommandBatchID = append(m.CommandBatchID[:0], dAtA[iNdEx:postIndex]...)
			if m.CommandBatchID == nil {
				m.CommandBatchID = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TokenDetails) 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 ErrIntOverflowTypes
			}
			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: TokenDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TokenDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TokenName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Symbol", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Symbol = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Decimals", wireType)
			}
			m.Decimals = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Decimals |= uint8(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Capacity.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Gateway) 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 ErrIntOverflowTypes
			}
			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: Gateway: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Gateway: 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 ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			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 := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PollMetadata) 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 ErrIntOverflowTypes
			}
			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: PollMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PollMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Chain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				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 ErrInvalidLengthTypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Chain = github_com_axelarnetwork_axelar_core_x_nexus_exported.ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxID", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTypes = fmt.Errorf("proto: unexpected end of group")
)