query.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: warmage/maker/v1/query.proto

package types

import (
	context "context"
	fmt "fmt"
	github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
	types "github.com/cosmos/cosmos-sdk/types"
	_ "github.com/gogo/protobuf/gogoproto"
	grpc1 "github.com/gogo/protobuf/grpc"
	proto "github.com/gogo/protobuf/proto"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	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

type QueryAllBackingRiskParamsRequest struct {
}

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

var xxx_messageInfo_QueryAllBackingRiskParamsRequest proto.InternalMessageInfo

type QueryAllBackingRiskParamsResponse struct {
	RiskParams []BackingRiskParams `protobuf:"bytes,1,rep,name=risk_params,json=riskParams,proto3" json:"risk_params"`
}

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

var xxx_messageInfo_QueryAllBackingRiskParamsResponse proto.InternalMessageInfo

func (m *QueryAllBackingRiskParamsResponse) GetRiskParams() []BackingRiskParams {
	if m != nil {
		return m.RiskParams
	}
	return nil
}

type QueryAllCollateralRiskParamsRequest struct {
}

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

var xxx_messageInfo_QueryAllCollateralRiskParamsRequest proto.InternalMessageInfo

type QueryAllCollateralRiskParamsResponse struct {
	RiskParams []CollateralRiskParams `protobuf:"bytes,1,rep,name=risk_params,json=riskParams,proto3" json:"risk_params"`
}

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

var xxx_messageInfo_QueryAllCollateralRiskParamsResponse proto.InternalMessageInfo

func (m *QueryAllCollateralRiskParamsResponse) GetRiskParams() []CollateralRiskParams {
	if m != nil {
		return m.RiskParams
	}
	return nil
}

type QueryAllBackingPoolsRequest struct {
}

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

var xxx_messageInfo_QueryAllBackingPoolsRequest proto.InternalMessageInfo

type QueryAllBackingPoolsResponse struct {
	BackingPools []PoolBacking `protobuf:"bytes,1,rep,name=backing_pools,json=backingPools,proto3" json:"backing_pools"`
}

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

var xxx_messageInfo_QueryAllBackingPoolsResponse proto.InternalMessageInfo

func (m *QueryAllBackingPoolsResponse) GetBackingPools() []PoolBacking {
	if m != nil {
		return m.BackingPools
	}
	return nil
}

type QueryAllCollateralPoolsRequest struct {
}

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

var xxx_messageInfo_QueryAllCollateralPoolsRequest proto.InternalMessageInfo

type QueryAllCollateralPoolsResponse struct {
	CollateralPools []PoolCollateral `protobuf:"bytes,1,rep,name=collateral_pools,json=collateralPools,proto3" json:"collateral_pools"`
}

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

var xxx_messageInfo_QueryAllCollateralPoolsResponse proto.InternalMessageInfo

func (m *QueryAllCollateralPoolsResponse) GetCollateralPools() []PoolCollateral {
	if m != nil {
		return m.CollateralPools
	}
	return nil
}

type QueryBackingPoolRequest struct {
	BackingDenom string `protobuf:"bytes,1,opt,name=backing_denom,json=backingDenom,proto3" json:"backing_denom,omitempty"`
}

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

var xxx_messageInfo_QueryBackingPoolRequest proto.InternalMessageInfo

func (m *QueryBackingPoolRequest) GetBackingDenom() string {
	if m != nil {
		return m.BackingDenom
	}
	return ""
}

type QueryBackingPoolResponse struct {
	BackingPool PoolBacking `protobuf:"bytes,1,opt,name=backing_pool,json=backingPool,proto3" json:"backing_pool"`
}

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

var xxx_messageInfo_QueryBackingPoolResponse proto.InternalMessageInfo

func (m *QueryBackingPoolResponse) GetBackingPool() PoolBacking {
	if m != nil {
		return m.BackingPool
	}
	return PoolBacking{}
}

type QueryCollateralPoolRequest struct {
	CollateralDenom string `protobuf:"bytes,1,opt,name=collateral_denom,json=collateralDenom,proto3" json:"collateral_denom,omitempty"`
}

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

var xxx_messageInfo_QueryCollateralPoolRequest proto.InternalMessageInfo

func (m *QueryCollateralPoolRequest) GetCollateralDenom() string {
	if m != nil {
		return m.CollateralDenom
	}
	return ""
}

type QueryCollateralPoolResponse struct {
	CollateralPool PoolCollateral `protobuf:"bytes,1,opt,name=collateral_pool,json=collateralPool,proto3" json:"collateral_pool"`
}

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

var xxx_messageInfo_QueryCollateralPoolResponse proto.InternalMessageInfo

func (m *QueryCollateralPoolResponse) GetCollateralPool() PoolCollateral {
	if m != nil {
		return m.CollateralPool
	}
	return PoolCollateral{}
}

type QueryCollateralOfAccountRequest struct {
	Account         string `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty"`
	CollateralDenom string `protobuf:"bytes,2,opt,name=collateral_denom,json=collateralDenom,proto3" json:"collateral_denom,omitempty"`
}

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

var xxx_messageInfo_QueryCollateralOfAccountRequest proto.InternalMessageInfo

func (m *QueryCollateralOfAccountRequest) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *QueryCollateralOfAccountRequest) GetCollateralDenom() string {
	if m != nil {
		return m.CollateralDenom
	}
	return ""
}

type QueryCollateralOfAccountResponse struct {
	AccountCollateral AccountCollateral `protobuf:"bytes,1,opt,name=account_collateral,json=accountCollateral,proto3" json:"account_collateral"`
}

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

var xxx_messageInfo_QueryCollateralOfAccountResponse proto.InternalMessageInfo

func (m *QueryCollateralOfAccountResponse) GetAccountCollateral() AccountCollateral {
	if m != nil {
		return m.AccountCollateral
	}
	return AccountCollateral{}
}

type QueryTotalBackingRequest struct {
}

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

var xxx_messageInfo_QueryTotalBackingRequest proto.InternalMessageInfo

type QueryTotalBackingResponse struct {
	TotalBacking TotalBacking `protobuf:"bytes,1,opt,name=total_backing,json=totalBacking,proto3" json:"total_backing"`
}

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

var xxx_messageInfo_QueryTotalBackingResponse proto.InternalMessageInfo

func (m *QueryTotalBackingResponse) GetTotalBacking() TotalBacking {
	if m != nil {
		return m.TotalBacking
	}
	return TotalBacking{}
}

type QueryTotalCollateralRequest struct {
}

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

var xxx_messageInfo_QueryTotalCollateralRequest proto.InternalMessageInfo

