// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: band/tunnel/v1beta1/route.proto

package types

import (
	fmt "fmt"
	github_com_bandprotocol_chain_v3_x_bandtss_types "github.com/bandprotocol/chain/v3/x/bandtss/types"
	types "github.com/bandprotocol/chain/v3/x/feeds/types"
	_ "github.com/cosmos/cosmos-proto"
	types1 "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/gogoproto/gogoproto"
	proto "github.com/cosmos/gogoproto/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// TSSRoute represents a route for tss packets and implements the RouteI interface.
type TSSRoute struct {
	// destination_chain_id is the destination chain ID
	DestinationChainID string `protobuf:"bytes,1,opt,name=destination_chain_id,json=destinationChainId,proto3" json:"destination_chain_id,omitempty"`
	// destination_contract_address is the destination contract address
	DestinationContractAddress string `protobuf:"bytes,2,opt,name=destination_contract_address,json=destinationContractAddress,proto3" json:"destination_contract_address,omitempty"`
	// encoder is the mode of encoding packet data.
	Encoder types.Encoder `protobuf:"varint,3,opt,name=encoder,proto3,enum=band.feeds.v1beta1.Encoder" json:"encoder,omitempty"`
}

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

var xxx_messageInfo_TSSRoute proto.InternalMessageInfo

func (m *TSSRoute) GetDestinationChainID() string {
	if m != nil {
		return m.DestinationChainID
	}
	return ""
}

func (m *TSSRoute) GetDestinationContractAddress() string {
	if m != nil {
		return m.DestinationContractAddress
	}
	return ""
}

func (m *TSSRoute) GetEncoder() types.Encoder {
	if m != nil {
		return m.Encoder
	}
	return types.ENCODER_UNSPECIFIED
}

// TSSPacketReceipt represents a receipt for a tss packet and implements the PacketReceiptI interface.
type TSSPacketReceipt struct {
	// signing_id is the signing ID
	SigningID github_com_bandprotocol_chain_v3_x_bandtss_types.SigningID `protobuf:"varint,1,opt,name=signing_id,json=signingId,proto3,casttype=github.com/bandprotocol/chain/v3/x/bandtss/types.SigningID" json:"signing_id,omitempty"`
}

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

var xxx_messageInfo_TSSPacketReceipt proto.InternalMessageInfo

func (m *TSSPacketReceipt) GetSigningID() github_com_bandprotocol_chain_v3_x_bandtss_types.SigningID {
	if m != nil {
		return m.SigningID
	}
	return 0
}

// IBCRoute represents a route for IBC packets and implements the RouteI interface.
type IBCRoute struct {
	// channel_id is the IBC channel ID
	ChannelID string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
}

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

var xxx_messageInfo_IBCRoute proto.InternalMessageInfo

func (m *IBCRoute) GetChannelID() string {
	if m != nil {
		return m.ChannelID
	}
	return ""
}

// IBCPacketReceipt represents a receipt for a IBC packet and implements the PacketReceiptI interface.
type IBCPacketReceipt struct {
	// sequence is representing the sequence of the IBC packet.
	Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
}

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

var xxx_messageInfo_IBCPacketReceipt proto.InternalMessageInfo

func (m *IBCPacketReceipt) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

// TunnelPricesPacketData represents the IBC packet payload for the tunnel packet.
type TunnelPricesPacketData struct {
	// tunnel_id is the tunnel ID
	TunnelID uint64 `protobuf:"varint,1,opt,name=tunnel_id,json=tunnelId,proto3" json:"tunnel_id,omitempty"`
	// sequence is representing the sequence of the tunnel packet.
	Sequence uint64 `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty"`
	// prices is the list of prices information from feeds module.
	Prices []types.Price `protobuf:"bytes,3,rep,name=prices,proto3" json:"prices"`
	// created_at is the timestamp when the packet is created
	CreatedAt int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
}

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

var xxx_messageInfo_TunnelPricesPacketData proto.InternalMessageInfo

func (m *TunnelPricesPacketData) GetTunnelID() uint64 {
	if m != nil {
		return m.TunnelID
	}
	return 0
}

func (m *TunnelPricesPacketData) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func (m *TunnelPricesPacketData) GetPrices() []types.Price {
	if m != nil {
		return m.Prices
	}
	return nil
}

func (m *TunnelPricesPacketData) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

// IBCHookRoute is the type for an IBC hook route
type IBCHookRoute struct {
	// channel_id is the IBC channel ID
	ChannelID string `protobuf:"bytes,1,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty"`
	// destination_contract_address is the destination contract address
	DestinationContractAddress string `protobuf:"bytes,2,opt,name=destination_contract_address,json=destinationContractAddress,proto3" json:"destination_contract_address,omitempty"`
}

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

var xxx_messageInfo_IBCHookRoute proto.InternalMessageInfo

func (m *IBCHookRoute) GetChannelID() string {
	if m != nil {
		return m.ChannelID
	}
	return ""
}

func (m *IBCHookRoute) GetDestinationContractAddress() string {
	if m != nil {
		return m.DestinationContractAddress
	}
	return ""
}

// IBCHookPacketReceipt represents a receipt for a IBC hook packet and implements the PacketReceiptI interface.
type IBCHookPacketReceipt struct {
	// sequence is representing the sequence of the IBC packet.
	Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
}

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

var xxx_messageInfo_IBCHookPacketReceipt proto.InternalMessageInfo

func (m *IBCHookPacketReceipt) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

// IBCHookMemo is the type for a data packet that will be stringtify to be a memo of IBC hook packet
type IBCHookMemo struct {
	// wasm is the payload for calling destination contract
	Wasm IBCHookMemo_Payload `protobuf:"bytes,1,opt,name=wasm,proto3" json:"wasm"`
}

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

var xxx_messageInfo_IBCHookMemo proto.InternalMessageInfo

func (m *IBCHookMemo) GetWasm() IBCHookMemo_Payload {
	if m != nil {
		return m.Wasm
	}
	return IBCHookMemo_Payload{}
}

// Payload defines target contract and detail of function call (msg).
type IBCHookMemo_Payload struct {
	// contract is destination contract address
	Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"`
	// msg is the ibc hook message
	Msg IBCHookMemo_Payload_Msg `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
}

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

var xxx_messageInfo_IBCHookMemo_Payload proto.InternalMessageInfo

func (m *IBCHookMemo_Payload) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *IBCHookMemo_Payload) GetMsg() IBCHookMemo_Payload_Msg {
	if m != nil {
		return m.Msg
	}
	return IBCHookMemo_Payload_Msg{}
}

// Msg defines function name (`receive_packet`) and a type of function arguments.
type IBCHookMemo_Payload_Msg struct {
	// receive_packet is the function name on the destination contract
	ReceivePacket IBCHookMemo_Payload_Msg_ReceivePacket `protobuf:"bytes,1,opt,name=receive_packet,json=receivePacket,proto3" json:"receive_packet"`
}

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

var xxx_messageInfo_IBCHookMemo_Payload_Msg proto.InternalMessageInfo

func (m *IBCHookMemo_Payload_Msg) GetReceivePacket() IBCHookMemo_Payload_Msg_ReceivePacket {
	if m != nil {
		return m.ReceivePacket
	}
	return IBCHookMemo_Payload_Msg_ReceivePacket{}
}

// ReceivePacket represents the arguments of `receive_packet` function
type IBCHookMemo_Payload_Msg_ReceivePacket struct {
	// packet represents the data packet
	Packet TunnelPricesPacketData `protobuf:"bytes,1,opt,name=packet,proto3" json:"packet"`
}

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

var xxx_messageInfo_IBCHookMemo_Payload_Msg_ReceivePacket proto.InternalMessageInfo

func (m *IBCHookMemo_Payload_Msg_ReceivePacket) GetPacket() TunnelPricesPacketData {
	if m != nil {
		return m.Packet
	}
	return TunnelPricesPacketData{}
}

// RouterRoute is the type for a Router route
type RouterRoute struct {
	// destination_chain_id is the destination chain ID
	DestinationChainID string `protobuf:"bytes,1,opt,name=destination_chain_id,json=destinationChainId,proto3" json:"destination_chain_id,omitempty"`
	// destination_contract_address is the destination contract address
	DestinationContractAddress string `protobuf:"bytes,2,opt,name=destination_contract_address,json=destinationContractAddress,proto3" json:"destination_contract_address,omitempty"`
	// destination_gas_limit is the destination gas limit
	DestinationGasLimit uint64 `protobuf:"varint,3,opt,name=destination_gas_limit,json=destinationGasLimit,proto3" json:"destination_gas_limit,omitempty"`
}

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

var xxx_messageInfo_RouterRoute proto.InternalMessageInfo

func (m *RouterRoute) GetDestinationChainID() string {
	if m != nil {
		return m.DestinationChainID
	}
	return ""
}

func (m *RouterRoute) GetDestinationContractAddress() string {
	if m != nil {
		return m.DestinationContractAddress
	}
	return ""
}

func (m *RouterRoute) GetDestinationGasLimit() uint64 {
	if m != nil {
		return m.DestinationGasLimit
	}
	return 0
}

// RouterPacketReceipt represents a receipt for a Router packet and implements the PacketReceiptI interface.
type RouterPacketReceipt struct {
	// sequence is representing the sequence of the IBC packet.
	Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
}

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

var xxx_messageInfo_RouterPacketReceipt proto.InternalMessageInfo

func (m *RouterPacketReceipt) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

// RouterMemo is the type for a data packet that will be stringtify to be a memo of IBC packet
type RouterMemo struct {
	// wasm is the payload for calling destination contract
	Wasm RouterMemo_Payload `protobuf:"bytes,1,opt,name=wasm,proto3" json:"wasm"`
}

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

var xxx_messageInfo_RouterMemo proto.InternalMessageInfo

func (m *RouterMemo) GetWasm() RouterMemo_Payload {
	if m != nil {
		return m.Wasm
	}
	return RouterMemo_Payload{}
}

// Payload defines target contract and detail of function call (msg).
type RouterMemo_Payload struct {
	// contract is destination contract address
	Contract string `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty"`
	// msg is the Router message
	Msg RouterMemo_Payload_Msg `protobuf:"bytes,2,opt,name=msg,proto3" json:"msg"`
}

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

var xxx_messageInfo_RouterMemo_Payload proto.InternalMessageInfo

func (m *RouterMemo_Payload) GetContract() string {
	if m != nil {
		return m.Contract
	}
	return ""
}

func (m *RouterMemo_Payload) GetMsg() RouterMemo_Payload_Msg {
	if m != nil {
		return m.Msg
	}
	return RouterMemo_Payload_Msg{}
}

// Msg defines function name (`receive_band_data`) and a type of function arguments.
type RouterMemo_Payload_Msg struct {
	// receive_band_data is the function name on the destination contract
	ReceiveBandData RouterMemo_Payload_Msg_ReceiveBandDataArgs `protobuf:"bytes,1,opt,name=receive_band_data,json=receiveBandData,proto3" json:"receive_band_data"`
}

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

var xxx_messageInfo_RouterMemo_Payload_Msg proto.InternalMessageInfo

func (m *RouterMemo_Payload_Msg) GetReceiveBandData() RouterMemo_Payload_Msg_ReceiveBandDataArgs {
	if m != nil {
		return m.ReceiveBandData
	}
	return RouterMemo_Payload_Msg_ReceiveBandDataArgs{}
}

// ReceiveBandDataArgs represents the arguments of `receive_band_data` function
type RouterMemo_Payload_Msg_ReceiveBandDataArgs struct {
	// dest_chain_id is the destination chain ID
	DestChainID string `protobuf:"bytes,1,opt,name=dest_chain_id,json=destChainId,proto3" json:"dest_chain_id,omitempty"`
	// dest_contract_address is the destination contract address
	DestContractAddress string `protobuf:"bytes,2,opt,name=dest_contract_address,json=destContractAddress,proto3" json:"dest_contract_address,omitempty"`
	// gas_limit is the destination gas limit
	GasLimit uint64 `protobuf:"varint,3,opt,name=gas_limit,json=gasLimit,proto3" json:"gas_limit,omitempty"`
	// payload is the payload of the packet
	Payload string `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"`
}

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

var xxx_messageInfo_RouterMemo_Payload_Msg_ReceiveBandDataArgs proto.InternalMessageInfo

func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) GetDestChainID() string {
	if m != nil {
		return m.DestChainID
	}
	return ""
}

