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

package exported

import (
	fmt "fmt"
	exported "github.com/axelarnetwork/axelar-core/x/tss/exported"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/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 TransferState int32

const (
	TRANSFER_STATE_UNSPECIFIED TransferState = 0
	Pending                    TransferState = 1
	Archived                   TransferState = 2
	InsufficientAmount         TransferState = 3
	TransferFailed             TransferState = 4
)

var TransferState_name = map[int32]string{
	0: "TRANSFER_STATE_UNSPECIFIED",
	1: "TRANSFER_STATE_PENDING",
	2: "TRANSFER_STATE_ARCHIVED",
	3: "TRANSFER_STATE_INSUFFICIENT_AMOUNT",
	4: "TRANSFER_STATE_FAILED",
}

var TransferState_value = map[string]int32{
	"TRANSFER_STATE_UNSPECIFIED":         0,
	"TRANSFER_STATE_PENDING":             1,
	"TRANSFER_STATE_ARCHIVED":            2,
	"TRANSFER_STATE_INSUFFICIENT_AMOUNT": 3,
	"TRANSFER_STATE_FAILED":              4,
}

func (x TransferState) String() string {
	return proto.EnumName(TransferState_name, int32(x))
}

func (TransferState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_82a7a8692925fe67, []int{0}
}

type TransferDirection int32

const (
	Unspecified           TransferDirection = 0
	TransferDirectionFrom TransferDirection = 1
	TransferDirectionTo   TransferDirection = 2
)

var TransferDirection_name = map[int32]string{
	0: "TRANSFER_DIRECTION_UNSPECIFIED",
	1: "TRANSFER_DIRECTION_FROM",
	2: "TRANSFER_DIRECTION_TO",
}

var TransferDirection_value = map[string]int32{
	"TRANSFER_DIRECTION_UNSPECIFIED": 0,
	"TRANSFER_DIRECTION_FROM":        1,
	"TRANSFER_DIRECTION_TO":          2,
}

func (x TransferDirection) String() string {
	return proto.EnumName(TransferDirection_name, int32(x))
}

func (TransferDirection) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_82a7a8692925fe67, []int{1}
}

type GeneralMessage_Status int32

const (
	NonExistent GeneralMessage_Status = 0
	Approved    GeneralMessage_Status = 1
	Processing  GeneralMessage_Status = 2
	Executed    GeneralMessage_Status = 3
	Failed      GeneralMessage_Status = 4
)

var GeneralMessage_Status_name = map[int32]string{
	0: "STATUS_UNSPECIFIED",
	1: "STATUS_APPROVED",
	2: "STATUS_PROCESSING",
	3: "STATUS_EXECUTED",
	4: "STATUS_FAILED",
}

var GeneralMessage_Status_value = map[string]int32{
	"STATUS_UNSPECIFIED": 0,
	"STATUS_APPROVED":    1,
	"STATUS_PROCESSING":  2,
	"STATUS_EXECUTED":    3,
	"STATUS_FAILED":      4,
}

func (x GeneralMessage_Status) String() string {
	return proto.EnumName(GeneralMessage_Status_name, int32(x))
}

func (GeneralMessage_Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_82a7a8692925fe67, []int{6, 0}
}

// Chain represents the properties of a registered blockchain
type Chain struct {
	Name                  ChainName        `protobuf:"bytes,1,opt,name=name,proto3,casttype=ChainName" json:"name,omitempty"`
	SupportsForeignAssets bool             `protobuf:"varint,3,opt,name=supports_foreign_assets,json=supportsForeignAssets,proto3" json:"supports_foreign_assets,omitempty"`
	KeyType               exported.KeyType `protobuf:"varint,4,opt,name=key_type,json=keyType,proto3,enum=axelar.tss.exported.v1beta1.KeyType" json:"key_type,omitempty"`
	Module                string           `protobuf:"bytes,5,opt,name=module,proto3" json:"module,omitempty"`
}

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

var xxx_messageInfo_Chain proto.InternalMessageInfo

