tx.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: bonds/tx.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"
	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 MsgCreateBond struct {
	BondDid                  string                                   `protobuf:"bytes,1,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
	Token                    string                                   `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty" yaml:"token"`
	Name                     string                                   `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	Description              string                                   `protobuf:"bytes,4,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	FunctionType             string                                   `protobuf:"bytes,5,opt,name=function_type,json=functionType,proto3" json:"function_type,omitempty" yaml:"function_type"`
	FunctionParameters       FunctionParams                           `protobuf:"bytes,6,rep,name=function_parameters,json=functionParameters,proto3,castrepeated=FunctionParams" json:"function_parameters" yaml:"function_parameters"`
	CreatorDid               string                                   `protobuf:"bytes,7,opt,name=creator_did,json=creatorDid,proto3" json:"creator_did,omitempty" yaml:"creator_did"`
	ControllerDid            string                                   `protobuf:"bytes,8,opt,name=controller_did,json=controllerDid,proto3" json:"controller_did,omitempty" yaml:"controller_did"`
	ReserveTokens            []string                                 `protobuf:"bytes,9,rep,name=reserve_tokens,json=reserveTokens,proto3" json:"reserve_tokens,omitempty" yaml:"reserve_tokens"`
	TxFeePercentage          github_com_cosmos_cosmos_sdk_types.Dec   `protobuf:"bytes,10,opt,name=tx_fee_percentage,json=txFeePercentage,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"tx_fee_percentage" yaml:"tx_fee_percentage"`
	ExitFeePercentage        github_com_cosmos_cosmos_sdk_types.Dec   `protobuf:"bytes,11,opt,name=exit_fee_percentage,json=exitFeePercentage,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"exit_fee_percentage" yaml:"exit_fee_percentage"`
	FeeAddress               string                                   `protobuf:"bytes,12,opt,name=fee_address,json=feeAddress,proto3" json:"fee_address,omitempty" yaml:"fee_address"`
	ReserveWithdrawalAddress string                                   `protobuf:"bytes,13,opt,name=reserve_withdrawal_address,json=reserveWithdrawalAddress,proto3" json:"reserve_withdrawal_address,omitempty" yaml:"reserve_withdrawal_address"`
	MaxSupply                types.Coin                               `protobuf:"bytes,14,opt,name=max_supply,json=maxSupply,proto3" json:"max_supply" yaml:"max_supply"`
	OrderQuantityLimits      github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,15,rep,name=order_quantity_limits,json=orderQuantityLimits,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"order_quantity_limits" yaml:"order_quantity_limits"`
	SanityRate               github_com_cosmos_cosmos_sdk_types.Dec   `protobuf:"bytes,16,opt,name=sanity_rate,json=sanityRate,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"sanity_rate" yaml:"sanity_rate"`
	SanityMarginPercentage   github_com_cosmos_cosmos_sdk_types.Dec   `protobuf:"bytes,17,opt,name=sanity_margin_percentage,json=sanityMarginPercentage,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"sanity_margin_percentage" yaml:"sanity_margin_percentage"`
	AllowSells               bool                                     `protobuf:"varint,18,opt,name=allow_sells,json=allowSells,proto3" json:"allow_sells,omitempty" yaml:"allow_sells"`
	AllowReserveWithdrawals  bool                                     `protobuf:"varint,19,opt,name=allow_reserve_withdrawals,json=allowReserveWithdrawals,proto3" json:"allow_reserve_withdrawals,omitempty" yaml:"allow_reserve_withdrawals"`
	AlphaBond                bool                                     `protobuf:"varint,20,opt,name=alpha_bond,json=alphaBond,proto3" json:"alpha_bond,omitempty" yaml:"alpha_bond"`
	BatchBlocks              github_com_cosmos_cosmos_sdk_types.Uint  `protobuf:"bytes,21,opt,name=batch_blocks,json=batchBlocks,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Uint" json:"batch_blocks" yaml:"batch_blocks"`
	OutcomePayment           github_com_cosmos_cosmos_sdk_types.Int   `protobuf:"bytes,22,opt,name=outcome_payment,json=outcomePayment,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"outcome_payment" yaml:"outcome_payment"`
}

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

var xxx_messageInfo_MsgCreateBond proto.InternalMessageInfo

func (m *MsgCreateBond) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

func (m *MsgCreateBond) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *MsgCreateBond) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MsgCreateBond) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *MsgCreateBond) GetFunctionType() string {
	if m != nil {
		return m.FunctionType
	}
	return ""
}