func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) GetDestContractAddress() string {
	if m != nil {
		return m.DestContractAddress
	}
	return ""
}

func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) GetGasLimit() uint64 {
	if m != nil {
		return m.GasLimit
	}
	return 0
}

func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) GetPayload() string {
	if m != nil {
		return m.Payload
	}
	return ""
}

// AxelarRoute represents a route for Axelar packets and implements the RouteI interface.
type AxelarRoute struct {
	// destination_chain_id is the destination chain ID
	DestinationChainID ChainName `protobuf:"bytes,1,opt,name=destination_chain_id,json=destinationChainId,proto3,casttype=ChainName" json:"destination_chain_id,omitempty"`
	// destination_contract_address is the destination contract address
	DestinationContractAddress string `protobuf:"bytes,2,opt,name=destination_contract_address,json=destinationContractAddress,proto3" json:"destination_contract_address,omitempty"`
	// fee is the fee for each packet in the Axelar network.
	Fee types1.Coin `protobuf:"bytes,3,opt,name=fee,proto3" json:"fee"`
}

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

var xxx_messageInfo_AxelarRoute proto.InternalMessageInfo

func (m *AxelarRoute) GetDestinationChainID() ChainName {
	if m != nil {
		return m.DestinationChainID
	}
	return ""
}

