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

// MsgCreateBond defines a message for creating a new bond.
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
}

// MsgCreateBondResponse defines the Msg/CreateBond response type.
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

// MsgEditBond defines a message for editing an existing bond.
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 ""
}

// MsgEditBondResponse defines the Msg/EditBond response type.
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

// MsgSetNextAlpha defines a message for editing a bond's alpha parameter.
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

// MsgUpdateBondState defines a message for updating a bond's current state.
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 ""
}

// MsgUpdateBondStateResponse defines the Msg/UpdateBondState response type.
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

// MsgBuy defines a message for buying from a bond.
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 ""
}

// MsgBuyResponse defines the Msg/Buy response type.
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

// MsgSell defines a message for selling from a bond.
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 ""
}

// MsgSellResponse defines the Msg/Sell response type.
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

// MsgSwap defines a message for swapping from one reserve bond token to another.
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 ""
}

// MsgSwapResponse defines the Msg/Swap response type.
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

// MsgMakeOutcomePayment defines a message for making an outcome payment to a bond.
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 ""
}

// MsgMakeOutcomePaymentResponse defines the Msg/MakeOutcomePayment response type.
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

// MsgWithdrawShare defines a message for withdrawing a share from a bond that is in the SETTLE stage.
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 ""
}

// MsgWithdrawShareResponse defines the Msg/WithdrawShare response type.
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

// MsgWithdrawReserve defines a message for withdrawing reserve from a bond.
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 ""
}

// MsgWithdrawReserveResponse defines the Msg/WithdrawReserve response type.
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 defines a method for creating a bond.
	CreateBond(ctx context.Context, in *MsgCreateBond, opts ...grpc.CallOption) (*MsgCreateBondResponse, error)
	// EditBond defines a method for editing a bond.
	EditBond(ctx context.Context, in *MsgEditBond, opts ...grpc.CallOption) (*MsgEditBondResponse, error)
	// SetNextAlpha defines a method for editing a bond's alpha parameter.
	SetNextAlpha(ctx context.Context, in *MsgSetNextAlpha, opts ...grpc.CallOption) (*MsgSetNextAlphaResponse, error)
	// UpdateBondState defines a method for updating a bond's current state.
	UpdateBondState(ctx context.Context, in *MsgUpdateBondState, opts ...grpc.CallOption) (*MsgUpdateBondStateResponse, error)
	// Buy defines a method for buying from a bond.
	Buy(ctx context.Context, in *MsgBuy, opts ...grpc.CallOption) (*MsgBuyResponse, error)
	// Sell defines a method for selling from a bond.
	Sell(ctx context.Context, in *MsgSell, opts ...grpc.CallOption) (*MsgSellResponse, error)
	// Swap defines a method for swapping from one reserve bond token to another.
	Swap(ctx context.Context, in *MsgSwap, opts ...grpc.CallOption) (*MsgSwapResponse, error)
	// MakeOutcomePayment defines a method for making an outcome payment to a bond.
	MakeOutcomePayment(ctx context.Context, in *MsgMakeOutcomePayment, opts ...grpc.CallOption) (*MsgMakeOutcomePaymentResponse, error)
	// WithdrawShare defines a method for withdrawing a share from a bond that is in the SETTLE stage.
	WithdrawShare(ctx context.Context, in *MsgWithdrawShare, opts ...grpc.CallOption) (*MsgWithdrawShareResponse, error)
	// WithdrawReserve defines a method for withdrawing reserve from a bond.
	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 defines a method for creating a bond.
	CreateBond(context.Context, *MsgCreateBond) (*MsgCreateBondResponse, error)
	// EditBond defines a method for editing a bond.
	EditBond(context.Context, *MsgEditBond) (*MsgEditBondResponse, error)
	// SetNextAlpha defines a method for editing a bond's alpha parameter.
	SetNextAlpha(context.Context, *MsgSetNextAlpha) (*MsgSetNextAlphaResponse, error)
	// UpdateBondState defines a method for updating a bond's current state.
	UpdateBondState(context.Context, *MsgUpdateBondState) (*MsgUpdateBondStateResponse, error)
	// Buy defines a method for buying from a bond.
	Buy(context.Context, *MsgBuy) (*MsgBuyResponse, error)
	// Sell defines a method for selling from a bond.
	Sell(context.Context, *MsgSell) (*MsgSellResponse, error)
	// Swap defines a method for swapping from one reserve bond token to another.
	Swap(context.Context, *MsgSwap) (*MsgSwapResponse, error)
	// MakeOutcomePayment defines a method for making an outcome payment to a bond.
	MakeOutcomePayment(context.Context, *MsgMakeOutcomePayment) (*MsgMakeOutcomePaymentResponse, error)
	// WithdrawShare defines a method for withdrawing a share from a bond that is in the SETTLE stage.
	WithdrawShare(context.Context, *MsgWithdrawShare) (*MsgWithdrawShareResponse, error)
	// WithdrawReserve defines a method for withdrawing reserve from a bond.
	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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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) || (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")
)