ledger.pb.go

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

package ledger

import (
	context "context"
	fmt "fmt"
	_ "github.com/bittorrent/protobuf/gogoproto"
	proto "github.com/bittorrent/protobuf/proto"
	golang_proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type Null struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Null proto.InternalMessageInfo

func (*Null) XXX_MessageName() string {
	return "ledger.Null"
}

type PublicKey struct {
	Key                  []byte   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty" pg:"key"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PublicKey proto.InternalMessageInfo

func (m *PublicKey) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (*PublicKey) XXX_MessageName() string {
	return "ledger.PublicKey"
}

type SignedPublicKey struct {
	Key                  *PublicKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty" pg:"key"`
	Signature            []byte     `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" pg:"signature"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPublicKey proto.InternalMessageInfo

func (m *SignedPublicKey) GetKey() *PublicKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *SignedPublicKey) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (*SignedPublicKey) XXX_MessageName() string {
	return "ledger.SignedPublicKey"
}

type ChannelCommit struct {
	Payer                *PublicKey `protobuf:"bytes,1,opt,name=payer,proto3" json:"payer,omitempty" pg:"payer"`
	Recipient            *PublicKey `protobuf:"bytes,2,opt,name=recipient,proto3" json:"recipient,omitempty" pg:"recipient"`
	Amount               int64      `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	PayerId              int64      `protobuf:"varint,4,opt,name=payer_id,json=payerId,proto3" json:"payer_id,omitempty" pg:"payer_id"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ChannelCommit proto.InternalMessageInfo

func (m *ChannelCommit) GetPayer() *PublicKey {
	if m != nil {
		return m.Payer
	}
	return nil
}

func (m *ChannelCommit) GetRecipient() *PublicKey {
	if m != nil {
		return m.Recipient
	}
	return nil
}

func (m *ChannelCommit) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (m *ChannelCommit) GetPayerId() int64 {
	if m != nil {
		return m.PayerId
	}
	return 0
}

func (*ChannelCommit) XXX_MessageName() string {
	return "ledger.ChannelCommit"
}

type SignedChannelCommit struct {
	Channel              *ChannelCommit `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty" pg:"channel"`
	Signature            []byte         `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" pg:"signature"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-" pg:"-"`
	XXX_unrecognized     []byte         `json:"-" pg:"-"`
	XXX_sizecache        int32          `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedChannelCommit proto.InternalMessageInfo

func (m *SignedChannelCommit) GetChannel() *ChannelCommit {
	if m != nil {
		return m.Channel
	}
	return nil
}

func (m *SignedChannelCommit) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (*SignedChannelCommit) XXX_MessageName() string {
	return "ledger.SignedChannelCommit"
}

type CreateAccountResult struct {
	Account              *Account `protobuf:"bytes,1,opt,name=account,proto3" json:"account,omitempty" pg:"account"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_CreateAccountResult proto.InternalMessageInfo

func (m *CreateAccountResult) GetAccount() *Account {
	if m != nil {
		return m.Account
	}
	return nil
}

func (*CreateAccountResult) XXX_MessageName() string {
	return "ledger.CreateAccountResult"
}

type SignedCreateAccountRequest struct {
	Key       *PublicKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty" pg:"key"`
	Signature []byte     `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" pg:"signature"`
	// client version number
	ClientVersionNumber  string   `protobuf:"bytes,3,opt,name=client_version_number,json=clientVersionNumber,proto3" json:"client_version_number,omitempty" pg:"client_version_number"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedCreateAccountRequest proto.InternalMessageInfo

func (m *SignedCreateAccountRequest) GetKey() *PublicKey {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *SignedCreateAccountRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (m *SignedCreateAccountRequest) GetClientVersionNumber() string {
	if m != nil {
		return m.ClientVersionNumber
	}
	return ""
}

func (*SignedCreateAccountRequest) XXX_MessageName() string {
	return "ledger.SignedCreateAccountRequest"
}

type SignedCreateAccountResult struct {
	Balance              int64    `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty" pg:"balance"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedCreateAccountResult proto.InternalMessageInfo

func (m *SignedCreateAccountResult) GetBalance() int64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (*SignedCreateAccountResult) XXX_MessageName() string {
	return "ledger.SignedCreateAccountResult"
}

type Account struct {
	Address *PublicKey `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" pg:"address"`
	// Current available balance
	Balance              int64    `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty" pg:"balance"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Account proto.InternalMessageInfo

func (m *Account) GetAddress() *PublicKey {
	if m != nil {
		return m.Address
	}
	return nil
}

func (m *Account) GetBalance() int64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (*Account) XXX_MessageName() string {
	return "ledger.Account"
}

type ChannelID struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ChannelID proto.InternalMessageInfo

func (m *ChannelID) GetId() int64 {
	if m != nil {
		return m.Id
	}
	return 0
}

func (*ChannelID) XXX_MessageName() string {
	return "ledger.ChannelID"
}

type ChannelInfo struct {
	Id                   *ChannelID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	FromAccount          *Account   `protobuf:"bytes,2,opt,name=from_account,json=fromAccount,proto3" json:"from_account,omitempty" pg:"from_account"`
	ToAccount            *Account   `protobuf:"bytes,3,opt,name=to_account,json=toAccount,proto3" json:"to_account,omitempty" pg:"to_account"`
	CloseSequence        int64      `protobuf:"varint,4,opt,name=close_sequence,json=closeSequence,proto3" json:"close_sequence,omitempty" pg:"close_sequence"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ChannelInfo proto.InternalMessageInfo

func (m *ChannelInfo) GetId() *ChannelID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *ChannelInfo) GetFromAccount() *Account {
	if m != nil {
		return m.FromAccount
	}
	return nil
}

func (m *ChannelInfo) GetToAccount() *Account {
	if m != nil {
		return m.ToAccount
	}
	return nil
}

func (m *ChannelInfo) GetCloseSequence() int64 {
	if m != nil {
		return m.CloseSequence
	}
	return 0
}

func (*ChannelInfo) XXX_MessageName() string {
	return "ledger.ChannelInfo"
}

type SignedChannelState struct {
	Channel              *ChannelState `protobuf:"bytes,1,opt,name=channel,proto3" json:"channel,omitempty" pg:"channel"`
	FromSignature        []byte        `protobuf:"bytes,2,opt,name=from_signature,json=fromSignature,proto3" json:"from_signature,omitempty" pg:"from_signature"`
	ToSignature          []byte        `protobuf:"bytes,3,opt,name=to_signature,json=toSignature,proto3" json:"to_signature,omitempty" pg:"to_signature"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedChannelState proto.InternalMessageInfo

func (m *SignedChannelState) GetChannel() *ChannelState {
	if m != nil {
		return m.Channel
	}
	return nil
}

func (m *SignedChannelState) GetFromSignature() []byte {
	if m != nil {
		return m.FromSignature
	}
	return nil
}

func (m *SignedChannelState) GetToSignature() []byte {
	if m != nil {
		return m.ToSignature
	}
	return nil
}

func (*SignedChannelState) XXX_MessageName() string {
	return "ledger.SignedChannelState"
}

type ClosedChannelCursor struct {
	Payer                *PublicKey `protobuf:"bytes,1,opt,name=payer,proto3" json:"payer,omitempty" pg:"payer"`
	CloseSequence        int64      `protobuf:"varint,2,opt,name=close_sequence,json=closeSequence,proto3" json:"close_sequence,omitempty" pg:"close_sequence"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ClosedChannelCursor proto.InternalMessageInfo

func (m *ClosedChannelCursor) GetPayer() *PublicKey {
	if m != nil {
		return m.Payer
	}
	return nil
}

func (m *ClosedChannelCursor) GetCloseSequence() int64 {
	if m != nil {
		return m.CloseSequence
	}
	return 0
}

func (*ClosedChannelCursor) XXX_MessageName() string {
	return "ledger.ClosedChannelCursor"
}

type ChannelState struct {
	Id                   *ChannelID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty" pg:"id"`
	Sequence             int64      `protobuf:"varint,2,opt,name=sequence,proto3" json:"sequence,omitempty" pg:"sequence"`
	From                 *Account   `protobuf:"bytes,3,opt,name=from,proto3" json:"from,omitempty" pg:"from"`
	To                   *Account   `protobuf:"bytes,4,opt,name=to,proto3" json:"to,omitempty" pg:"to"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ChannelState proto.InternalMessageInfo

func (m *ChannelState) GetId() *ChannelID {
	if m != nil {
		return m.Id
	}
	return nil
}

func (m *ChannelState) GetSequence() int64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func (m *ChannelState) GetFrom() *Account {
	if m != nil {
		return m.From
	}
	return nil
}

func (m *ChannelState) GetTo() *Account {
	if m != nil {
		return m.To
	}
	return nil
}

func (*ChannelState) XXX_MessageName() string {
	return "ledger.ChannelState"
}

type ChannelClosed struct {
	State                *SignedChannelState `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty" pg:"state"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-" pg:"-"`
	XXX_unrecognized     []byte              `json:"-" pg:"-"`
	XXX_sizecache        int32               `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ChannelClosed proto.InternalMessageInfo

func (m *ChannelClosed) GetState() *SignedChannelState {
	if m != nil {
		return m.State
	}
	return nil
}

func (*ChannelClosed) XXX_MessageName() string {
	return "ledger.ChannelClosed"
}

type SignedPublicKeyPair struct {
	OldKey               *PublicKey `protobuf:"bytes,1,opt,name=old_key,json=oldKey,proto3" json:"old_key,omitempty" pg:"old_key"`
	NewKey               *PublicKey `protobuf:"bytes,2,opt,name=new_key,json=newKey,proto3" json:"new_key,omitempty" pg:"new_key"`
	OldSignature         []byte     `protobuf:"bytes,3,opt,name=old_signature,json=oldSignature,proto3" json:"old_signature,omitempty" pg:"old_signature"`
	NewSignature         []byte     `protobuf:"bytes,4,opt,name=new_signature,json=newSignature,proto3" json:"new_signature,omitempty" pg:"new_signature"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPublicKeyPair proto.InternalMessageInfo

func (m *SignedPublicKeyPair) GetOldKey() *PublicKey {
	if m != nil {
		return m.OldKey
	}
	return nil
}

func (m *SignedPublicKeyPair) GetNewKey() *PublicKey {
	if m != nil {
		return m.NewKey
	}
	return nil
}

func (m *SignedPublicKeyPair) GetOldSignature() []byte {
	if m != nil {
		return m.OldSignature
	}
	return nil
}

func (m *SignedPublicKeyPair) GetNewSignature() []byte {
	if m != nil {
		return m.NewSignature
	}
	return nil
}

func (*SignedPublicKeyPair) XXX_MessageName() string {
	return "ledger.SignedPublicKeyPair"
}

type TransferRequest struct {
	Payer                *PublicKey `protobuf:"bytes,1,opt,name=payer,proto3" json:"payer,omitempty" pg:"payer"`
	Recipient            *PublicKey `protobuf:"bytes,2,opt,name=recipient,proto3" json:"recipient,omitempty" pg:"recipient"`
	Amount               int64      `protobuf:"varint,3,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_TransferRequest proto.InternalMessageInfo

func (m *TransferRequest) GetPayer() *PublicKey {
	if m != nil {
		return m.Payer
	}
	return nil
}

func (m *TransferRequest) GetRecipient() *PublicKey {
	if m != nil {
		return m.Recipient
	}
	return nil
}

func (m *TransferRequest) GetAmount() int64 {
	if m != nil {
		return m.Amount
	}
	return 0
}

func (*TransferRequest) XXX_MessageName() string {
	return "ledger.TransferRequest"
}

type SignedTransferRequest struct {
	TransferRequest      *TransferRequest `protobuf:"bytes,1,opt,name=transfer_request,json=transferRequest,proto3" json:"transfer_request,omitempty" pg:"transfer_request"`
	Signature            []byte           `protobuf:"bytes,2,opt,name=signature,proto3" json:"signature,omitempty" pg:"signature"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-" pg:"-"`
	XXX_unrecognized     []byte           `json:"-" pg:"-"`
	XXX_sizecache        int32            `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedTransferRequest proto.InternalMessageInfo

func (m *SignedTransferRequest) GetTransferRequest() *TransferRequest {
	if m != nil {
		return m.TransferRequest
	}
	return nil
}

func (m *SignedTransferRequest) GetSignature() []byte {
	if m != nil {
		return m.Signature
	}
	return nil
}

func (*SignedTransferRequest) XXX_MessageName() string {
	return "ledger.SignedTransferRequest"
}

type TransferResult struct {
	Balance              int64    `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty" pg:"balance"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_TransferResult proto.InternalMessageInfo

func (m *TransferResult) GetBalance() int64 {
	if m != nil {
		return m.Balance
	}
	return 0
}

func (*TransferResult) XXX_MessageName() string {
	return "ledger.TransferResult"
}
func init() {
	proto.RegisterType((*Null)(nil), "ledger.Null")
	golang_proto.RegisterType((*Null)(nil), "ledger.Null")
	proto.RegisterType((*PublicKey)(nil), "ledger.PublicKey")
	golang_proto.RegisterType((*PublicKey)(nil), "ledger.PublicKey")
	proto.RegisterType((*SignedPublicKey)(nil), "ledger.SignedPublicKey")
	golang_proto.RegisterType((*SignedPublicKey)(nil), "ledger.SignedPublicKey")
	proto.RegisterType((*ChannelCommit)(nil), "ledger.ChannelCommit")
	golang_proto.RegisterType((*ChannelCommit)(nil), "ledger.ChannelCommit")
	proto.RegisterType((*SignedChannelCommit)(nil), "ledger.SignedChannelCommit")
	golang_proto.RegisterType((*SignedChannelCommit)(nil), "ledger.SignedChannelCommit")
	proto.RegisterType((*CreateAccountResult)(nil), "ledger.CreateAccountResult")
	golang_proto.RegisterType((*CreateAccountResult)(nil), "ledger.CreateAccountResult")
	proto.RegisterType((*SignedCreateAccountRequest)(nil), "ledger.SignedCreateAccountRequest")
	golang_proto.RegisterType((*SignedCreateAccountRequest)(nil), "ledger.SignedCreateAccountRequest")
	proto.RegisterType((*SignedCreateAccountResult)(nil), "ledger.SignedCreateAccountResult")
	golang_proto.RegisterType((*SignedCreateAccountResult)(nil), "ledger.SignedCreateAccountResult")
	proto.RegisterType((*Account)(nil), "ledger.Account")
	golang_proto.RegisterType((*Account)(nil), "ledger.Account")
	proto.RegisterType((*ChannelID)(nil), "ledger.ChannelID")
	golang_proto.RegisterType((*ChannelID)(nil), "ledger.ChannelID")
	proto.RegisterType((*ChannelInfo)(nil), "ledger.ChannelInfo")
	golang_proto.RegisterType((*ChannelInfo)(nil), "ledger.ChannelInfo")
	proto.RegisterType((*SignedChannelState)(nil), "ledger.SignedChannelState")
	golang_proto.RegisterType((*SignedChannelState)(nil), "ledger.SignedChannelState")
	proto.RegisterType((*ClosedChannelCursor)(nil), "ledger.ClosedChannelCursor")
	golang_proto.RegisterType((*ClosedChannelCursor)(nil), "ledger.ClosedChannelCursor")
	proto.RegisterType((*ChannelState)(nil), "ledger.ChannelState")
	golang_proto.RegisterType((*ChannelState)(nil), "ledger.ChannelState")
	proto.RegisterType((*ChannelClosed)(nil), "ledger.ChannelClosed")
	golang_proto.RegisterType((*ChannelClosed)(nil), "ledger.ChannelClosed")
	proto.RegisterType((*SignedPublicKeyPair)(nil), "ledger.SignedPublicKeyPair")
	golang_proto.RegisterType((*SignedPublicKeyPair)(nil), "ledger.SignedPublicKeyPair")
	proto.RegisterType((*TransferRequest)(nil), "ledger.TransferRequest")
	golang_proto.RegisterType((*TransferRequest)(nil), "ledger.TransferRequest")
	proto.RegisterType((*SignedTransferRequest)(nil), "ledger.SignedTransferRequest")
	golang_proto.RegisterType((*SignedTransferRequest)(nil), "ledger.SignedTransferRequest")
	proto.RegisterType((*TransferResult)(nil), "ledger.TransferResult")
	golang_proto.RegisterType((*TransferResult)(nil), "ledger.TransferResult")
}

func init() { proto.RegisterFile("protos/ledger/ledger.proto", fileDescriptor_858b35020cfe9185) }
func init() { golang_proto.RegisterFile("protos/ledger/ledger.proto", fileDescriptor_858b35020cfe9185) }

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

// ChannelsClient is the client API for Channels service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ChannelsClient interface {
	// Creates a channel on the ledger and returns the ID of the ledger
	CreateChannel(ctx context.Context, in *SignedChannelCommit, opts ...grpc.CallOption) (*ChannelID, error)
	// Retrieves the state of a channel on the ledger.
	GetChannelInfo(ctx context.Context, in *ChannelID, opts ...grpc.CallOption) (*ChannelInfo, error)
	// Closes a channel on the ledger.
	CloseChannel(ctx context.Context, in *SignedChannelState, opts ...grpc.CallOption) (*ChannelClosed, error)
	// Retrieves the state of the next closed channel with the given payer
	// returns OUT_OF_RANGE status if there are no more closed channels
	GetNextClosedChannel(ctx context.Context, in *ClosedChannelCursor, opts ...grpc.CallOption) (*ChannelInfo, error)
	// Create an account and return
	CreateAccount(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*CreateAccountResult, error)
	// Create an account, securely, and return
	SignedCreateAccount(ctx context.Context, in *SignedCreateAccountRequest, opts ...grpc.CallOption) (*SignedCreateAccountResult, error)
	// Update an account pub key (BIP 44 compatible)
	UpdateAccountPubKey(ctx context.Context, in *SignedPublicKeyPair, opts ...grpc.CallOption) (*Null, error)
	// Transfers funds from one off-chain account to another
	Transfer(ctx context.Context, in *SignedTransferRequest, opts ...grpc.CallOption) (*TransferResult, error)
}

type channelsClient struct {
	cc *grpc.ClientConn
}

func NewChannelsClient(cc *grpc.ClientConn) ChannelsClient {
	return &channelsClient{cc}
}

func (c *channelsClient) CreateChannel(ctx context.Context, in *SignedChannelCommit, opts ...grpc.CallOption) (*ChannelID, error) {
	out := new(ChannelID)
	err := c.cc.Invoke(ctx, "/ledger.Channels/CreateChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) GetChannelInfo(ctx context.Context, in *ChannelID, opts ...grpc.CallOption) (*ChannelInfo, error) {
	out := new(ChannelInfo)
	err := c.cc.Invoke(ctx, "/ledger.Channels/GetChannelInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) CloseChannel(ctx context.Context, in *SignedChannelState, opts ...grpc.CallOption) (*ChannelClosed, error) {
	out := new(ChannelClosed)
	err := c.cc.Invoke(ctx, "/ledger.Channels/CloseChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) GetNextClosedChannel(ctx context.Context, in *ClosedChannelCursor, opts ...grpc.CallOption) (*ChannelInfo, error) {
	out := new(ChannelInfo)
	err := c.cc.Invoke(ctx, "/ledger.Channels/GetNextClosedChannel", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) CreateAccount(ctx context.Context, in *PublicKey, opts ...grpc.CallOption) (*CreateAccountResult, error) {
	out := new(CreateAccountResult)
	err := c.cc.Invoke(ctx, "/ledger.Channels/CreateAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) SignedCreateAccount(ctx context.Context, in *SignedCreateAccountRequest, opts ...grpc.CallOption) (*SignedCreateAccountResult, error) {
	out := new(SignedCreateAccountResult)
	err := c.cc.Invoke(ctx, "/ledger.Channels/SignedCreateAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) UpdateAccountPubKey(ctx context.Context, in *SignedPublicKeyPair, opts ...grpc.CallOption) (*Null, error) {
	out := new(Null)
	err := c.cc.Invoke(ctx, "/ledger.Channels/UpdateAccountPubKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *channelsClient) Transfer(ctx context.Context, in *SignedTransferRequest, opts ...grpc.CallOption) (*TransferResult, error) {
	out := new(TransferResult)
	err := c.cc.Invoke(ctx, "/ledger.Channels/Transfer", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ChannelsServer is the server API for Channels service.
type ChannelsServer interface {
	// Creates a channel on the ledger and returns the ID of the ledger
	CreateChannel(context.Context, *SignedChannelCommit) (*ChannelID, error)
	// Retrieves the state of a channel on the ledger.
	GetChannelInfo(context.Context, *ChannelID) (*ChannelInfo, error)
	// Closes a channel on the ledger.
	CloseChannel(context.Context, *SignedChannelState) (*ChannelClosed, error)
	// Retrieves the state of the next closed channel with the given payer
	// returns OUT_OF_RANGE status if there are no more closed channels
	GetNextClosedChannel(context.Context, *ClosedChannelCursor) (*ChannelInfo, error)
	// Create an account and return
	CreateAccount(context.Context, *PublicKey) (*CreateAccountResult, error)
	// Create an account, securely, and return
	SignedCreateAccount(context.Context, *SignedCreateAccountRequest) (*SignedCreateAccountResult, error)
	// Update an account pub key (BIP 44 compatible)
	UpdateAccountPubKey(context.Context, *SignedPublicKeyPair) (*Null, error)
	// Transfers funds from one off-chain account to another
	Transfer(context.Context, *SignedTransferRequest) (*TransferResult, error)
}

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

func (*UnimplementedChannelsServer) CreateChannel(ctx context.Context, req *SignedChannelCommit) (*ChannelID, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateChannel not implemented")
}
func (*UnimplementedChannelsServer) GetChannelInfo(ctx context.Context, req *ChannelID) (*ChannelInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetChannelInfo not implemented")
}
func (*UnimplementedChannelsServer) CloseChannel(ctx context.Context, req *SignedChannelState) (*ChannelClosed, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseChannel not implemented")
}
func (*UnimplementedChannelsServer) GetNextClosedChannel(ctx context.Context, req *ClosedChannelCursor) (*ChannelInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNextClosedChannel not implemented")
}
func (*UnimplementedChannelsServer) CreateAccount(ctx context.Context, req *PublicKey) (*CreateAccountResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateAccount not implemented")
}
func (*UnimplementedChannelsServer) SignedCreateAccount(ctx context.Context, req *SignedCreateAccountRequest) (*SignedCreateAccountResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SignedCreateAccount not implemented")
}
func (*UnimplementedChannelsServer) UpdateAccountPubKey(ctx context.Context, req *SignedPublicKeyPair) (*Null, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAccountPubKey not implemented")
}
func (*UnimplementedChannelsServer) Transfer(ctx context.Context, req *SignedTransferRequest) (*TransferResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Transfer not implemented")
}

func RegisterChannelsServer(s *grpc.Server, srv ChannelsServer) {
	s.RegisterService(&_Channels_serviceDesc, srv)
}

func _Channels_CreateChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedChannelCommit)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).CreateChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/CreateChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).CreateChannel(ctx, req.(*SignedChannelCommit))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_GetChannelInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChannelID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).GetChannelInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/GetChannelInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).GetChannelInfo(ctx, req.(*ChannelID))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_CloseChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedChannelState)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).CloseChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/CloseChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).CloseChannel(ctx, req.(*SignedChannelState))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_GetNextClosedChannel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClosedChannelCursor)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).GetNextClosedChannel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/GetNextClosedChannel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).GetNextClosedChannel(ctx, req.(*ClosedChannelCursor))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_CreateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PublicKey)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).CreateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/CreateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).CreateAccount(ctx, req.(*PublicKey))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_SignedCreateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedCreateAccountRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).SignedCreateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/SignedCreateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).SignedCreateAccount(ctx, req.(*SignedCreateAccountRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_UpdateAccountPubKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedPublicKeyPair)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).UpdateAccountPubKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/UpdateAccountPubKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).UpdateAccountPubKey(ctx, req.(*SignedPublicKeyPair))
	}
	return interceptor(ctx, in, info, handler)
}

