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

package types

import (
	context "context"
	cosmossdk_io_math "cosmossdk.io/math"
	fmt "fmt"
	_ "github.com/cosmos/cosmos-proto"
	_ "github.com/cosmos/cosmos-sdk/types/msgservice"
	_ "github.com/cosmos/gogoproto/gogoproto"
	grpc1 "github.com/cosmos/gogoproto/grpc"
	proto "github.com/cosmos/gogoproto/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

// MsgCreateLedgerRequest represents a request to create a new ledger.
type MsgCreateLedgerRequest struct {
	// The ledger to create.
	Ledger *Ledger `protobuf:"bytes,1,opt,name=ledger,proto3" json:"ledger,omitempty"`
	// The signer address that can create ledgers.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgCreateLedgerRequest proto.InternalMessageInfo

func (m *MsgCreateLedgerRequest) GetLedger() *Ledger {
	if m != nil {
		return m.Ledger
	}
	return nil
}

func (m *MsgCreateLedgerRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgCreateLedgerResponse represents the response from creating a ledger.
type MsgCreateLedgerResponse struct {
}

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

var xxx_messageInfo_MsgCreateLedgerResponse proto.InternalMessageInfo

// MsgUpdateStatusRequest represents a request to update the status of a ledger.
type MsgUpdateStatusRequest struct {
	// Ledger key of the ledger whose status is being updated.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The signer that is updating the status.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	// The new status type id of the ledger.
	StatusTypeId int32 `protobuf:"varint,3,opt,name=status_type_id,json=statusTypeId,proto3" json:"status_type_id,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateStatusRequest proto.InternalMessageInfo

func (m *MsgUpdateStatusRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgUpdateStatusRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgUpdateStatusRequest) GetStatusTypeId() int32 {
	if m != nil {
		return m.StatusTypeId
	}
	return 0
}

// MsgUpdateStatusResponse represents the response from updating a ledger status.
type MsgUpdateStatusResponse struct {
}

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

var xxx_messageInfo_MsgUpdateStatusResponse proto.InternalMessageInfo

// MsgUpdateInterestRateRequest represents a request to update the interest rate configuration of a ledger.
type MsgUpdateInterestRateRequest struct {
	// Ledger key of the ledger whose interest rate is being updated.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The signer that is updating the interest rate.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	// The new interest rate of the ledger.
	// This field is NOT optional. If not provided (or provided as zero),
	// then the ledger's interest_rate field will be updated to be zero.
	InterestRate int32 `protobuf:"varint,3,opt,name=interest_rate,json=interestRate,proto3" json:"interest_rate,omitempty"`
	// The new interest day count convention of the ledger.
	// This field is optional. If not provided (or set to unspecified),
	// the interest day count convention will not be updated.
	InterestDayCountConvention DayCountConvention `protobuf:"varint,4,opt,name=interest_day_count_convention,json=interestDayCountConvention,proto3,enum=provenance.ledger.v1.DayCountConvention" json:"interest_day_count_convention,omitempty"`
	// The new interest accrual method of the ledger.
	// This field is optional. If not provided (or set to unspecified),
	// the interest accrual method will not be updated.
	InterestAccrualMethod InterestAccrualMethod `protobuf:"varint,5,opt,name=interest_accrual_method,json=interestAccrualMethod,proto3,enum=provenance.ledger.v1.InterestAccrualMethod" json:"interest_accrual_method,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateInterestRateRequest proto.InternalMessageInfo

func (m *MsgUpdateInterestRateRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgUpdateInterestRateRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgUpdateInterestRateRequest) GetInterestRate() int32 {
	if m != nil {
		return m.InterestRate
	}
	return 0
}

func (m *MsgUpdateInterestRateRequest) GetInterestDayCountConvention() DayCountConvention {
	if m != nil {
		return m.InterestDayCountConvention
	}
	return DAY_COUNT_CONVENTION_UNSPECIFIED
}

func (m *MsgUpdateInterestRateRequest) GetInterestAccrualMethod() InterestAccrualMethod {
	if m != nil {
		return m.InterestAccrualMethod
	}
	return INTEREST_ACCRUAL_METHOD_UNSPECIFIED
}

// MsgUpdateInterestRateResponse represents the response from updating a ledger interest rate.
type MsgUpdateInterestRateResponse struct {
}

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

var xxx_messageInfo_MsgUpdateInterestRateResponse proto.InternalMessageInfo

// MsgUpdatePaymentRequest represents a request to update payment configuration of a ledger.
type MsgUpdatePaymentRequest struct {
	// Ledger key of the ledger whose payment is being updated.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The signer that is updating the payment.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	// The new next payment amount of the ledger.
	// The units of this field are defined by the denom field in this ledger's class.
	// This field is NOT optional. If you don't provide a value (or provide it as zero),
	// then the ledger's next_pmt_amt field will be updated to be zero.
	NextPmtAmt cosmossdk_io_math.Int `protobuf:"bytes,3,opt,name=next_pmt_amt,json=nextPmtAmt,proto3,customtype=cosmossdk.io/math.Int" json:"nextPmtAmt,omitempty"`
	// The new next payment date in days since epoch.
	// This field is not optional and cannot be zero.
	NextPmtDate int32 `protobuf:"varint,4,opt,name=next_pmt_date,json=nextPmtDate,proto3" json:"next_pmt_date,omitempty"`
	// The new payment frequency of the ledger.
	// This field is optional. If set to unspecified, it will be ignored and the payment_frequency will not be changed.
	PaymentFrequency PaymentFrequency `protobuf:"varint,5,opt,name=payment_frequency,json=paymentFrequency,proto3,enum=provenance.ledger.v1.PaymentFrequency" json:"payment_frequency,omitempty"`
}

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

var xxx_messageInfo_MsgUpdatePaymentRequest proto.InternalMessageInfo

func (m *MsgUpdatePaymentRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgUpdatePaymentRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgUpdatePaymentRequest) GetNextPmtDate() int32 {
	if m != nil {
		return m.NextPmtDate
	}
	return 0
}

func (m *MsgUpdatePaymentRequest) GetPaymentFrequency() PaymentFrequency {
	if m != nil {
		return m.PaymentFrequency
	}
	return PAYMENT_FREQUENCY_UNSPECIFIED
}

// MsgUpdatePaymentResponse represents the response from updating a ledger payment configuration.
type MsgUpdatePaymentResponse struct {
}

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

var xxx_messageInfo_MsgUpdatePaymentResponse proto.InternalMessageInfo

// MsgUpdateMaturityDateRequest represents a request to update the maturity date of a ledger.
type MsgUpdateMaturityDateRequest struct {
	// Ledger key of the ledger whose maturity date is being updated.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The signer that is updating the maturity date.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	// The new maturity date in days since epoch.
	MaturityDate int32 `protobuf:"varint,3,opt,name=maturity_date,json=maturityDate,proto3" json:"maturity_date,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateMaturityDateRequest proto.InternalMessageInfo

func (m *MsgUpdateMaturityDateRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgUpdateMaturityDateRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgUpdateMaturityDateRequest) GetMaturityDate() int32 {
	if m != nil {
		return m.MaturityDate
	}
	return 0
}

// MsgUpdateMaturityDateResponse represents the response from updating a ledger maturity date.
type MsgUpdateMaturityDateResponse struct {
}

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

var xxx_messageInfo_MsgUpdateMaturityDateResponse proto.InternalMessageInfo

// MsgAppendRequest represents a request to append entries to a ledger.
type MsgAppendRequest struct {
	// Ledger key of the ledger whose entries are being appended.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The entries to append to the ledger.
	Entries []*LedgerEntry `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries,omitempty"`
	// The signer that is appending the entries.
	Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgAppendRequest proto.InternalMessageInfo

func (m *MsgAppendRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgAppendRequest) GetEntries() []*LedgerEntry {
	if m != nil {
		return m.Entries
	}
	return nil
}

func (m *MsgAppendRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgAppendResponse represents the response from appending entries to a ledger.
type MsgAppendResponse struct {
}

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

var xxx_messageInfo_MsgAppendResponse proto.InternalMessageInfo

// MsgUpdateBalancesRequest represents a request to update balances for a ledger entry.
type MsgUpdateBalancesRequest struct {
	// Ledger key of the ledger whose balances are being updated.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The signer that is updating the balances.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
	// The correlation id of the ledger entry.
	CorrelationId string `protobuf:"bytes,3,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"`
	// The total amount of the ledger entry.
	// The units of this field are defined by the denom field in this ledger's class.
	TotalAmt cosmossdk_io_math.Int `protobuf:"bytes,4,opt,name=total_amt,json=totalAmt,proto3,customtype=cosmossdk.io/math.Int" json:"totalAmt,omitempty"`
	// Applied amounts represent how the entry affects different buckets.
	AppliedAmounts []*LedgerBucketAmount `protobuf:"bytes,5,rep,name=applied_amounts,json=appliedAmounts,proto3" json:"applied_amounts,omitempty"`
	// Bucket balances represent the current state of funds in each bucket.
	BalanceAmounts []*BucketBalance `protobuf:"bytes,6,rep,name=balance_amounts,json=balanceAmounts,proto3" json:"balance_amounts,omitempty"`
}

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

var xxx_messageInfo_MsgUpdateBalancesRequest proto.InternalMessageInfo

func (m *MsgUpdateBalancesRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgUpdateBalancesRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgUpdateBalancesRequest) GetCorrelationId() string {
	if m != nil {
		return m.CorrelationId
	}
	return ""
}

func (m *MsgUpdateBalancesRequest) GetAppliedAmounts() []*LedgerBucketAmount {
	if m != nil {
		return m.AppliedAmounts
	}
	return nil
}

func (m *MsgUpdateBalancesRequest) GetBalanceAmounts() []*BucketBalance {
	if m != nil {
		return m.BalanceAmounts
	}
	return nil
}

// MsgUpdateBalancesResponse represents the response from updating ledger balances.
type MsgUpdateBalancesResponse struct {
}

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

var xxx_messageInfo_MsgUpdateBalancesResponse proto.InternalMessageInfo

// MsgTransferFundsWithSettlementRequest represents a request to transfer funds with settlement instructions.
type MsgTransferFundsWithSettlementRequest struct {
	// The signer that is transferring the funds.
	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
	// The transfers to be made.
	Transfers []*FundTransferWithSettlement `protobuf:"bytes,2,rep,name=transfers,proto3" json:"transfers,omitempty"`
}

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

var xxx_messageInfo_MsgTransferFundsWithSettlementRequest proto.InternalMessageInfo

func (m *MsgTransferFundsWithSettlementRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgTransferFundsWithSettlementRequest) GetTransfers() []*FundTransferWithSettlement {
	if m != nil {
		return m.Transfers
	}
	return nil
}

// MsgTransferFundsWithSettlementResponse represents the response from transferring funds with settlement.
type MsgTransferFundsWithSettlementResponse struct {
}

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

var xxx_messageInfo_MsgTransferFundsWithSettlementResponse proto.InternalMessageInfo

// MsgDestroyRequest represents a request to destroy a ledger.
type MsgDestroyRequest struct {
	// Ledger key of the ledger to destroy.
	Key *LedgerKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	// The signer that is destroying the ledger.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgDestroyRequest proto.InternalMessageInfo

func (m *MsgDestroyRequest) GetKey() *LedgerKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *MsgDestroyRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgDestroyResponse represents the response from destroying a ledger.
type MsgDestroyResponse struct {
}

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

var xxx_messageInfo_MsgDestroyResponse proto.InternalMessageInfo

// MsgCreateLedgerClassRequest represents a request to create a new ledger class.
type MsgCreateLedgerClassRequest struct {
	// The ledger class to create.
	LedgerClass *LedgerClass `protobuf:"bytes,1,opt,name=ledger_class,json=ledgerClass,proto3" json:"ledger_class,omitempty"`
	// The signer that is creating the ledger class.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgCreateLedgerClassRequest proto.InternalMessageInfo

func (m *MsgCreateLedgerClassRequest) GetLedgerClass() *LedgerClass {
	if m != nil {
		return m.LedgerClass
	}
	return nil
}

func (m *MsgCreateLedgerClassRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgCreateLedgerClassResponse represents the response from creating a ledger class.
type MsgCreateLedgerClassResponse struct {
}

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

var xxx_messageInfo_MsgCreateLedgerClassResponse proto.InternalMessageInfo

// MsgAddLedgerClassStatusTypeRequest represents a request to add a status type to a ledger class.
type MsgAddLedgerClassStatusTypeRequest struct {
	// Ledger class id to add the status type to.
	LedgerClassId string `protobuf:"bytes,1,opt,name=ledger_class_id,json=ledgerClassId,proto3" json:"ledger_class_id,omitempty"`
	// The status type to add to the ledger class.
	StatusType *LedgerClassStatusType `protobuf:"bytes,2,opt,name=status_type,json=statusType,proto3" json:"status_type,omitempty"`
	// The signer that is adding the status type.
	Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgAddLedgerClassStatusTypeRequest proto.InternalMessageInfo

func (m *MsgAddLedgerClassStatusTypeRequest) GetLedgerClassId() string {
	if m != nil {
		return m.LedgerClassId
	}
	return ""
}

func (m *MsgAddLedgerClassStatusTypeRequest) GetStatusType() *LedgerClassStatusType {
	if m != nil {
		return m.StatusType
	}
	return nil
}

func (m *MsgAddLedgerClassStatusTypeRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgAddLedgerClassStatusTypeResponse represents the response from adding a status type.
type MsgAddLedgerClassStatusTypeResponse struct {
}

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

var xxx_messageInfo_MsgAddLedgerClassStatusTypeResponse proto.InternalMessageInfo

// MsgAddLedgerClassEntryTypeRequest represents a request to add an entry type to a ledger class.
type MsgAddLedgerClassEntryTypeRequest struct {
	// Ledger class id to add the entry type to.
	LedgerClassId string `protobuf:"bytes,1,opt,name=ledger_class_id,json=ledgerClassId,proto3" json:"ledger_class_id,omitempty"`
	// The entry type to add to the ledger class.
	EntryType *LedgerClassEntryType `protobuf:"bytes,2,opt,name=entry_type,json=entryType,proto3" json:"entry_type,omitempty"`
	// The signer that is adding the entry type.
	Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgAddLedgerClassEntryTypeRequest proto.InternalMessageInfo

func (m *MsgAddLedgerClassEntryTypeRequest) GetLedgerClassId() string {
	if m != nil {
		return m.LedgerClassId
	}
	return ""
}

func (m *MsgAddLedgerClassEntryTypeRequest) GetEntryType() *LedgerClassEntryType {
	if m != nil {
		return m.EntryType
	}
	return nil
}

func (m *MsgAddLedgerClassEntryTypeRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgAddLedgerClassEntryTypeResponse represents the response from adding an entry type.
type MsgAddLedgerClassEntryTypeResponse struct {
}

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

var xxx_messageInfo_MsgAddLedgerClassEntryTypeResponse proto.InternalMessageInfo

// MsgAddLedgerClassBucketTypeRequest represents a request to add a bucket type to a ledger class.
type MsgAddLedgerClassBucketTypeRequest struct {
	// Ledger class id to add the bucket type to.
	LedgerClassId string `protobuf:"bytes,1,opt,name=ledger_class_id,json=ledgerClassId,proto3" json:"ledger_class_id,omitempty"`
	// The bucket type to add to the ledger class.
	BucketType *LedgerClassBucketType `protobuf:"bytes,2,opt,name=bucket_type,json=bucketType,proto3" json:"bucket_type,omitempty"`
	// The signer that is adding the bucket type.
	Signer string `protobuf:"bytes,3,opt,name=signer,proto3" json:"signer,omitempty"`
}

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

var xxx_messageInfo_MsgAddLedgerClassBucketTypeRequest proto.InternalMessageInfo

func (m *MsgAddLedgerClassBucketTypeRequest) GetLedgerClassId() string {
	if m != nil {
		return m.LedgerClassId
	}
	return ""
}

func (m *MsgAddLedgerClassBucketTypeRequest) GetBucketType() *LedgerClassBucketType {
	if m != nil {
		return m.BucketType
	}
	return nil
}

func (m *MsgAddLedgerClassBucketTypeRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

// MsgAddLedgerClassBucketTypeResponse represents the response from adding a bucket type.
type MsgAddLedgerClassBucketTypeResponse struct {
}

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

var xxx_messageInfo_MsgAddLedgerClassBucketTypeResponse proto.InternalMessageInfo

// MsgBulkCreateRequest represents a request to bulk create ledgers and entries.
type MsgBulkCreateRequest struct {
	// The signer that is bulk importing the ledger data.
	Signer string `protobuf:"bytes,1,opt,name=signer,proto3" json:"signer,omitempty"`
	// The genesis state to bulk import.
	LedgerAndEntries []*LedgerAndEntries `protobuf:"bytes,2,rep,name=ledger_and_entries,json=ledgerAndEntries,proto3" json:"ledger_and_entries,omitempty"`
}

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

var xxx_messageInfo_MsgBulkCreateRequest proto.InternalMessageInfo

func (m *MsgBulkCreateRequest) GetSigner() string {
	if m != nil {
		return m.Signer
	}
	return ""
}

func (m *MsgBulkCreateRequest) GetLedgerAndEntries() []*LedgerAndEntries {
	if m != nil {
		return m.LedgerAndEntries
	}
	return nil
}

// MsgBulkCreateResponse represents the response from bulk creating ledgers and entries.
type MsgBulkCreateResponse struct {
}

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

var xxx_messageInfo_MsgBulkCreateResponse proto.InternalMessageInfo

func init() {
	proto.RegisterType((*MsgCreateLedgerRequest)(nil), "provenance.ledger.v1.MsgCreateLedgerRequest")
	proto.RegisterType((*MsgCreateLedgerResponse)(nil), "provenance.ledger.v1.MsgCreateLedgerResponse")
	proto.RegisterType((*MsgUpdateStatusRequest)(nil), "provenance.ledger.v1.MsgUpdateStatusRequest")
	proto.RegisterType((*MsgUpdateStatusResponse)(nil), "provenance.ledger.v1.MsgUpdateStatusResponse")
	proto.RegisterType((*MsgUpdateInterestRateRequest)(nil), "provenance.ledger.v1.MsgUpdateInterestRateRequest")
	proto.RegisterType((*MsgUpdateInterestRateResponse)(nil), "provenance.ledger.v1.MsgUpdateInterestRateResponse")
	proto.RegisterType((*MsgUpdatePaymentRequest)(nil), "provenance.ledger.v1.MsgUpdatePaymentRequest")
	proto.RegisterType((*MsgUpdatePaymentResponse)(nil), "provenance.ledger.v1.MsgUpdatePaymentResponse")
	proto.RegisterType((*MsgUpdateMaturityDateRequest)(nil), "provenance.ledger.v1.MsgUpdateMaturityDateRequest")
	proto.RegisterType((*MsgUpdateMaturityDateResponse)(nil), "provenance.ledger.v1.MsgUpdateMaturityDateResponse")
	proto.RegisterType((*MsgAppendRequest)(nil), "provenance.ledger.v1.MsgAppendRequest")
	proto.RegisterType((*MsgAppendResponse)(nil), "provenance.ledger.v1.MsgAppendResponse")
	proto.RegisterType((*MsgUpdateBalancesRequest)(nil), "provenance.ledger.v1.MsgUpdateBalancesRequest")
	proto.RegisterType((*MsgUpdateBalancesResponse)(nil), "provenance.ledger.v1.MsgUpdateBalancesResponse")
	proto.RegisterType((*MsgTransferFundsWithSettlementRequest)(nil), "provenance.ledger.v1.MsgTransferFundsWithSettlementRequest")
	proto.RegisterType((*MsgTransferFundsWithSettlementResponse)(nil), "provenance.ledger.v1.MsgTransferFundsWithSettlementResponse")
	proto.RegisterType((*MsgDestroyRequest)(nil), "provenance.ledger.v1.MsgDestroyRequest")
	proto.RegisterType((*MsgDestroyResponse)(nil), "provenance.ledger.v1.MsgDestroyResponse")
	proto.RegisterType((*MsgCreateLedgerClassRequest)(nil), "provenance.ledger.v1.MsgCreateLedgerClassRequest")
	proto.RegisterType((*MsgCreateLedgerClassResponse)(nil), "provenance.ledger.v1.MsgCreateLedgerClassResponse")
	proto.RegisterType((*MsgAddLedgerClassStatusTypeRequest)(nil), "provenance.ledger.v1.MsgAddLedgerClassStatusTypeRequest")
	proto.RegisterType((*MsgAddLedgerClassStatusTypeResponse)(nil), "provenance.ledger.v1.MsgAddLedgerClassStatusTypeResponse")
	proto.RegisterType((*MsgAddLedgerClassEntryTypeRequest)(nil), "provenance.ledger.v1.MsgAddLedgerClassEntryTypeRequest")
	proto.RegisterType((*MsgAddLedgerClassEntryTypeResponse)(nil), "provenance.ledger.v1.MsgAddLedgerClassEntryTypeResponse")
	proto.RegisterType((*MsgAddLedgerClassBucketTypeRequest)(nil), "provenance.ledger.v1.MsgAddLedgerClassBucketTypeRequest")
	proto.RegisterType((*MsgAddLedgerClassBucketTypeResponse)(nil), "provenance.ledger.v1.MsgAddLedgerClassBucketTypeResponse")
	proto.RegisterType((*MsgBulkCreateRequest)(nil), "provenance.ledger.v1.MsgBulkCreateRequest")
	proto.RegisterType((*MsgBulkCreateResponse)(nil), "provenance.ledger.v1.MsgBulkCreateResponse")
}

func init() { proto.RegisterFile("provenance/ledger/v1/tx.proto", fileDescriptor_3c124d2e9569f84d) }

var fileDescriptor_3c124d2e9569f84d = []byte{
	// 1409 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x58, 0xcf, 0x6f, 0x1b, 0xc5,
	0x17, 0xcf, 0xd4, 0x4d, 0xfa, 0xcd, 0x73, 0x92, 0xb6, 0xf3, 0x4d, 0x89, 0xbb, 0x6d, 0x9d, 0x34,
	0x6d, 0x83, 0x95, 0x36, 0x76, 0xe3, 0x22, 0x51, 0x28, 0x17, 0x27, 0x69, 0x25, 0x8b, 0x1a, 0x95,
	0x4d, 0x11, 0x02, 0x21, 0x56, 0x9b, 0xdd, 0xe9, 0x66, 0x65, 0xef, 0x8f, 0xee, 0x8c, 0xa3, 0x2e,
	0x12, 0x12, 0x42, 0x42, 0x5c, 0x40, 0x70, 0xe4, 0xcc, 0x95, 0x4b, 0x91, 0x0a, 0x77, 0x6e, 0x3d,
	0x56, 0x95, 0x90, 0x80, 0x43, 0x85, 0xda, 0x43, 0x25, 0xf8, 0x27, 0xd0, 0xee, 0xcc, 0xda, 0xbb,
	0xf6, 0x7a, 0xed, 0x38, 0x22, 0xdc, 0xbc, 0x33, 0xef, 0xc7, 0xe7, 0xf3, 0xde, 0xbc, 0x37, 0x6f,
	0x0c, 0xe7, 0x5c, 0xcf, 0xd9, 0x23, 0xb6, 0x6a, 0x6b, 0xa4, 0xd2, 0x22, 0xba, 0x41, 0xbc, 0xca,
	0xde, 0x7a, 0x85, 0x3d, 0x28, 0xbb, 0x9e, 0xc3, 0x1c, 0x3c, 0xdf, 0xdd, 0x2e, 0xf3, 0xed, 0xf2,
	0xde, 0xba, 0xb4, 0xa0, 0x39, 0xd4, 0x72, 0x68, 0xc5, 0xa2, 0x46, 0x20, 0x6d, 0x51, 0x83, 0x8b,
	0x4b, 0xa7, 0xf9, 0x86, 0x12, 0x7e, 0x55, 0xf8, 0x87, 0xd8, 0x9a, 0x37, 0x1c, 0xc3, 0xe1, 0xeb,
	0xc1, 0x2f, 0xb1, 0x7a, 0x3e, 0xd5, 0xbd, 0xf0, 0xc4, 0x45, 0xae, 0x64, 0x88, 0x28, 0x94, 0x30,
	0xd6, 0x22, 0x16, 0xb1, 0x19, 0x97, 0x5e, 0xfe, 0x1a, 0xc1, 0x2b, 0x0d, 0x6a, 0x6c, 0x7a, 0x44,
	0x65, 0xe4, 0x76, 0x28, 0x24, 0x93, 0xfb, 0x6d, 0x42, 0x19, 0x7e, 0x0d, 0xa6, 0xb8, 0x56, 0x01,
	0x2d, 0xa1, 0x52, 0xbe, 0x7a, 0xb6, 0x9c, 0x46, 0xae, 0x2c, 0x94, 0x84, 0x2c, 0xbe, 0x0a, 0x53,
	0xd4, 0x34, 0x6c, 0xe2, 0x15, 0x8e, 0x2c, 0xa1, 0xd2, 0xf4, 0x46, 0xe1, 0xe9, 0xa3, 0xb5, 0x79,
	0xc1, 0xac, 0xa6, 0xeb, 0x1e, 0xa1, 0x74, 0x9b, 0x79, 0xa6, 0x6d, 0xc8, 0x42, 0xee, 0xcd, 0xfc,
	0xe7, 0x2f, 0x1f, 0xae, 0x8a, 0x8f, 0xe5, 0xd3, 0xb0, 0xd0, 0x07, 0x87, 0xba, 0x8e, 0x4d, 0xc9,
	0xf2, 0x43, 0x0e, 0xf5, 0x3d, 0x57, 0x57, 0x19, 0xd9, 0x66, 0x2a, 0x6b, 0xd3, 0x08, 0xea, 0x3a,
	0xe4, 0x9a, 0xc4, 0x17, 0x38, 0x17, 0xb3, 0x70, 0xbe, 0x4d, 0x7c, 0x39, 0x90, 0xdd, 0x3f, 0x4e,
	0x7c, 0x11, 0xe6, 0x68, 0xe8, 0x55, 0x61, 0xbe, 0x4b, 0x14, 0x53, 0x2f, 0xe4, 0x96, 0x50, 0x69,
	0x52, 0x9e, 0xe1, 0xab, 0x77, 0x7d, 0x97, 0xd4, 0xf5, 0x34, 0x36, 0x49, 0xc4, 0x82, 0xcd, 0x97,
	0x39, 0x38, 0xdb, 0xd9, 0xab, 0xdb, 0x8c, 0x78, 0x84, 0x32, 0x59, 0x65, 0xe4, 0x50, 0x39, 0x5d,
	0x80, 0x59, 0x53, 0xf8, 0x56, 0x3c, 0x95, 0x91, 0x88, 0x92, 0x19, 0x03, 0x84, 0x9b, 0x70, 0xae,
	0x23, 0xa4, 0xab, 0xbe, 0xa2, 0x39, 0x6d, 0x9b, 0x29, 0x9a, 0x63, 0xef, 0x11, 0x9b, 0x99, 0x8e,
	0x5d, 0x38, 0xba, 0x84, 0x4a, 0x73, 0xd5, 0x52, 0x3a, 0xc6, 0x2d, 0xd5, 0xdf, 0x0c, 0x14, 0x36,
	0x3b, 0xf2, 0xb2, 0x14, 0x99, 0xeb, 0xdf, 0xc3, 0x1a, 0x2c, 0x74, 0x9c, 0xa9, 0x9a, 0xe6, 0xb5,
	0xd5, 0x96, 0x62, 0x11, 0xb6, 0xeb, 0xe8, 0x85, 0xc9, 0xd0, 0xcd, 0xe5, 0x74, 0x37, 0x51, 0x08,
	0x6b, 0x5c, 0xa7, 0x11, 0xaa, 0xc8, 0xa7, 0xcc, 0xb4, 0xe5, 0x64, 0x92, 0x16, 0xe1, 0xdc, 0x80,
	0x44, 0x88, 0x54, 0xfd, 0x7d, 0x24, 0x96, 0xc6, 0x3b, 0xaa, 0x1f, 0x94, 0xcf, 0xa1, 0x66, 0x89,
	0xc0, 0x8c, 0x4d, 0x1e, 0x30, 0xc5, 0xb5, 0x98, 0xa2, 0x5a, 0x2c, 0x4c, 0xd2, 0xf4, 0xc6, 0xe6,
	0xe3, 0x67, 0x8b, 0x13, 0x7f, 0x3c, 0x5b, 0x3c, 0xc5, 0x75, 0xa9, 0xde, 0x2c, 0x9b, 0x4e, 0xc5,
	0x52, 0xd9, 0x6e, 0x10, 0x8c, 0xbf, 0x9e, 0x2d, 0xce, 0x07, 0x4a, 0x77, 0x2c, 0x56, 0xb3, 0xd8,
	0x15, 0xc7, 0x32, 0x19, 0xb1, 0x5c, 0xe6, 0x3f, 0x7d, 0xb4, 0x06, 0xc2, 0x59, 0xdd, 0x66, 0x32,
	0x74, 0x65, 0xf0, 0x32, 0xcc, 0x76, 0xdc, 0x04, 0x54, 0xc3, 0xbc, 0x4e, 0xca, 0x79, 0x21, 0xb2,
	0x15, 0x9c, 0x85, 0x6d, 0x38, 0xe9, 0xf2, 0x08, 0x28, 0xf7, 0xbc, 0x20, 0x06, 0xb6, 0xe6, 0x8b,
	0xc4, 0xac, 0xa4, 0xb3, 0x17, 0x01, 0xbb, 0x15, 0x49, 0xcb, 0x27, 0xdc, 0x9e, 0x95, 0x64, 0x3a,
	0x24, 0x28, 0xf4, 0x07, 0x5b, 0x64, 0xe2, 0x27, 0x14, 0x2b, 0x9a, 0x86, 0xca, 0xda, 0x9e, 0xc9,
	0xfc, 0xad, 0xff, 0xa0, 0x68, 0x2c, 0xe1, 0x9b, 0xc7, 0x49, 0x14, 0x8d, 0x15, 0x03, 0x34, 0xf8,
	0x88, 0x25, 0x61, 0x0b, 0x62, 0xbf, 0x20, 0x38, 0xd1, 0xa0, 0x46, 0xcd, 0x75, 0x89, 0xad, 0x1f,
	0x80, 0xcc, 0x0d, 0x38, 0x46, 0x6c, 0xe6, 0x99, 0x84, 0x16, 0x8e, 0x2c, 0xe5, 0x4a, 0xf9, 0xea,
	0xf9, 0x2c, 0xb5, 0x9b, 0x36, 0xf3, 0x7c, 0x39, 0xd2, 0x88, 0x45, 0x22, 0x37, 0x4e, 0xeb, 0xfe,
	0x3f, 0x9c, 0x8c, 0x51, 0x10, 0xc4, 0x1e, 0xe5, 0x62, 0xe9, 0xdc, 0x50, 0x5b, 0x01, 0x8e, 0xc3,
	0x6d, 0xdb, 0x97, 0x60, 0x4e, 0x73, 0x3c, 0x8f, 0xb4, 0xd4, 0xa0, 0xbf, 0x44, 0x6d, 0x7b, 0x5a,
	0x9e, 0x8d, 0xad, 0xd6, 0x75, 0xfc, 0x31, 0x4c, 0x33, 0x87, 0xa9, 0xad, 0xb0, 0xc0, 0x8e, 0x86,
	0xb6, 0x6b, 0xc3, 0x0a, 0x0c, 0x87, 0x1a, 0x59, 0xe5, 0xf5, 0xbf, 0x48, 0x02, 0xbf, 0x0b, 0xc7,
	0x55, 0xd7, 0x6d, 0x99, 0x44, 0x57, 0x54, 0x2b, 0xe8, 0x79, 0xb4, 0x30, 0x19, 0x66, 0xa8, 0x94,
	0xc5, 0x7b, 0xa3, 0xad, 0x35, 0x09, 0xab, 0x85, 0x0a, 0xf2, 0x9c, 0x30, 0xc0, 0x3f, 0x29, 0xbe,
	0x0d, 0xc7, 0x77, 0x78, 0x44, 0x3b, 0x26, 0xa7, 0x42, 0x93, 0x17, 0xd2, 0x4d, 0x72, 0x63, 0x22,
	0x09, 0xf2, 0x9c, 0xd0, 0x15, 0xd6, 0x92, 0xb9, 0x3c, 0x03, 0xa7, 0x53, 0xb2, 0x26, 0x72, 0xfa,
	0x33, 0x82, 0x4b, 0x0d, 0x6a, 0xdc, 0xf5, 0x54, 0x9b, 0xde, 0x23, 0xde, 0xad, 0xb6, 0xad, 0xd3,
	0xf7, 0x4d, 0xb6, 0xbb, 0xdd, 0x19, 0x2e, 0xa2, 0x04, 0x77, 0xb3, 0x85, 0x46, 0xcc, 0xd6, 0x3b,
	0x30, 0xcd, 0x84, 0xdd, 0xe8, 0x08, 0x5f, 0x4d, 0x67, 0x13, 0xb8, 0x8d, 0x20, 0xf4, 0x78, 0xef,
	0x9a, 0x48, 0xb2, 0x2a, 0xc1, 0xca, 0x30, 0xdc, 0x82, 0xe2, 0x17, 0x28, 0x3c, 0xcc, 0x5b, 0x84,
	0x32, 0xcf, 0xf1, 0x0f, 0xf3, 0xbc, 0x26, 0x11, 0xcf, 0x03, 0x8e, 0xc3, 0x10, 0xe8, 0xbe, 0x47,
	0x70, 0xa6, 0x67, 0x4a, 0xda, 0x6c, 0xa9, 0xb4, 0x53, 0x57, 0x5b, 0x30, 0x23, 0xe6, 0x3d, 0x2d,
	0x58, 0x16, 0x80, 0x33, 0x5b, 0x01, 0xd7, 0xcf, 0xb7, 0xba, 0x1f, 0x07, 0x85, 0x5e, 0x0c, 0x5b,
	0x75, 0x0a, 0x46, 0x41, 0xe2, 0x77, 0x04, 0xcb, 0x41, 0xbf, 0xd0, 0xf5, 0xd8, 0xee, 0x76, 0x67,
	0x94, 0x8a, 0xb8, 0xac, 0xc0, 0xf1, 0x38, 0x97, 0xa0, 0x7e, 0x11, 0xaf, 0xdf, 0x18, 0xd6, 0xba,
	0x8e, 0x6f, 0x43, 0x3e, 0x36, 0x9d, 0x85, 0x90, 0xf3, 0x83, 0x66, 0x85, 0x74, 0x87, 0xd0, 0x9d,
	0xe3, 0x0e, 0xda, 0x0a, 0x2f, 0xc1, 0x85, 0x4c, 0x6a, 0x22, 0x04, 0xbf, 0x22, 0x38, 0xdf, 0x27,
	0x17, 0x36, 0xe5, 0x71, 0x22, 0x50, 0x07, 0x08, 0x3a, 0xb9, 0x1f, 0x0f, 0xc0, 0xea, 0xd0, 0x00,
	0x74, 0xdd, 0x4d, 0x93, 0xe8, 0xe7, 0x41, 0xe9, 0x5f, 0x4c, 0xc9, 0x6c, 0x8c, 0x56, 0xd6, 0x01,
	0xe0, 0x3d, 0x6a, 0xcc, 0x03, 0xb0, 0x13, 0x2a, 0xef, 0xef, 0x00, 0xc4, 0x1c, 0xc2, 0x4e, 0xe7,
	0xf7, 0xbf, 0x71, 0x00, 0xe2, 0xd4, 0x44, 0x08, 0x7e, 0x40, 0x30, 0xdf, 0xa0, 0xc6, 0x46, 0xbb,
	0xd5, 0xe4, 0x85, 0x32, 0x7e, 0xe3, 0xbc, 0x0b, 0x58, 0x84, 0x49, 0xb5, 0x75, 0x25, 0x39, 0x04,
	0xac, 0x64, 0x45, 0xa1, 0x66, 0xeb, 0x37, 0xb9, 0xb4, 0x7c, 0xa2, 0xd5, 0xb3, 0x92, 0x24, 0xb5,
	0x00, 0xa7, 0x7a, 0xc0, 0x72, 0x1a, 0xd5, 0x1f, 0x67, 0x21, 0xd7, 0xa0, 0x06, 0x6e, 0xc2, 0x4c,
	0xbc, 0xde, 0xf1, 0x95, 0x74, 0xbf, 0xe9, 0xef, 0x4d, 0x69, 0x6d, 0x44, 0x69, 0xee, 0x34, 0x70,
	0x16, 0x7f, 0x58, 0x65, 0x38, 0x4b, 0x79, 0x31, 0x66, 0x38, 0x4b, 0x7b, 0xad, 0xe1, 0x4f, 0x01,
	0xf7, 0x3f, 0x10, 0x70, 0x75, 0x88, 0x91, 0x94, 0x67, 0x9d, 0x74, 0x6d, 0x5f, 0x3a, 0xc2, 0xbd,
	0x0d, 0xb3, 0x89, 0x81, 0x18, 0x0f, 0x83, 0x9f, 0x7c, 0xa5, 0x48, 0xe5, 0x51, 0xc5, 0x7b, 0xe9,
	0xc6, 0x87, 0xd5, 0xa1, 0x74, 0x53, 0x06, 0xf2, 0xa1, 0x74, 0xd3, 0xa6, 0x61, 0xfc, 0x01, 0x4c,
	0xf1, 0x31, 0x12, 0xaf, 0x0c, 0x54, 0x4f, 0x8c, 0xca, 0xd2, 0xab, 0x43, 0xe5, 0x84, 0xe9, 0xfb,
	0x30, 0x97, 0x9c, 0x6a, 0xf0, 0xb0, 0xd8, 0xf4, 0x0c, 0xad, 0x52, 0x65, 0x64, 0x79, 0xe1, 0xf2,
	0x3b, 0x04, 0x67, 0x32, 0x66, 0x0e, 0x7c, 0x63, 0xa0, 0xc1, 0xe1, 0x13, 0x96, 0xf4, 0xd6, 0x78,
	0xca, 0x02, 0xda, 0x47, 0x70, 0x4c, 0xcc, 0x16, 0x78, 0x70, 0x04, 0x93, 0x43, 0x90, 0x54, 0x1a,
	0x2e, 0x28, 0xac, 0x7f, 0x02, 0x27, 0xfb, 0xae, 0x7f, 0xbc, 0x3e, 0x52, 0x95, 0xc7, 0xc7, 0x19,
	0xa9, 0xba, 0x1f, 0x15, 0xe1, 0xfb, 0x1b, 0x04, 0x85, 0x41, 0xf7, 0x2f, 0xbe, 0x3e, 0xf8, 0xb4,
	0x64, 0x4f, 0x23, 0xd2, 0x1b, 0x63, 0x68, 0x0a, 0x44, 0x5f, 0x21, 0x58, 0x18, 0x70, 0x25, 0xe2,
	0xd7, 0x47, 0x34, 0xdb, 0x3b, 0x1b, 0x48, 0xd7, 0xf7, 0xaf, 0x38, 0x30, 0x40, 0xdd, 0xfb, 0x69,
	0xe4, 0x00, 0xf5, 0xdd, 0xd6, 0x23, 0x07, 0xa8, 0xff, 0x32, 0xc4, 0x04, 0xa0, 0x7b, 0xb7, 0xe0,
	0xd5, 0x81, 0x86, 0xfa, 0x6e, 0x4b, 0xe9, 0xf2, 0x48, 0xb2, 0xdc, 0x8d, 0x34, 0xf9, 0xd9, 0xcb,
	0x87, 0xab, 0x68, 0xc3, 0x78, 0xfc, 0xbc, 0x88, 0x9e, 0x3c, 0x2f, 0xa2, 0x3f, 0x9f, 0x17, 0xd1,
	0xb7, 0x2f, 0x8a, 0x13, 0x4f, 0x5e, 0x14, 0x27, 0x7e, 0x7b, 0x51, 0x9c, 0x80, 0x05, 0xd3, 0x49,
	0xb5, 0x77, 0x07, 0x7d, 0x58, 0x35, 0x4c, 0xb6, 0xdb, 0xde, 0x29, 0x6b, 0x8e, 0x55, 0xe9, 0x8a,
	0xac, 0x99, 0x4e, 0xec, 0xab, 0xf2, 0x20, 0xfa, 0xdb, 0x35, 0x98, 0x43, 0xe8, 0xce, 0x54, 0xf8,
	0x47, 0xeb, 0xb5, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0x93, 0x24, 0x8c, 0x08, 0x3a, 0x16, 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 {
	// CreateLedger creates a new NFT ledger.
	CreateLedger(ctx context.Context, in *MsgCreateLedgerRequest, opts ...grpc.CallOption) (*MsgCreateLedgerResponse, error)
	// UpdateStatus updates the Status of a ledger.
	UpdateStatus(ctx context.Context, in *MsgUpdateStatusRequest, opts ...grpc.CallOption) (*MsgUpdateStatusResponse, error)
	// UpdateInterestRate updates the interest rate of a ledger.
	UpdateInterestRate(ctx context.Context, in *MsgUpdateInterestRateRequest, opts ...grpc.CallOption) (*MsgUpdateInterestRateResponse, error)
	// UpdatePayment updates the payment amount, next payment date, and payment frequency of a ledger.
	UpdatePayment(ctx context.Context, in *MsgUpdatePaymentRequest, opts ...grpc.CallOption) (*MsgUpdatePaymentResponse, error)
	// UpdateMaturityDate updates the maturity date of a ledger.
	UpdateMaturityDate(ctx context.Context, in *MsgUpdateMaturityDateRequest, opts ...grpc.CallOption) (*MsgUpdateMaturityDateResponse, error)
	// Append adds an entry to a ledger.
	Append(ctx context.Context, in *MsgAppendRequest, opts ...grpc.CallOption) (*MsgAppendResponse, error)
	// UpdateBalances updates the balances for a ledger entry, allowing for retroactive adjustments to be applied.
	UpdateBalances(ctx context.Context, in *MsgUpdateBalancesRequest, opts ...grpc.CallOption) (*MsgUpdateBalancesResponse, error)
	// TransferFundsWithSettlement processes multiple fund transfers with manual settlement instructions.
	TransferFundsWithSettlement(ctx context.Context, in *MsgTransferFundsWithSettlementRequest, opts ...grpc.CallOption) (*MsgTransferFundsWithSettlementResponse, error)
	// Destroy deletes a ledger and its ledger entries.
	Destroy(ctx context.Context, in *MsgDestroyRequest, opts ...grpc.CallOption) (*MsgDestroyResponse, error)
	// CreateLedgerClass creates a new ledger class.
	CreateLedgerClass(ctx context.Context, in *MsgCreateLedgerClassRequest, opts ...grpc.CallOption) (*MsgCreateLedgerClassResponse, error)
	// AddLedgerClassStatusType adds a status type to a ledger class.
	AddLedgerClassStatusType(ctx context.Context, in *MsgAddLedgerClassStatusTypeRequest, opts ...grpc.CallOption) (*MsgAddLedgerClassStatusTypeResponse, error)
	// AddLedgerClassEntryType adds an entry type to a ledger class.
	AddLedgerClassEntryType(ctx context.Context, in *MsgAddLedgerClassEntryTypeRequest, opts ...grpc.CallOption) (*MsgAddLedgerClassEntryTypeResponse, error)
	// AddLedgerClassBucketType adds a bucket type to a ledger class.
	AddLedgerClassBucketType(ctx context.Context, in *MsgAddLedgerClassBucketTypeRequest, opts ...grpc.CallOption) (*MsgAddLedgerClassBucketTypeResponse, error)
	// BulkCreate creates ledgers and entries in bulk.
	// Each ledger in this will cost one MsgCreateLedgerRequest.
	BulkCreate(ctx context.Context, in *MsgBulkCreateRequest, opts ...grpc.CallOption) (*MsgBulkCreateResponse, error)
}

type msgClient struct {
	cc grpc1.ClientConn
}

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

func (c *msgClient) CreateLedger(ctx context.Context, in *MsgCreateLedgerRequest, opts ...grpc.CallOption) (*MsgCreateLedgerResponse, error) {
	out := new(MsgCreateLedgerResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/CreateLedger", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateStatus(ctx context.Context, in *MsgUpdateStatusRequest, opts ...grpc.CallOption) (*MsgUpdateStatusResponse, error) {
	out := new(MsgUpdateStatusResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/UpdateStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateInterestRate(ctx context.Context, in *MsgUpdateInterestRateRequest, opts ...grpc.CallOption) (*MsgUpdateInterestRateResponse, error) {
	out := new(MsgUpdateInterestRateResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/UpdateInterestRate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdatePayment(ctx context.Context, in *MsgUpdatePaymentRequest, opts ...grpc.CallOption) (*MsgUpdatePaymentResponse, error) {
	out := new(MsgUpdatePaymentResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/UpdatePayment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateMaturityDate(ctx context.Context, in *MsgUpdateMaturityDateRequest, opts ...grpc.CallOption) (*MsgUpdateMaturityDateResponse, error) {
	out := new(MsgUpdateMaturityDateResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/UpdateMaturityDate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Append(ctx context.Context, in *MsgAppendRequest, opts ...grpc.CallOption) (*MsgAppendResponse, error) {
	out := new(MsgAppendResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/Append", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) UpdateBalances(ctx context.Context, in *MsgUpdateBalancesRequest, opts ...grpc.CallOption) (*MsgUpdateBalancesResponse, error) {
	out := new(MsgUpdateBalancesResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/UpdateBalances", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) TransferFundsWithSettlement(ctx context.Context, in *MsgTransferFundsWithSettlementRequest, opts ...grpc.CallOption) (*MsgTransferFundsWithSettlementResponse, error) {
	out := new(MsgTransferFundsWithSettlementResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/TransferFundsWithSettlement", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) Destroy(ctx context.Context, in *MsgDestroyRequest, opts ...grpc.CallOption) (*MsgDestroyResponse, error) {
	out := new(MsgDestroyResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/Destroy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) CreateLedgerClass(ctx context.Context, in *MsgCreateLedgerClassRequest, opts ...grpc.CallOption) (*MsgCreateLedgerClassResponse, error) {
	out := new(MsgCreateLedgerClassResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/CreateLedgerClass", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddLedgerClassStatusType(ctx context.Context, in *MsgAddLedgerClassStatusTypeRequest, opts ...grpc.CallOption) (*MsgAddLedgerClassStatusTypeResponse, error) {
	out := new(MsgAddLedgerClassStatusTypeResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/AddLedgerClassStatusType", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddLedgerClassEntryType(ctx context.Context, in *MsgAddLedgerClassEntryTypeRequest, opts ...grpc.CallOption) (*MsgAddLedgerClassEntryTypeResponse, error) {
	out := new(MsgAddLedgerClassEntryTypeResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/AddLedgerClassEntryType", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) AddLedgerClassBucketType(ctx context.Context, in *MsgAddLedgerClassBucketTypeRequest, opts ...grpc.CallOption) (*MsgAddLedgerClassBucketTypeResponse, error) {
	out := new(MsgAddLedgerClassBucketTypeResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/AddLedgerClassBucketType", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *msgClient) BulkCreate(ctx context.Context, in *MsgBulkCreateRequest, opts ...grpc.CallOption) (*MsgBulkCreateResponse, error) {
	out := new(MsgBulkCreateResponse)
	err := c.cc.Invoke(ctx, "/provenance.ledger.v1.Msg/BulkCreate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MsgServer is the server API for Msg service.
type MsgServer interface {
	// CreateLedger creates a new NFT ledger.
	CreateLedger(context.Context, *MsgCreateLedgerRequest) (*MsgCreateLedgerResponse, error)
	// UpdateStatus updates the Status of a ledger.
	UpdateStatus(context.Context, *MsgUpdateStatusRequest) (*MsgUpdateStatusResponse, error)
	// UpdateInterestRate updates the interest rate of a ledger.
	UpdateInterestRate(context.Context, *MsgUpdateInterestRateRequest) (*MsgUpdateInterestRateResponse, error)
	// UpdatePayment updates the payment amount, next payment date, and payment frequency of a ledger.
	UpdatePayment(context.Context, *MsgUpdatePaymentRequest) (*MsgUpdatePaymentResponse, error)
	// UpdateMaturityDate updates the maturity date of a ledger.
	UpdateMaturityDate(context.Context, *MsgUpdateMaturityDateRequest) (*MsgUpdateMaturityDateResponse, error)
	// Append adds an entry to a ledger.
	Append(context.Context, *MsgAppendRequest) (*MsgAppendResponse, error)
	// UpdateBalances updates the balances for a ledger entry, allowing for retroactive adjustments to be applied.
	UpdateBalances(context.Context, *MsgUpdateBalancesRequest) (*MsgUpdateBalancesResponse, error)
	// TransferFundsWithSettlement processes multiple fund transfers with manual settlement instructions.
	TransferFundsWithSettlement(context.Context, *MsgTransferFundsWithSettlementRequest) (*MsgTransferFundsWithSettlementResponse, error)
	// Destroy deletes a ledger and its ledger entries.
	Destroy(context.Context, *MsgDestroyRequest) (*MsgDestroyResponse, error)
	// CreateLedgerClass creates a new ledger class.
	CreateLedgerClass(context.Context, *MsgCreateLedgerClassRequest) (*MsgCreateLedgerClassResponse, error)
	// AddLedgerClassStatusType adds a status type to a ledger class.
	AddLedgerClassStatusType(context.Context, *MsgAddLedgerClassStatusTypeRequest) (*MsgAddLedgerClassStatusTypeResponse, error)
	// AddLedgerClassEntryType adds an entry type to a ledger class.
	AddLedgerClassEntryType(context.Context, *MsgAddLedgerClassEntryTypeRequest) (*MsgAddLedgerClassEntryTypeResponse, error)
	// AddLedgerClassBucketType adds a bucket type to a ledger class.
	AddLedgerClassBucketType(context.Context, *MsgAddLedgerClassBucketTypeRequest) (*MsgAddLedgerClassBucketTypeResponse, error)
	// BulkCreate creates ledgers and entries in bulk.
	// Each ledger in this will cost one MsgCreateLedgerRequest.
	BulkCreate(context.Context, *MsgBulkCreateRequest) (*MsgBulkCreateResponse, error)
}

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

func (*UnimplementedMsgServer) CreateLedger(ctx context.Context, req *MsgCreateLedgerRequest) (*MsgCreateLedgerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateLedger not implemented")
}
func (*UnimplementedMsgServer) UpdateStatus(ctx context.Context, req *MsgUpdateStatusRequest) (*MsgUpdateStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateStatus not implemented")
}
func (*UnimplementedMsgServer) UpdateInterestRate(ctx context.Context, req *MsgUpdateInterestRateRequest) (*MsgUpdateInterestRateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateInterestRate not implemented")
}
func (*UnimplementedMsgServer) UpdatePayment(ctx context.Context, req *MsgUpdatePaymentRequest) (*MsgUpdatePaymentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdatePayment not implemented")
}
func (*UnimplementedMsgServer) UpdateMaturityDate(ctx context.Context, req *MsgUpdateMaturityDateRequest) (*MsgUpdateMaturityDateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateMaturityDate not implemented")
}
func (*UnimplementedMsgServer) Append(ctx context.Context, req *MsgAppendRequest) (*MsgAppendResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Append not implemented")
}
func (*UnimplementedMsgServer) UpdateBalances(ctx context.Context, req *MsgUpdateBalancesRequest) (*MsgUpdateBalancesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateBalances not implemented")
}
func (*UnimplementedMsgServer) TransferFundsWithSettlement(ctx context.Context, req *MsgTransferFundsWithSettlementRequest) (*MsgTransferFundsWithSettlementResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransferFundsWithSettlement not implemented")
}
func (*UnimplementedMsgServer) Destroy(ctx context.Context, req *MsgDestroyRequest) (*MsgDestroyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Destroy not implemented")
}
func (*UnimplementedMsgServer) CreateLedgerClass(ctx context.Context, req *MsgCreateLedgerClassRequest) (*MsgCreateLedgerClassResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateLedgerClass not implemented")
}
func (*UnimplementedMsgServer) AddLedgerClassStatusType(ctx context.Context, req *MsgAddLedgerClassStatusTypeRequest) (*MsgAddLedgerClassStatusTypeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddLedgerClassStatusType not implemented")
}
func (*UnimplementedMsgServer) AddLedgerClassEntryType(ctx context.Context, req *MsgAddLedgerClassEntryTypeRequest) (*MsgAddLedgerClassEntryTypeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddLedgerClassEntryType not implemented")
}
func (*UnimplementedMsgServer) AddLedgerClassBucketType(ctx context.Context, req *MsgAddLedgerClassBucketTypeRequest) (*MsgAddLedgerClassBucketTypeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddLedgerClassBucketType not implemented")
}
func (*UnimplementedMsgServer) BulkCreate(ctx context.Context, req *MsgBulkCreateRequest) (*MsgBulkCreateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BulkCreate not implemented")
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

var Msg_serviceDesc = _Msg_serviceDesc
var _Msg_serviceDesc = grpc.ServiceDesc{
	ServiceName: "provenance.ledger.v1.Msg",
	HandlerType: (*MsgServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateLedger",
			Handler:    _Msg_CreateLedger_Handler,
		},
		{
			MethodName: "UpdateStatus",
			Handler:    _Msg_UpdateStatus_Handler,
		},
		{
			MethodName: "UpdateInterestRate",
			Handler:    _Msg_UpdateInterestRate_Handler,
		},
		{
			MethodName: "UpdatePayment",
			Handler:    _Msg_UpdatePayment_Handler,
		},
		{
			MethodName: "UpdateMaturityDate",
			Handler:    _Msg_UpdateMaturityDate_Handler,
		},
		{
			MethodName: "Append",
			Handler:    _Msg_Append_Handler,
		},
		{
			MethodName: "UpdateBalances",
			Handler:    _Msg_UpdateBalances_Handler,
		},
		{
			MethodName: "TransferFundsWithSettlement",
			Handler:    _Msg_TransferFundsWithSettlement_Handler,
		},
		{
			MethodName: "Destroy",
			Handler:    _Msg_Destroy_Handler,
		},
		{
			MethodName: "CreateLedgerClass",
			Handler:    _Msg_CreateLedgerClass_Handler,
		},
		{
			MethodName: "AddLedgerClassStatusType",
			Handler:    _Msg_AddLedgerClassStatusType_Handler,
		},
		{
			MethodName: "AddLedgerClassEntryType",
			Handler:    _Msg_AddLedgerClassEntryType_Handler,
		},
		{
			MethodName: "AddLedgerClassBucketType",
			Handler:    _Msg_AddLedgerClassBucketType_Handler,
		},
		{
			MethodName: "BulkCreate",
			Handler:    _Msg_BulkCreate_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "provenance/ledger/v1/tx.proto",
}

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

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

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

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

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

func (m *MsgUpdateStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.StatusTypeId != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.StatusTypeId))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x12
	}
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgUpdateInterestRateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.InterestAccrualMethod != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.InterestAccrualMethod))
		i--
		dAtA[i] = 0x28
	}
	if m.InterestDayCountConvention != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.InterestDayCountConvention))
		i--
		dAtA[i] = 0x20
	}
	if m.InterestRate != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.InterestRate))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x12
	}
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgUpdatePaymentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.PaymentFrequency != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.PaymentFrequency))
		i--
		dAtA[i] = 0x28
	}
	if m.NextPmtDate != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.NextPmtDate))
		i--
		dAtA[i] = 0x20
	}
	{
		size := m.NextPmtAmt.Size()
		i -= size
		if _, err := m.NextPmtAmt.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x12
	}
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgUpdateMaturityDateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.MaturityDate != 0 {
		i = encodeVarintTx(dAtA, i, uint64(m.MaturityDate))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x12
	}
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *MsgUpdateBalancesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.BalanceAmounts) > 0 {
		for iNdEx := len(m.BalanceAmounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.BalanceAmounts[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.AppliedAmounts) > 0 {
		for iNdEx := len(m.AppliedAmounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.AppliedAmounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTx(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	{
		size := m.TotalAmt.Size()
		i -= size
		if _, err := m.TotalAmt.MarshalTo(dAtA[i:]); err != nil {
			return 0, err
		}
		i = encodeVarintTx(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.CorrelationId) > 0 {
		i -= len(m.CorrelationId)
		copy(dAtA[i:], m.CorrelationId)
		i = encodeVarintTx(dAtA, i, uint64(len(m.CorrelationId)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0x12
	}
	if m.Key != nil {
		{
			size, err := m.Key.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTx(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *MsgTransferFundsWithSettlementRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Transfers) > 0 {
		for iNdEx := len(m.Transfers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Transfers[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.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (m *MsgBulkCreateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.LedgerAndEntries) > 0 {
		for iNdEx := len(m.LedgerAndEntries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.LedgerAndEntries[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.Signer) > 0 {
		i -= len(m.Signer)
		copy(dAtA[i:], m.Signer)
		i = encodeVarintTx(dAtA, i, uint64(len(m.Signer)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *MsgBulkCreateResponse) 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 *MsgCreateLedgerRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ledger != nil {
		l = m.Ledger.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgUpdateStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.StatusTypeId != 0 {
		n += 1 + sovTx(uint64(m.StatusTypeId))
	}
	return n
}

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

func (m *MsgUpdateInterestRateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.InterestRate != 0 {
		n += 1 + sovTx(uint64(m.InterestRate))
	}
	if m.InterestDayCountConvention != 0 {
		n += 1 + sovTx(uint64(m.InterestDayCountConvention))
	}
	if m.InterestAccrualMethod != 0 {
		n += 1 + sovTx(uint64(m.InterestAccrualMethod))
	}
	return n
}

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

func (m *MsgUpdatePaymentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.NextPmtAmt.Size()
	n += 1 + l + sovTx(uint64(l))
	if m.NextPmtDate != 0 {
		n += 1 + sovTx(uint64(m.NextPmtDate))
	}
	if m.PaymentFrequency != 0 {
		n += 1 + sovTx(uint64(m.PaymentFrequency))
	}
	return n
}

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

func (m *MsgUpdateMaturityDateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.MaturityDate != 0 {
		n += 1 + sovTx(uint64(m.MaturityDate))
	}
	return n
}

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

func (m *MsgAppendRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgUpdateBalancesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.CorrelationId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	l = m.TotalAmt.Size()
	n += 1 + l + sovTx(uint64(l))
	if len(m.AppliedAmounts) > 0 {
		for _, e := range m.AppliedAmounts {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	if len(m.BalanceAmounts) > 0 {
		for _, e := range m.BalanceAmounts {
			l = e.Size()
			n += 1 + l + sovTx(uint64(l))
		}
	}
	return n
}

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

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

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

func (m *MsgDestroyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgCreateLedgerClassRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.LedgerClass != nil {
		l = m.LedgerClass.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgAddLedgerClassStatusTypeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LedgerClassId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.StatusType != nil {
		l = m.StatusType.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgAddLedgerClassEntryTypeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LedgerClassId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.EntryType != nil {
		l = m.EntryType.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

func (m *MsgAddLedgerClassBucketTypeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.LedgerClassId)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	if m.BucketType != nil {
		l = m.BucketType.Size()
		n += 1 + l + sovTx(uint64(l))
	}
	l = len(m.Signer)
	if l > 0 {
		n += 1 + l + sovTx(uint64(l))
	}
	return n
}

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MsgUpdateMaturityDateResponse) 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: MsgUpdateMaturityDateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateMaturityDateResponse: 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 *MsgAppendRequest) 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: MsgAppendRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAppendRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &LedgerKey{}
			}
			if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", 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.Entries = append(m.Entries, &LedgerEntry{})
			if err := m.Entries[len(m.Entries)-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 Signer", 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.Signer = 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 *MsgAppendResponse) 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: MsgAppendResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAppendResponse: 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 *MsgUpdateBalancesRequest) 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: MsgUpdateBalancesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateBalancesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &LedgerKey{}
			}
			if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CorrelationId", 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.CorrelationId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalAmt", 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.TotalAmt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppliedAmounts", 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.AppliedAmounts = append(m.AppliedAmounts, &LedgerBucketAmount{})
			if err := m.AppliedAmounts[len(m.AppliedAmounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BalanceAmounts", 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.BalanceAmounts = append(m.BalanceAmounts, &BucketBalance{})
			if err := m.BalanceAmounts[len(m.BalanceAmounts)-1].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 *MsgUpdateBalancesResponse) 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: MsgUpdateBalancesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgUpdateBalancesResponse: 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 *MsgTransferFundsWithSettlementRequest) 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: MsgTransferFundsWithSettlementRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgTransferFundsWithSettlementRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Transfers", 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.Transfers = append(m.Transfers, &FundTransferWithSettlement{})
			if err := m.Transfers[len(m.Transfers)-1].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 *MsgTransferFundsWithSettlementResponse) 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: MsgTransferFundsWithSettlementResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgTransferFundsWithSettlementResponse: 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 *MsgDestroyRequest) 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: MsgDestroyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDestroyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &LedgerKey{}
			}
			if err := m.Key.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgDestroyResponse) 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: MsgDestroyResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgDestroyResponse: 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 *MsgCreateLedgerClassRequest) 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: MsgCreateLedgerClassRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateLedgerClassRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerClass", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LedgerClass == nil {
				m.LedgerClass = &LedgerClass{}
			}
			if err := m.LedgerClass.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgCreateLedgerClassResponse) 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: MsgCreateLedgerClassResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgCreateLedgerClassResponse: 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 *MsgAddLedgerClassStatusTypeRequest) 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: MsgAddLedgerClassStatusTypeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddLedgerClassStatusTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerClassId", 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.LedgerClassId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StatusType == nil {
				m.StatusType = &LedgerClassStatusType{}
			}
			if err := m.StatusType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgAddLedgerClassStatusTypeResponse) 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: MsgAddLedgerClassStatusTypeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddLedgerClassStatusTypeResponse: 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 *MsgAddLedgerClassEntryTypeRequest) 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: MsgAddLedgerClassEntryTypeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddLedgerClassEntryTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerClassId", 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.LedgerClassId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EntryType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.EntryType == nil {
				m.EntryType = &LedgerClassEntryType{}
			}
			if err := m.EntryType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgAddLedgerClassEntryTypeResponse) 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: MsgAddLedgerClassEntryTypeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddLedgerClassEntryTypeResponse: 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 *MsgAddLedgerClassBucketTypeRequest) 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: MsgAddLedgerClassBucketTypeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddLedgerClassBucketTypeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerClassId", 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.LedgerClassId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BucketType", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTx
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTx
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTx
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BucketType == nil {
				m.BucketType = &LedgerClassBucketType{}
			}
			if err := m.BucketType.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = 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 *MsgAddLedgerClassBucketTypeResponse) 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: MsgAddLedgerClassBucketTypeResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgAddLedgerClassBucketTypeResponse: 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 *MsgBulkCreateRequest) 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: MsgBulkCreateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgBulkCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Signer", 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.Signer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LedgerAndEntries", 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.LedgerAndEntries = append(m.LedgerAndEntries, &LedgerAndEntries{})
			if err := m.LedgerAndEntries[len(m.LedgerAndEntries)-1].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 *MsgBulkCreateResponse) 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: MsgBulkCreateResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MsgBulkCreateResponse: 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")
)