func (m *MsgCreateBond) GetFunctionParameters() FunctionParams {
	if m != nil {
		return m.FunctionParameters
	}
	return nil
}

func (m *MsgCreateBond) GetCreatorDid() string {
	if m != nil {
		return m.CreatorDid
	}
	return ""
}

func (m *MsgCreateBond) GetControllerDid() string {
	if m != nil {
		return m.ControllerDid
	}
	return ""
}

func (m *MsgCreateBond) GetReserveTokens() []string {
	if m != nil {
		return m.ReserveTokens
	}
	return nil
}

func (m *MsgCreateBond) GetFeeAddress() string {
	if m != nil {
		return m.FeeAddress
	}
	return ""
}

func (m *MsgCreateBond) GetReserveWithdrawalAddress() string {
	if m != nil {
		return m.ReserveWithdrawalAddress
	}
	return ""
}

func (m *MsgCreateBond) GetMaxSupply() types.Coin {
	if m != nil {
		return m.MaxSupply
	}
	return types.Coin{}
}

func (m *MsgCreateBond) GetOrderQuantityLimits() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.OrderQuantityLimits
	}
	return nil
}

func (m *MsgCreateBond) GetAllowSells() bool {
	if m != nil {
		return m.AllowSells
	}
	return false
}

func (m *MsgCreateBond) GetAllowReserveWithdrawals() bool {
	if m != nil {
		return m.AllowReserveWithdrawals
	}
	return false
}

func (m *MsgCreateBond) GetAlphaBond() bool {
	if m != nil {
		return m.AlphaBond
	}
	return false
}

type MsgCreateBondResponse struct {
}

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

var xxx_messageInfo_MsgCreateBondResponse proto.InternalMessageInfo

type MsgEditBond struct {
	BondDid                string `protobuf:"bytes,1,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
	Name                   string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty" yaml:"name"`
	Description            string `protobuf:"bytes,3,opt,name=description,proto3" json:"description,omitempty" yaml:"description"`
	OrderQuantityLimits    string `protobuf:"bytes,4,opt,name=order_quantity_limits,json=orderQuantityLimits,proto3" json:"order_quantity_limits,omitempty" yaml:"order_quantity_limits"`
	SanityRate             string `protobuf:"bytes,5,opt,name=sanity_rate,json=sanityRate,proto3" json:"sanity_rate,omitempty" yaml:"sanity_rate"`
	SanityMarginPercentage string `protobuf:"bytes,6,opt,name=sanity_margin_percentage,json=sanityMarginPercentage,proto3" json:"sanity_margin_percentage,omitempty" yaml:"sanity_margin_percentage"`
	EditorDid              string `protobuf:"bytes,7,opt,name=editor_did,json=editorDid,proto3" json:"editor_did,omitempty" yaml:"editor_did"`
}

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

var xxx_messageInfo_MsgEditBond proto.InternalMessageInfo

func (m *MsgEditBond) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

func (m *MsgEditBond) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MsgEditBond) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *MsgEditBond) GetOrderQuantityLimits() string {
	if m != nil {
		return m.OrderQuantityLimits
	}
	return ""
}

func (m *MsgEditBond) GetSanityRate() string {
	if m != nil {
		return m.SanityRate
	}
	return ""
}

func (m *MsgEditBond) GetSanityMarginPercentage() string {
	if m != nil {
		return m.SanityMarginPercentage
	}
	return ""
}

func (m *MsgEditBond) GetEditorDid() string {
	if m != nil {
		return m.EditorDid
	}
	return ""
}

type MsgEditBondResponse struct {
}

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

var xxx_messageInfo_MsgEditBondResponse proto.InternalMessageInfo

type MsgSetNextAlpha struct {
	BondDid   string                                 `protobuf:"bytes,1,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
	Alpha     github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=alpha,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"alpha" yaml:"alpha"`
	EditorDid string                                 `protobuf:"bytes,3,opt,name=editor_did,json=editorDid,proto3" json:"editor_did,omitempty" yaml:"editor_did"`
}

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

var xxx_messageInfo_MsgSetNextAlpha proto.InternalMessageInfo

func (m *MsgSetNextAlpha) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

func (m *MsgSetNextAlpha) GetEditorDid() string {
	if m != nil {
		return m.EditorDid
	}
	return ""
}

type MsgSetNextAlphaResponse struct {
}

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

var xxx_messageInfo_MsgSetNextAlphaResponse proto.InternalMessageInfo

type MsgUpdateBondState struct {
	BondDid   string `protobuf:"bytes,1,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
	State     string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty" yaml:"state"`
	EditorDid string `protobuf:"bytes,3,opt,name=editor_did,json=editorDid,proto3" json:"editor_did,omitempty" yaml:"editor_did"`
}

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