// CrossChainAddress represents a generalized address on any registered chain
type CrossChainAddress struct {
	Chain   Chain  `protobuf:"bytes,1,opt,name=chain,proto3" json:"chain"`
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

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

var xxx_messageInfo_CrossChainAddress proto.InternalMessageInfo

// CrossChainTransfer represents a generalized transfer of some asset to a
// registered blockchain
type CrossChainTransfer struct {
	Recipient CrossChainAddress `protobuf:"bytes,1,opt,name=recipient,proto3" json:"recipient"`
	Asset     types.Coin        `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset"`
	ID        TransferID        `protobuf:"varint,3,opt,name=id,proto3,casttype=TransferID" json:"id,omitempty"`
	State     TransferState     `protobuf:"varint,4,opt,name=state,proto3,enum=axelar.nexus.exported.v1beta1.TransferState" json:"state,omitempty"`
}

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

var xxx_messageInfo_CrossChainTransfer proto.InternalMessageInfo

// TransferFee represents accumulated fees generated by the network
type TransferFee struct {
	Coins github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=coins,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"coins"`
}

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

var xxx_messageInfo_TransferFee proto.InternalMessageInfo

type FeeInfo struct {
	Chain   ChainName                              `protobuf:"bytes,1,opt,name=chain,proto3,casttype=ChainName" json:"chain,omitempty"`
	Asset   string                                 `protobuf:"bytes,2,opt,name=asset,proto3" json:"asset,omitempty"`
	FeeRate github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,3,opt,name=fee_rate,json=feeRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"fee_rate"`
	MinFee  github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,4,opt,name=min_fee,json=minFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"min_fee"`
	MaxFee  github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,5,opt,name=max_fee,json=maxFee,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"max_fee"`
}

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

var xxx_messageInfo_FeeInfo proto.InternalMessageInfo

type Asset struct {
	Denom         string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"`
	IsNativeAsset bool   `protobuf:"varint,3,opt,name=is_native_asset,json=isNativeAsset,proto3" json:"is_native_asset,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_82a7a8692925fe67, []int{5}
}
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 GeneralMessage struct {
	ID            string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Sender        CrossChainAddress     `protobuf:"bytes,2,opt,name=sender,proto3" json:"sender"`
	Recipient     CrossChainAddress     `protobuf:"bytes,3,opt,name=recipient,proto3" json:"recipient"`
	PayloadHash   []byte                `protobuf:"bytes,4,opt,name=payload_hash,json=payloadHash,proto3" json:"payload_hash,omitempty"`
	Status        GeneralMessage_Status `protobuf:"varint,5,opt,name=status,proto3,enum=axelar.nexus.exported.v1beta1.GeneralMessage_Status" json:"status,omitempty"`
	Asset         *types.Coin           `protobuf:"bytes,6,opt,name=asset,proto3" json:"asset,omitempty"`
	SourceTxID    []byte                `protobuf:"bytes,7,opt,name=source_tx_id,json=sourceTxId,proto3" json:"source_tx_id,omitempty"`
	SourceTxIndex uint64                `protobuf:"varint,8,opt,name=source_tx_index,json=sourceTxIndex,proto3" json:"source_tx_index,omitempty"`
}

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

var xxx_messageInfo_GeneralMessage proto.InternalMessageInfo

type WasmMessage struct {
	SourceChain        ChainName                                     `protobuf:"bytes,1,opt,name=source_chain,json=sourceChain,proto3,casttype=ChainName" json:"source_chain,omitempty"`
	SourceAddress      string                                        `protobuf:"bytes,2,opt,name=source_address,json=sourceAddress,proto3" json:"source_address,omitempty"`
	DestinationChain   ChainName                                     `protobuf:"bytes,3,opt,name=destination_chain,json=destinationChain,proto3,casttype=ChainName" json:"destination_chain,omitempty"`
	DestinationAddress string                                        `protobuf:"bytes,4,opt,name=destination_address,json=destinationAddress,proto3" json:"destination_address,omitempty"`
	PayloadHash        WasmBytes                                     `protobuf:"bytes,5,opt,name=payload_hash,json=payloadHash,proto3,casttype=WasmBytes" json:"payload_hash,omitempty"`
	SourceTxID         WasmBytes                                     `protobuf:"bytes,6,opt,name=source_tx_id,json=sourceTxId,proto3,casttype=WasmBytes" json:"source_tx_id,omitempty"`
	SourceTxIndex      uint64                                        `protobuf:"varint,7,opt,name=source_tx_index,json=sourceTxIndex,proto3" json:"source_tx_index"`
	Sender             github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,8,opt,name=sender,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"sender,omitempty"`
	ID                 string                                        `protobuf:"bytes,9,opt,name=id,proto3" json:"id,omitempty"`
}

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

var xxx_messageInfo_WasmMessage proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("axelar.nexus.exported.v1beta1.TransferState", TransferState_name, TransferState_value)
	proto.RegisterEnum("axelar.nexus.exported.v1beta1.TransferDirection", TransferDirection_name, TransferDirection_value)
	proto.RegisterEnum("axelar.nexus.exported.v1beta1.GeneralMessage_Status", GeneralMessage_Status_name, GeneralMessage_Status_value)
	proto.RegisterType((*Chain)(nil), "axelar.nexus.exported.v1beta1.Chain")
	proto.RegisterType((*CrossChainAddress)(nil), "axelar.nexus.exported.v1beta1.CrossChainAddress")
	proto.RegisterType((*CrossChainTransfer)(nil), "axelar.nexus.exported.v1beta1.CrossChainTransfer")
	proto.RegisterType((*TransferFee)(nil), "axelar.nexus.exported.v1beta1.TransferFee")
	proto.RegisterType((*FeeInfo)(nil), "axelar.nexus.exported.v1beta1.FeeInfo")
	proto.RegisterType((*Asset)(nil), "axelar.nexus.exported.v1beta1.Asset")
	proto.RegisterType((*GeneralMessage)(nil), "axelar.nexus.exported.v1beta1.GeneralMessage")
	proto.RegisterType((*WasmMessage)(nil), "axelar.nexus.exported.v1beta1.WasmMessage")
}