func _Channels_Transfer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedTransferRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChannelsServer).Transfer(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/ledger.Channels/Transfer",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChannelsServer).Transfer(ctx, req.(*SignedTransferRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Channels_serviceDesc = grpc.ServiceDesc{
	ServiceName: "ledger.Channels",
	HandlerType: (*ChannelsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateChannel",
			Handler:    _Channels_CreateChannel_Handler,
		},
		{
			MethodName: "GetChannelInfo",
			Handler:    _Channels_GetChannelInfo_Handler,
		},
		{
			MethodName: "CloseChannel",
			Handler:    _Channels_CloseChannel_Handler,
		},
		{
			MethodName: "GetNextClosedChannel",
			Handler:    _Channels_GetNextClosedChannel_Handler,
		},
		{
			MethodName: "CreateAccount",
			Handler:    _Channels_CreateAccount_Handler,
		},
		{
			MethodName: "SignedCreateAccount",
			Handler:    _Channels_SignedCreateAccount_Handler,
		},
		{
			MethodName: "UpdateAccountPubKey",
			Handler:    _Channels_UpdateAccountPubKey_Handler,
		},
		{
			MethodName: "Transfer",
			Handler:    _Channels_Transfer_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "protos/ledger/ledger.proto",
}

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

func (m *Null) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *ChannelCommit) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.PayerId != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.PayerId))
		i--
		dAtA[i] = 0x20
	}
	if m.Amount != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x18
	}
	if m.Recipient != nil {
		{
			size, err := m.Recipient.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Payer != nil {
		{
			size, err := m.Payer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

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

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

func (m *SignedCreateAccountResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Balance != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Balance))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Account) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Balance != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Balance))
		i--
		dAtA[i] = 0x10
	}
	if m.Address != nil {
		{
			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ChannelID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Id != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ChannelInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CloseSequence != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.CloseSequence))
		i--
		dAtA[i] = 0x20
	}
	if m.ToAccount != nil {
		{
			size, err := m.ToAccount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.FromAccount != nil {
		{
			size, err := m.FromAccount.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Id != nil {
		{
			size, err := m.Id.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedChannelState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ToSignature) > 0 {
		i -= len(m.ToSignature)
		copy(dAtA[i:], m.ToSignature)
		i = encodeVarintLedger(dAtA, i, uint64(len(m.ToSignature)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.FromSignature) > 0 {
		i -= len(m.FromSignature)
		copy(dAtA[i:], m.FromSignature)
		i = encodeVarintLedger(dAtA, i, uint64(len(m.FromSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Channel != nil {
		{
			size, err := m.Channel.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClosedChannelCursor) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.CloseSequence != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.CloseSequence))
		i--
		dAtA[i] = 0x10
	}
	if m.Payer != nil {
		{
			size, err := m.Payer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ChannelState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.To != nil {
		{
			size, err := m.To.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.From != nil {
		{
			size, err := m.From.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Sequence != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Sequence))
		i--
		dAtA[i] = 0x10
	}
	if m.Id != nil {
		{
			size, err := m.Id.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *SignedPublicKeyPair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.NewSignature) > 0 {
		i -= len(m.NewSignature)
		copy(dAtA[i:], m.NewSignature)
		i = encodeVarintLedger(dAtA, i, uint64(len(m.NewSignature)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.OldSignature) > 0 {
		i -= len(m.OldSignature)
		copy(dAtA[i:], m.OldSignature)
		i = encodeVarintLedger(dAtA, i, uint64(len(m.OldSignature)))
		i--
		dAtA[i] = 0x1a
	}
	if m.NewKey != nil {
		{
			size, err := m.NewKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.OldKey != nil {
		{
			size, err := m.OldKey.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TransferRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Amount != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x18
	}
	if m.Recipient != nil {
		{
			size, err := m.Recipient.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Payer != nil {
		{
			size, err := m.Payer.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintLedger(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *TransferResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Balance != 0 {
		i = encodeVarintLedger(dAtA, i, uint64(m.Balance))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintLedger(dAtA []byte, offset int, v uint64) int {
	offset -= sovLedger(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func NewPopulatedNull(r randyLedger, easy bool) *Null {
	this := &Null{}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 1)
	}
	return this
}

func NewPopulatedPublicKey(r randyLedger, easy bool) *PublicKey {
	this := &PublicKey{}
	v1 := r.Intn(100)
	this.Key = make([]byte, v1)
	for i := 0; i < v1; i++ {
		this.Key[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 2)
	}
	return this
}

func NewPopulatedSignedPublicKey(r randyLedger, easy bool) *SignedPublicKey {
	this := &SignedPublicKey{}
	if r.Intn(5) != 0 {
		this.Key = NewPopulatedPublicKey(r, easy)
	}
	v2 := r.Intn(100)
	this.Signature = make([]byte, v2)
	for i := 0; i < v2; i++ {
		this.Signature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 3)
	}
	return this
}

func NewPopulatedChannelCommit(r randyLedger, easy bool) *ChannelCommit {
	this := &ChannelCommit{}
	if r.Intn(5) != 0 {
		this.Payer = NewPopulatedPublicKey(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Recipient = NewPopulatedPublicKey(r, easy)
	}
	this.Amount = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Amount *= -1
	}
	this.PayerId = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.PayerId *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 5)
	}
	return this
}

func NewPopulatedSignedChannelCommit(r randyLedger, easy bool) *SignedChannelCommit {
	this := &SignedChannelCommit{}
	if r.Intn(5) != 0 {
		this.Channel = NewPopulatedChannelCommit(r, easy)
	}
	v3 := r.Intn(100)
	this.Signature = make([]byte, v3)
	for i := 0; i < v3; i++ {
		this.Signature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 3)
	}
	return this
}

func NewPopulatedCreateAccountResult(r randyLedger, easy bool) *CreateAccountResult {
	this := &CreateAccountResult{}
	if r.Intn(5) != 0 {
		this.Account = NewPopulatedAccount(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 2)
	}
	return this
}

func NewPopulatedSignedCreateAccountRequest(r randyLedger, easy bool) *SignedCreateAccountRequest {
	this := &SignedCreateAccountRequest{}
	if r.Intn(5) != 0 {
		this.Key = NewPopulatedPublicKey(r, easy)
	}
	v4 := r.Intn(100)
	this.Signature = make([]byte, v4)
	for i := 0; i < v4; i++ {
		this.Signature[i] = byte(r.Intn(256))
	}
	this.ClientVersionNumber = string(randStringLedger(r))
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 4)
	}
	return this
}

func NewPopulatedSignedCreateAccountResult(r randyLedger, easy bool) *SignedCreateAccountResult {
	this := &SignedCreateAccountResult{}
	this.Balance = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Balance *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 2)
	}
	return this
}

func NewPopulatedAccount(r randyLedger, easy bool) *Account {
	this := &Account{}
	if r.Intn(5) != 0 {
		this.Address = NewPopulatedPublicKey(r, easy)
	}
	this.Balance = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Balance *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 3)
	}
	return this
}

func NewPopulatedChannelID(r randyLedger, easy bool) *ChannelID {
	this := &ChannelID{}
	this.Id = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Id *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 2)
	}
	return this
}

func NewPopulatedChannelInfo(r randyLedger, easy bool) *ChannelInfo {
	this := &ChannelInfo{}
	if r.Intn(5) != 0 {
		this.Id = NewPopulatedChannelID(r, easy)
	}
	if r.Intn(5) != 0 {
		this.FromAccount = NewPopulatedAccount(r, easy)
	}
	if r.Intn(5) != 0 {
		this.ToAccount = NewPopulatedAccount(r, easy)
	}
	this.CloseSequence = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CloseSequence *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 5)
	}
	return this
}

func NewPopulatedSignedChannelState(r randyLedger, easy bool) *SignedChannelState {
	this := &SignedChannelState{}
	if r.Intn(5) != 0 {
		this.Channel = NewPopulatedChannelState(r, easy)
	}
	v5 := r.Intn(100)
	this.FromSignature = make([]byte, v5)
	for i := 0; i < v5; i++ {
		this.FromSignature[i] = byte(r.Intn(256))
	}
	v6 := r.Intn(100)
	this.ToSignature = make([]byte, v6)
	for i := 0; i < v6; i++ {
		this.ToSignature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 4)
	}
	return this
}

func NewPopulatedClosedChannelCursor(r randyLedger, easy bool) *ClosedChannelCursor {
	this := &ClosedChannelCursor{}
	if r.Intn(5) != 0 {
		this.Payer = NewPopulatedPublicKey(r, easy)
	}
	this.CloseSequence = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.CloseSequence *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 3)
	}
	return this
}

func NewPopulatedChannelState(r randyLedger, easy bool) *ChannelState {
	this := &ChannelState{}
	if r.Intn(5) != 0 {
		this.Id = NewPopulatedChannelID(r, easy)
	}
	this.Sequence = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Sequence *= -1
	}
	if r.Intn(5) != 0 {
		this.From = NewPopulatedAccount(r, easy)
	}
	if r.Intn(5) != 0 {
		this.To = NewPopulatedAccount(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 5)
	}
	return this
}

func NewPopulatedChannelClosed(r randyLedger, easy bool) *ChannelClosed {
	this := &ChannelClosed{}
	if r.Intn(5) != 0 {
		this.State = NewPopulatedSignedChannelState(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 2)
	}
	return this
}

func NewPopulatedSignedPublicKeyPair(r randyLedger, easy bool) *SignedPublicKeyPair {
	this := &SignedPublicKeyPair{}
	if r.Intn(5) != 0 {
		this.OldKey = NewPopulatedPublicKey(r, easy)
	}
	if r.Intn(5) != 0 {
		this.NewKey = NewPopulatedPublicKey(r, easy)
	}
	v7 := r.Intn(100)
	this.OldSignature = make([]byte, v7)
	for i := 0; i < v7; i++ {
		this.OldSignature[i] = byte(r.Intn(256))
	}
	v8 := r.Intn(100)
	this.NewSignature = make([]byte, v8)
	for i := 0; i < v8; i++ {
		this.NewSignature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 5)
	}
	return this
}

func NewPopulatedTransferRequest(r randyLedger, easy bool) *TransferRequest {
	this := &TransferRequest{}
	if r.Intn(5) != 0 {
		this.Payer = NewPopulatedPublicKey(r, easy)
	}
	if r.Intn(5) != 0 {
		this.Recipient = NewPopulatedPublicKey(r, easy)
	}
	this.Amount = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Amount *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 4)
	}
	return this
}

func NewPopulatedSignedTransferRequest(r randyLedger, easy bool) *SignedTransferRequest {
	this := &SignedTransferRequest{}
	if r.Intn(5) != 0 {
		this.TransferRequest = NewPopulatedTransferRequest(r, easy)
	}
	v9 := r.Intn(100)
	this.Signature = make([]byte, v9)
	for i := 0; i < v9; i++ {
		this.Signature[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 3)
	}
	return this
}

func NewPopulatedTransferResult(r randyLedger, easy bool) *TransferResult {
	this := &TransferResult{}
	this.Balance = int64(r.Int63())
	if r.Intn(2) == 0 {
		this.Balance *= -1
	}
	if !easy && r.Intn(10) != 0 {
		this.XXX_unrecognized = randUnrecognizedLedger(r, 2)
	}
	return this
}

type randyLedger interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneLedger(r randyLedger) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringLedger(r randyLedger) string {
	v10 := r.Intn(100)
	tmps := make([]rune, v10)
	for i := 0; i < v10; i++ {
		tmps[i] = randUTF8RuneLedger(r)
	}
	return string(tmps)
}
func randUnrecognizedLedger(r randyLedger, maxFieldNumber int) (dAtA []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		dAtA = randFieldLedger(dAtA, r, fieldNumber, wire)
	}
	return dAtA
}
func randFieldLedger(dAtA []byte, r randyLedger, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		dAtA = encodeVarintPopulateLedger(dAtA, uint64(key))
		v11 := r.Int63()
		if r.Intn(2) == 0 {
			v11 *= -1
		}
		dAtA = encodeVarintPopulateLedger(dAtA, uint64(v11))
	case 1:
		dAtA = encodeVarintPopulateLedger(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		dAtA = encodeVarintPopulateLedger(dAtA, uint64(key))
		ll := r.Intn(100)
		dAtA = encodeVarintPopulateLedger(dAtA, uint64(ll))
		for j := 0; j < ll; j++ {
			dAtA = append(dAtA, byte(r.Intn(256)))
		}
	default:
		dAtA = encodeVarintPopulateLedger(dAtA, uint64(key))
		dAtA = append(dAtA, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return dAtA
}
func encodeVarintPopulateLedger(dAtA []byte, v uint64) []byte {
	for v >= 1<<7 {
		dAtA = append(dAtA, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	dAtA = append(dAtA, uint8(v))
	return dAtA
}
func (m *Null) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *SignedPublicKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Payer != nil {
		l = m.Payer.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.Recipient != nil {
		l = m.Recipient.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovLedger(uint64(m.Amount))
	}
	if m.PayerId != 0 {
		n += 1 + sovLedger(uint64(m.PayerId))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedChannelCommit) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Channel != nil {
		l = m.Channel.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateAccountResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Account != nil {
		l = m.Account.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedCreateAccountRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.ClientVersionNumber)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedCreateAccountResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Balance != 0 {
		n += 1 + sovLedger(uint64(m.Balance))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Account) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Address != nil {
		l = m.Address.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.Balance != 0 {
		n += 1 + sovLedger(uint64(m.Balance))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + sovLedger(uint64(m.Id))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.FromAccount != nil {
		l = m.FromAccount.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.ToAccount != nil {
		l = m.ToAccount.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.CloseSequence != 0 {
		n += 1 + sovLedger(uint64(m.CloseSequence))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedChannelState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Channel != nil {
		l = m.Channel.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.FromSignature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.ToSignature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClosedChannelCursor) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Payer != nil {
		l = m.Payer.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.CloseSequence != 0 {
		n += 1 + sovLedger(uint64(m.CloseSequence))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != nil {
		l = m.Id.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.Sequence != 0 {
		n += 1 + sovLedger(uint64(m.Sequence))
	}
	if m.From != nil {
		l = m.From.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.To != nil {
		l = m.To.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ChannelClosed) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != nil {
		l = m.State.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPublicKeyPair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OldKey != nil {
		l = m.OldKey.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.NewKey != nil {
		l = m.NewKey.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.OldSignature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.NewSignature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TransferRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Payer != nil {
		l = m.Payer.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.Recipient != nil {
		l = m.Recipient.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovLedger(uint64(m.Amount))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedTransferRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TransferRequest != nil {
		l = m.TransferRequest.Size()
		n += 1 + l + sovLedger(uint64(l))
	}
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovLedger(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TransferResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Balance != 0 {
		n += 1 + sovLedger(uint64(m.Balance))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PublicKey) 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 ErrIntOverflowLedger
			}
			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: PublicKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PublicKey: 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 byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
			if m.Key == nil {
				m.Key = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignedPublicKey) 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 ErrIntOverflowLedger
			}
			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: SignedPublicKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPublicKey: 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 ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &PublicKey{}
			}
			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 Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChannelCommit) 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 ErrIntOverflowLedger
			}
			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: ChannelCommit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChannelCommit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Payer == nil {
				m.Payer = &PublicKey{}
			}
			if err := m.Payer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Recipient", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Recipient == nil {
				m.Recipient = &PublicKey{}
			}
			if err := m.Recipient.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
			}
			m.Amount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayerId", wireType)
			}
			m.PayerId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PayerId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignedCreateAccountRequest) 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 ErrIntOverflowLedger
			}
			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: SignedCreateAccountRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedCreateAccountRequest: 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 ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Key == nil {
				m.Key = &PublicKey{}
			}
			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 Signature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Signature = append(m.Signature[:0], dAtA[iNdEx:postIndex]...)
			if m.Signature == nil {
				m.Signature = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClientVersionNumber", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				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 ErrInvalidLengthLedger
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientVersionNumber = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignedCreateAccountResult) 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 ErrIntOverflowLedger
			}
			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: SignedCreateAccountResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedCreateAccountResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
			}
			m.Balance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChannelID) 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 ErrIntOverflowLedger
			}
			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: ChannelID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChannelID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChannelInfo) 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 ErrIntOverflowLedger
			}
			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: ChannelInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChannelInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ChannelID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAccount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FromAccount == nil {
				m.FromAccount = &Account{}
			}
			if err := m.FromAccount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAccount", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ToAccount == nil {
				m.ToAccount = &Account{}
			}
			if err := m.ToAccount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CloseSequence", wireType)
			}
			m.CloseSequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CloseSequence |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ChannelState) 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 ErrIntOverflowLedger
			}
			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: ChannelState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChannelState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Id == nil {
				m.Id = &ChannelID{}
			}
			if err := m.Id.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sequence", wireType)
			}
			m.Sequence = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Sequence |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field From", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.From == nil {
				m.From = &Account{}
			}
			if err := m.From.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field To", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.To == nil {
				m.To = &Account{}
			}
			if err := m.To.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SignedPublicKeyPair) 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 ErrIntOverflowLedger
			}
			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: SignedPublicKeyPair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPublicKeyPair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OldKey == nil {
				m.OldKey = &PublicKey{}
			}
			if err := m.OldKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewKey", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NewKey == nil {
				m.NewKey = &PublicKey{}
			}
			if err := m.NewKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OldSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OldSignature = append(m.OldSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.OldSignature == nil {
				m.OldSignature = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NewSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthLedger
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthLedger
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NewSignature = append(m.NewSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.NewSignature == nil {
				m.NewSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransferResult) 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 ErrIntOverflowLedger
			}
			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: TransferResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransferResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Balance", wireType)
			}
			m.Balance = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowLedger
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipLedger(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthLedger
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthLedger        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowLedger          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupLedger = fmt.Errorf("proto: unexpected end of group")
)