var xxx_messageInfo_MsgUpdateBondState proto.InternalMessageInfo

func (m *MsgUpdateBondState) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

func (m *MsgUpdateBondState) GetState() string {
	if m != nil {
		return m.State
	}
	return ""
}

func (m *MsgUpdateBondState) GetEditorDid() string {
	if m != nil {
		return m.EditorDid
	}
	return ""
}

type MsgUpdateBondStateResponse struct {
}

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

var xxx_messageInfo_MsgUpdateBondStateResponse proto.InternalMessageInfo

type MsgBuy struct {
	BuyerDid  string                                   `protobuf:"bytes,1,opt,name=buyer_did,json=buyerDid,proto3" json:"buyer_did,omitempty" yaml:"buyer_did"`
	Amount    types.Coin                               `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount" yaml:"amount"`
	MaxPrices github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=max_prices,json=maxPrices,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"max_prices" yaml:"max_prices"`
	BondDid   string                                   `protobuf:"bytes,4,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
}

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

var xxx_messageInfo_MsgBuy proto.InternalMessageInfo

func (m *MsgBuy) GetBuyerDid() string {
	if m != nil {
		return m.BuyerDid
	}
	return ""
}

func (m *MsgBuy) GetAmount() types.Coin {
	if m != nil {
		return m.Amount
	}
	return types.Coin{}
}

func (m *MsgBuy) GetMaxPrices() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.MaxPrices
	}
	return nil
}

func (m *MsgBuy) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

type MsgBuyResponse struct {
}

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

var xxx_messageInfo_MsgBuyResponse proto.InternalMessageInfo

type MsgSell struct {
	SellerDid string     `protobuf:"bytes,1,opt,name=seller_did,json=sellerDid,proto3" json:"seller_did,omitempty" yaml:"seller_did"`
	Amount    types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount" yaml:"amount"`
	BondDid   string     `protobuf:"bytes,3,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
}

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

var xxx_messageInfo_MsgSell proto.InternalMessageInfo

func (m *MsgSell) GetSellerDid() string {
	if m != nil {
		return m.SellerDid
	}
	return ""
}

func (m *MsgSell) GetAmount() types.Coin {
	if m != nil {
		return m.Amount
	}
	return types.Coin{}
}

func (m *MsgSell) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

type MsgSellResponse struct {
}

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

var xxx_messageInfo_MsgSellResponse proto.InternalMessageInfo

type MsgSwap struct {
	SwapperDid string     `protobuf:"bytes,1,opt,name=swapper_did,json=swapperDid,proto3" json:"swapper_did,omitempty" yaml:"swapper_did"`
	BondDid    string     `protobuf:"bytes,2,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
	From       types.Coin `protobuf:"bytes,3,opt,name=from,proto3" json:"from" yaml:"from"`
	ToToken    string     `protobuf:"bytes,4,opt,name=to_token,json=toToken,proto3" json:"to_token,omitempty" yaml:"to_token"`
}

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

var xxx_messageInfo_MsgSwap proto.InternalMessageInfo

func (m *MsgSwap) GetSwapperDid() string {
	if m != nil {
		return m.SwapperDid
	}
	return ""
}

func (m *MsgSwap) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

func (m *MsgSwap) GetFrom() types.Coin {
	if m != nil {
		return m.From
	}
	return types.Coin{}
}

func (m *MsgSwap) GetToToken() string {
	if m != nil {
		return m.ToToken
	}
	return ""
}

type MsgSwapResponse struct {
}

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

var xxx_messageInfo_MsgSwapResponse proto.InternalMessageInfo

type MsgMakeOutcomePayment struct {
	SenderDid string                                 `protobuf:"bytes,1,opt,name=sender_did,json=senderDid,proto3" json:"sender_did,omitempty" yaml:"sender_did"`
	Amount    github_com_cosmos_cosmos_sdk_types.Int `protobuf:"bytes,2,opt,name=amount,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Int" json:"amount" yaml:"amount"`
	BondDid   string                                 `protobuf:"bytes,3,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
}

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

var xxx_messageInfo_MsgMakeOutcomePayment proto.InternalMessageInfo

func (m *MsgMakeOutcomePayment) GetSenderDid() string {
	if m != nil {
		return m.SenderDid
	}
	return ""
}

func (m *MsgMakeOutcomePayment) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

type MsgMakeOutcomePaymentResponse struct {
}

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

var xxx_messageInfo_MsgMakeOutcomePaymentResponse proto.InternalMessageInfo

type MsgWithdrawShare struct {
	RecipientDid string `protobuf:"bytes,1,opt,name=recipient_did,json=recipientDid,proto3" json:"recipient_did,omitempty" yaml:"recipient_did"`
	BondDid      string `protobuf:"bytes,2,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
}

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

