// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: hyperlane/warp/v1/tx.proto

package types

import (
	context "context"
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	github_com_bcp_innovations_hyperlane_cosmos_util "github.com/bcp-innovations/hyperlane-cosmos/util"
	_ "github.com/cosmos/cosmos-proto"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/cosmos-sdk/types/tx/amino"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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

// MsgCreateCollateralToken ...
type MsgCreateCollateralToken struct {
	// owner is the message sender.
	Owner         string                                                      `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	OriginMailbox github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=origin_mailbox,json=originMailbox,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"origin_mailbox"`
	OriginDenom   string                                                      `protobuf:"bytes,3,opt,name=origin_denom,json=originDenom,proto3" json:"origin_denom,omitempty"`
}

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

var xxx_messageInfo_MsgCreateCollateralToken proto.InternalMessageInfo

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

func (m *MsgCreateCollateralToken) GetOriginDenom() string {
	if m != nil {
		return m.OriginDenom
	}
	return ""
}

// MsgCreateCollateralTokenResponse ...
type MsgCreateCollateralTokenResponse struct {
	Id github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=id,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"id"`
}

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

var xxx_messageInfo_MsgCreateCollateralTokenResponse proto.InternalMessageInfo

// MsgCreateSyntheticToken ...
type MsgCreateSyntheticToken struct {
	// owner is the message sender.
	Owner         string                                                      `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	OriginMailbox github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=origin_mailbox,json=originMailbox,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"origin_mailbox"`
}

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

var xxx_messageInfo_MsgCreateSyntheticToken proto.InternalMessageInfo

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

// MsgCreateNativeSyntheticToken ...
type MsgCreateNativeSyntheticToken struct {
	Owner         string                                                      `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	OriginMailbox github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=origin_mailbox,json=originMailbox,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"origin_mailbox"`
	OriginDenom   string                                                      `protobuf:"bytes,3,opt,name=origin_denom,json=originDenom,proto3" json:"origin_denom,omitempty"`
}

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

var xxx_messageInfo_MsgCreateNativeSyntheticToken proto.InternalMessageInfo

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

func (m *MsgCreateNativeSyntheticToken) GetOriginDenom() string {
	if m != nil {
		return m.OriginDenom
	}
	return ""
}

// MsgCreateSyntheticTokenResponse ...
type MsgCreateSyntheticTokenResponse struct {
	Id github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=id,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"id"`
}

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

var xxx_messageInfo_MsgCreateSyntheticTokenResponse proto.InternalMessageInfo

// MsgSetToken ...
type MsgSetToken struct {
	// owner is the message sender.
	Owner             string                                                       `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	TokenId           github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress  `protobuf:"bytes,2,opt,name=token_id,json=tokenId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"token_id"`
	NewOwner          string                                                       `protobuf:"bytes,3,opt,name=new_owner,json=newOwner,proto3" json:"new_owner,omitempty"`
	IsmId             *github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,4,opt,name=ism_id,json=ismId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"ism_id,omitempty"`
	RenounceOwnership bool                                                         `protobuf:"varint,7,opt,name=renounce_ownership,json=renounceOwnership,proto3" json:"renounce_ownership,omitempty"`
}

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

var xxx_messageInfo_MsgSetToken proto.InternalMessageInfo

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

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

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

// MsgSetTokenResponse ...
type MsgSetTokenResponse struct {
}

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

var xxx_messageInfo_MsgSetTokenResponse proto.InternalMessageInfo

// MsgEnrollRemoteRouter ...
type MsgEnrollRemoteRouter struct {
	// owner is the message sender.
	Owner        string                                                      `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	TokenId      github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=token_id,json=tokenId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"token_id"`
	RemoteRouter *RemoteRouter                                               `protobuf:"bytes,3,opt,name=remote_router,json=remoteRouter,proto3" json:"remote_router,omitempty"`
}

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

var xxx_messageInfo_MsgEnrollRemoteRouter proto.InternalMessageInfo

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

func (m *MsgEnrollRemoteRouter) GetRemoteRouter() *RemoteRouter {
	if m != nil {
		return m.RemoteRouter
	}
	return nil
}

// MsgEnrollRemoteRouterResponse ...
type MsgEnrollRemoteRouterResponse struct {
}

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

var xxx_messageInfo_MsgEnrollRemoteRouterResponse proto.InternalMessageInfo

// MsgUnrollRemoteRouter ...
type MsgUnrollRemoteRouter struct {
	// owner is the message sender.
	Owner          string                                                      `protobuf:"bytes,1,opt,name=owner,proto3" json:"owner,omitempty"`
	TokenId        github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=token_id,json=tokenId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"token_id"`
	ReceiverDomain uint32                                                      `protobuf:"varint,3,opt,name=receiver_domain,json=receiverDomain,proto3" json:"receiver_domain,omitempty"`
}

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

var xxx_messageInfo_MsgUnrollRemoteRouter proto.InternalMessageInfo

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

func (m *MsgUnrollRemoteRouter) GetReceiverDomain() uint32 {
	if m != nil {
		return m.ReceiverDomain
	}
	return 0
}

// MsgUnrollRemoteRouterResponse ...
type MsgUnrollRemoteRouterResponse struct {
}

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

var xxx_messageInfo_MsgUnrollRemoteRouterResponse proto.InternalMessageInfo

// MsgRemoteTransfer ...
type MsgRemoteTransfer struct {
	Sender            string                                                      `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty"`
	TokenId           github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,2,opt,name=token_id,json=tokenId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"token_id"`
	DestinationDomain uint32                                                      `protobuf:"varint,3,opt,name=destination_domain,json=destinationDomain,proto3" json:"destination_domain,omitempty"`
	Recipient         github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,4,opt,name=recipient,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"recipient"`
	Amount            cosmossdk_io_math.Int                                       `protobuf:"bytes,5,opt,name=amount,proto3,customtype=cosmossdk.io/math.Int" json:"amount"`
	// Post Dispatch
	CustomHookId       *github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,6,opt,name=custom_hook_id,json=customHookId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"custom_hook_id,omitempty"`
	GasLimit           cosmossdk_io_math.Int                                        `protobuf:"bytes,7,opt,name=gas_limit,json=gasLimit,proto3,customtype=cosmossdk.io/math.Int" json:"gas_limit"`
	MaxFee             types.Coin                                                   `protobuf:"bytes,8,opt,name=max_fee,json=maxFee,proto3" json:"max_fee"`
	CustomHookMetadata string                                                       `protobuf:"bytes,9,opt,name=custom_hook_metadata,json=customHookMetadata,proto3" json:"custom_hook_metadata,omitempty"`
}

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

var xxx_messageInfo_MsgRemoteTransfer proto.InternalMessageInfo

func (m *MsgRemoteTransfer) GetSender() string {
	if m != nil {
		return m.Sender
	}
	return ""
}

func (m *MsgRemoteTransfer) GetDestinationDomain() uint32 {
	if m != nil {
		return m.DestinationDomain
	}
	return 0
}

func (m *MsgRemoteTransfer) GetMaxFee() types.Coin {
	if m != nil {
		return m.MaxFee
	}
	return types.Coin{}
}

func (m *MsgRemoteTransfer) GetCustomHookMetadata() string {
	if m != nil {
		return m.CustomHookMetadata
	}
	return ""
}

// MsgRemoteTransferResponse ...
type MsgRemoteTransferResponse struct {
	MessageId github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress `protobuf:"bytes,1,opt,name=message_id,json=messageId,proto3,customtype=github.com/bcp-innovations/hyperlane-cosmos/util.HexAddress" json:"message_id"`
}

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

var xxx_messageInfo_MsgRemoteTransferResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreateCollateralToken)(nil), "hyperlane.warp.v1.MsgCreateCollateralToken")
	proto.RegisterType((*MsgCreateCollateralTokenResponse)(nil), "hyperlane.warp.v1.MsgCreateCollateralTokenResponse")
	proto.RegisterType((*MsgCreateSyntheticToken)(nil), "hyperlane.warp.v1.MsgCreateSyntheticToken")
	proto.RegisterType((*MsgCreateNativeSyntheticToken)(nil), "hyperlane.warp.v1.MsgCreateNativeSyntheticToken")
	proto.RegisterType((*MsgCreateSyntheticTokenResponse)(nil), "hyperlane.warp.v1.MsgCreateSyntheticTokenResponse")
	proto.RegisterType((*MsgSetToken)(nil), "hyperlane.warp.v1.MsgSetToken")
	proto.RegisterType((*MsgSetTokenResponse)(nil), "hyperlane.warp.v1.MsgSetTokenResponse")
	proto.RegisterType((*MsgEnrollRemoteRouter)(nil), "hyperlane.warp.v1.MsgEnrollRemoteRouter")
	proto.RegisterType((*MsgEnrollRemoteRouterResponse)(nil), "hyperlane.warp.v1.MsgEnrollRemoteRouterResponse")
	proto.RegisterType((*MsgUnrollRemoteRouter)(nil), "hyperlane.warp.v1.MsgUnrollRemoteRouter")
	proto.RegisterType((*MsgUnrollRemoteRouterResponse)(nil), "hyperlane.warp.v1.MsgUnrollRemoteRouterResponse")
	proto.RegisterType((*MsgRemoteTransfer)(nil), "hyperlane.warp.v1.MsgRemoteTransfer")
	proto.RegisterType((*MsgRemoteTransferResponse)(nil), "hyperlane.warp.v1.MsgRemoteTransferResponse")
}

func init() { proto.RegisterFile("hyperlane/warp/v1/tx.proto", fileDescriptor_9d1a3f4c9d53a091) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	// CreateCollateralToken ...
	CreateCollateralToken(ctx context.Context, in *MsgCreateCollateralToken, opts ...grpc.CallOption) (*MsgCreateCollateralTokenResponse, error)
	// CreateSyntheticToken ...
	CreateSyntheticToken(ctx context.Context, in *MsgCreateSyntheticToken, opts ...grpc.CallOption) (*MsgCreateSyntheticTokenResponse, error)
	// CreateNativeSyntheticToken ...
	CreateNativeSyntheticToken(ctx context.Context, in *MsgCreateNativeSyntheticToken, opts ...grpc.CallOption) (*MsgCreateSyntheticTokenResponse, error)
	// SetToken ...
	SetToken(ctx context.Context, in *MsgSetToken, opts ...grpc.CallOption) (*MsgSetTokenResponse, error)
	// EnrollRemoteRouter ...
	EnrollRemoteRouter(ctx context.Context, in *MsgEnrollRemoteRouter, opts ...grpc.CallOption) (*MsgEnrollRemoteRouterResponse, error)
	// UnrollRemoteRouter ...
	UnrollRemoteRouter(ctx context.Context, in *MsgUnrollRemoteRouter, opts ...grpc.CallOption) (*MsgUnrollRemoteRouterResponse, error)
	// RemoteTransfer ...
	RemoteTransfer(ctx context.Context, in *MsgRemoteTransfer, opts ...grpc.CallOption) (*MsgRemoteTransferResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

func NewMsgClient(cc grpc1.ClientConn) MsgClient {
	return &msgClient{cc}
}

func (c *msgClient) CreateCollateralToken(ctx context.Context, in *MsgCreateCollateralToken, opts ...grpc.CallOption) (*MsgCreateCollateralTokenResponse, error) {
	out := new(MsgCreateCollateralTokenResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/CreateCollateralToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateSyntheticToken(ctx context.Context, in *MsgCreateSyntheticToken, opts ...grpc.CallOption) (*MsgCreateSyntheticTokenResponse, error) {
	out := new(MsgCreateSyntheticTokenResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/CreateSyntheticToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateNativeSyntheticToken(ctx context.Context, in *MsgCreateNativeSyntheticToken, opts ...grpc.CallOption) (*MsgCreateSyntheticTokenResponse, error) {
	out := new(MsgCreateSyntheticTokenResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/CreateNativeSyntheticToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SetToken(ctx context.Context, in *MsgSetToken, opts ...grpc.CallOption) (*MsgSetTokenResponse, error) {
	out := new(MsgSetTokenResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/SetToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) EnrollRemoteRouter(ctx context.Context, in *MsgEnrollRemoteRouter, opts ...grpc.CallOption) (*MsgEnrollRemoteRouterResponse, error) {
	out := new(MsgEnrollRemoteRouterResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/EnrollRemoteRouter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UnrollRemoteRouter(ctx context.Context, in *MsgUnrollRemoteRouter, opts ...grpc.CallOption) (*MsgUnrollRemoteRouterResponse, error) {
	out := new(MsgUnrollRemoteRouterResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/UnrollRemoteRouter", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) RemoteTransfer(ctx context.Context, in *MsgRemoteTransfer, opts ...grpc.CallOption) (*MsgRemoteTransferResponse, error) {
	out := new(MsgRemoteTransferResponse)
	err := c.cc.Invoke(ctx, "/hyperlane.warp.v1.Msg/RemoteTransfer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// CreateCollateralToken ...
	CreateCollateralToken(context.Context, *MsgCreateCollateralToken) (*MsgCreateCollateralTokenResponse, error)
	// CreateSyntheticToken ...
	CreateSyntheticToken(context.Context, *MsgCreateSyntheticToken) (*MsgCreateSyntheticTokenResponse, error)
	// CreateNativeSyntheticToken ...
	CreateNativeSyntheticToken(context.Context, *MsgCreateNativeSyntheticToken) (*MsgCreateSyntheticTokenResponse, error)
	// SetToken ...
	SetToken(context.Context, *MsgSetToken) (*MsgSetTokenResponse, error)
	// EnrollRemoteRouter ...
	EnrollRemoteRouter(context.Context, *MsgEnrollRemoteRouter) (*MsgEnrollRemoteRouterResponse, error)
	// UnrollRemoteRouter ...
	UnrollRemoteRouter(context.Context, *MsgUnrollRemoteRouter) (*MsgUnrollRemoteRouterResponse, error)
	// RemoteTransfer ...
	RemoteTransfer(context.Context, *MsgRemoteTransfer) (*MsgRemoteTransferResponse, error)
}

// UnimplementedMsgServer can be embedded to have forward compatible implementations.
type UnimplementedMsgServer struct {
}

func (*UnimplementedMsgServer) CreateCollateralToken(ctx context.Context, req *MsgCreateCollateralToken) (*MsgCreateCollateralTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCollateralToken not implemented")
}
func (*UnimplementedMsgServer) CreateSyntheticToken(ctx context.Context, req *MsgCreateSyntheticToken) (*MsgCreateSyntheticTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSyntheticToken not implemented")
}
func (*UnimplementedMsgServer) CreateNativeSyntheticToken(ctx context.Context, req *MsgCreateNativeSyntheticToken) (*MsgCreateSyntheticTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateNativeSyntheticToken not implemented")
}
func (*UnimplementedMsgServer) SetToken(ctx context.Context, req *MsgSetToken) (*MsgSetTokenResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetToken not implemented")
}
func (*UnimplementedMsgServer) EnrollRemoteRouter(ctx context.Context, req *MsgEnrollRemoteRouter) (*MsgEnrollRemoteRouterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EnrollRemoteRouter not implemented")
}
func (*UnimplementedMsgServer) UnrollRemoteRouter(ctx context.Context, req *MsgUnrollRemoteRouter) (*MsgUnrollRemoteRouterResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnrollRemoteRouter not implemented")
}
func (*UnimplementedMsgServer) RemoteTransfer(ctx context.Context, req *MsgRemoteTransfer) (*MsgRemoteTransferResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoteTransfer not implemented")
}

func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
	s.RegisterService(&_Msg_serviceDesc, srv)
}

func _Msg_CreateCollateralToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateCollateralToken)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateCollateralToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/CreateCollateralToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateCollateralToken(ctx, req.(*MsgCreateCollateralToken))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateSyntheticToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateSyntheticToken)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateSyntheticToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/CreateSyntheticToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateSyntheticToken(ctx, req.(*MsgCreateSyntheticToken))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_CreateNativeSyntheticToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateNativeSyntheticToken)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateNativeSyntheticToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/CreateNativeSyntheticToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateNativeSyntheticToken(ctx, req.(*MsgCreateNativeSyntheticToken))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SetToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetToken)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/SetToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetToken(ctx, req.(*MsgSetToken))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_EnrollRemoteRouter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgEnrollRemoteRouter)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).EnrollRemoteRouter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/EnrollRemoteRouter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).EnrollRemoteRouter(ctx, req.(*MsgEnrollRemoteRouter))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UnrollRemoteRouter_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUnrollRemoteRouter)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UnrollRemoteRouter(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/UnrollRemoteRouter",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UnrollRemoteRouter(ctx, req.(*MsgUnrollRemoteRouter))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_RemoteTransfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgRemoteTransfer)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).RemoteTransfer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/hyperlane.warp.v1.Msg/RemoteTransfer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).RemoteTransfer(ctx, req.(*MsgRemoteTransfer))
	}
	return interceptor(ctx, in, info, handler)
}

var Msg_serviceDesc = _Msg_serviceDesc
var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "hyperlane.warp.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateCollateralToken",
			Handler:    _Msg_CreateCollateralToken_Handler,
		},
		{
			MethodName: "CreateSyntheticToken",
			Handler:    _Msg_CreateSyntheticToken_Handler,
		},
		{
			MethodName: "CreateNativeSyntheticToken",
			Handler:    _Msg_CreateNativeSyntheticToken_Handler,
		},
		{
			MethodName: "SetToken",
			Handler:    _Msg_SetToken_Handler,
		},
		{
			MethodName: "EnrollRemoteRouter",
			Handler:    _Msg_EnrollRemoteRouter_Handler,
		},
		{
			MethodName: "UnrollRemoteRouter",
			Handler:    _Msg_UnrollRemoteRouter_Handler,
		},
		{
			MethodName: "RemoteTransfer",
			Handler:    _Msg_RemoteTransfer_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "hyperlane/warp/v1/tx.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgSetTokenResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgEnrollRemoteRouterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgUnrollRemoteRouterResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

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

func (m *MsgRemoteTransfer) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CustomHookMetadata) > 0 {
		i -= len(m.CustomHookMetadata)
		copy(dAtA[i:], m.CustomHookMetadata)
		i = encodeVarintTx(dAtA, i, uint64(len(m.CustomHookMetadata)))
		i--
		dAtA[i] = 0x4a
	}
	{
		size, err := m.MaxFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	{
		size := m.GasLimit.Size()
		i -= size
		if _, err := m.GasLimit.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	if m.CustomHookId != nil {
		{
			size := m.CustomHookId.Size()
			i -= size
			if _, err := m.CustomHookId.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	{
		size := m.Amount.Size()
		i -= size
		if _, err := m.Amount.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size := m.Recipient.Size()
		i -= size
		if _, err := m.Recipient.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if m.DestinationDomain != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.DestinationDomain))
		i--
		dAtA[i] = 0x18
	}
	{
		size := m.TokenId.Size()
		i -= size
		if _, err := m.TokenId.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.Sender) > 0 {
		i -= len(m.Sender)
		copy(dAtA[i:], m.Sender)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgCreateCollateralTokenResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Id.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

func (m *MsgCreateNativeSyntheticToken) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.OriginMailbox.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.OriginDenom)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgCreateSyntheticTokenResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Id.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

func (m *MsgSetToken) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.TokenId.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.NewOwner)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.IsmId != nil {
		l = m.IsmId.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	if m.RenounceOwnership {
		n += 2
	}
	return n
}

func (m *MsgSetTokenResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgEnrollRemoteRouter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.TokenId.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.RemoteRouter != nil {
		l = m.RemoteRouter.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgEnrollRemoteRouterResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgUnrollRemoteRouter) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.TokenId.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.ReceiverDomain != 0 {
		n += 1 + sovTx(uint64(m.ReceiverDomain))
	}
	return n
}

func (m *MsgUnrollRemoteRouterResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *MsgRemoteTransfer) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Sender)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.TokenId.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.DestinationDomain != 0 {
		n += 1 + sovTx(uint64(m.DestinationDomain))
	}
	l = m.Recipient.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.CustomHookId != nil {
		l = m.CustomHookId.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.GasLimit.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.MaxFee.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.CustomHookMetadata)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

func (m *MsgRemoteTransferResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MessageId.Size()
	n += 1 + l + sovTx(uint64(l))
	return n
}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSetTokenResponse) 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 ErrIntOverflowTx
			}
			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: MsgSetTokenResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetTokenResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEnrollRemoteRouterResponse) 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 ErrIntOverflowTx
			}
			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: MsgEnrollRemoteRouterResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEnrollRemoteRouterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUnrollRemoteRouterResponse) 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 ErrIntOverflowTx
			}
			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: MsgUnrollRemoteRouterResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUnrollRemoteRouterResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgRemoteTransfer) 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 ErrIntOverflowTx
			}
			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: MsgRemoteTransfer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgRemoteTransfer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sender = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TokenId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DestinationDomain", wireType)
			}
			m.DestinationDomain = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DestinationDomain |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Recipient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomHookId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			var v github_com_bcp_innovations_hyperlane_cosmos_util.HexAddress
			m.CustomHookId = &v
			if err := m.CustomHookId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GasLimit", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.GasLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxFee", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxFee.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomHookMetadata", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				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 ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CustomHookMetadata = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