func init() {
	proto.RegisterFile("axelar/nexus/exported/v1beta1/types.proto", fileDescriptor_82a7a8692925fe67)
}

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

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

func (m *Chain) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Module) > 0 {
		i -= len(m.Module)
		copy(dAtA[i:], m.Module)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Module)))
		i--
		dAtA[i] = 0x2a
	}
	if m.KeyType != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.KeyType))
		i--
		dAtA[i] = 0x20
	}
	if m.SupportsForeignAssets {
		i--
		if m.SupportsForeignAssets {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	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 *CrossChainAddress) 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 *CrossChainAddress) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

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

func (m *CrossChainTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x20
	}
	if m.ID != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.Recipient.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *FeeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.MaxFee.Size()
		i -= size
		if _, err := m.MaxFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.MinFee.Size()
		i -= size
		if _, err := m.MinFee.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size := m.FeeRate.Size()
		i -= size
		if _, err := m.FeeRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	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] = 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 *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 m.IsNativeAsset {
		i--
		if m.IsNativeAsset {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Denom) > 0 {
		i -= len(m.Denom)
		copy(dAtA[i:], m.Denom)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Denom)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *GeneralMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SourceTxIndex != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SourceTxIndex))
		i--
		dAtA[i] = 0x40
	}
	if len(m.SourceTxID) > 0 {
		i -= len(m.SourceTxID)
		copy(dAtA[i:], m.SourceTxID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.SourceTxID)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Asset != nil {
		{
			size, err := m.Asset.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTypes(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.Status != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x28
	}
	if len(m.PayloadHash) > 0 {
		i -= len(m.PayloadHash)
		copy(dAtA[i:], m.PayloadHash)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.PayloadHash)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.Recipient.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTypes(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Sender.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		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 *WasmMessage) 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 *WasmMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WasmMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	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] = 0x4a
	}
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0x42
	}
	if m.SourceTxIndex != 0 {
		i = encodeVarintTypes(dAtA, i, uint64(m.SourceTxIndex))
		i--
		dAtA[i] = 0x38
	}
	if len(m.SourceTxID) > 0 {
		i -= len(m.SourceTxID)
		copy(dAtA[i:], m.SourceTxID)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.SourceTxID)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.PayloadHash) > 0 {
		i -= len(m.PayloadHash)
		copy(dAtA[i:], m.PayloadHash)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.PayloadHash)))
		i--
		dAtA[i] = 0x2a
	}
	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] = 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
	}
	if len(m.SourceAddress) > 0 {
		i -= len(m.SourceAddress)
		copy(dAtA[i:], m.SourceAddress)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.SourceAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SourceChain) > 0 {
		i -= len(m.SourceChain)
		copy(dAtA[i:], m.SourceChain)
		i = encodeVarintTypes(dAtA, i, uint64(len(m.SourceChain)))
		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 *Chain) 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))
	}
	if m.SupportsForeignAssets {
		n += 2
	}
	if m.KeyType != 0 {
		n += 1 + sovTypes(uint64(m.KeyType))
	}
	l = len(m.Module)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	return n
}

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