var xxx_messageInfo_MsgWithdrawShare proto.InternalMessageInfo

func (m *MsgWithdrawShare) GetRecipientDid() string {
	if m != nil {
		return m.RecipientDid
	}
	return ""
}

func (m *MsgWithdrawShare) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

type MsgWithdrawShareResponse struct {
}

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

var xxx_messageInfo_MsgWithdrawShareResponse proto.InternalMessageInfo

type MsgWithdrawReserve struct {
	WithdrawerDid string                                   `protobuf:"bytes,1,opt,name=withdrawer_did,json=withdrawerDid,proto3" json:"withdrawer_did,omitempty" yaml:"withdrawer_did"`
	Amount        github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"amount" yaml:"amount"`
	BondDid       string                                   `protobuf:"bytes,3,opt,name=bond_did,json=bondDid,proto3" json:"bond_did,omitempty" yaml:"bond_did"`
}

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

var xxx_messageInfo_MsgWithdrawReserve proto.InternalMessageInfo

func (m *MsgWithdrawReserve) GetWithdrawerDid() string {
	if m != nil {
		return m.WithdrawerDid
	}
	return ""
}

func (m *MsgWithdrawReserve) GetAmount() github_com_cosmos_cosmos_sdk_types.Coins {
	if m != nil {
		return m.Amount
	}
	return nil
}

func (m *MsgWithdrawReserve) GetBondDid() string {
	if m != nil {
		return m.BondDid
	}
	return ""
}

type MsgWithdrawReserveResponse struct {
}

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

var xxx_messageInfo_MsgWithdrawReserveResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreateBond)(nil), "bonds.MsgCreateBond")
	proto.RegisterType((*MsgCreateBondResponse)(nil), "bonds.MsgCreateBondResponse")
	proto.RegisterType((*MsgEditBond)(nil), "bonds.MsgEditBond")
	proto.RegisterType((*MsgEditBondResponse)(nil), "bonds.MsgEditBondResponse")
	proto.RegisterType((*MsgSetNextAlpha)(nil), "bonds.MsgSetNextAlpha")
	proto.RegisterType((*MsgSetNextAlphaResponse)(nil), "bonds.MsgSetNextAlphaResponse")
	proto.RegisterType((*MsgUpdateBondState)(nil), "bonds.MsgUpdateBondState")
	proto.RegisterType((*MsgUpdateBondStateResponse)(nil), "bonds.MsgUpdateBondStateResponse")
	proto.RegisterType((*MsgBuy)(nil), "bonds.MsgBuy")
	proto.RegisterType((*MsgBuyResponse)(nil), "bonds.MsgBuyResponse")
	proto.RegisterType((*MsgSell)(nil), "bonds.MsgSell")
	proto.RegisterType((*MsgSellResponse)(nil), "bonds.MsgSellResponse")
	proto.RegisterType((*MsgSwap)(nil), "bonds.MsgSwap")
	proto.RegisterType((*MsgSwapResponse)(nil), "bonds.MsgSwapResponse")
	proto.RegisterType((*MsgMakeOutcomePayment)(nil), "bonds.MsgMakeOutcomePayment")
	proto.RegisterType((*MsgMakeOutcomePaymentResponse)(nil), "bonds.MsgMakeOutcomePaymentResponse")
	proto.RegisterType((*MsgWithdrawShare)(nil), "bonds.MsgWithdrawShare")
	proto.RegisterType((*MsgWithdrawShareResponse)(nil), "bonds.MsgWithdrawShareResponse")
	proto.RegisterType((*MsgWithdrawReserve)(nil), "bonds.MsgWithdrawReserve")
	proto.RegisterType((*MsgWithdrawReserveResponse)(nil), "bonds.MsgWithdrawReserveResponse")
}

func init() { proto.RegisterFile("bonds/tx.proto", fileDescriptor_27ad5b938c9f2476) }

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

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

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

// MsgClient is the client API for Msg service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MsgClient interface {
	CreateBond(ctx context.Context, in *MsgCreateBond, opts ...grpc.CallOption) (*MsgCreateBondResponse, error)
	EditBond(ctx context.Context, in *MsgEditBond, opts ...grpc.CallOption) (*MsgEditBondResponse, error)
	SetNextAlpha(ctx context.Context, in *MsgSetNextAlpha, opts ...grpc.CallOption) (*MsgSetNextAlphaResponse, error)
	UpdateBondState(ctx context.Context, in *MsgUpdateBondState, opts ...grpc.CallOption) (*MsgUpdateBondStateResponse, error)
	Buy(ctx context.Context, in *MsgBuy, opts ...grpc.CallOption) (*MsgBuyResponse, error)
	Sell(ctx context.Context, in *MsgSell, opts ...grpc.CallOption) (*MsgSellResponse, error)
	Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error)
	MakeOutcomePayment(ctx context.Context, in *MsgMakeOutcomePayment, opts ...grpc.CallOption) (*MsgMakeOutcomePaymentResponse, error)
	WithdrawShare(ctx context.Context, in *MsgWithdrawShare, opts ...grpc.CallOption) (*MsgWithdrawShareResponse, error)
	WithdrawReserve(ctx context.Context, in *MsgWithdrawReserve, opts ...grpc.CallOption) (*MsgWithdrawReserveResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) CreateBond(ctx context.Context, in *MsgCreateBond, opts ...grpc.CallOption) (*MsgCreateBondResponse, error) {
	out := new(MsgCreateBondResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/CreateBond", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) EditBond(ctx context.Context, in *MsgEditBond, opts ...grpc.CallOption) (*MsgEditBondResponse, error) {
	out := new(MsgEditBondResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/EditBond", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) SetNextAlpha(ctx context.Context, in *MsgSetNextAlpha, opts ...grpc.CallOption) (*MsgSetNextAlphaResponse, error) {
	out := new(MsgSetNextAlphaResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/SetNextAlpha", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateBondState(ctx context.Context, in *MsgUpdateBondState, opts ...grpc.CallOption) (*MsgUpdateBondStateResponse, error) {
	out := new(MsgUpdateBondStateResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/UpdateBondState", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Buy(ctx context.Context, in *MsgBuy, opts ...grpc.CallOption) (*MsgBuyResponse, error) {
	out := new(MsgBuyResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/Buy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Sell(ctx context.Context, in *MsgSell, opts ...grpc.CallOption) (*MsgSellResponse, error) {
	out := new(MsgSellResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/Sell", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error) {
	out := new(MsgSwapResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/Swap", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) MakeOutcomePayment(ctx context.Context, in *MsgMakeOutcomePayment, opts ...grpc.CallOption) (*MsgMakeOutcomePaymentResponse, error) {
	out := new(MsgMakeOutcomePaymentResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/MakeOutcomePayment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawShare(ctx context.Context, in *MsgWithdrawShare, opts ...grpc.CallOption) (*MsgWithdrawShareResponse, error) {
	out := new(MsgWithdrawShareResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/WithdrawShare", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) WithdrawReserve(ctx context.Context, in *MsgWithdrawReserve, opts ...grpc.CallOption) (*MsgWithdrawReserveResponse, error) {
	out := new(MsgWithdrawReserveResponse)
	err := c.cc.Invoke(ctx, "/bonds.Msg/WithdrawReserve", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	CreateBond(context.Context, *MsgCreateBond) (*MsgCreateBondResponse, error)
	EditBond(context.Context, *MsgEditBond) (*MsgEditBondResponse, error)
	SetNextAlpha(context.Context, *MsgSetNextAlpha) (*MsgSetNextAlphaResponse, error)
	UpdateBondState(context.Context, *MsgUpdateBondState) (*MsgUpdateBondStateResponse, error)
	Buy(context.Context, *MsgBuy) (*MsgBuyResponse, error)
	Sell(context.Context, *MsgSell) (*MsgSellResponse, error)
	Swap(context.Context, *MsgSwap) (*MsgSwapResponse, error)
	MakeOutcomePayment(context.Context, *MsgMakeOutcomePayment) (*MsgMakeOutcomePaymentResponse, error)
	WithdrawShare(context.Context, *MsgWithdrawShare) (*MsgWithdrawShareResponse, error)
	WithdrawReserve(context.Context, *MsgWithdrawReserve) (*MsgWithdrawReserveResponse, error)
}

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

func (*UnimplementedMsgServer) CreateBond(ctx context.Context, req *MsgCreateBond) (*MsgCreateBondResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateBond not implemented")
}
func (*UnimplementedMsgServer) EditBond(ctx context.Context, req *MsgEditBond) (*MsgEditBondResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EditBond not implemented")
}
func (*UnimplementedMsgServer) SetNextAlpha(ctx context.Context, req *MsgSetNextAlpha) (*MsgSetNextAlphaResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetNextAlpha not implemented")
}
func (*UnimplementedMsgServer) UpdateBondState(ctx context.Context, req *MsgUpdateBondState) (*MsgUpdateBondStateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateBondState not implemented")
}
func (*UnimplementedMsgServer) Buy(ctx context.Context, req *MsgBuy) (*MsgBuyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Buy not implemented")
}
func (*UnimplementedMsgServer) Sell(ctx context.Context, req *MsgSell) (*MsgSellResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sell not implemented")
}
func (*UnimplementedMsgServer) Swap(ctx context.Context, req *MsgSwap) (*MsgSwapResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Swap not implemented")
}
func (*UnimplementedMsgServer) MakeOutcomePayment(ctx context.Context, req *MsgMakeOutcomePayment) (*MsgMakeOutcomePaymentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MakeOutcomePayment not implemented")
}
func (*UnimplementedMsgServer) WithdrawShare(ctx context.Context, req *MsgWithdrawShare) (*MsgWithdrawShareResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawShare not implemented")
}
func (*UnimplementedMsgServer) WithdrawReserve(ctx context.Context, req *MsgWithdrawReserve) (*MsgWithdrawReserveResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method WithdrawReserve not implemented")
}

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

func _Msg_CreateBond_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgCreateBond)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).CreateBond(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/CreateBond",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).CreateBond(ctx, req.(*MsgCreateBond))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_EditBond_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgEditBond)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).EditBond(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/EditBond",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).EditBond(ctx, req.(*MsgEditBond))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_SetNextAlpha_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSetNextAlpha)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).SetNextAlpha(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/SetNextAlpha",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).SetNextAlpha(ctx, req.(*MsgSetNextAlpha))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_UpdateBondState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgUpdateBondState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).UpdateBondState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/UpdateBondState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).UpdateBondState(ctx, req.(*MsgUpdateBondState))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Buy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgBuy)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Buy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/Buy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Buy(ctx, req.(*MsgBuy))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Sell_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSell)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Sell(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/Sell",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Sell(ctx, req.(*MsgSell))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_Swap_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgSwap)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).Swap(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/Swap",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).Swap(ctx, req.(*MsgSwap))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_MakeOutcomePayment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgMakeOutcomePayment)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).MakeOutcomePayment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/MakeOutcomePayment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).MakeOutcomePayment(ctx, req.(*MsgMakeOutcomePayment))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawShare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawShare)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawShare(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/WithdrawShare",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawShare(ctx, req.(*MsgWithdrawShare))
	}
	return interceptor(ctx, in, info, handler)
}

func _Msg_WithdrawReserve_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MsgWithdrawReserve)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MsgServer).WithdrawReserve(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/bonds.Msg/WithdrawReserve",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MsgServer).WithdrawReserve(ctx, req.(*MsgWithdrawReserve))
	}
	return interceptor(ctx, in, info, handler)
}

var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "bonds.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateBond",
			Handler:    _Msg_CreateBond_Handler,
		},
		{
			MethodName: "EditBond",
			Handler:    _Msg_EditBond_Handler,
		},
		{
			MethodName: "SetNextAlpha",
			Handler:    _Msg_SetNextAlpha_Handler,
		},
		{
			MethodName: "UpdateBondState",
			Handler:    _Msg_UpdateBondState_Handler,
		},
		{
			MethodName: "Buy",
			Handler:    _Msg_Buy_Handler,
		},
		{
			MethodName: "Sell",
			Handler:    _Msg_Sell_Handler,
		},
		{
			MethodName: "Swap",
			Handler:    _Msg_Swap_Handler,
		},
		{
			MethodName: "MakeOutcomePayment",
			Handler:    _Msg_MakeOutcomePayment_Handler,
		},
		{
			MethodName: "WithdrawShare",
			Handler:    _Msg_WithdrawShare_Handler,
		},
		{
			MethodName: "WithdrawReserve",
			Handler:    _Msg_WithdrawReserve_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "bonds/tx.proto",
}

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

func (m *MsgCreateBond) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size := m.OutcomePayment.Size()
		i -= size
		if _, err := m.OutcomePayment.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xb2
	{
		size := m.BatchBlocks.Size()
		i -= size
		if _, err := m.BatchBlocks.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xaa
	if m.AlphaBond {
		i--
		if m.AlphaBond {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa0
	}
	if m.AllowReserveWithdrawals {
		i--
		if m.AllowReserveWithdrawals {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x98
	}
	if m.AllowSells {
		i--
		if m.AllowSells {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x90
	}
	{
		size := m.SanityMarginPercentage.Size()
		i -= size
		if _, err := m.SanityMarginPercentage.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x8a
	{
		size := m.SanityRate.Size()
		i -= size
		if _, err := m.SanityRate.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	if len(m.OrderQuantityLimits) > 0 {
		for iNdEx := len(m.OrderQuantityLimits) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.OrderQuantityLimits[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x7a
		}
	}
	{
		size, err := m.MaxSupply.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x72
	if len(m.ReserveWithdrawalAddress) > 0 {
		i -= len(m.ReserveWithdrawalAddress)
		copy(dAtA[i:], m.ReserveWithdrawalAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ReserveWithdrawalAddress)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.FeeAddress) > 0 {
		i -= len(m.FeeAddress)
		copy(dAtA[i:], m.FeeAddress)
		i = encodeVarintTx(dAtA, i, uint64(len(m.FeeAddress)))
		i--
		dAtA[i] = 0x62
	}
	{
		size := m.ExitFeePercentage.Size()
		i -= size
		if _, err := m.ExitFeePercentage.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x5a
	{
		size := m.TxFeePercentage.Size()
		i -= size
		if _, err := m.TxFeePercentage.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x52
	if len(m.ReserveTokens) > 0 {
		for iNdEx := len(m.ReserveTokens) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ReserveTokens[iNdEx])
			copy(dAtA[i:], m.ReserveTokens[iNdEx])
			i = encodeVarintTx(dAtA, i, uint64(len(m.ReserveTokens[iNdEx])))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.ControllerDid) > 0 {
		i -= len(m.ControllerDid)
		copy(dAtA[i:], m.ControllerDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ControllerDid)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.CreatorDid) > 0 {
		i -= len(m.CreatorDid)
		copy(dAtA[i:], m.CreatorDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.CreatorDid)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.FunctionParameters) > 0 {
		for iNdEx := len(m.FunctionParameters) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.FunctionParameters[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.FunctionType) > 0 {
		i -= len(m.FunctionType)
		copy(dAtA[i:], m.FunctionType)
		i = encodeVarintTx(dAtA, i, uint64(len(m.FunctionType)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgEditBond) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EditorDid) > 0 {
		i -= len(m.EditorDid)
		copy(dAtA[i:], m.EditorDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.EditorDid)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.SanityMarginPercentage) > 0 {
		i -= len(m.SanityMarginPercentage)
		copy(dAtA[i:], m.SanityMarginPercentage)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SanityMarginPercentage)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.SanityRate) > 0 {
		i -= len(m.SanityRate)
		copy(dAtA[i:], m.SanityRate)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SanityRate)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.OrderQuantityLimits) > 0 {
		i -= len(m.OrderQuantityLimits)
		copy(dAtA[i:], m.OrderQuantityLimits)
		i = encodeVarintTx(dAtA, i, uint64(len(m.OrderQuantityLimits)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgUpdateBondState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.EditorDid) > 0 {
		i -= len(m.EditorDid)
		copy(dAtA[i:], m.EditorDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.EditorDid)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.State) > 0 {
		i -= len(m.State)
		copy(dAtA[i:], m.State)
		i = encodeVarintTx(dAtA, i, uint64(len(m.State)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgBuy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.MaxPrices) > 0 {
		for iNdEx := len(m.MaxPrices) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MaxPrices[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.BuyerDid) > 0 {
		i -= len(m.BuyerDid)
		copy(dAtA[i:], m.BuyerDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BuyerDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSell) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if len(m.SellerDid) > 0 {
		i -= len(m.SellerDid)
		copy(dAtA[i:], m.SellerDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SellerDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgSwap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ToToken) > 0 {
		i -= len(m.ToToken)
		copy(dAtA[i:], m.ToToken)
		i = encodeVarintTx(dAtA, i, uint64(len(m.ToToken)))
		i--
		dAtA[i] = 0x22
	}
	{
		size, err := m.From.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.SwapperDid) > 0 {
		i -= len(m.SwapperDid)
		copy(dAtA[i:], m.SwapperDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.SwapperDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgWithdrawReserve) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BondDid) > 0 {
		i -= len(m.BondDid)
		copy(dAtA[i:], m.BondDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.BondDid)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Amount) > 0 {
		for iNdEx := len(m.Amount) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Amount[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.WithdrawerDid) > 0 {
		i -= len(m.WithdrawerDid)
		copy(dAtA[i:], m.WithdrawerDid)
		i = encodeVarintTx(dAtA, i, uint64(len(m.WithdrawerDid)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
	offset -= sovTx(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *MsgCreateBond) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.FunctionType)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.FunctionParameters) > 0 {
		for _, e := range m.FunctionParameters {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.CreatorDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ControllerDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.ReserveTokens) > 0 {
		for _, s := range m.ReserveTokens {
			l = len(s)
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = m.TxFeePercentage.Size()
	n += 1 + l + sovTx(uint64(l))
	l = m.ExitFeePercentage.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.FeeAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.ReserveWithdrawalAddress)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.MaxSupply.Size()
	n += 1 + l + sovTx(uint64(l))
	if len(m.OrderQuantityLimits) > 0 {
		for _, e := range m.OrderQuantityLimits {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = m.SanityRate.Size()
	n += 2 + l + sovTx(uint64(l))
	l = m.SanityMarginPercentage.Size()
	n += 2 + l + sovTx(uint64(l))
	if m.AllowSells {
		n += 3
	}
	if m.AllowReserveWithdrawals {
		n += 3
	}
	if m.AlphaBond {
		n += 3
	}
	l = m.BatchBlocks.Size()
	n += 2 + l + sovTx(uint64(l))
	l = m.OutcomePayment.Size()
	n += 2 + l + sovTx(uint64(l))
	return n
}

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

func (m *MsgEditBond) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.OrderQuantityLimits)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SanityRate)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.SanityMarginPercentage)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.EditorDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgSetNextAlpha) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Alpha.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.EditorDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgUpdateBondState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.EditorDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgBuy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.BuyerDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	if len(m.MaxPrices) > 0 {
		for _, e := range m.MaxPrices {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgSell) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SellerDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgSwap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SwapperDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.From.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.ToToken)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgMakeOutcomePayment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.SenderDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.Amount.Size()
	n += 1 + l + sovTx(uint64(l))
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

func (m *MsgWithdrawReserve) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.WithdrawerDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Amount) > 0 {
		for _, e := range m.Amount {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.BondDid)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func sovTx(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTx(x uint64) (n int) {
	return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *MsgCreateBond) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateBond: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateBond: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BondDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FunctionType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FunctionParameters", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FunctionParameters = append(m.FunctionParameters, FunctionParam{})
			if err := m.FunctionParameters[len(m.FunctionParameters)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatorDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CreatorDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControllerDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControllerDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReserveTokens", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReserveTokens = append(m.ReserveTokens, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TxFeePercentage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TxFeePercentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExitFeePercentage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ExitFeePercentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FeeAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FeeAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReserveWithdrawalAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReserveWithdrawalAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSupply", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.MaxSupply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderQuantityLimits", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderQuantityLimits = append(m.OrderQuantityLimits, types.Coin{})
			if err := m.OrderQuantityLimits[len(m.OrderQuantityLimits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SanityRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SanityRate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SanityMarginPercentage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.SanityMarginPercentage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowSells", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowSells = bool(v != 0)
		case 19:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllowReserveWithdrawals", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AllowReserveWithdrawals = bool(v != 0)
		case 20:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlphaBond", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AlphaBond = bool(v != 0)
		case 21:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BatchBlocks", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.BatchBlocks.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OutcomePayment", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.OutcomePayment.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgCreateBondResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgCreateBondResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateBondResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEditBond) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgEditBond: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditBond: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BondDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrderQuantityLimits", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OrderQuantityLimits = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SanityRate", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SanityRate = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SanityMarginPercentage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SanityMarginPercentage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EditorDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EditorDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgEditBondResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgEditBondResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgEditBondResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSetNextAlphaResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgSetNextAlphaResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSetNextAlphaResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateBondStateResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgUpdateBondStateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateBondStateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgBuy) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgBuy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgBuy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuyerDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPrices", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MaxPrices = append(m.MaxPrices, types.Coin{})
			if err := m.MaxPrices[len(m.MaxPrices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BondDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgBuyResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgBuyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgBuyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSellResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgSellResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSellResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgSwapResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgSwapResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgSwapResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgMakeOutcomePaymentResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgMakeOutcomePaymentResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgMakeOutcomePaymentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawShareResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawShareResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawShareResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawReserve) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawReserve: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawReserve: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithdrawerDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.WithdrawerDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Amount = append(m.Amount, types.Coin{})
			if err := m.Amount[len(m.Amount)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BondDid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BondDid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgWithdrawReserveResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowTx
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MsgWithdrawReserveResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgWithdrawReserveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipTx(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthTx
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipTx(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowTx
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowTx
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthTx
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupTx
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthTx
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

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