func (m *AxelarRoute) GetDestinationContractAddress() string {
	if m != nil {
		return m.DestinationContractAddress
	}
	return ""
}

func (m *AxelarRoute) GetFee() types1.Coin {
	if m != nil {
		return m.Fee
	}
	return types1.Coin{}
}

// AxelarPacketReceipt represents a receipt for a Axelar packet and implements the PacketReceiptI interface.
type AxelarPacketReceipt struct {
	// sequence is representing the sequence of the Axelar packet.
	Sequence uint64 `protobuf:"varint,1,opt,name=sequence,proto3" json:"sequence,omitempty"`
}

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

var xxx_messageInfo_AxelarPacketReceipt proto.InternalMessageInfo

func (m *AxelarPacketReceipt) GetSequence() uint64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func init() {
	proto.RegisterType((*TSSRoute)(nil), "band.tunnel.v1beta1.TSSRoute")
	proto.RegisterType((*TSSPacketReceipt)(nil), "band.tunnel.v1beta1.TSSPacketReceipt")
	proto.RegisterType((*IBCRoute)(nil), "band.tunnel.v1beta1.IBCRoute")
	proto.RegisterType((*IBCPacketReceipt)(nil), "band.tunnel.v1beta1.IBCPacketReceipt")
	proto.RegisterType((*TunnelPricesPacketData)(nil), "band.tunnel.v1beta1.TunnelPricesPacketData")
	proto.RegisterType((*IBCHookRoute)(nil), "band.tunnel.v1beta1.IBCHookRoute")
	proto.RegisterType((*IBCHookPacketReceipt)(nil), "band.tunnel.v1beta1.IBCHookPacketReceipt")
	proto.RegisterType((*IBCHookMemo)(nil), "band.tunnel.v1beta1.IBCHookMemo")
	proto.RegisterType((*IBCHookMemo_Payload)(nil), "band.tunnel.v1beta1.IBCHookMemo.Payload")
	proto.RegisterType((*IBCHookMemo_Payload_Msg)(nil), "band.tunnel.v1beta1.IBCHookMemo.Payload.Msg")
	proto.RegisterType((*IBCHookMemo_Payload_Msg_ReceivePacket)(nil), "band.tunnel.v1beta1.IBCHookMemo.Payload.Msg.ReceivePacket")
	proto.RegisterType((*RouterRoute)(nil), "band.tunnel.v1beta1.RouterRoute")
	proto.RegisterType((*RouterPacketReceipt)(nil), "band.tunnel.v1beta1.RouterPacketReceipt")
	proto.RegisterType((*RouterMemo)(nil), "band.tunnel.v1beta1.RouterMemo")
	proto.RegisterType((*RouterMemo_Payload)(nil), "band.tunnel.v1beta1.RouterMemo.Payload")
	proto.RegisterType((*RouterMemo_Payload_Msg)(nil), "band.tunnel.v1beta1.RouterMemo.Payload.Msg")
	proto.RegisterType((*RouterMemo_Payload_Msg_ReceiveBandDataArgs)(nil), "band.tunnel.v1beta1.RouterMemo.Payload.Msg.ReceiveBandDataArgs")
	proto.RegisterType((*AxelarRoute)(nil), "band.tunnel.v1beta1.AxelarRoute")
	proto.RegisterType((*AxelarPacketReceipt)(nil), "band.tunnel.v1beta1.AxelarPacketReceipt")
}