type QueryTotalCollateralResponse struct {
	TotalCollateral TotalCollateral `protobuf:"bytes,1,opt,name=total_collateral,json=totalCollateral,proto3" json:"total_collateral"`
}

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

var xxx_messageInfo_QueryTotalCollateralResponse proto.InternalMessageInfo

func (m *QueryTotalCollateralResponse) GetTotalCollateral() TotalCollateral {
	if m != nil {
		return m.TotalCollateral
	}
	return TotalCollateral{}
}

type QueryBackingRatioRequest struct {
}

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

var xxx_messageInfo_QueryBackingRatioRequest proto.InternalMessageInfo

type QueryBackingRatioResponse struct {
	BackingRatio    github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=backing_ratio,json=backingRatio,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"backing_ratio"`
	LastUpdateBlock int64                                  `protobuf:"varint,2,opt,name=last_update_block,json=lastUpdateBlock,proto3" json:"last_update_block,omitempty"`
}

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

var xxx_messageInfo_QueryBackingRatioResponse proto.InternalMessageInfo

func (m *QueryBackingRatioResponse) GetLastUpdateBlock() int64 {
	if m != nil {
		return m.LastUpdateBlock
	}
	return 0
}

// QueryParamsRequest is request type for the Query/Params RPC method.
type QueryParamsRequest struct {
}

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

var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo

// QueryParamsResponse is response type for the Query/Params RPC method.
type QueryParamsResponse struct {
	// params holds all the parameters of this module.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

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

var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo

func (m *QueryParamsResponse) GetParams() Params {
	if m != nil {
		return m.Params
	}
	return Params{}
}

type EstimateMintBySwapInRequest struct {
	MintOut      types.Coin `protobuf:"bytes,1,opt,name=mint_out,json=mintOut,proto3" json:"mint_out"`
	BackingDenom string     `protobuf:"bytes,2,opt,name=backing_denom,json=backingDenom,proto3" json:"backing_denom,omitempty"`
	FullBacking  bool       `protobuf:"varint,3,opt,name=full_backing,json=fullBacking,proto3" json:"full_backing,omitempty"`
}

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

var xxx_messageInfo_EstimateMintBySwapInRequest proto.InternalMessageInfo

func (m *EstimateMintBySwapInRequest) GetMintOut() types.Coin {
	if m != nil {
		return m.MintOut
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapInRequest) GetBackingDenom() string {
	if m != nil {
		return m.BackingDenom
	}
	return ""
}

func (m *EstimateMintBySwapInRequest) GetFullBacking() bool {
	if m != nil {
		return m.FullBacking
	}
	return false
}

type EstimateMintBySwapInResponse struct {
	BackingIn types.Coin `protobuf:"bytes,1,opt,name=backing_in,json=backingIn,proto3" json:"backing_in"`
	MageIn    types.Coin `protobuf:"bytes,2,opt,name=mage_in,json=mageIn,proto3" json:"mage_in"`
	MintFee   types.Coin `protobuf:"bytes,3,opt,name=mint_fee,json=mintFee,proto3" json:"mint_fee"`
}

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

var xxx_messageInfo_EstimateMintBySwapInResponse proto.InternalMessageInfo

func (m *EstimateMintBySwapInResponse) GetBackingIn() types.Coin {
	if m != nil {
		return m.BackingIn
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapInResponse) GetMageIn() types.Coin {
	if m != nil {
		return m.MageIn
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapInResponse) GetMintFee() types.Coin {
	if m != nil {
		return m.MintFee
	}
	return types.Coin{}
}

type EstimateMintBySwapOutRequest struct {
	BackingInMax types.Coin `protobuf:"bytes,1,opt,name=backing_in_max,json=backingInMax,proto3" json:"backing_in_max"`
	MageInMax    types.Coin `protobuf:"bytes,2,opt,name=mage_in_max,json=mageInMax,proto3" json:"mage_in_max"`
	FullBacking  bool       `protobuf:"varint,3,opt,name=full_backing,json=fullBacking,proto3" json:"full_backing,omitempty"`
}

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

var xxx_messageInfo_EstimateMintBySwapOutRequest proto.InternalMessageInfo

func (m *EstimateMintBySwapOutRequest) GetBackingInMax() types.Coin {
	if m != nil {
		return m.BackingInMax
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapOutRequest) GetMageInMax() types.Coin {
	if m != nil {
		return m.MageInMax
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapOutRequest) GetFullBacking() bool {
	if m != nil {
		return m.FullBacking
	}
	return false
}

type EstimateMintBySwapOutResponse struct {
	BackingIn types.Coin `protobuf:"bytes,1,opt,name=backing_in,json=backingIn,proto3" json:"backing_in"`
	MageIn    types.Coin `protobuf:"bytes,2,opt,name=mage_in,json=mageIn,proto3" json:"mage_in"`
	MintOut   types.Coin `protobuf:"bytes,3,opt,name=mint_out,json=mintOut,proto3" json:"mint_out"`
	MintFee   types.Coin `protobuf:"bytes,4,opt,name=mint_fee,json=mintFee,proto3" json:"mint_fee"`
}

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

var xxx_messageInfo_EstimateMintBySwapOutResponse proto.InternalMessageInfo

func (m *EstimateMintBySwapOutResponse) GetBackingIn() types.Coin {
	if m != nil {
		return m.BackingIn
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapOutResponse) GetMageIn() types.Coin {
	if m != nil {
		return m.MageIn
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapOutResponse) GetMintOut() types.Coin {
	if m != nil {
		return m.MintOut
	}
	return types.Coin{}
}

func (m *EstimateMintBySwapOutResponse) GetMintFee() types.Coin {
	if m != nil {
		return m.MintFee
	}
	return types.Coin{}
}

type EstimateBurnBySwapInRequest struct {
	BackingOutMax types.Coin `protobuf:"bytes,1,opt,name=backing_out_max,json=backingOutMax,proto3" json:"backing_out_max"`
	MageOutMax    types.Coin `protobuf:"bytes,2,opt,name=mage_out_max,json=mageOutMax,proto3" json:"mage_out_max"`
}

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

var xxx_messageInfo_EstimateBurnBySwapInRequest proto.InternalMessageInfo

func (m *EstimateBurnBySwapInRequest) GetBackingOutMax() types.Coin {
	if m != nil {
		return m.BackingOutMax
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapInRequest) GetMageOutMax() types.Coin {
	if m != nil {
		return m.MageOutMax
	}
	return types.Coin{}
}

type EstimateBurnBySwapInResponse struct {
	BurnIn     types.Coin `protobuf:"bytes,1,opt,name=burn_in,json=burnIn,proto3" json:"burn_in"`
	BackingOut types.Coin `protobuf:"bytes,2,opt,name=backing_out,json=backingOut,proto3" json:"backing_out"`
	MageOut    types.Coin `protobuf:"bytes,3,opt,name=mage_out,json=mageOut,proto3" json:"mage_out"`
	BurnFee    types.Coin `protobuf:"bytes,4,opt,name=burn_fee,json=burnFee,proto3" json:"burn_fee"`
}

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

var xxx_messageInfo_EstimateBurnBySwapInResponse proto.InternalMessageInfo

func (m *EstimateBurnBySwapInResponse) GetBurnIn() types.Coin {
	if m != nil {
		return m.BurnIn
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapInResponse) GetBackingOut() types.Coin {
	if m != nil {
		return m.BackingOut
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapInResponse) GetMageOut() types.Coin {
	if m != nil {
		return m.MageOut
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapInResponse) GetBurnFee() types.Coin {
	if m != nil {
		return m.BurnFee
	}
	return types.Coin{}
}

type EstimateBurnBySwapOutRequest struct {
	BurnIn       types.Coin `protobuf:"bytes,1,opt,name=burn_in,json=burnIn,proto3" json:"burn_in"`
	BackingDenom string     `protobuf:"bytes,2,opt,name=backing_denom,json=backingDenom,proto3" json:"backing_denom,omitempty"`
}

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

var xxx_messageInfo_EstimateBurnBySwapOutRequest proto.InternalMessageInfo

func (m *EstimateBurnBySwapOutRequest) GetBurnIn() types.Coin {
	if m != nil {
		return m.BurnIn
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapOutRequest) GetBackingDenom() string {
	if m != nil {
		return m.BackingDenom
	}
	return ""
}

type EstimateBurnBySwapOutResponse struct {
	BackingOut types.Coin `protobuf:"bytes,1,opt,name=backing_out,json=backingOut,proto3" json:"backing_out"`
	MageOut    types.Coin `protobuf:"bytes,2,opt,name=mage_out,json=mageOut,proto3" json:"mage_out"`
	BurnFee    types.Coin `protobuf:"bytes,3,opt,name=burn_fee,json=burnFee,proto3" json:"burn_fee"`
}

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

var xxx_messageInfo_EstimateBurnBySwapOutResponse proto.InternalMessageInfo

func (m *EstimateBurnBySwapOutResponse) GetBackingOut() types.Coin {
	if m != nil {
		return m.BackingOut
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapOutResponse) GetMageOut() types.Coin {
	if m != nil {
		return m.MageOut
	}
	return types.Coin{}
}

func (m *EstimateBurnBySwapOutResponse) GetBurnFee() types.Coin {
	if m != nil {
		return m.BurnFee
	}
	return types.Coin{}
}

type EstimateBuyBackingInRequest struct {
	BackingOut types.Coin `protobuf:"bytes,1,opt,name=backing_out,json=backingOut,proto3" json:"backing_out"`
}

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

var xxx_messageInfo_EstimateBuyBackingInRequest proto.InternalMessageInfo

func (m *EstimateBuyBackingInRequest) GetBackingOut() types.Coin {
	if m != nil {
		return m.BackingOut
	}
	return types.Coin{}
}

type EstimateBuyBackingInResponse struct {
	MageIn     types.Coin `protobuf:"bytes,1,opt,name=mage_in,json=mageIn,proto3" json:"mage_in"`
	BuybackFee types.Coin `protobuf:"bytes,2,opt,name=buyback_fee,json=buybackFee,proto3" json:"buyback_fee"`
}

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

var xxx_messageInfo_EstimateBuyBackingInResponse proto.InternalMessageInfo

func (m *EstimateBuyBackingInResponse) GetMageIn() types.Coin {
	if m != nil {
		return m.MageIn
	}
	return types.Coin{}
}

func (m *EstimateBuyBackingInResponse) GetBuybackFee() types.Coin {
	if m != nil {
		return m.BuybackFee
	}
	return types.Coin{}
}

type EstimateBuyBackingOutRequest struct {
	MageIn       types.Coin `protobuf:"bytes,1,opt,name=mage_in,json=mageIn,proto3" json:"mage_in"`
	BackingDenom string     `protobuf:"bytes,2,opt,name=backing_denom,json=backingDenom,proto3" json:"backing_denom,omitempty"`
}

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

var xxx_messageInfo_EstimateBuyBackingOutRequest proto.InternalMessageInfo

func (m *EstimateBuyBackingOutRequest) GetMageIn() types.Coin {
	if m != nil {
		return m.MageIn
	}
	return types.Coin{}
}

func (m *EstimateBuyBackingOutRequest) GetBackingDenom() string {
	if m != nil {
		return m.BackingDenom
	}
	return ""
}

type EstimateBuyBackingOutResponse struct {
	BackingOut types.Coin `protobuf:"bytes,1,opt,name=backing_out,json=backingOut,proto3" json:"backing_out"`
	BuybackFee types.Coin `protobuf:"bytes,2,opt,name=buyback_fee,json=buybackFee,proto3" json:"buyback_fee"`
}

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

var xxx_messageInfo_EstimateBuyBackingOutResponse proto.InternalMessageInfo

func (m *EstimateBuyBackingOutResponse) GetBackingOut() types.Coin {
	if m != nil {
		return m.BackingOut
	}
	return types.Coin{}
}

func (m *EstimateBuyBackingOutResponse) GetBuybackFee() types.Coin {
	if m != nil {
		return m.BuybackFee
	}
	return types.Coin{}
}

type EstimateSellBackingInRequest struct {
	MageOut      types.Coin `protobuf:"bytes,1,opt,name=mage_out,json=mageOut,proto3" json:"mage_out"`
	BackingDenom string     `protobuf:"bytes,2,opt,name=backing_denom,json=backingDenom,proto3" json:"backing_denom,omitempty"`
}

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

var xxx_messageInfo_EstimateSellBackingInRequest proto.InternalMessageInfo

func (m *EstimateSellBackingInRequest) GetMageOut() types.Coin {
	if m != nil {
		return m.MageOut
	}
	return types.Coin{}
}

func (m *EstimateSellBackingInRequest) GetBackingDenom() string {
	if m != nil {
		return m.BackingDenom
	}
	return ""
}

type EstimateSellBackingInResponse struct {
	BackingIn   types.Coin `protobuf:"bytes,1,opt,name=backing_in,json=backingIn,proto3" json:"backing_in"`
	SellbackFee types.Coin `protobuf:"bytes,2,opt,name=sellback_fee,json=sellbackFee,proto3" json:"sellback_fee"`
}

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

var xxx_messageInfo_EstimateSellBackingInResponse proto.InternalMessageInfo

func (m *EstimateSellBackingInResponse) GetBackingIn() types.Coin {
	if m != nil {
		return m.BackingIn
	}
	return types.Coin{}
}

func (m *EstimateSellBackingInResponse) GetSellbackFee() types.Coin {
	if m != nil {
		return m.SellbackFee
	}
	return types.Coin{}
}

type EstimateSellBackingOutRequest struct {
	BackingIn types.Coin `protobuf:"bytes,1,opt,name=backing_in,json=backingIn,proto3" json:"backing_in"`
}

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

var xxx_messageInfo_EstimateSellBackingOutRequest proto.InternalMessageInfo

func (m *EstimateSellBackingOutRequest) GetBackingIn() types.Coin {
	if m != nil {
		return m.BackingIn
	}
	return types.Coin{}
}

type EstimateSellBackingOutResponse struct {
	MageOut     types.Coin `protobuf:"bytes,1,opt,name=mage_out,json=mageOut,proto3" json:"mage_out"`
	SellbackFee types.Coin `protobuf:"bytes,2,opt,name=sellback_fee,json=sellbackFee,proto3" json:"sellback_fee"`
}

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

var xxx_messageInfo_EstimateSellBackingOutResponse proto.InternalMessageInfo

func (m *EstimateSellBackingOutResponse) GetMageOut() types.Coin {
	if m != nil {
		return m.MageOut
	}
	return types.Coin{}
}

func (m *EstimateSellBackingOutResponse) GetSellbackFee() types.Coin {
	if m != nil {
		return m.SellbackFee
	}
	return types.Coin{}
}

func init() {
	proto.RegisterType((*QueryAllBackingRiskParamsRequest)(nil), "warmage.maker.v1.QueryAllBackingRiskParamsRequest")
	proto.RegisterType((*QueryAllBackingRiskParamsResponse)(nil), "warmage.maker.v1.QueryAllBackingRiskParamsResponse")
	proto.RegisterType((*QueryAllCollateralRiskParamsRequest)(nil), "warmage.maker.v1.QueryAllCollateralRiskParamsRequest")
	proto.RegisterType((*QueryAllCollateralRiskParamsResponse)(nil), "warmage.maker.v1.QueryAllCollateralRiskParamsResponse")
	proto.RegisterType((*QueryAllBackingPoolsRequest)(nil), "warmage.maker.v1.QueryAllBackingPoolsRequest")
	proto.RegisterType((*QueryAllBackingPoolsResponse)(nil), "warmage.maker.v1.QueryAllBackingPoolsResponse")
	proto.RegisterType((*QueryAllCollateralPoolsRequest)(nil), "warmage.maker.v1.QueryAllCollateralPoolsRequest")
	proto.RegisterType((*QueryAllCollateralPoolsResponse)(nil), "warmage.maker.v1.QueryAllCollateralPoolsResponse")
	proto.RegisterType((*QueryBackingPoolRequest)(nil), "warmage.maker.v1.QueryBackingPoolRequest")
	proto.RegisterType((*QueryBackingPoolResponse)(nil), "warmage.maker.v1.QueryBackingPoolResponse")
	proto.RegisterType((*QueryCollateralPoolRequest)(nil), "warmage.maker.v1.QueryCollateralPoolRequest")
	proto.RegisterType((*QueryCollateralPoolResponse)(nil), "warmage.maker.v1.QueryCollateralPoolResponse")
	proto.RegisterType((*QueryCollateralOfAccountRequest)(nil), "warmage.maker.v1.QueryCollateralOfAccountRequest")
	proto.RegisterType((*QueryCollateralOfAccountResponse)(nil), "warmage.maker.v1.QueryCollateralOfAccountResponse")
	proto.RegisterType((*QueryTotalBackingRequest)(nil), "warmage.maker.v1.QueryTotalBackingRequest")
	proto.RegisterType((*QueryTotalBackingResponse)(nil), "warmage.maker.v1.QueryTotalBackingResponse")
	proto.RegisterType((*QueryTotalCollateralRequest)(nil), "warmage.maker.v1.QueryTotalCollateralRequest")
	proto.RegisterType((*QueryTotalCollateralResponse)(nil), "warmage.maker.v1.QueryTotalCollateralResponse")
	proto.RegisterType((*QueryBackingRatioRequest)(nil), "warmage.maker.v1.QueryBackingRatioRequest")
	proto.RegisterType((*QueryBackingRatioResponse)(nil), "warmage.maker.v1.QueryBackingRatioResponse")
	proto.RegisterType((*QueryParamsRequest)(nil), "warmage.maker.v1.QueryParamsRequest")
	proto.RegisterType((*QueryParamsResponse)(nil), "warmage.maker.v1.QueryParamsResponse")
	proto.RegisterType((*EstimateMintBySwapInRequest)(nil), "warmage.maker.v1.EstimateMintBySwapInRequest")
	proto.RegisterType((*EstimateMintBySwapInResponse)(nil), "warmage.maker.v1.EstimateMintBySwapInResponse")
	proto.RegisterType((*EstimateMintBySwapOutRequest)(nil), "warmage.maker.v1.EstimateMintBySwapOutRequest")
	proto.RegisterType((*EstimateMintBySwapOutResponse)(nil), "warmage.maker.v1.EstimateMintBySwapOutResponse")
	proto.RegisterType((*EstimateBurnBySwapInRequest)(nil), "warmage.maker.v1.EstimateBurnBySwapInRequest")
	proto.RegisterType((*EstimateBurnBySwapInResponse)(nil), "warmage.maker.v1.EstimateBurnBySwapInResponse")
	proto.RegisterType((*EstimateBurnBySwapOutRequest)(nil), "warmage.maker.v1.EstimateBurnBySwapOutRequest")
	proto.RegisterType((*EstimateBurnBySwapOutResponse)(nil), "warmage.maker.v1.EstimateBurnBySwapOutResponse")
	proto.RegisterType((*EstimateBuyBackingInRequest)(nil), "warmage.maker.v1.EstimateBuyBackingInRequest")
	proto.RegisterType((*EstimateBuyBackingInResponse)(nil), "warmage.maker.v1.EstimateBuyBackingInResponse")
	proto.RegisterType((*EstimateBuyBackingOutRequest)(nil), "warmage.maker.v1.EstimateBuyBackingOutRequest")
	proto.RegisterType((*EstimateBuyBackingOutResponse)(nil), "warmage.maker.v1.EstimateBuyBackingOutResponse")
	proto.RegisterType((*EstimateSellBackingInRequest)(nil), "warmage.maker.v1.EstimateSellBackingInRequest")
	proto.RegisterType((*EstimateSellBackingInResponse)(nil), "warmage.maker.v1.EstimateSellBackingInResponse")
	proto.RegisterType((*EstimateSellBackingOutRequest)(nil), "warmage.maker.v1.EstimateSellBackingOutRequest")
	proto.RegisterType((*EstimateSellBackingOutResponse)(nil), "warmage.maker.v1.EstimateSellBackingOutResponse")
}

func init() { proto.RegisterFile("warmage/maker/v1/query.proto", fileDescriptor_0c6c4552b535aace) }

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

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type QueryClient interface {
	// AllBackingRiskParams queries risk params of all the backing pools.
	AllBackingRiskParams(ctx context.Context, in *QueryAllBackingRiskParamsRequest, opts ...grpc.CallOption) (*QueryAllBackingRiskParamsResponse, error)
	// AllCollateralRiskParams queries risk params of all the collateral pools.
	AllCollateralRiskParams(ctx context.Context, in *QueryAllCollateralRiskParamsRequest, opts ...grpc.CallOption) (*QueryAllCollateralRiskParamsResponse, error)
	// AllBackingPools queries all the backing pools.
	AllBackingPools(ctx context.Context, in *QueryAllBackingPoolsRequest, opts ...grpc.CallOption) (*QueryAllBackingPoolsResponse, error)
	// AllCollateralPools queries all the collateral pools.
	AllCollateralPools(ctx context.Context, in *QueryAllCollateralPoolsRequest, opts ...grpc.CallOption) (*QueryAllCollateralPoolsResponse, error)
	// BackingPool queries a backing pool.
	BackingPool(ctx context.Context, in *QueryBackingPoolRequest, opts ...grpc.CallOption) (*QueryBackingPoolResponse, error)
	// CollateralPool queries a collateral pool.
	CollateralPool(ctx context.Context, in *QueryCollateralPoolRequest, opts ...grpc.CallOption) (*QueryCollateralPoolResponse, error)
	// CollateralOfAccount queries the collateral of an account.
	CollateralOfAccount(ctx context.Context, in *QueryCollateralOfAccountRequest, opts ...grpc.CallOption) (*QueryCollateralOfAccountResponse, error)
	// TotalBacking queries the total backing.
	TotalBacking(ctx context.Context, in *QueryTotalBackingRequest, opts ...grpc.CallOption) (*QueryTotalBackingResponse, error)
	// TotalCollateral queries the total collateral.
	TotalCollateral(ctx context.Context, in *QueryTotalCollateralRequest, opts ...grpc.CallOption) (*QueryTotalCollateralResponse, error)
	// BackingRatio queries the backing ratio.
	BackingRatio(ctx context.Context, in *QueryBackingRatioRequest, opts ...grpc.CallOption) (*QueryBackingRatioResponse, error)
	// Parameters queries the parameters of the module.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// EstimateMintBySwapIn estimates input of minting by swap.
	EstimateMintBySwapIn(ctx context.Context, in *EstimateMintBySwapInRequest, opts ...grpc.CallOption) (*EstimateMintBySwapInResponse, error)
	// EstimateMintBySwapOut estimates output of minting by swap.
	EstimateMintBySwapOut(ctx context.Context, in *EstimateMintBySwapOutRequest, opts ...grpc.CallOption) (*EstimateMintBySwapOutResponse, error)
	// EstimateBurnBySwapIn estimates input of burning by swap.
	EstimateBurnBySwapIn(ctx context.Context, in *EstimateBurnBySwapInRequest, opts ...grpc.CallOption) (*EstimateBurnBySwapInResponse, error)
	// EstimateBurnBySwapOut estimates output of burning by swap.
	EstimateBurnBySwapOut(ctx context.Context, in *EstimateBurnBySwapOutRequest, opts ...grpc.CallOption) (*EstimateBurnBySwapOutResponse, error)
	// EstimateBuyBackingIn estimates inpput of buying backing assets.
	EstimateBuyBackingIn(ctx context.Context, in *EstimateBuyBackingInRequest, opts ...grpc.CallOption) (*EstimateBuyBackingInResponse, error)
	// EstimateBuyBackingOut estimates output of buying backing assets.
	EstimateBuyBackingOut(ctx context.Context, in *EstimateBuyBackingOutRequest, opts ...grpc.CallOption) (*EstimateBuyBackingOutResponse, error)
	// EstimateSellBackingIn estimates input of selling backing assets.
	EstimateSellBackingIn(ctx context.Context, in *EstimateSellBackingInRequest, opts ...grpc.CallOption) (*EstimateSellBackingInResponse, error)
	// EstimateSellBackingOut estimates output of selling backing assets.
	EstimateSellBackingOut(ctx context.Context, in *EstimateSellBackingOutRequest, opts ...grpc.CallOption) (*EstimateSellBackingOutResponse, error)
}

type queryClient struct {
	cc grpc1.ClientConn
}

func NewQueryClient(cc grpc1.ClientConn) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) AllBackingRiskParams(ctx context.Context, in *QueryAllBackingRiskParamsRequest, opts ...grpc.CallOption) (*QueryAllBackingRiskParamsResponse, error) {
	out := new(QueryAllBackingRiskParamsResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/AllBackingRiskParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllCollateralRiskParams(ctx context.Context, in *QueryAllCollateralRiskParamsRequest, opts ...grpc.CallOption) (*QueryAllCollateralRiskParamsResponse, error) {
	out := new(QueryAllCollateralRiskParamsResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/AllCollateralRiskParams", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllBackingPools(ctx context.Context, in *QueryAllBackingPoolsRequest, opts ...grpc.CallOption) (*QueryAllBackingPoolsResponse, error) {
	out := new(QueryAllBackingPoolsResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/AllBackingPools", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) AllCollateralPools(ctx context.Context, in *QueryAllCollateralPoolsRequest, opts ...grpc.CallOption) (*QueryAllCollateralPoolsResponse, error) {
	out := new(QueryAllCollateralPoolsResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/AllCollateralPools", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BackingPool(ctx context.Context, in *QueryBackingPoolRequest, opts ...grpc.CallOption) (*QueryBackingPoolResponse, error) {
	out := new(QueryBackingPoolResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/BackingPool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollateralPool(ctx context.Context, in *QueryCollateralPoolRequest, opts ...grpc.CallOption) (*QueryCollateralPoolResponse, error) {
	out := new(QueryCollateralPoolResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/CollateralPool", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CollateralOfAccount(ctx context.Context, in *QueryCollateralOfAccountRequest, opts ...grpc.CallOption) (*QueryCollateralOfAccountResponse, error) {
	out := new(QueryCollateralOfAccountResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/CollateralOfAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TotalBacking(ctx context.Context, in *QueryTotalBackingRequest, opts ...grpc.CallOption) (*QueryTotalBackingResponse, error) {
	out := new(QueryTotalBackingResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/TotalBacking", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) TotalCollateral(ctx context.Context, in *QueryTotalCollateralRequest, opts ...grpc.CallOption) (*QueryTotalCollateralResponse, error) {
	out := new(QueryTotalCollateralResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/TotalCollateral", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BackingRatio(ctx context.Context, in *QueryBackingRatioRequest, opts ...grpc.CallOption) (*QueryBackingRatioResponse, error) {
	out := new(QueryBackingRatioResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/BackingRatio", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
	out := new(QueryParamsResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/Params", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateMintBySwapIn(ctx context.Context, in *EstimateMintBySwapInRequest, opts ...grpc.CallOption) (*EstimateMintBySwapInResponse, error) {
	out := new(EstimateMintBySwapInResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateMintBySwapIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateMintBySwapOut(ctx context.Context, in *EstimateMintBySwapOutRequest, opts ...grpc.CallOption) (*EstimateMintBySwapOutResponse, error) {
	out := new(EstimateMintBySwapOutResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateMintBySwapOut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateBurnBySwapIn(ctx context.Context, in *EstimateBurnBySwapInRequest, opts ...grpc.CallOption) (*EstimateBurnBySwapInResponse, error) {
	out := new(EstimateBurnBySwapInResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateBurnBySwapIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateBurnBySwapOut(ctx context.Context, in *EstimateBurnBySwapOutRequest, opts ...grpc.CallOption) (*EstimateBurnBySwapOutResponse, error) {
	out := new(EstimateBurnBySwapOutResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateBurnBySwapOut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateBuyBackingIn(ctx context.Context, in *EstimateBuyBackingInRequest, opts ...grpc.CallOption) (*EstimateBuyBackingInResponse, error) {
	out := new(EstimateBuyBackingInResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateBuyBackingIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateBuyBackingOut(ctx context.Context, in *EstimateBuyBackingOutRequest, opts ...grpc.CallOption) (*EstimateBuyBackingOutResponse, error) {
	out := new(EstimateBuyBackingOutResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateBuyBackingOut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateSellBackingIn(ctx context.Context, in *EstimateSellBackingInRequest, opts ...grpc.CallOption) (*EstimateSellBackingInResponse, error) {
	out := new(EstimateSellBackingInResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateSellBackingIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) EstimateSellBackingOut(ctx context.Context, in *EstimateSellBackingOutRequest, opts ...grpc.CallOption) (*EstimateSellBackingOutResponse, error) {
	out := new(EstimateSellBackingOutResponse)
	err := c.cc.Invoke(ctx, "/warmage.maker.v1.Query/EstimateSellBackingOut", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// QueryServer is the server API for Query service.
type QueryServer interface {
	// AllBackingRiskParams queries risk params of all the backing pools.
	AllBackingRiskParams(context.Context, *QueryAllBackingRiskParamsRequest) (*QueryAllBackingRiskParamsResponse, error)
	// AllCollateralRiskParams queries risk params of all the collateral pools.
	AllCollateralRiskParams(context.Context, *QueryAllCollateralRiskParamsRequest) (*QueryAllCollateralRiskParamsResponse, error)
	// AllBackingPools queries all the backing pools.
	AllBackingPools(context.Context, *QueryAllBackingPoolsRequest) (*QueryAllBackingPoolsResponse, error)
	// AllCollateralPools queries all the collateral pools.
	AllCollateralPools(context.Context, *QueryAllCollateralPoolsRequest) (*QueryAllCollateralPoolsResponse, error)
	// BackingPool queries a backing pool.
	BackingPool(context.Context, *QueryBackingPoolRequest) (*QueryBackingPoolResponse, error)
	// CollateralPool queries a collateral pool.
	CollateralPool(context.Context, *QueryCollateralPoolRequest) (*QueryCollateralPoolResponse, error)
	// CollateralOfAccount queries the collateral of an account.
	CollateralOfAccount(context.Context, *QueryCollateralOfAccountRequest) (*QueryCollateralOfAccountResponse, error)
	// TotalBacking queries the total backing.
	TotalBacking(context.Context, *QueryTotalBackingRequest) (*QueryTotalBackingResponse, error)
	// TotalCollateral queries the total collateral.
	TotalCollateral(context.Context, *QueryTotalCollateralRequest) (*QueryTotalCollateralResponse, error)
	// BackingRatio queries the backing ratio.
	BackingRatio(context.Context, *QueryBackingRatioRequest) (*QueryBackingRatioResponse, error)
	// Parameters queries the parameters of the module.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// EstimateMintBySwapIn estimates input of minting by swap.
	EstimateMintBySwapIn(context.Context, *EstimateMintBySwapInRequest) (*EstimateMintBySwapInResponse, error)
	// EstimateMintBySwapOut estimates output of minting by swap.
	EstimateMintBySwapOut(context.Context, *EstimateMintBySwapOutRequest) (*EstimateMintBySwapOutResponse, error)
	// EstimateBurnBySwapIn estimates input of burning by swap.
	EstimateBurnBySwapIn(context.Context, *EstimateBurnBySwapInRequest) (*EstimateBurnBySwapInResponse, error)
	// EstimateBurnBySwapOut estimates output of burning by swap.
	EstimateBurnBySwapOut(context.Context, *EstimateBurnBySwapOutRequest) (*EstimateBurnBySwapOutResponse, error)
	// EstimateBuyBackingIn estimates inpput of buying backing assets.
	EstimateBuyBackingIn(context.Context, *EstimateBuyBackingInRequest) (*EstimateBuyBackingInResponse, error)
	// EstimateBuyBackingOut estimates output of buying backing assets.
	EstimateBuyBackingOut(context.Context, *EstimateBuyBackingOutRequest) (*EstimateBuyBackingOutResponse, error)
	// EstimateSellBackingIn estimates input of selling backing assets.
	EstimateSellBackingIn(context.Context, *EstimateSellBackingInRequest) (*EstimateSellBackingInResponse, error)
	// EstimateSellBackingOut estimates output of selling backing assets.
	EstimateSellBackingOut(context.Context, *EstimateSellBackingOutRequest) (*EstimateSellBackingOutResponse, error)
}

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

func (*UnimplementedQueryServer) AllBackingRiskParams(ctx context.Context, req *QueryAllBackingRiskParamsRequest) (*QueryAllBackingRiskParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllBackingRiskParams not implemented")
}
func (*UnimplementedQueryServer) AllCollateralRiskParams(ctx context.Context, req *QueryAllCollateralRiskParamsRequest) (*QueryAllCollateralRiskParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllCollateralRiskParams not implemented")
}
func (*UnimplementedQueryServer) AllBackingPools(ctx context.Context, req *QueryAllBackingPoolsRequest) (*QueryAllBackingPoolsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllBackingPools not implemented")
}
func (*UnimplementedQueryServer) AllCollateralPools(ctx context.Context, req *QueryAllCollateralPoolsRequest) (*QueryAllCollateralPoolsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AllCollateralPools not implemented")
}
func (*UnimplementedQueryServer) BackingPool(ctx context.Context, req *QueryBackingPoolRequest) (*QueryBackingPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BackingPool not implemented")
}
func (*UnimplementedQueryServer) CollateralPool(ctx context.Context, req *QueryCollateralPoolRequest) (*QueryCollateralPoolResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollateralPool not implemented")
}
func (*UnimplementedQueryServer) CollateralOfAccount(ctx context.Context, req *QueryCollateralOfAccountRequest) (*QueryCollateralOfAccountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CollateralOfAccount not implemented")
}
func (*UnimplementedQueryServer) TotalBacking(ctx context.Context, req *QueryTotalBackingRequest) (*QueryTotalBackingResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TotalBacking not implemented")
}
func (*UnimplementedQueryServer) TotalCollateral(ctx context.Context, req *QueryTotalCollateralRequest) (*QueryTotalCollateralResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TotalCollateral not implemented")
}
func (*UnimplementedQueryServer) BackingRatio(ctx context.Context, req *QueryBackingRatioRequest) (*QueryBackingRatioResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BackingRatio not implemented")
}
func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
}
func (*UnimplementedQueryServer) EstimateMintBySwapIn(ctx context.Context, req *EstimateMintBySwapInRequest) (*EstimateMintBySwapInResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateMintBySwapIn not implemented")
}
func (*UnimplementedQueryServer) EstimateMintBySwapOut(ctx context.Context, req *EstimateMintBySwapOutRequest) (*EstimateMintBySwapOutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateMintBySwapOut not implemented")
}
func (*UnimplementedQueryServer) EstimateBurnBySwapIn(ctx context.Context, req *EstimateBurnBySwapInRequest) (*EstimateBurnBySwapInResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateBurnBySwapIn not implemented")
}
func (*UnimplementedQueryServer) EstimateBurnBySwapOut(ctx context.Context, req *EstimateBurnBySwapOutRequest) (*EstimateBurnBySwapOutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateBurnBySwapOut not implemented")
}
func (*UnimplementedQueryServer) EstimateBuyBackingIn(ctx context.Context, req *EstimateBuyBackingInRequest) (*EstimateBuyBackingInResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateBuyBackingIn not implemented")
}
func (*UnimplementedQueryServer) EstimateBuyBackingOut(ctx context.Context, req *EstimateBuyBackingOutRequest) (*EstimateBuyBackingOutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateBuyBackingOut not implemented")
}
func (*UnimplementedQueryServer) EstimateSellBackingIn(ctx context.Context, req *EstimateSellBackingInRequest) (*EstimateSellBackingInResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateSellBackingIn not implemented")
}
func (*UnimplementedQueryServer) EstimateSellBackingOut(ctx context.Context, req *EstimateSellBackingOutRequest) (*EstimateSellBackingOutResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EstimateSellBackingOut not implemented")
}

func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
	s.RegisterService(&_Query_serviceDesc, srv)
}

func _Query_AllBackingRiskParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllBackingRiskParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllBackingRiskParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/AllBackingRiskParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllBackingRiskParams(ctx, req.(*QueryAllBackingRiskParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AllCollateralRiskParams_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllCollateralRiskParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllCollateralRiskParams(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/AllCollateralRiskParams",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllCollateralRiskParams(ctx, req.(*QueryAllCollateralRiskParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AllBackingPools_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllBackingPoolsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllBackingPools(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/AllBackingPools",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllBackingPools(ctx, req.(*QueryAllBackingPoolsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_AllCollateralPools_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryAllCollateralPoolsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).AllCollateralPools(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/AllCollateralPools",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).AllCollateralPools(ctx, req.(*QueryAllCollateralPoolsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BackingPool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryBackingPoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BackingPool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/BackingPool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BackingPool(ctx, req.(*QueryBackingPoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollateralPool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCollateralPoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollateralPool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/CollateralPool",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollateralPool(ctx, req.(*QueryCollateralPoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CollateralOfAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryCollateralOfAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CollateralOfAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/CollateralOfAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CollateralOfAccount(ctx, req.(*QueryCollateralOfAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_TotalBacking_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTotalBackingRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).TotalBacking(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/TotalBacking",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).TotalBacking(ctx, req.(*QueryTotalBackingRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_TotalCollateral_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryTotalCollateralRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).TotalCollateral(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/TotalCollateral",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).TotalCollateral(ctx, req.(*QueryTotalCollateralRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BackingRatio_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryBackingRatioRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BackingRatio(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/BackingRatio",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BackingRatio(ctx, req.(*QueryBackingRatioRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryParamsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Params(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/Params",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateMintBySwapIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateMintBySwapInRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateMintBySwapIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateMintBySwapIn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateMintBySwapIn(ctx, req.(*EstimateMintBySwapInRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateMintBySwapOut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateMintBySwapOutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateMintBySwapOut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateMintBySwapOut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateMintBySwapOut(ctx, req.(*EstimateMintBySwapOutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateBurnBySwapIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateBurnBySwapInRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateBurnBySwapIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateBurnBySwapIn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateBurnBySwapIn(ctx, req.(*EstimateBurnBySwapInRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateBurnBySwapOut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateBurnBySwapOutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateBurnBySwapOut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateBurnBySwapOut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateBurnBySwapOut(ctx, req.(*EstimateBurnBySwapOutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateBuyBackingIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateBuyBackingInRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateBuyBackingIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateBuyBackingIn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateBuyBackingIn(ctx, req.(*EstimateBuyBackingInRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateBuyBackingOut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateBuyBackingOutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateBuyBackingOut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateBuyBackingOut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateBuyBackingOut(ctx, req.(*EstimateBuyBackingOutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateSellBackingIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateSellBackingInRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateSellBackingIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateSellBackingIn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateSellBackingIn(ctx, req.(*EstimateSellBackingInRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_EstimateSellBackingOut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EstimateSellBackingOutRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).EstimateSellBackingOut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/warmage.maker.v1.Query/EstimateSellBackingOut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).EstimateSellBackingOut(ctx, req.(*EstimateSellBackingOutRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Query_serviceDesc = grpc.ServiceDesc{
	ServiceName: "warmage.maker.v1.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "AllBackingRiskParams",
			Handler:    _Query_AllBackingRiskParams_Handler,
		},
		{
			MethodName: "AllCollateralRiskParams",
			Handler:    _Query_AllCollateralRiskParams_Handler,
		},
		{
			MethodName: "AllBackingPools",
			Handler:    _Query_AllBackingPools_Handler,
		},
		{
			MethodName: "AllCollateralPools",
			Handler:    _Query_AllCollateralPools_Handler,
		},
		{
			MethodName: "BackingPool",
			Handler:    _Query_BackingPool_Handler,
		},
		{
			MethodName: "CollateralPool",
			Handler:    _Query_CollateralPool_Handler,
		},
		{
			MethodName: "CollateralOfAccount",
			Handler:    _Query_CollateralOfAccount_Handler,
		},
		{
			MethodName: "TotalBacking",
			Handler:    _Query_TotalBacking_Handler,
		},
		{
			MethodName: "TotalCollateral",
			Handler:    _Query_TotalCollateral_Handler,
		},
		{
			MethodName: "BackingRatio",
			Handler:    _Query_BackingRatio_Handler,
		},
		{
			MethodName: "Params",
			Handler:    _Query_Params_Handler,
		},
		{
			MethodName: "EstimateMintBySwapIn",
			Handler:    _Query_EstimateMintBySwapIn_Handler,
		},
		{
			MethodName: "EstimateMintBySwapOut",
			Handler:    _Query_EstimateMintBySwapOut_Handler,
		},
		{
			MethodName: "EstimateBurnBySwapIn",
			Handler:    _Query_EstimateBurnBySwapIn_Handler,
		},
		{
			MethodName: "EstimateBurnBySwapOut",
			Handler:    _Query_EstimateBurnBySwapOut_Handler,
		},
		{
			MethodName: "EstimateBuyBackingIn",
			Handler:    _Query_EstimateBuyBackingIn_Handler,
		},
		{
			MethodName: "EstimateBuyBackingOut",
			Handler:    _Query_EstimateBuyBackingOut_Handler,
		},
		{
			MethodName: "EstimateSellBackingIn",
			Handler:    _Query_EstimateSellBackingIn_Handler,
		},
		{
			MethodName: "EstimateSellBackingOut",
			Handler:    _Query_EstimateSellBackingOut_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "warmage/maker/v1/query.proto",
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *EstimateMintBySwapInRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FullBacking {
		i--
		if m.FullBacking {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.BackingDenom) > 0 {
		i -= len(m.BackingDenom)
		copy(dAtA[i:], m.BackingDenom)
		i = encodeVarintQuery(dAtA, i, uint64(len(m.BackingDenom)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.MintOut.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EstimateMintBySwapInResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.MintFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.MageIn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.BackingIn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EstimateMintBySwapOutRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FullBacking {
		i--
		if m.FullBacking {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.MageInMax.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.BackingInMax.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *EstimateMintBySwapOutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.MintFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.MintOut.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.MageIn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.BackingIn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *EstimateBurnBySwapInResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.BurnFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.MageOut.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.BackingOut.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.BurnIn.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *EstimateBurnBySwapOutResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.BurnFee.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.MageOut.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.BackingOut.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQuery(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
	offset -= sovQuery(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *QueryAllBackingRiskParamsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

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

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

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

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

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

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

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

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

func (m *QueryBackingPoolResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingPool.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

func (m *QueryCollateralPoolResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.CollateralPool.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *QueryCollateralOfAccountRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	l = len(m.CollateralDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *QueryCollateralOfAccountResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.AccountCollateral.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

func (m *QueryTotalBackingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TotalBacking.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

func (m *QueryTotalCollateralResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TotalCollateral.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

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

func (m *QueryBackingRatioResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingRatio.Size()
	n += 1 + l + sovQuery(uint64(l))
	if m.LastUpdateBlock != 0 {
		n += 1 + sovQuery(uint64(m.LastUpdateBlock))
	}
	return n
}

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

func (m *QueryParamsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Params.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateMintBySwapInRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MintOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = len(m.BackingDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	if m.FullBacking {
		n += 2
	}
	return n
}

func (m *EstimateMintBySwapInResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MageIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MintFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateMintBySwapOutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingInMax.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MageInMax.Size()
	n += 1 + l + sovQuery(uint64(l))
	if m.FullBacking {
		n += 2
	}
	return n
}

func (m *EstimateMintBySwapOutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MageIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MintOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MintFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateBurnBySwapInRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingOutMax.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MageOutMax.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateBurnBySwapInResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BurnIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.BackingOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MageOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.BurnFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateBurnBySwapOutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BurnIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = len(m.BackingDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *EstimateBurnBySwapOutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.MageOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.BurnFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateBuyBackingInRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateBuyBackingInResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MageIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.BuybackFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateBuyBackingOutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MageIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = len(m.BackingDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *EstimateBuyBackingOutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.BuybackFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateSellBackingInRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MageOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = len(m.BackingDenom)
	if l > 0 {
		n += 1 + l + sovQuery(uint64(l))
	}
	return n
}

func (m *EstimateSellBackingInResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.SellbackFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateSellBackingOutRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.BackingIn.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func (m *EstimateSellBackingOutResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.MageOut.Size()
	n += 1 + l + sovQuery(uint64(l))
	l = m.SellbackFee.Size()
	n += 1 + l + sovQuery(uint64(l))
	return n
}

func sovQuery(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQuery(x uint64) (n int) {
	return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *QueryAllBackingRiskParamsRequest) 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 ErrIntOverflowQuery
			}
			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: QueryAllBackingRiskParamsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueryAllBackingRiskParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipQuery(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQuery
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)