func (m *CrossChainTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Recipient.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Asset.Size()
	n += 1 + l + sovTypes(uint64(l))
	if m.ID != 0 {
		n += 1 + sovTypes(uint64(m.ID))
	}
	if m.State != 0 {
		n += 1 + sovTypes(uint64(m.State))
	}
	return n
}

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

func (m *FeeInfo) 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.Asset)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = m.FeeRate.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.MinFee.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.MaxFee.Size()
	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.Denom)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.IsNativeAsset {
		n += 2
	}
	return n
}

func (m *GeneralMessage) 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))
	}
	l = m.Sender.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = m.Recipient.Size()
	n += 1 + l + sovTypes(uint64(l))
	l = len(m.PayloadHash)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovTypes(uint64(m.Status))
	}
	if m.Asset != nil {
		l = m.Asset.Size()
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.SourceTxID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.SourceTxIndex != 0 {
		n += 1 + sovTypes(uint64(m.SourceTxIndex))
	}
	return n
}

func (m *WasmMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SourceChain)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.SourceAddress)
	if l > 0 {
		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.PayloadHash)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.SourceTxID)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	if m.SourceTxIndex != 0 {
		n += 1 + sovTypes(uint64(m.SourceTxIndex))
	}
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTypes(uint64(l))
	}
	l = len(m.ID)
	if l > 0 {
		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 *Chain) 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: Chain: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Chain: 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 = ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SupportsForeignAssets", 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.SupportsForeignAssets = bool(v != 0)
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field KeyType", wireType)
			}
			m.KeyType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.KeyType |= exported.KeyType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Module", 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.Module = 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 *CrossChainAddress) 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: CrossChainAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossChainAddress: 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 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.Chain.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", 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.Address = 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 *CrossChainTransfer) 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: CrossChainTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CrossChainTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", 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.Recipient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", 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.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= TransferID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= TransferState(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 *TransferFee) 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: TransferFee: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransferFee: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Coins", 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.Coins = append(m.Coins, types.Coin{})
			if err := m.Coins[len(m.Coins)-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 *FeeInfo) 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: FeeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FeeInfo: 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 = ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeRate", 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.FeeRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinFee", 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.MinFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxFee", 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.MaxFee.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 *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 Denom", 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.Denom = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IsNativeAsset", 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.IsNativeAsset = bool(v != 0)
		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 *GeneralMessage) 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: GeneralMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GeneralMessage: 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 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.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", 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.Sender.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", 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.Recipient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
			}
			m.PayloadHash = append(m.PayloadHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PayloadHash == nil {
				m.PayloadHash = []byte{}
			}
			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 |= GeneralMessage_Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", 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.Asset == nil {
				m.Asset = &types.Coin{}
			}
			if err := m.Asset.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceTxID", 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.SourceTxID = append(m.SourceTxID[:0], dAtA[iNdEx:postIndex]...)
			if m.SourceTxID == nil {
				m.SourceTxID = []byte{}
			}
			iNdEx = postIndex
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceTxIndex", wireType)
			}
			m.SourceTxIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SourceTxIndex |= 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 *WasmMessage) 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: WasmMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WasmMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceChain", 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.SourceChain = ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceAddress", 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.SourceAddress = string(dAtA[iNdEx:postIndex])
			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 = ChainName(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 5:
			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
			}
			m.PayloadHash = append(m.PayloadHash[:0], dAtA[iNdEx:postIndex]...)
			if m.PayloadHash == nil {
				m.PayloadHash = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceTxID", 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.SourceTxID = append(m.SourceTxID[:0], dAtA[iNdEx:postIndex]...)
			if m.SourceTxID == nil {
				m.SourceTxID = []byte{}
			}
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SourceTxIndex", wireType)
			}
			m.SourceTxIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SourceTxIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			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
			}
			m.Sender = append(m.Sender[:0], dAtA[iNdEx:postIndex]...)
			if m.Sender == nil {
				m.Sender = []byte{}
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", 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.ID = 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 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")
)