func init() { proto.RegisterFile("band/tunnel/v1beta1/route.proto", fileDescriptor_543238289d94b7a6) }

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

func (this *TSSRoute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TSSRoute)
	if !ok {
		that2, ok := that.(TSSRoute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DestinationChainID != that1.DestinationChainID {
		return false
	}
	if this.DestinationContractAddress != that1.DestinationContractAddress {
		return false
	}
	if this.Encoder != that1.Encoder {
		return false
	}
	return true
}
func (this *TSSPacketReceipt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TSSPacketReceipt)
	if !ok {
		that2, ok := that.(TSSPacketReceipt)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.SigningID != that1.SigningID {
		return false
	}
	return true
}
func (this *IBCRoute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCRoute)
	if !ok {
		that2, ok := that.(IBCRoute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ChannelID != that1.ChannelID {
		return false
	}
	return true
}
func (this *IBCPacketReceipt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCPacketReceipt)
	if !ok {
		that2, ok := that.(IBCPacketReceipt)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Sequence != that1.Sequence {
		return false
	}
	return true
}
func (this *TunnelPricesPacketData) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TunnelPricesPacketData)
	if !ok {
		that2, ok := that.(TunnelPricesPacketData)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.TunnelID != that1.TunnelID {
		return false
	}
	if this.Sequence != that1.Sequence {
		return false
	}
	if len(this.Prices) != len(that1.Prices) {
		return false
	}
	for i := range this.Prices {
		if !this.Prices[i].Equal(&that1.Prices[i]) {
			return false
		}
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	return true
}
func (this *IBCHookRoute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCHookRoute)
	if !ok {
		that2, ok := that.(IBCHookRoute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.ChannelID != that1.ChannelID {
		return false
	}
	if this.DestinationContractAddress != that1.DestinationContractAddress {
		return false
	}
	return true
}
func (this *IBCHookPacketReceipt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCHookPacketReceipt)
	if !ok {
		that2, ok := that.(IBCHookPacketReceipt)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Sequence != that1.Sequence {
		return false
	}
	return true
}
func (this *IBCHookMemo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCHookMemo)
	if !ok {
		that2, ok := that.(IBCHookMemo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Wasm.Equal(&that1.Wasm) {
		return false
	}
	return true
}
func (this *IBCHookMemo_Payload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCHookMemo_Payload)
	if !ok {
		that2, ok := that.(IBCHookMemo_Payload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Contract != that1.Contract {
		return false
	}
	if !this.Msg.Equal(&that1.Msg) {
		return false
	}
	return true
}
func (this *IBCHookMemo_Payload_Msg) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCHookMemo_Payload_Msg)
	if !ok {
		that2, ok := that.(IBCHookMemo_Payload_Msg)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ReceivePacket.Equal(&that1.ReceivePacket) {
		return false
	}
	return true
}
func (this *IBCHookMemo_Payload_Msg_ReceivePacket) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*IBCHookMemo_Payload_Msg_ReceivePacket)
	if !ok {
		that2, ok := that.(IBCHookMemo_Payload_Msg_ReceivePacket)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Packet.Equal(&that1.Packet) {
		return false
	}
	return true
}
func (this *RouterRoute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RouterRoute)
	if !ok {
		that2, ok := that.(RouterRoute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DestinationChainID != that1.DestinationChainID {
		return false
	}
	if this.DestinationContractAddress != that1.DestinationContractAddress {
		return false
	}
	if this.DestinationGasLimit != that1.DestinationGasLimit {
		return false
	}
	return true
}
func (this *RouterPacketReceipt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RouterPacketReceipt)
	if !ok {
		that2, ok := that.(RouterPacketReceipt)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Sequence != that1.Sequence {
		return false
	}
	return true
}
func (this *RouterMemo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RouterMemo)
	if !ok {
		that2, ok := that.(RouterMemo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Wasm.Equal(&that1.Wasm) {
		return false
	}
	return true
}
func (this *RouterMemo_Payload) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RouterMemo_Payload)
	if !ok {
		that2, ok := that.(RouterMemo_Payload)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Contract != that1.Contract {
		return false
	}
	if !this.Msg.Equal(&that1.Msg) {
		return false
	}
	return true
}
func (this *RouterMemo_Payload_Msg) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RouterMemo_Payload_Msg)
	if !ok {
		that2, ok := that.(RouterMemo_Payload_Msg)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ReceiveBandData.Equal(&that1.ReceiveBandData) {
		return false
	}
	return true
}
func (this *RouterMemo_Payload_Msg_ReceiveBandDataArgs) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RouterMemo_Payload_Msg_ReceiveBandDataArgs)
	if !ok {
		that2, ok := that.(RouterMemo_Payload_Msg_ReceiveBandDataArgs)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DestChainID != that1.DestChainID {
		return false
	}
	if this.DestContractAddress != that1.DestContractAddress {
		return false
	}
	if this.GasLimit != that1.GasLimit {
		return false
	}
	if this.Payload != that1.Payload {
		return false
	}
	return true
}
func (this *AxelarRoute) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AxelarRoute)
	if !ok {
		that2, ok := that.(AxelarRoute)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.DestinationChainID != that1.DestinationChainID {
		return false
	}
	if this.DestinationContractAddress != that1.DestinationContractAddress {
		return false
	}
	if !this.Fee.Equal(&that1.Fee) {
		return false
	}
	return true
}
func (this *AxelarPacketReceipt) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*AxelarPacketReceipt)
	if !ok {
		that2, ok := that.(AxelarPacketReceipt)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Sequence != that1.Sequence {
		return false
	}
	return true
}
func (m *TSSRoute) 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 *TSSRoute) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TSSRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Encoder != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.Encoder))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DestinationContractAddress) > 0 {
		i -= len(m.DestinationContractAddress)
		copy(dAtA[i:], m.DestinationContractAddress)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestinationContractAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DestinationChainID) > 0 {
		i -= len(m.DestinationChainID)
		copy(dAtA[i:], m.DestinationChainID)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestinationChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TSSPacketReceipt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.SigningID != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.SigningID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *IBCPacketReceipt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sequence != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TunnelPricesPacketData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.CreatedAt != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Prices) > 0 {
		for iNdEx := len(m.Prices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Prices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintRoute(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Sequence != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x10
	}
	if m.TunnelID != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.TunnelID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *IBCHookPacketReceipt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sequence != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

func (m *RouterRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.DestinationGasLimit != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.DestinationGasLimit))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DestinationContractAddress) > 0 {
		i -= len(m.DestinationContractAddress)
		copy(dAtA[i:], m.DestinationContractAddress)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestinationContractAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DestinationChainID) > 0 {
		i -= len(m.DestinationChainID)
		copy(dAtA[i:], m.DestinationChainID)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestinationChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *RouterPacketReceipt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sequence != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Payload) > 0 {
		i -= len(m.Payload)
		copy(dAtA[i:], m.Payload)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.Payload)))
		i--
		dAtA[i] = 0x22
	}
	if m.GasLimit != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.GasLimit))
		i--
		dAtA[i] = 0x18
	}
	if len(m.DestContractAddress) > 0 {
		i -= len(m.DestContractAddress)
		copy(dAtA[i:], m.DestContractAddress)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestContractAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DestChainID) > 0 {
		i -= len(m.DestChainID)
		copy(dAtA[i:], m.DestChainID)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AxelarRoute) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Fee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintRoute(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.DestinationContractAddress) > 0 {
		i -= len(m.DestinationContractAddress)
		copy(dAtA[i:], m.DestinationContractAddress)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestinationContractAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.DestinationChainID) > 0 {
		i -= len(m.DestinationChainID)
		copy(dAtA[i:], m.DestinationChainID)
		i = encodeVarintRoute(dAtA, i, uint64(len(m.DestinationChainID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AxelarPacketReceipt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Sequence != 0 {
		i = encodeVarintRoute(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintRoute(dAtA []byte, offset int, v uint64) int {
	offset -= sovRoute(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TSSRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DestinationChainID)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = len(m.DestinationContractAddress)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	if m.Encoder != 0 {
		n += 1 + sovRoute(uint64(m.Encoder))
	}
	return n
}

func (m *TSSPacketReceipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SigningID != 0 {
		n += 1 + sovRoute(uint64(m.SigningID))
	}
	return n
}

func (m *IBCRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChannelID)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	return n
}

func (m *IBCPacketReceipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sequence != 0 {
		n += 1 + sovRoute(uint64(m.Sequence))
	}
	return n
}

func (m *TunnelPricesPacketData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TunnelID != 0 {
		n += 1 + sovRoute(uint64(m.TunnelID))
	}
	if m.Sequence != 0 {
		n += 1 + sovRoute(uint64(m.Sequence))
	}
	if len(m.Prices) > 0 {
		for _, e := range m.Prices {
			l = e.Size()
			n += 1 + l + sovRoute(uint64(l))
		}
	}
	if m.CreatedAt != 0 {
		n += 1 + sovRoute(uint64(m.CreatedAt))
	}
	return n
}

func (m *IBCHookRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ChannelID)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = len(m.DestinationContractAddress)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	return n
}

func (m *IBCHookPacketReceipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sequence != 0 {
		n += 1 + sovRoute(uint64(m.Sequence))
	}
	return n
}

func (m *IBCHookMemo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Wasm.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *IBCHookMemo_Payload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = m.Msg.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *IBCHookMemo_Payload_Msg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ReceivePacket.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *IBCHookMemo_Payload_Msg_ReceivePacket) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Packet.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *RouterRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DestinationChainID)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = len(m.DestinationContractAddress)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	if m.DestinationGasLimit != 0 {
		n += 1 + sovRoute(uint64(m.DestinationGasLimit))
	}
	return n
}

func (m *RouterPacketReceipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sequence != 0 {
		n += 1 + sovRoute(uint64(m.Sequence))
	}
	return n
}

func (m *RouterMemo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Wasm.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *RouterMemo_Payload) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Contract)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = m.Msg.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *RouterMemo_Payload_Msg) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ReceiveBandData.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DestChainID)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = len(m.DestContractAddress)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	if m.GasLimit != 0 {
		n += 1 + sovRoute(uint64(m.GasLimit))
	}
	l = len(m.Payload)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	return n
}

func (m *AxelarRoute) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.DestinationChainID)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = len(m.DestinationContractAddress)
	if l > 0 {
		n += 1 + l + sovRoute(uint64(l))
	}
	l = m.Fee.Size()
	n += 1 + l + sovRoute(uint64(l))
	return n
}

func (m *AxelarPacketReceipt) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Sequence != 0 {
		n += 1 + sovRoute(uint64(m.Sequence))
	}
	return n
}

func sovRoute(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozRoute(x uint64) (n int) {
	return sovRoute(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TSSRoute) 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 ErrIntOverflowRoute
			}
			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: TSSRoute: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TSSRoute: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				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 ErrInvalidLengthRoute
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRoute
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				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 ErrInvalidLengthRoute
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRoute
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestinationContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Encoder", wireType)
			}
			m.Encoder = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Encoder |= types.Encoder(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TSSPacketReceipt) 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 ErrIntOverflowRoute
			}
			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: TSSPacketReceipt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TSSPacketReceipt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SigningID", wireType)
			}
			m.SigningID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SigningID |= github_com_bandprotocol_chain_v3_x_bandtss_types.SigningID(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IBCPacketReceipt) 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 ErrIntOverflowRoute
			}
			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: IBCPacketReceipt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IBCPacketReceipt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TunnelPricesPacketData) 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 ErrIntOverflowRoute
			}
			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: TunnelPricesPacketData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TunnelPricesPacketData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TunnelID", wireType)
			}
			m.TunnelID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TunnelID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Prices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthRoute
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthRoute
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Prices = append(m.Prices, types.Price{})
			if err := m.Prices[len(m.Prices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IBCHookPacketReceipt) 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 ErrIntOverflowRoute
			}
			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: IBCHookPacketReceipt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IBCHookPacketReceipt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouterPacketReceipt) 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 ErrIntOverflowRoute
			}
			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: RouterPacketReceipt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RouterPacketReceipt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RouterMemo_Payload_Msg_ReceiveBandDataArgs) 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 ErrIntOverflowRoute
			}
			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: ReceiveBandDataArgs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReceiveBandDataArgs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestChainID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				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 ErrInvalidLengthRoute
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRoute
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestChainID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestContractAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				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 ErrInvalidLengthRoute
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRoute
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DestContractAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType)
			}
			m.GasLimit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.GasLimit |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payload", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				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 ErrInvalidLengthRoute
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthRoute
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payload = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AxelarPacketReceipt) 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 ErrIntOverflowRoute
			}
			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: AxelarPacketReceipt: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AxelarPacketReceipt: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowRoute
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipRoute(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthRoute
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthRoute        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowRoute          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupRoute = fmt.Errorf("proto: unexpected end of group")
)
