escrow.pb.go

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

package escrow

import (
	context "context"
	fmt "fmt"
	ledger "github.com/simbadMarino/go-btfs-common/protos/ledger"
	_ "github.com/bittorrent/protobuf/gogoproto"
	proto "github.com/bittorrent/protobuf/proto"
	github_com_bittorrent_protobuf_types "github.com/bittorrent/protobuf/types"
	_ "github.com/gogo/protobuf/types"
	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"
	time "time"
)

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

// 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 TokenType int32

const (
	TokenType_BTT TokenType = 0
)

var TokenType_name = map[int32]string{
	0: "BTT",
}

var TokenType_value = map[string]int32{
	"BTT": 0,
}

func (x TokenType) String() string {
	return proto.EnumName(TokenType_name, int32(x))
}

func (TokenType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{0}
}

type Schedule int32

const (
	Schedule_MONTHLY    Schedule = 0
	Schedule_QUARTERLY  Schedule = 1
	Schedule_ANNUALLY   Schedule = 2
	Schedule_CUSTOMIZED Schedule = 3
)

var Schedule_name = map[int32]string{
	0: "MONTHLY",
	1: "QUARTERLY",
	2: "ANNUALLY",
	3: "CUSTOMIZED",
}

var Schedule_value = map[string]int32{
	"MONTHLY":    0,
	"QUARTERLY":  1,
	"ANNUALLY":   2,
	"CUSTOMIZED": 3,
}

func (x Schedule) String() string {
	return proto.EnumName(Schedule_name, int32(x))
}

func (Schedule) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{1}
}

type ContractType int32

const (
	ContractType_REGULAR ContractType = 0
	ContractType_PLAN    ContractType = 1
	ContractType_REVISE  ContractType = 2
)

var ContractType_name = map[int32]string{
	0: "REGULAR",
	1: "PLAN",
	2: "REVISE",
}

var ContractType_value = map[string]int32{
	"REGULAR": 0,
	"PLAN":    1,
	"REVISE":  2,
}

func (x ContractType) String() string {
	return proto.EnumName(ContractType_name, int32(x))
}

func (ContractType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{2}
}

type EscrowStatus int32

const (
	EscrowStatus_INITIATED     EscrowStatus = 0
	EscrowStatus_ACTIVE        EscrowStatus = 1
	EscrowStatus_CANCELED      EscrowStatus = 2
	EscrowStatus_CLOSED        EscrowStatus = 3
	EscrowStatus_NOTSTART      EscrowStatus = 4
	EscrowStatus_NOTSTART_PAID EscrowStatus = 5
)

var EscrowStatus_name = map[int32]string{
	0: "INITIATED",
	1: "ACTIVE",
	2: "CANCELED",
	3: "CLOSED",
	4: "NOTSTART",
	5: "NOTSTART_PAID",
}

var EscrowStatus_value = map[string]int32{
	"INITIATED":     0,
	"ACTIVE":        1,
	"CANCELED":      2,
	"CLOSED":        3,
	"NOTSTART":      4,
	"NOTSTART_PAID": 5,
}

func (x EscrowStatus) String() string {
	return proto.EnumName(EscrowStatus_name, int32(x))
}

func (EscrowStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{3}
}

type StakeStatus int32

const (
	StakeStatus_PROCEEDING StakeStatus = 0
	StakeStatus_FAIL       StakeStatus = 1
)

var StakeStatus_name = map[int32]string{
	0: "PROCEEDING",
	1: "FAIL",
}

var StakeStatus_value = map[string]int32{
	"PROCEEDING": 0,
	"FAIL":       1,
}

func (x StakeStatus) String() string {
	return proto.EnumName(StakeStatus_name, int32(x))
}

func (StakeStatus) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{4}
}

type OperationType int32

const (
	OperationType_STAKE              OperationType = 0
	OperationType_CHEAT_PENALTY      OperationType = 1
	OperationType_LOST_SHARD_PENALTY OperationType = 2
)

var OperationType_name = map[int32]string{
	0: "STAKE",
	1: "CHEAT_PENALTY",
	2: "LOST_SHARD_PENALTY",
}

var OperationType_value = map[string]int32{
	"STAKE":              0,
	"CHEAT_PENALTY":      1,
	"LOST_SHARD_PENALTY": 2,
}

func (x OperationType) String() string {
	return proto.EnumName(OperationType_name, int32(x))
}

func (OperationType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{5}
}

type ContractID struct {
	ContractId           string   `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	Address              []byte   `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty" pg:"address"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ContractID proto.InternalMessageInfo

func (m *ContractID) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *ContractID) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (*ContractID) XXX_MessageName() string {
	return "escrow.ContractID"
}

type ContractIDBatch struct {
	ContractId           []string `protobuf:"bytes,1,rep,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	Address              []byte   `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty" pg:"address"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_ContractIDBatch proto.InternalMessageInfo

func (m *ContractIDBatch) GetContractId() []string {
	if m != nil {
		return m.ContractId
	}
	return nil
}

func (m *ContractIDBatch) GetAddress() []byte {
	if m != nil {
		return m.Address
	}
	return nil
}

func (*ContractIDBatch) XXX_MessageName() string {
	return "escrow.ContractIDBatch"
}

type SignedContractID struct {
	Data                 *ContractID `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	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 *SignedContractID) Reset()         { *m = SignedContractID{} }
func (m *SignedContractID) String() string { return proto.CompactTextString(m) }
func (*SignedContractID) ProtoMessage()    {}
func (*SignedContractID) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{2}
}
func (m *SignedContractID) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedContractID) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedContractID.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 *SignedContractID) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedContractID.Merge(m, src)
}
func (m *SignedContractID) XXX_Size() int {
	return m.Size()
}
func (m *SignedContractID) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedContractID.DiscardUnknown(m)
}

var xxx_messageInfo_SignedContractID proto.InternalMessageInfo

func (m *SignedContractID) GetData() *ContractID {
	if m != nil {
		return m.Data
	}
	return nil
}

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

func (*SignedContractID) XXX_MessageName() string {
	return "escrow.SignedContractID"
}

type SignedContractIDBatch struct {
	Data                 *ContractIDBatch `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	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 *SignedContractIDBatch) Reset()         { *m = SignedContractIDBatch{} }
func (m *SignedContractIDBatch) String() string { return proto.CompactTextString(m) }
func (*SignedContractIDBatch) ProtoMessage()    {}
func (*SignedContractIDBatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{3}
}
func (m *SignedContractIDBatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedContractIDBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedContractIDBatch.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 *SignedContractIDBatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedContractIDBatch.Merge(m, src)
}
func (m *SignedContractIDBatch) XXX_Size() int {
	return m.Size()
}
func (m *SignedContractIDBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedContractIDBatch.DiscardUnknown(m)
}

var xxx_messageInfo_SignedContractIDBatch proto.InternalMessageInfo

func (m *SignedContractIDBatch) GetData() *ContractIDBatch {
	if m != nil {
		return m.Data
	}
	return nil
}

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

func (*SignedContractIDBatch) XXX_MessageName() string {
	return "escrow.SignedContractIDBatch"
}

type SignedModifyContractIDBatch struct {
	Data                 *ContractIDBatch `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	LastModifyTime       time.Time        `protobuf:"bytes,2,opt,name=last_modify_time,json=lastModifyTime,proto3,stdtime" json:"last_modify_time" pg:"last_modify_time"`
	Signature            []byte           `protobuf:"bytes,3,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 *SignedModifyContractIDBatch) Reset()         { *m = SignedModifyContractIDBatch{} }
func (m *SignedModifyContractIDBatch) String() string { return proto.CompactTextString(m) }
func (*SignedModifyContractIDBatch) ProtoMessage()    {}
func (*SignedModifyContractIDBatch) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{4}
}
func (m *SignedModifyContractIDBatch) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedModifyContractIDBatch) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedModifyContractIDBatch.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 *SignedModifyContractIDBatch) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedModifyContractIDBatch.Merge(m, src)
}
func (m *SignedModifyContractIDBatch) XXX_Size() int {
	return m.Size()
}
func (m *SignedModifyContractIDBatch) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedModifyContractIDBatch.DiscardUnknown(m)
}

var xxx_messageInfo_SignedModifyContractIDBatch proto.InternalMessageInfo

func (m *SignedModifyContractIDBatch) GetData() *ContractIDBatch {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *SignedModifyContractIDBatch) GetLastModifyTime() time.Time {
	if m != nil {
		return m.LastModifyTime
	}
	return time.Time{}
}

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

func (*SignedModifyContractIDBatch) XXX_MessageName() string {
	return "escrow.SignedModifyContractIDBatch"
}

type EscrowContract struct {
	ContractId            string       `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	BuyerAddress          []byte       `protobuf:"bytes,2,opt,name=buyer_address,json=buyerAddress,proto3" json:"buyer_address,omitempty" pg:"buyer_address"`
	SellerAddress         []byte       `protobuf:"bytes,3,opt,name=seller_address,json=sellerAddress,proto3" json:"seller_address,omitempty" pg:"seller_address"`
	AuthAddress           []byte       `protobuf:"bytes,4,opt,name=auth_address,json=authAddress,proto3" json:"auth_address,omitempty" pg:"auth_address"`
	Amount                int64        `protobuf:"varint,5,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	CollateralAmount      int64        `protobuf:"varint,6,opt,name=collateral_amount,json=collateralAmount,proto3" json:"collateral_amount,omitempty" pg:"collateral_amount"`
	WithholdAmount        int64        `protobuf:"varint,7,opt,name=withhold_amount,json=withholdAmount,proto3" json:"withhold_amount,omitempty" pg:"withhold_amount"`
	TokenType             TokenType    `protobuf:"varint,8,opt,name=token_type,json=tokenType,proto3,enum=escrow.TokenType" json:"token_type,omitempty" pg:"token_type"`
	PayoutSchedule        Schedule     `protobuf:"varint,9,opt,name=payout_schedule,json=payoutSchedule,proto3,enum=escrow.Schedule" json:"payout_schedule,omitempty" pg:"payout_schedule"`
	NumPayouts            int32        `protobuf:"varint,10,opt,name=num_payouts,json=numPayouts,proto3" json:"num_payouts,omitempty" pg:"num_payouts"`
	Reference             []byte       `protobuf:"bytes,11,opt,name=reference,proto3" json:"reference,omitempty" pg:"reference"`
	CustomizePayoutPeriod int32        `protobuf:"varint,12,opt,name=customize_payout_period,json=customizePayoutPeriod,proto3" json:"customize_payout_period,omitempty" pg:"customize_payout_period"`
	Type                  ContractType `protobuf:"varint,13,opt,name=type,proto3,enum=escrow.ContractType" json:"type,omitempty" pg:"type"`
	ContingentAmount      int64        `protobuf:"varint,14,opt,name=contingent_amount,json=contingentAmount,proto3" json:"contingent_amount,omitempty" pg:"contingent_amount"`
	XXX_NoUnkeyedLiteral  struct{}     `json:"-" pg:"-"`
	XXX_unrecognized      []byte       `json:"-" pg:"-"`
	XXX_sizecache         int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_EscrowContract proto.InternalMessageInfo

func (m *EscrowContract) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *EscrowContract) GetBuyerAddress() []byte {
	if m != nil {
		return m.BuyerAddress
	}
	return nil
}

func (m *EscrowContract) GetSellerAddress() []byte {
	if m != nil {
		return m.SellerAddress
	}
	return nil
}

func (m *EscrowContract) GetAuthAddress() []byte {
	if m != nil {
		return m.AuthAddress
	}
	return nil
}

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

func (m *EscrowContract) GetCollateralAmount() int64 {
	if m != nil {
		return m.CollateralAmount
	}
	return 0
}

func (m *EscrowContract) GetWithholdAmount() int64 {
	if m != nil {
		return m.WithholdAmount
	}
	return 0
}

func (m *EscrowContract) GetTokenType() TokenType {
	if m != nil {
		return m.TokenType
	}
	return TokenType_BTT
}

func (m *EscrowContract) GetPayoutSchedule() Schedule {
	if m != nil {
		return m.PayoutSchedule
	}
	return Schedule_MONTHLY
}

func (m *EscrowContract) GetNumPayouts() int32 {
	if m != nil {
		return m.NumPayouts
	}
	return 0
}

func (m *EscrowContract) GetReference() []byte {
	if m != nil {
		return m.Reference
	}
	return nil
}

func (m *EscrowContract) GetCustomizePayoutPeriod() int32 {
	if m != nil {
		return m.CustomizePayoutPeriod
	}
	return 0
}

func (m *EscrowContract) GetType() ContractType {
	if m != nil {
		return m.Type
	}
	return ContractType_REGULAR
}

func (m *EscrowContract) GetContingentAmount() int64 {
	if m != nil {
		return m.ContingentAmount
	}
	return 0
}

func (*EscrowContract) XXX_MessageName() string {
	return "escrow.EscrowContract"
}

type SignedEscrowContract struct {
	Contract             *EscrowContract `protobuf:"bytes,1,opt,name=contract,proto3" json:"contract,omitempty" pg:"contract"`
	BuyerSignature       []byte          `protobuf:"bytes,2,opt,name=buyer_signature,json=buyerSignature,proto3" json:"buyer_signature,omitempty" pg:"buyer_signature"`
	SellerSignature      []byte          `protobuf:"bytes,3,opt,name=seller_signature,json=sellerSignature,proto3" json:"seller_signature,omitempty" pg:"seller_signature"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-" pg:"-"`
	XXX_unrecognized     []byte          `json:"-" pg:"-"`
	XXX_sizecache        int32           `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedEscrowContract proto.InternalMessageInfo

func (m *SignedEscrowContract) GetContract() *EscrowContract {
	if m != nil {
		return m.Contract
	}
	return nil
}

func (m *SignedEscrowContract) GetBuyerSignature() []byte {
	if m != nil {
		return m.BuyerSignature
	}
	return nil
}

func (m *SignedEscrowContract) GetSellerSignature() []byte {
	if m != nil {
		return m.SellerSignature
	}
	return nil
}

func (*SignedEscrowContract) XXX_MessageName() string {
	return "escrow.SignedEscrowContract"
}

type EscrowContractRequest struct {
	Contract             []*SignedEscrowContract     `protobuf:"bytes,1,rep,name=contract,proto3" json:"contract,omitempty" pg:"contract"`
	BuyerChannel         *ledger.SignedChannelCommit `protobuf:"bytes,2,opt,name=buyer_channel,json=buyerChannel,proto3" json:"buyer_channel,omitempty" pg:"buyer_channel"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-" pg:"-"`
	XXX_unrecognized     []byte                      `json:"-" pg:"-"`
	XXX_sizecache        int32                       `json:"-" pg:"-"`
}

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

var xxx_messageInfo_EscrowContractRequest proto.InternalMessageInfo

func (m *EscrowContractRequest) GetContract() []*SignedEscrowContract {
	if m != nil {
		return m.Contract
	}
	return nil
}

func (m *EscrowContractRequest) GetBuyerChannel() *ledger.SignedChannelCommit {
	if m != nil {
		return m.BuyerChannel
	}
	return nil
}

func (*EscrowContractRequest) XXX_MessageName() string {
	return "escrow.EscrowContractRequest"
}

type Escrow struct {
	ContractId           string   `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	EscrowId             int64    `protobuf:"varint,2,opt,name=escrow_id,json=escrowId,proto3" json:"escrow_id,omitempty" pg:"escrow_id"`
	FromAddress          []byte   `protobuf:"bytes,3,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty" pg:"from_address"`
	ToAddress            []byte   `protobuf:"bytes,4,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty" pg:"to_address"`
	Amount               int64    `protobuf:"varint,5,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	CollateralAmount     int64    `protobuf:"varint,6,opt,name=collateral_amount,json=collateralAmount,proto3" json:"collateral_amount,omitempty" pg:"collateral_amount"`
	ErrorCode            int32    `protobuf:"varint,7,opt,name=error_code,json=errorCode,proto3" json:"error_code,omitempty" pg:"error_code"`
	ErrorMessage         string   `protobuf:"bytes,8,opt,name=error_message,json=errorMessage,proto3" json:"error_message,omitempty" pg:"error_message"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Escrow proto.InternalMessageInfo

func (m *Escrow) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *Escrow) GetEscrowId() int64 {
	if m != nil {
		return m.EscrowId
	}
	return 0
}

func (m *Escrow) GetFromAddress() []byte {
	if m != nil {
		return m.FromAddress
	}
	return nil
}

func (m *Escrow) GetToAddress() []byte {
	if m != nil {
		return m.ToAddress
	}
	return nil
}

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

func (m *Escrow) GetCollateralAmount() int64 {
	if m != nil {
		return m.CollateralAmount
	}
	return 0
}

func (m *Escrow) GetErrorCode() int32 {
	if m != nil {
		return m.ErrorCode
	}
	return 0
}

func (m *Escrow) GetErrorMessage() string {
	if m != nil {
		return m.ErrorMessage
	}
	return ""
}

func (*Escrow) XXX_MessageName() string {
	return "escrow.Escrow"
}

type SubmitContractResult struct {
	PayinId              string                     `protobuf:"bytes,1,opt,name=payin_id,json=payinId,proto3" json:"payin_id,omitempty" pg:"payin_id"`
	Escrow               []*Escrow                  `protobuf:"bytes,2,rep,name=escrow,proto3" json:"escrow,omitempty" pg:"escrow"`
	EscrowAddress        []byte                     `protobuf:"bytes,3,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time                  `protobuf:"bytes,4,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	BuyerChannelState    *ledger.SignedChannelState `protobuf:"bytes,5,opt,name=buyer_channel_state,json=buyerChannelState,proto3" json:"buyer_channel_state,omitempty" pg:"buyer_channel_state"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-" pg:"-"`
	XXX_unrecognized     []byte                     `json:"-" pg:"-"`
	XXX_sizecache        int32                      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SubmitContractResult proto.InternalMessageInfo

func (m *SubmitContractResult) GetPayinId() string {
	if m != nil {
		return m.PayinId
	}
	return ""
}

func (m *SubmitContractResult) GetEscrow() []*Escrow {
	if m != nil {
		return m.Escrow
	}
	return nil
}

func (m *SubmitContractResult) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *SubmitContractResult) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

func (m *SubmitContractResult) GetBuyerChannelState() *ledger.SignedChannelState {
	if m != nil {
		return m.BuyerChannelState
	}
	return nil
}

func (*SubmitContractResult) XXX_MessageName() string {
	return "escrow.SubmitContractResult"
}

type SignedSubmitContractResult struct {
	Result               *SubmitContractResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" pg:"result"`
	EscrowSignature      []byte                `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-" pg:"-"`
	XXX_unrecognized     []byte                `json:"-" pg:"-"`
	XXX_sizecache        int32                 `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedSubmitContractResult proto.InternalMessageInfo

func (m *SignedSubmitContractResult) GetResult() *SubmitContractResult {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *SignedSubmitContractResult) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedSubmitContractResult) XXX_MessageName() string {
	return "escrow.SignedSubmitContractResult"
}

type StartEscrowResult struct {
	Escrow               []*Escrow `protobuf:"bytes,1,rep,name=escrow,proto3" json:"escrow,omitempty" pg:"escrow"`
	EscrowAddress        []byte    `protobuf:"bytes,2,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time `protobuf:"bytes,3,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StartEscrowResult proto.InternalMessageInfo

func (m *StartEscrowResult) GetEscrow() []*Escrow {
	if m != nil {
		return m.Escrow
	}
	return nil
}

func (m *StartEscrowResult) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *StartEscrowResult) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

func (*StartEscrowResult) XXX_MessageName() string {
	return "escrow.StartEscrowResult"
}

type SignedStartEscrowResult struct {
	Result               *StartEscrowResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" pg:"result"`
	EscrowSignature      []byte             `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-" pg:"-"`
	XXX_unrecognized     []byte             `json:"-" pg:"-"`
	XXX_sizecache        int32              `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedStartEscrowResult proto.InternalMessageInfo

func (m *SignedStartEscrowResult) GetResult() *StartEscrowResult {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *SignedStartEscrowResult) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedStartEscrowResult) XXX_MessageName() string {
	return "escrow.SignedStartEscrowResult"
}

type PayinRequest struct {
	PayinId              string                     `protobuf:"bytes,1,opt,name=payin_id,json=payinId,proto3" json:"payin_id,omitempty" pg:"payin_id"`
	BuyerAddress         []byte                     `protobuf:"bytes,2,opt,name=buyer_address,json=buyerAddress,proto3" json:"buyer_address,omitempty" pg:"buyer_address"`
	BuyerChannelState    *ledger.SignedChannelState `protobuf:"bytes,3,opt,name=buyer_channel_state,json=buyerChannelState,proto3" json:"buyer_channel_state,omitempty" pg:"buyer_channel_state"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-" pg:"-"`
	XXX_unrecognized     []byte                     `json:"-" pg:"-"`
	XXX_sizecache        int32                      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PayinRequest proto.InternalMessageInfo

func (m *PayinRequest) GetPayinId() string {
	if m != nil {
		return m.PayinId
	}
	return ""
}

func (m *PayinRequest) GetBuyerAddress() []byte {
	if m != nil {
		return m.BuyerAddress
	}
	return nil
}

func (m *PayinRequest) GetBuyerChannelState() *ledger.SignedChannelState {
	if m != nil {
		return m.BuyerChannelState
	}
	return nil
}

func (*PayinRequest) XXX_MessageName() string {
	return "escrow.PayinRequest"
}

type SignedPayinRequest struct {
	Request              *PayinRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty" pg:"request"`
	BuyerSignature       []byte        `protobuf:"bytes,2,opt,name=buyer_signature,json=buyerSignature,proto3" json:"buyer_signature,omitempty" pg:"buyer_signature"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPayinRequest proto.InternalMessageInfo

func (m *SignedPayinRequest) GetRequest() *PayinRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SignedPayinRequest) GetBuyerSignature() []byte {
	if m != nil {
		return m.BuyerSignature
	}
	return nil
}

func (*SignedPayinRequest) XXX_MessageName() string {
	return "escrow.SignedPayinRequest"
}

type PayinResult struct {
	PayinId              string    `protobuf:"bytes,1,opt,name=payin_id,json=payinId,proto3" json:"payin_id,omitempty" pg:"payin_id"`
	Amount               int64     `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	ChannelId            int64     `protobuf:"varint,3,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" pg:"channel_id"`
	EscrowAddress        []byte    `protobuf:"bytes,4,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time `protobuf:"bytes,5,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PayinResult proto.InternalMessageInfo

func (m *PayinResult) GetPayinId() string {
	if m != nil {
		return m.PayinId
	}
	return ""
}

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

func (m *PayinResult) GetChannelId() int64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *PayinResult) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *PayinResult) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

func (*PayinResult) XXX_MessageName() string {
	return "escrow.PayinResult"
}

type SignedPayinResult struct {
	Result               *PayinResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" pg:"result"`
	EscrowSignature      []byte       `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-" pg:"-"`
	XXX_unrecognized     []byte       `json:"-" pg:"-"`
	XXX_sizecache        int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPayinResult proto.InternalMessageInfo

func (m *SignedPayinResult) GetResult() *PayinResult {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *SignedPayinResult) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedPayinResult) XXX_MessageName() string {
	return "escrow.SignedPayinResult"
}

type PayinStatus struct {
	Paid                 bool      `protobuf:"varint,1,opt,name=paid,proto3" json:"paid,omitempty" pg:"paid"`
	ChannelId            int64     `protobuf:"varint,2,opt,name=channel_id,json=channelId,proto3" json:"channel_id,omitempty" pg:"channel_id"`
	EscrowAddress        []byte    `protobuf:"bytes,3,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time `protobuf:"bytes,4,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PayinStatus proto.InternalMessageInfo

func (m *PayinStatus) GetPaid() bool {
	if m != nil {
		return m.Paid
	}
	return false
}

func (m *PayinStatus) GetChannelId() int64 {
	if m != nil {
		return m.ChannelId
	}
	return 0
}

func (m *PayinStatus) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *PayinStatus) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

func (*PayinStatus) XXX_MessageName() string {
	return "escrow.PayinStatus"
}

type SignedPayinStatus struct {
	Status               *PayinStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty" pg:"status"`
	EscrowSignature      []byte       `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-" pg:"-"`
	XXX_unrecognized     []byte       `json:"-" pg:"-"`
	XXX_sizecache        int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPayinStatus proto.InternalMessageInfo

func (m *SignedPayinStatus) GetStatus() *PayinStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *SignedPayinStatus) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedPayinStatus) XXX_MessageName() string {
	return "escrow.SignedPayinStatus"
}

type PayoutStatus struct {
	ContractId           string       `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	EscrowId             int64        `protobuf:"varint,2,opt,name=escrow_id,json=escrowId,proto3" json:"escrow_id,omitempty" pg:"escrow_id"`
	FromAddress          []byte       `protobuf:"bytes,3,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty" pg:"from_address"`
	ToAddress            []byte       `protobuf:"bytes,4,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty" pg:"to_address"`
	AuthAddress          []byte       `protobuf:"bytes,5,opt,name=auth_address,json=authAddress,proto3" json:"auth_address,omitempty" pg:"auth_address"`
	Status               EscrowStatus `protobuf:"varint,6,opt,name=status,proto3,enum=escrow.EscrowStatus" json:"status,omitempty" pg:"status"`
	Amount               int64        `protobuf:"varint,7,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	Collateral           int64        `protobuf:"varint,8,opt,name=collateral,proto3" json:"collateral,omitempty" pg:"collateral"`
	Withhold             int64        `protobuf:"varint,9,opt,name=withhold,proto3" json:"withhold,omitempty" pg:"withhold"`
	PaidAmount           int64        `protobuf:"varint,10,opt,name=paid_amount,json=paidAmount,proto3" json:"paid_amount,omitempty" pg:"paid_amount"`
	NumPaid              int32        `protobuf:"varint,11,opt,name=num_paid,json=numPaid,proto3" json:"num_paid,omitempty" pg:"num_paid"`
	LeftAmount           int64        `protobuf:"varint,12,opt,name=left_amount,json=leftAmount,proto3" json:"left_amount,omitempty" pg:"left_amount"`
	NumLeft              int32        `protobuf:"varint,13,opt,name=num_left,json=numLeft,proto3" json:"num_left,omitempty" pg:"num_left"`
	NextAmount           int64        `protobuf:"varint,14,opt,name=next_amount,json=nextAmount,proto3" json:"next_amount,omitempty" pg:"next_amount"`
	LastPayoutTime       time.Time    `protobuf:"bytes,15,opt,name=last_payout_time,json=lastPayoutTime,proto3,stdtime" json:"last_payout_time" pg:"last_payout_time"`
	NextPayoutTime       time.Time    `protobuf:"bytes,16,opt,name=next_payout_time,json=nextPayoutTime,proto3,stdtime" json:"next_payout_time" pg:"next_payout_time"`
	EscrowAddress        []byte       `protobuf:"bytes,17,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignTime       time.Time    `protobuf:"bytes,18,opt,name=escrow_sign_time,json=escrowSignTime,proto3,stdtime" json:"escrow_sign_time" pg:"escrow_sign_time"`
	ErrorMsg             string       `protobuf:"bytes,19,opt,name=error_msg,json=errorMsg,proto3" json:"error_msg,omitempty" pg:"error_msg"`
	LastModifyTime       time.Time    `protobuf:"bytes,20,opt,name=last_modify_time,json=lastModifyTime,proto3,stdtime" json:"last_modify_time" pg:"last_modify_time"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-" pg:"-"`
	XXX_unrecognized     []byte       `json:"-" pg:"-"`
	XXX_sizecache        int32        `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PayoutStatus proto.InternalMessageInfo

func (m *PayoutStatus) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *PayoutStatus) GetEscrowId() int64 {
	if m != nil {
		return m.EscrowId
	}
	return 0
}

func (m *PayoutStatus) GetFromAddress() []byte {
	if m != nil {
		return m.FromAddress
	}
	return nil
}

func (m *PayoutStatus) GetToAddress() []byte {
	if m != nil {
		return m.ToAddress
	}
	return nil
}

func (m *PayoutStatus) GetAuthAddress() []byte {
	if m != nil {
		return m.AuthAddress
	}
	return nil
}

func (m *PayoutStatus) GetStatus() EscrowStatus {
	if m != nil {
		return m.Status
	}
	return EscrowStatus_INITIATED
}

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

func (m *PayoutStatus) GetCollateral() int64 {
	if m != nil {
		return m.Collateral
	}
	return 0
}

func (m *PayoutStatus) GetWithhold() int64 {
	if m != nil {
		return m.Withhold
	}
	return 0
}

func (m *PayoutStatus) GetPaidAmount() int64 {
	if m != nil {
		return m.PaidAmount
	}
	return 0
}

func (m *PayoutStatus) GetNumPaid() int32 {
	if m != nil {
		return m.NumPaid
	}
	return 0
}

func (m *PayoutStatus) GetLeftAmount() int64 {
	if m != nil {
		return m.LeftAmount
	}
	return 0
}

func (m *PayoutStatus) GetNumLeft() int32 {
	if m != nil {
		return m.NumLeft
	}
	return 0
}

func (m *PayoutStatus) GetNextAmount() int64 {
	if m != nil {
		return m.NextAmount
	}
	return 0
}

func (m *PayoutStatus) GetLastPayoutTime() time.Time {
	if m != nil {
		return m.LastPayoutTime
	}
	return time.Time{}
}

func (m *PayoutStatus) GetNextPayoutTime() time.Time {
	if m != nil {
		return m.NextPayoutTime
	}
	return time.Time{}
}

func (m *PayoutStatus) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *PayoutStatus) GetEscrowSignTime() time.Time {
	if m != nil {
		return m.EscrowSignTime
	}
	return time.Time{}
}

func (m *PayoutStatus) GetErrorMsg() string {
	if m != nil {
		return m.ErrorMsg
	}
	return ""
}

func (m *PayoutStatus) GetLastModifyTime() time.Time {
	if m != nil {
		return m.LastModifyTime
	}
	return time.Time{}
}

func (*PayoutStatus) XXX_MessageName() string {
	return "escrow.PayoutStatus"
}

type SignedPayoutStatus struct {
	Status               *PayoutStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty" pg:"status"`
	EscrowSignature      []byte        `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPayoutStatus proto.InternalMessageInfo

func (m *SignedPayoutStatus) GetStatus() *PayoutStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *SignedPayoutStatus) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedPayoutStatus) XXX_MessageName() string {
	return "escrow.SignedPayoutStatus"
}

type SignedPayoutStatusBatch struct {
	Status               []*PayoutStatus `protobuf:"bytes,1,rep,name=status,proto3" json:"status,omitempty" pg:"status"`
	EscrowSignature      []byte          `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-" pg:"-"`
	XXX_unrecognized     []byte          `json:"-" pg:"-"`
	XXX_sizecache        int32           `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPayoutStatusBatch proto.InternalMessageInfo

func (m *SignedPayoutStatusBatch) GetStatus() []*PayoutStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

func (m *SignedPayoutStatusBatch) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedPayoutStatusBatch) XXX_MessageName() string {
	return "escrow.SignedPayoutStatusBatch"
}

type CancelContractRequest struct {
	ContractId           string    `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	AuthAddress          []byte    `protobuf:"bytes,2,opt,name=auth_address,json=authAddress,proto3" json:"auth_address,omitempty" pg:"auth_address"`
	AuthSignedTime       time.Time `protobuf:"bytes,3,opt,name=auth_signed_time,json=authSignedTime,proto3,stdtime" json:"auth_signed_time" pg:"auth_signed_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_CancelContractRequest proto.InternalMessageInfo

func (m *CancelContractRequest) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *CancelContractRequest) GetAuthAddress() []byte {
	if m != nil {
		return m.AuthAddress
	}
	return nil
}

func (m *CancelContractRequest) GetAuthSignedTime() time.Time {
	if m != nil {
		return m.AuthSignedTime
	}
	return time.Time{}
}

func (*CancelContractRequest) XXX_MessageName() string {
	return "escrow.CancelContractRequest"
}

type SignedCancelRequest struct {
	Request              *CancelContractRequest `protobuf:"bytes,1,opt,name=request,proto3" json:"request,omitempty" pg:"request"`
	AuthSignature        []byte                 `protobuf:"bytes,2,opt,name=auth_signature,json=authSignature,proto3" json:"auth_signature,omitempty" pg:"auth_signature"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-" pg:"-"`
	XXX_unrecognized     []byte                 `json:"-" pg:"-"`
	XXX_sizecache        int32                  `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedCancelRequest proto.InternalMessageInfo

func (m *SignedCancelRequest) GetRequest() *CancelContractRequest {
	if m != nil {
		return m.Request
	}
	return nil
}

func (m *SignedCancelRequest) GetAuthSignature() []byte {
	if m != nil {
		return m.AuthSignature
	}
	return nil
}

func (*SignedCancelRequest) XXX_MessageName() string {
	return "escrow.SignedCancelRequest"
}

type CancelContractResult struct {
	ContractId           string    `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	EscrowId             int64     `protobuf:"varint,2,opt,name=escrow_id,json=escrowId,proto3" json:"escrow_id,omitempty" pg:"escrow_id"`
	Canceled             bool      `protobuf:"varint,3,opt,name=canceled,proto3" json:"canceled,omitempty" pg:"canceled"`
	EscrowAddress        []byte    `protobuf:"bytes,4,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time `protobuf:"bytes,5,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	Amount               int64     `protobuf:"varint,6,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	Paid                 bool      `protobuf:"varint,7,opt,name=paid,proto3" json:"paid,omitempty" pg:"paid"`
	Reference            string    `protobuf:"bytes,8,opt,name=reference,proto3" json:"reference,omitempty" pg:"reference"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_CancelContractResult proto.InternalMessageInfo

func (m *CancelContractResult) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *CancelContractResult) GetEscrowId() int64 {
	if m != nil {
		return m.EscrowId
	}
	return 0
}

func (m *CancelContractResult) GetCanceled() bool {
	if m != nil {
		return m.Canceled
	}
	return false
}

func (m *CancelContractResult) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *CancelContractResult) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

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

func (m *CancelContractResult) GetPaid() bool {
	if m != nil {
		return m.Paid
	}
	return false
}

func (m *CancelContractResult) GetReference() string {
	if m != nil {
		return m.Reference
	}
	return ""
}

func (*CancelContractResult) XXX_MessageName() string {
	return "escrow.CancelContractResult"
}

type SignedCancelContractResult struct {
	Result               *CancelContractResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" pg:"result"`
	EscrowSignature      []byte                `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-" pg:"-"`
	XXX_unrecognized     []byte                `json:"-" pg:"-"`
	XXX_sizecache        int32                 `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedCancelContractResult proto.InternalMessageInfo

func (m *SignedCancelContractResult) GetResult() *CancelContractResult {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *SignedCancelContractResult) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedCancelContractResult) XXX_MessageName() string {
	return "escrow.SignedCancelContractResult"
}

type PayoutAddress struct {
	ToAddress            []byte    `protobuf:"bytes,1,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty" pg:"to_address"`
	SignedTime           time.Time `protobuf:"bytes,2,opt,name=signed_time,json=signedTime,proto3,stdtime" json:"signed_time" pg:"signed_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PayoutAddress proto.InternalMessageInfo

func (m *PayoutAddress) GetToAddress() []byte {
	if m != nil {
		return m.ToAddress
	}
	return nil
}

func (m *PayoutAddress) GetSignedTime() time.Time {
	if m != nil {
		return m.SignedTime
	}
	return time.Time{}
}

func (*PayoutAddress) XXX_MessageName() string {
	return "escrow.PayoutAddress"
}

type SignedPayoutAddress struct {
	Address              *PayoutAddress `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty" pg:"address"`
	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 *SignedPayoutAddress) Reset()         { *m = SignedPayoutAddress{} }
func (m *SignedPayoutAddress) String() string { return proto.CompactTextString(m) }
func (*SignedPayoutAddress) ProtoMessage()    {}
func (*SignedPayoutAddress) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{27}
}
func (m *SignedPayoutAddress) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedPayoutAddress) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedPayoutAddress.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 *SignedPayoutAddress) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedPayoutAddress.Merge(m, src)
}
func (m *SignedPayoutAddress) XXX_Size() int {
	return m.Size()
}
func (m *SignedPayoutAddress) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedPayoutAddress.DiscardUnknown(m)
}

var xxx_messageInfo_SignedPayoutAddress proto.InternalMessageInfo

func (m *SignedPayoutAddress) GetAddress() *PayoutAddress {
	if m != nil {
		return m.Address
	}
	return nil
}

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

func (*SignedPayoutAddress) XXX_MessageName() string {
	return "escrow.SignedPayoutAddress"
}

type Payment struct {
	ContractId           string   `protobuf:"bytes,1,opt,name=contract_id,json=contractId,proto3" json:"contract_id,omitempty" pg:"contract_id"`
	EscrowId             int64    `protobuf:"varint,2,opt,name=escrow_id,json=escrowId,proto3" json:"escrow_id,omitempty" pg:"escrow_id"`
	FromAddress          []byte   `protobuf:"bytes,3,opt,name=from_address,json=fromAddress,proto3" json:"from_address,omitempty" pg:"from_address"`
	ToAddress            []byte   `protobuf:"bytes,4,opt,name=to_address,json=toAddress,proto3" json:"to_address,omitempty" pg:"to_address"`
	Amount               int64    `protobuf:"varint,5,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	Index                int32    `protobuf:"varint,6,opt,name=index,proto3" json:"index,omitempty" pg:"index"`
	XXX_NoUnkeyedLiteral struct{} `json:"-" pg:"-"`
	XXX_unrecognized     []byte   `json:"-" pg:"-"`
	XXX_sizecache        int32    `json:"-" pg:"-"`
}

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

var xxx_messageInfo_Payment proto.InternalMessageInfo

func (m *Payment) GetContractId() string {
	if m != nil {
		return m.ContractId
	}
	return ""
}

func (m *Payment) GetEscrowId() int64 {
	if m != nil {
		return m.EscrowId
	}
	return 0
}

func (m *Payment) GetFromAddress() []byte {
	if m != nil {
		return m.FromAddress
	}
	return nil
}

func (m *Payment) GetToAddress() []byte {
	if m != nil {
		return m.ToAddress
	}
	return nil
}

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

func (m *Payment) GetIndex() int32 {
	if m != nil {
		return m.Index
	}
	return 0
}

func (*Payment) XXX_MessageName() string {
	return "escrow.Payment"
}

type PaymentResult struct {
	Payment              []*Payment `protobuf:"bytes,1,rep,name=payment,proto3" json:"payment,omitempty" pg:"payment"`
	EscrowAddress        []byte     `protobuf:"bytes,2,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time  `protobuf:"bytes,3,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-" pg:"-"`
	XXX_unrecognized     []byte     `json:"-" pg:"-"`
	XXX_sizecache        int32      `json:"-" pg:"-"`
}

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

var xxx_messageInfo_PaymentResult proto.InternalMessageInfo

func (m *PaymentResult) GetPayment() []*Payment {
	if m != nil {
		return m.Payment
	}
	return nil
}

func (m *PaymentResult) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *PaymentResult) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

func (*PaymentResult) XXX_MessageName() string {
	return "escrow.PaymentResult"
}

type SignedPaymentResult struct {
	Result               *PaymentResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" pg:"result"`
	EscrowSignature      []byte         `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-" pg:"-"`
	XXX_unrecognized     []byte         `json:"-" pg:"-"`
	XXX_sizecache        int32          `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedPaymentResult proto.InternalMessageInfo

func (m *SignedPaymentResult) GetResult() *PaymentResult {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *SignedPaymentResult) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedPaymentResult) XXX_MessageName() string {
	return "escrow.SignedPaymentResult"
}

type BalanceResult struct {
	Balance              int64     `protobuf:"varint,1,opt,name=balance,proto3" json:"balance,omitempty" pg:"balance"`
	EscrowAddress        []byte    `protobuf:"bytes,2,opt,name=escrow_address,json=escrowAddress,proto3" json:"escrow_address,omitempty" pg:"escrow_address"`
	EscrowSignedTime     time.Time `protobuf:"bytes,3,opt,name=escrow_signed_time,json=escrowSignedTime,proto3,stdtime" json:"escrow_signed_time" pg:"escrow_signed_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_BalanceResult proto.InternalMessageInfo

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

func (m *BalanceResult) GetEscrowAddress() []byte {
	if m != nil {
		return m.EscrowAddress
	}
	return nil
}

func (m *BalanceResult) GetEscrowSignedTime() time.Time {
	if m != nil {
		return m.EscrowSignedTime
	}
	return time.Time{}
}

func (*BalanceResult) XXX_MessageName() string {
	return "escrow.BalanceResult"
}

type SignedBalanceResult struct {
	Result               *BalanceResult `protobuf:"bytes,1,opt,name=result,proto3" json:"result,omitempty" pg:"result"`
	EscrowSignature      []byte         `protobuf:"bytes,2,opt,name=escrow_signature,json=escrowSignature,proto3" json:"escrow_signature,omitempty" pg:"escrow_signature"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-" pg:"-"`
	XXX_unrecognized     []byte         `json:"-" pg:"-"`
	XXX_sizecache        int32          `json:"-" pg:"-"`
}

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

var xxx_messageInfo_SignedBalanceResult proto.InternalMessageInfo

func (m *SignedBalanceResult) GetResult() *BalanceResult {
	if m != nil {
		return m.Result
	}
	return nil
}

func (m *SignedBalanceResult) GetEscrowSignature() []byte {
	if m != nil {
		return m.EscrowSignature
	}
	return nil
}

func (*SignedBalanceResult) XXX_MessageName() string {
	return "escrow.SignedBalanceResult"
}

type SignedStakeRequest struct {
	Data                 *StakeRequest `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	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 *SignedStakeRequest) Reset()         { *m = SignedStakeRequest{} }
func (m *SignedStakeRequest) String() string { return proto.CompactTextString(m) }
func (*SignedStakeRequest) ProtoMessage()    {}
func (*SignedStakeRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{33}
}
func (m *SignedStakeRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedStakeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedStakeRequest.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 *SignedStakeRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedStakeRequest.Merge(m, src)
}
func (m *SignedStakeRequest) XXX_Size() int {
	return m.Size()
}
func (m *SignedStakeRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedStakeRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SignedStakeRequest proto.InternalMessageInfo

func (m *SignedStakeRequest) GetData() *StakeRequest {
	if m != nil {
		return m.Data
	}
	return nil
}

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

func (*SignedStakeRequest) XXX_MessageName() string {
	return "escrow.SignedStakeRequest"
}

type StakeRequest struct {
	StakerId             string                        `protobuf:"bytes,1,opt,name=staker_id,json=stakerId,proto3" json:"staker_id,omitempty" pg:"staker_id"`
	StakeAmount          int64                         `protobuf:"varint,2,opt,name=stake_amount,json=stakeAmount,proto3" json:"stake_amount,omitempty" pg:"stake_amount"`
	TransferRequest      *ledger.SignedTransferRequest `protobuf:"bytes,3,opt,name=transfer_request,json=transferRequest,proto3" json:"transfer_request,omitempty" pg:"transfer_request"`
	RequestTime          time.Time                     `protobuf:"bytes,4,opt,name=request_time,json=requestTime,proto3,stdtime" json:"request_time" pg:"request_time"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-" pg:"-"`
	XXX_unrecognized     []byte                        `json:"-" pg:"-"`
	XXX_sizecache        int32                         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StakeRequest proto.InternalMessageInfo

func (m *StakeRequest) GetStakerId() string {
	if m != nil {
		return m.StakerId
	}
	return ""
}

func (m *StakeRequest) GetStakeAmount() int64 {
	if m != nil {
		return m.StakeAmount
	}
	return 0
}

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

func (m *StakeRequest) GetRequestTime() time.Time {
	if m != nil {
		return m.RequestTime
	}
	return time.Time{}
}

func (*StakeRequest) XXX_MessageName() string {
	return "escrow.StakeRequest"
}

type StakeResult struct {
	StakerId             string                 `protobuf:"bytes,1,opt,name=staker_id,json=stakerId,proto3" json:"staker_id,omitempty" pg:"staker_id"`
	Balance              int64                  `protobuf:"varint,2,opt,name=balance,proto3" json:"balance,omitempty" pg:"balance"`
	MatureAmount         int64                  `protobuf:"varint,3,opt,name=mature_amount,json=matureAmount,proto3" json:"mature_amount,omitempty" pg:"mature_amount"`
	PendingAmount        int64                  `protobuf:"varint,4,opt,name=pending_amount,json=pendingAmount,proto3" json:"pending_amount,omitempty" pg:"pending_amount"`
	Ledgers              []*StakeLedger         `protobuf:"bytes,5,rep,name=ledgers,proto3" json:"ledgers,omitempty" pg:"ledgers"`
	UnfinishLedgers      []*UnfinishStakeLedger `protobuf:"bytes,6,rep,name=unfinish_ledgers,json=unfinishLedgers,proto3" json:"unfinish_ledgers,omitempty" pg:"unfinish_ledgers"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-" pg:"-"`
	XXX_unrecognized     []byte                 `json:"-" pg:"-"`
	XXX_sizecache        int32                  `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StakeResult proto.InternalMessageInfo

func (m *StakeResult) GetStakerId() string {
	if m != nil {
		return m.StakerId
	}
	return ""
}

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

func (m *StakeResult) GetMatureAmount() int64 {
	if m != nil {
		return m.MatureAmount
	}
	return 0
}

func (m *StakeResult) GetPendingAmount() int64 {
	if m != nil {
		return m.PendingAmount
	}
	return 0
}

func (m *StakeResult) GetLedgers() []*StakeLedger {
	if m != nil {
		return m.Ledgers
	}
	return nil
}

func (m *StakeResult) GetUnfinishLedgers() []*UnfinishStakeLedger {
	if m != nil {
		return m.UnfinishLedgers
	}
	return nil
}

func (*StakeResult) XXX_MessageName() string {
	return "escrow.StakeResult"
}

type SignedStakeResult struct {
	Data                 *StakeResult `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	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 *SignedStakeResult) Reset()         { *m = SignedStakeResult{} }
func (m *SignedStakeResult) String() string { return proto.CompactTextString(m) }
func (*SignedStakeResult) ProtoMessage()    {}
func (*SignedStakeResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{36}
}
func (m *SignedStakeResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedStakeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedStakeResult.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 *SignedStakeResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedStakeResult.Merge(m, src)
}
func (m *SignedStakeResult) XXX_Size() int {
	return m.Size()
}
func (m *SignedStakeResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedStakeResult.DiscardUnknown(m)
}

var xxx_messageInfo_SignedStakeResult proto.InternalMessageInfo

func (m *SignedStakeResult) GetData() *StakeResult {
	if m != nil {
		return m.Data
	}
	return nil
}

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

func (*SignedStakeResult) XXX_MessageName() string {
	return "escrow.SignedStakeResult"
}

type StakeLedger struct {
	StakerId             string        `protobuf:"bytes,1,opt,name=staker_id,json=stakerId,proto3" json:"staker_id,omitempty" pg:"staker_id"`
	Amount               int64         `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	StartTime            time.Time     `protobuf:"bytes,3,opt,name=start_time,json=startTime,proto3,stdtime" json:"start_time" pg:"start_time"`
	MatureTime           time.Time     `protobuf:"bytes,4,opt,name=mature_time,json=matureTime,proto3,stdtime" json:"mature_time" pg:"mature_time"`
	OperatorId           string        `protobuf:"bytes,5,opt,name=operator_id,json=operatorId,proto3" json:"operator_id,omitempty" pg:"operator_id"`
	Type                 OperationType `protobuf:"varint,6,opt,name=type,proto3,enum=escrow.OperationType" json:"type,omitempty" pg:"type"`
	OperationLog         string        `protobuf:"bytes,7,opt,name=operation_log,json=operationLog,proto3" json:"operation_log,omitempty" pg:"operation_log"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StakeLedger proto.InternalMessageInfo

func (m *StakeLedger) GetStakerId() string {
	if m != nil {
		return m.StakerId
	}
	return ""
}

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

func (m *StakeLedger) GetStartTime() time.Time {
	if m != nil {
		return m.StartTime
	}
	return time.Time{}
}

func (m *StakeLedger) GetMatureTime() time.Time {
	if m != nil {
		return m.MatureTime
	}
	return time.Time{}
}

func (m *StakeLedger) GetOperatorId() string {
	if m != nil {
		return m.OperatorId
	}
	return ""
}

func (m *StakeLedger) GetType() OperationType {
	if m != nil {
		return m.Type
	}
	return OperationType_STAKE
}

func (m *StakeLedger) GetOperationLog() string {
	if m != nil {
		return m.OperationLog
	}
	return ""
}

func (*StakeLedger) XXX_MessageName() string {
	return "escrow.StakeLedger"
}

type UnfinishStakeLedger struct {
	StakerId             string      `protobuf:"bytes,1,opt,name=staker_id,json=stakerId,proto3" json:"staker_id,omitempty" pg:"staker_id"`
	Amount               int64       `protobuf:"varint,2,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	Status               StakeStatus `protobuf:"varint,3,opt,name=status,proto3,enum=escrow.StakeStatus" json:"status,omitempty" pg:"status"`
	FailReason           string      `protobuf:"bytes,4,opt,name=fail_reason,json=failReason,proto3" json:"fail_reason,omitempty" pg:"fail_reason"`
	SubmitTime           time.Time   `protobuf:"bytes,5,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time" pg:"submit_time"`
	FailTime             time.Time   `protobuf:"bytes,6,opt,name=fail_time,json=failTime,proto3,stdtime" json:"fail_time" pg:"fail_time"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-" pg:"-"`
	XXX_unrecognized     []byte      `json:"-" pg:"-"`
	XXX_sizecache        int32       `json:"-" pg:"-"`
}

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

var xxx_messageInfo_UnfinishStakeLedger proto.InternalMessageInfo

func (m *UnfinishStakeLedger) GetStakerId() string {
	if m != nil {
		return m.StakerId
	}
	return ""
}

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

func (m *UnfinishStakeLedger) GetStatus() StakeStatus {
	if m != nil {
		return m.Status
	}
	return StakeStatus_PROCEEDING
}

func (m *UnfinishStakeLedger) GetFailReason() string {
	if m != nil {
		return m.FailReason
	}
	return ""
}

func (m *UnfinishStakeLedger) GetSubmitTime() time.Time {
	if m != nil {
		return m.SubmitTime
	}
	return time.Time{}
}

func (m *UnfinishStakeLedger) GetFailTime() time.Time {
	if m != nil {
		return m.FailTime
	}
	return time.Time{}
}

func (*UnfinishStakeLedger) XXX_MessageName() string {
	return "escrow.UnfinishStakeLedger"
}

type SignedStakePenaltyRequest struct {
	Data                 *StakePenaltyRequest `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	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 *SignedStakePenaltyRequest) Reset()         { *m = SignedStakePenaltyRequest{} }
func (m *SignedStakePenaltyRequest) String() string { return proto.CompactTextString(m) }
func (*SignedStakePenaltyRequest) ProtoMessage()    {}
func (*SignedStakePenaltyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{39}
}
func (m *SignedStakePenaltyRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedStakePenaltyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedStakePenaltyRequest.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 *SignedStakePenaltyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedStakePenaltyRequest.Merge(m, src)
}
func (m *SignedStakePenaltyRequest) XXX_Size() int {
	return m.Size()
}
func (m *SignedStakePenaltyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedStakePenaltyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SignedStakePenaltyRequest proto.InternalMessageInfo

func (m *SignedStakePenaltyRequest) GetData() *StakePenaltyRequest {
	if m != nil {
		return m.Data
	}
	return nil
}

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

func (*SignedStakePenaltyRequest) XXX_MessageName() string {
	return "escrow.SignedStakePenaltyRequest"
}

type StakePenaltyRequest struct {
	StakerId             string        `protobuf:"bytes,1,opt,name=staker_id,json=stakerId,proto3" json:"staker_id,omitempty" pg:"staker_id"`
	OperatorId           string        `protobuf:"bytes,2,opt,name=operator_id,json=operatorId,proto3" json:"operator_id,omitempty" pg:"operator_id"`
	Reason               OperationType `protobuf:"varint,3,opt,name=reason,proto3,enum=escrow.OperationType" json:"reason,omitempty" pg:"reason"`
	OperationLog         string        `protobuf:"bytes,4,opt,name=operation_log,json=operationLog,proto3" json:"operation_log,omitempty" pg:"operation_log"`
	Amount               int64         `protobuf:"varint,5,opt,name=amount,proto3" json:"amount,omitempty" pg:"amount"`
	SubmitTime           time.Time     `protobuf:"bytes,6,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time" pg:"submit_time"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-" pg:"-"`
	XXX_unrecognized     []byte        `json:"-" pg:"-"`
	XXX_sizecache        int32         `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StakePenaltyRequest proto.InternalMessageInfo

func (m *StakePenaltyRequest) GetStakerId() string {
	if m != nil {
		return m.StakerId
	}
	return ""
}

func (m *StakePenaltyRequest) GetOperatorId() string {
	if m != nil {
		return m.OperatorId
	}
	return ""
}

func (m *StakePenaltyRequest) GetReason() OperationType {
	if m != nil {
		return m.Reason
	}
	return OperationType_STAKE
}

func (m *StakePenaltyRequest) GetOperationLog() string {
	if m != nil {
		return m.OperationLog
	}
	return ""
}

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

func (m *StakePenaltyRequest) GetSubmitTime() time.Time {
	if m != nil {
		return m.SubmitTime
	}
	return time.Time{}
}

func (*StakePenaltyRequest) XXX_MessageName() string {
	return "escrow.StakePenaltyRequest"
}

type StakePenaltyResult struct {
	StakerId             string    `protobuf:"bytes,1,opt,name=staker_id,json=stakerId,proto3" json:"staker_id,omitempty" pg:"staker_id"`
	RequestPenaltyAmount int64     `protobuf:"varint,2,opt,name=request_penalty_amount,json=requestPenaltyAmount,proto3" json:"request_penalty_amount,omitempty" pg:"request_penalty_amount"`
	OperatePenaltyAmount int64     `protobuf:"varint,3,opt,name=operate_penalty_amount,json=operatePenaltyAmount,proto3" json:"operate_penalty_amount,omitempty" pg:"operate_penalty_amount"`
	OperatorId           string    `protobuf:"bytes,4,opt,name=operator_id,json=operatorId,proto3" json:"operator_id,omitempty" pg:"operator_id"`
	ReceiveTime          time.Time `protobuf:"bytes,5,opt,name=receive_time,json=receiveTime,proto3,stdtime" json:"receive_time" pg:"receive_time"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-" pg:"-"`
	XXX_unrecognized     []byte    `json:"-" pg:"-"`
	XXX_sizecache        int32     `json:"-" pg:"-"`
}

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

var xxx_messageInfo_StakePenaltyResult proto.InternalMessageInfo

func (m *StakePenaltyResult) GetStakerId() string {
	if m != nil {
		return m.StakerId
	}
	return ""
}

func (m *StakePenaltyResult) GetRequestPenaltyAmount() int64 {
	if m != nil {
		return m.RequestPenaltyAmount
	}
	return 0
}

func (m *StakePenaltyResult) GetOperatePenaltyAmount() int64 {
	if m != nil {
		return m.OperatePenaltyAmount
	}
	return 0
}

func (m *StakePenaltyResult) GetOperatorId() string {
	if m != nil {
		return m.OperatorId
	}
	return ""
}

func (m *StakePenaltyResult) GetReceiveTime() time.Time {
	if m != nil {
		return m.ReceiveTime
	}
	return time.Time{}
}

func (*StakePenaltyResult) XXX_MessageName() string {
	return "escrow.StakePenaltyResult"
}

type SignedStakePenaltyResult struct {
	Data                 *StakePenaltyResult `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty" pg:"data"`
	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 *SignedStakePenaltyResult) Reset()         { *m = SignedStakePenaltyResult{} }
func (m *SignedStakePenaltyResult) String() string { return proto.CompactTextString(m) }
func (*SignedStakePenaltyResult) ProtoMessage()    {}
func (*SignedStakePenaltyResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_92a6463c7f7e20b5, []int{42}
}
func (m *SignedStakePenaltyResult) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *SignedStakePenaltyResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_SignedStakePenaltyResult.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 *SignedStakePenaltyResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SignedStakePenaltyResult.Merge(m, src)
}
func (m *SignedStakePenaltyResult) XXX_Size() int {
	return m.Size()
}
func (m *SignedStakePenaltyResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SignedStakePenaltyResult.DiscardUnknown(m)
}

var xxx_messageInfo_SignedStakePenaltyResult proto.InternalMessageInfo

func (m *SignedStakePenaltyResult) GetData() *StakePenaltyResult {
	if m != nil {
		return m.Data
	}
	return nil
}

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

func (*SignedStakePenaltyResult) XXX_MessageName() string {
	return "escrow.SignedStakePenaltyResult"
}
func init() {
	proto.RegisterEnum("escrow.TokenType", TokenType_name, TokenType_value)
	golang_proto.RegisterEnum("escrow.TokenType", TokenType_name, TokenType_value)
	proto.RegisterEnum("escrow.Schedule", Schedule_name, Schedule_value)
	golang_proto.RegisterEnum("escrow.Schedule", Schedule_name, Schedule_value)
	proto.RegisterEnum("escrow.ContractType", ContractType_name, ContractType_value)
	golang_proto.RegisterEnum("escrow.ContractType", ContractType_name, ContractType_value)
	proto.RegisterEnum("escrow.EscrowStatus", EscrowStatus_name, EscrowStatus_value)
	golang_proto.RegisterEnum("escrow.EscrowStatus", EscrowStatus_name, EscrowStatus_value)
	proto.RegisterEnum("escrow.StakeStatus", StakeStatus_name, StakeStatus_value)
	golang_proto.RegisterEnum("escrow.StakeStatus", StakeStatus_name, StakeStatus_value)
	proto.RegisterEnum("escrow.OperationType", OperationType_name, OperationType_value)
	golang_proto.RegisterEnum("escrow.OperationType", OperationType_name, OperationType_value)
	proto.RegisterType((*ContractID)(nil), "escrow.ContractID")
	golang_proto.RegisterType((*ContractID)(nil), "escrow.ContractID")
	proto.RegisterType((*ContractIDBatch)(nil), "escrow.ContractIDBatch")
	golang_proto.RegisterType((*ContractIDBatch)(nil), "escrow.ContractIDBatch")
	proto.RegisterType((*SignedContractID)(nil), "escrow.SignedContractID")
	golang_proto.RegisterType((*SignedContractID)(nil), "escrow.SignedContractID")
	proto.RegisterType((*SignedContractIDBatch)(nil), "escrow.SignedContractIDBatch")
	golang_proto.RegisterType((*SignedContractIDBatch)(nil), "escrow.SignedContractIDBatch")
	proto.RegisterType((*SignedModifyContractIDBatch)(nil), "escrow.SignedModifyContractIDBatch")
	golang_proto.RegisterType((*SignedModifyContractIDBatch)(nil), "escrow.SignedModifyContractIDBatch")
	proto.RegisterType((*EscrowContract)(nil), "escrow.EscrowContract")
	golang_proto.RegisterType((*EscrowContract)(nil), "escrow.EscrowContract")
	proto.RegisterType((*SignedEscrowContract)(nil), "escrow.SignedEscrowContract")
	golang_proto.RegisterType((*SignedEscrowContract)(nil), "escrow.SignedEscrowContract")
	proto.RegisterType((*EscrowContractRequest)(nil), "escrow.EscrowContractRequest")
	golang_proto.RegisterType((*EscrowContractRequest)(nil), "escrow.EscrowContractRequest")
	proto.RegisterType((*Escrow)(nil), "escrow.Escrow")
	golang_proto.RegisterType((*Escrow)(nil), "escrow.Escrow")
	proto.RegisterType((*SubmitContractResult)(nil), "escrow.SubmitContractResult")
	golang_proto.RegisterType((*SubmitContractResult)(nil), "escrow.SubmitContractResult")
	proto.RegisterType((*SignedSubmitContractResult)(nil), "escrow.SignedSubmitContractResult")
	golang_proto.RegisterType((*SignedSubmitContractResult)(nil), "escrow.SignedSubmitContractResult")
	proto.RegisterType((*StartEscrowResult)(nil), "escrow.StartEscrowResult")
	golang_proto.RegisterType((*StartEscrowResult)(nil), "escrow.StartEscrowResult")
	proto.RegisterType((*SignedStartEscrowResult)(nil), "escrow.SignedStartEscrowResult")
	golang_proto.RegisterType((*SignedStartEscrowResult)(nil), "escrow.SignedStartEscrowResult")
	proto.RegisterType((*PayinRequest)(nil), "escrow.PayinRequest")
	golang_proto.RegisterType((*PayinRequest)(nil), "escrow.PayinRequest")
	proto.RegisterType((*SignedPayinRequest)(nil), "escrow.SignedPayinRequest")
	golang_proto.RegisterType((*SignedPayinRequest)(nil), "escrow.SignedPayinRequest")
	proto.RegisterType((*PayinResult)(nil), "escrow.PayinResult")
	golang_proto.RegisterType((*PayinResult)(nil), "escrow.PayinResult")
	proto.RegisterType((*SignedPayinResult)(nil), "escrow.SignedPayinResult")
	golang_proto.RegisterType((*SignedPayinResult)(nil), "escrow.SignedPayinResult")
	proto.RegisterType((*PayinStatus)(nil), "escrow.PayinStatus")
	golang_proto.RegisterType((*PayinStatus)(nil), "escrow.PayinStatus")
	proto.RegisterType((*SignedPayinStatus)(nil), "escrow.SignedPayinStatus")
	golang_proto.RegisterType((*SignedPayinStatus)(nil), "escrow.SignedPayinStatus")
	proto.RegisterType((*PayoutStatus)(nil), "escrow.PayoutStatus")
	golang_proto.RegisterType((*PayoutStatus)(nil), "escrow.PayoutStatus")
	proto.RegisterType((*SignedPayoutStatus)(nil), "escrow.SignedPayoutStatus")
	golang_proto.RegisterType((*SignedPayoutStatus)(nil), "escrow.SignedPayoutStatus")
	proto.RegisterType((*SignedPayoutStatusBatch)(nil), "escrow.SignedPayoutStatusBatch")
	golang_proto.RegisterType((*SignedPayoutStatusBatch)(nil), "escrow.SignedPayoutStatusBatch")
	proto.RegisterType((*CancelContractRequest)(nil), "escrow.CancelContractRequest")
	golang_proto.RegisterType((*CancelContractRequest)(nil), "escrow.CancelContractRequest")
	proto.RegisterType((*SignedCancelRequest)(nil), "escrow.SignedCancelRequest")
	golang_proto.RegisterType((*SignedCancelRequest)(nil), "escrow.SignedCancelRequest")
	proto.RegisterType((*CancelContractResult)(nil), "escrow.CancelContractResult")
	golang_proto.RegisterType((*CancelContractResult)(nil), "escrow.CancelContractResult")
	proto.RegisterType((*SignedCancelContractResult)(nil), "escrow.SignedCancelContractResult")
	golang_proto.RegisterType((*SignedCancelContractResult)(nil), "escrow.SignedCancelContractResult")
	proto.RegisterType((*PayoutAddress)(nil), "escrow.PayoutAddress")
	golang_proto.RegisterType((*PayoutAddress)(nil), "escrow.PayoutAddress")
	proto.RegisterType((*SignedPayoutAddress)(nil), "escrow.SignedPayoutAddress")
	golang_proto.RegisterType((*SignedPayoutAddress)(nil), "escrow.SignedPayoutAddress")
	proto.RegisterType((*Payment)(nil), "escrow.Payment")
	golang_proto.RegisterType((*Payment)(nil), "escrow.Payment")
	proto.RegisterType((*PaymentResult)(nil), "escrow.PaymentResult")
	golang_proto.RegisterType((*PaymentResult)(nil), "escrow.PaymentResult")
	proto.RegisterType((*SignedPaymentResult)(nil), "escrow.SignedPaymentResult")
	golang_proto.RegisterType((*SignedPaymentResult)(nil), "escrow.SignedPaymentResult")
	proto.RegisterType((*BalanceResult)(nil), "escrow.BalanceResult")
	golang_proto.RegisterType((*BalanceResult)(nil), "escrow.BalanceResult")
	proto.RegisterType((*SignedBalanceResult)(nil), "escrow.SignedBalanceResult")
	golang_proto.RegisterType((*SignedBalanceResult)(nil), "escrow.SignedBalanceResult")
	proto.RegisterType((*SignedStakeRequest)(nil), "escrow.SignedStakeRequest")
	golang_proto.RegisterType((*SignedStakeRequest)(nil), "escrow.SignedStakeRequest")
	proto.RegisterType((*StakeRequest)(nil), "escrow.StakeRequest")
	golang_proto.RegisterType((*StakeRequest)(nil), "escrow.StakeRequest")
	proto.RegisterType((*StakeResult)(nil), "escrow.StakeResult")
	golang_proto.RegisterType((*StakeResult)(nil), "escrow.StakeResult")
	proto.RegisterType((*SignedStakeResult)(nil), "escrow.SignedStakeResult")
	golang_proto.RegisterType((*SignedStakeResult)(nil), "escrow.SignedStakeResult")
	proto.RegisterType((*StakeLedger)(nil), "escrow.StakeLedger")
	golang_proto.RegisterType((*StakeLedger)(nil), "escrow.StakeLedger")
	proto.RegisterType((*UnfinishStakeLedger)(nil), "escrow.UnfinishStakeLedger")
	golang_proto.RegisterType((*UnfinishStakeLedger)(nil), "escrow.UnfinishStakeLedger")
	proto.RegisterType((*SignedStakePenaltyRequest)(nil), "escrow.SignedStakePenaltyRequest")
	golang_proto.RegisterType((*SignedStakePenaltyRequest)(nil), "escrow.SignedStakePenaltyRequest")
	proto.RegisterType((*StakePenaltyRequest)(nil), "escrow.StakePenaltyRequest")
	golang_proto.RegisterType((*StakePenaltyRequest)(nil), "escrow.StakePenaltyRequest")
	proto.RegisterType((*StakePenaltyResult)(nil), "escrow.StakePenaltyResult")
	golang_proto.RegisterType((*StakePenaltyResult)(nil), "escrow.StakePenaltyResult")
	proto.RegisterType((*SignedStakePenaltyResult)(nil), "escrow.SignedStakePenaltyResult")
	golang_proto.RegisterType((*SignedStakePenaltyResult)(nil), "escrow.SignedStakePenaltyResult")
}

func init() { proto.RegisterFile("protos/escrow/escrow.proto", fileDescriptor_92a6463c7f7e20b5) }
func init() { golang_proto.RegisterFile("protos/escrow/escrow.proto", fileDescriptor_92a6463c7f7e20b5) }

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

// EscrowServiceClient is the client API for EscrowService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type EscrowServiceClient interface {
	// buyer submit contracts to escrow after buyer and seller agreed contract
	// one contract is one buyer to one seller, and is one escrow in escrow service
	// buyer can submit multiple contracts in one request
	// return same number of results as request contracts
	SubmitContracts(ctx context.Context, in *EscrowContractRequest, opts ...grpc.CallOption) (*SignedSubmitContractResult, error)
	StartEscrow(ctx context.Context, in *EscrowContractRequest, opts ...grpc.CallOption) (*SignedStartEscrowResult, error)
	// after submit contract, buyer request to pay in
	// escrow will transfer contract amount from buyer wallet to escrow wallet
	PayIn(ctx context.Context, in *SignedPayinRequest, opts ...grpc.CallOption) (*SignedPayinResult, error)
	// seller use this to check if a contract is paid in
	IsPaid(ctx context.Context, in *SignedContractID, opts ...grpc.CallOption) (*SignedPayinStatus, error)
	// check escrow pay out to seller status of a contract
	GetPayOutStatus(ctx context.Context, in *SignedContractID, opts ...grpc.CallOption) (*SignedPayoutStatus, error)
	//get the payout status in batch
	GetPayOutStatusBatch(ctx context.Context, in *SignedContractIDBatch, opts ...grpc.CallOption) (*SignedPayoutStatusBatch, error)
	//get the modified payout status in batch
	GetModifyPayOutStatusBatch(ctx context.Context, in *SignedModifyContractIDBatch, opts ...grpc.CallOption) (*SignedPayoutStatusBatch, error)
	// auth request to cancel the contract
	// escrow will cancel the left payments to seller
	CancelContracts(ctx context.Context, in *SignedCancelRequest, opts ...grpc.CallOption) (*SignedCancelContractResult, error)
	// seller query what new payments to receive
	MyPayment(ctx context.Context, in *SignedPayoutAddress, opts ...grpc.CallOption) (*SignedPaymentResult, error)
	// query balance and create account if account not exist
	BalanceOf(ctx context.Context, in *ledger.SignedCreateAccountRequest, opts ...grpc.CallOption) (*SignedBalanceResult, error)
	// Creates a channel on the ledger and returns the ID of the ledger
	CreateChannel(ctx context.Context, in *ledger.SignedChannelCommit, opts ...grpc.CallOption) (*ledger.ChannelID, error)
	// Closes a channel on the ledger.
	CloseChannel(ctx context.Context, in *ledger.SignedChannelState, opts ...grpc.CallOption) (*ledger.ChannelClosed, error)
	//use escrow as proxy to do the payment
	Pay(ctx context.Context, in *ledger.SignedTransferRequest, opts ...grpc.CallOption) (*ledger.TransferResult, error)
	Stake(ctx context.Context, in *SignedStakeRequest, opts ...grpc.CallOption) (*SignedStakeResult, error)
	StakePenalty(ctx context.Context, in *SignedStakePenaltyRequest, opts ...grpc.CallOption) (*SignedStakePenaltyResult, error)
}

type escrowServiceClient struct {
	cc *grpc.ClientConn
}

func NewEscrowServiceClient(cc *grpc.ClientConn) EscrowServiceClient {
	return &escrowServiceClient{cc}
}

func (c *escrowServiceClient) SubmitContracts(ctx context.Context, in *EscrowContractRequest, opts ...grpc.CallOption) (*SignedSubmitContractResult, error) {
	out := new(SignedSubmitContractResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/SubmitContracts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) StartEscrow(ctx context.Context, in *EscrowContractRequest, opts ...grpc.CallOption) (*SignedStartEscrowResult, error) {
	out := new(SignedStartEscrowResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/StartEscrow", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) PayIn(ctx context.Context, in *SignedPayinRequest, opts ...grpc.CallOption) (*SignedPayinResult, error) {
	out := new(SignedPayinResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/PayIn", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) IsPaid(ctx context.Context, in *SignedContractID, opts ...grpc.CallOption) (*SignedPayinStatus, error) {
	out := new(SignedPayinStatus)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/IsPaid", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) GetPayOutStatus(ctx context.Context, in *SignedContractID, opts ...grpc.CallOption) (*SignedPayoutStatus, error) {
	out := new(SignedPayoutStatus)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/GetPayOutStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) GetPayOutStatusBatch(ctx context.Context, in *SignedContractIDBatch, opts ...grpc.CallOption) (*SignedPayoutStatusBatch, error) {
	out := new(SignedPayoutStatusBatch)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/GetPayOutStatusBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) GetModifyPayOutStatusBatch(ctx context.Context, in *SignedModifyContractIDBatch, opts ...grpc.CallOption) (*SignedPayoutStatusBatch, error) {
	out := new(SignedPayoutStatusBatch)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/GetModifyPayOutStatusBatch", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) CancelContracts(ctx context.Context, in *SignedCancelRequest, opts ...grpc.CallOption) (*SignedCancelContractResult, error) {
	out := new(SignedCancelContractResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/CancelContracts", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) MyPayment(ctx context.Context, in *SignedPayoutAddress, opts ...grpc.CallOption) (*SignedPaymentResult, error) {
	out := new(SignedPaymentResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/MyPayment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) BalanceOf(ctx context.Context, in *ledger.SignedCreateAccountRequest, opts ...grpc.CallOption) (*SignedBalanceResult, error) {
	out := new(SignedBalanceResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/BalanceOf", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

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

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

func (c *escrowServiceClient) Stake(ctx context.Context, in *SignedStakeRequest, opts ...grpc.CallOption) (*SignedStakeResult, error) {
	out := new(SignedStakeResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/Stake", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *escrowServiceClient) StakePenalty(ctx context.Context, in *SignedStakePenaltyRequest, opts ...grpc.CallOption) (*SignedStakePenaltyResult, error) {
	out := new(SignedStakePenaltyResult)
	err := c.cc.Invoke(ctx, "/escrow.EscrowService/StakePenalty", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EscrowServiceServer is the server API for EscrowService service.
type EscrowServiceServer interface {
	// buyer submit contracts to escrow after buyer and seller agreed contract
	// one contract is one buyer to one seller, and is one escrow in escrow service
	// buyer can submit multiple contracts in one request
	// return same number of results as request contracts
	SubmitContracts(context.Context, *EscrowContractRequest) (*SignedSubmitContractResult, error)
	StartEscrow(context.Context, *EscrowContractRequest) (*SignedStartEscrowResult, error)
	// after submit contract, buyer request to pay in
	// escrow will transfer contract amount from buyer wallet to escrow wallet
	PayIn(context.Context, *SignedPayinRequest) (*SignedPayinResult, error)
	// seller use this to check if a contract is paid in
	IsPaid(context.Context, *SignedContractID) (*SignedPayinStatus, error)
	// check escrow pay out to seller status of a contract
	GetPayOutStatus(context.Context, *SignedContractID) (*SignedPayoutStatus, error)
	//get the payout status in batch
	GetPayOutStatusBatch(context.Context, *SignedContractIDBatch) (*SignedPayoutStatusBatch, error)
	//get the modified payout status in batch
	GetModifyPayOutStatusBatch(context.Context, *SignedModifyContractIDBatch) (*SignedPayoutStatusBatch, error)
	// auth request to cancel the contract
	// escrow will cancel the left payments to seller
	CancelContracts(context.Context, *SignedCancelRequest) (*SignedCancelContractResult, error)
	// seller query what new payments to receive
	MyPayment(context.Context, *SignedPayoutAddress) (*SignedPaymentResult, error)
	// query balance and create account if account not exist
	BalanceOf(context.Context, *ledger.SignedCreateAccountRequest) (*SignedBalanceResult, error)
	// Creates a channel on the ledger and returns the ID of the ledger
	CreateChannel(context.Context, *ledger.SignedChannelCommit) (*ledger.ChannelID, error)
	// Closes a channel on the ledger.
	CloseChannel(context.Context, *ledger.SignedChannelState) (*ledger.ChannelClosed, error)
	//use escrow as proxy to do the payment
	Pay(context.Context, *ledger.SignedTransferRequest) (*ledger.TransferResult, error)
	Stake(context.Context, *SignedStakeRequest) (*SignedStakeResult, error)
	StakePenalty(context.Context, *SignedStakePenaltyRequest) (*SignedStakePenaltyResult, error)
}

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

func (*UnimplementedEscrowServiceServer) SubmitContracts(ctx context.Context, req *EscrowContractRequest) (*SignedSubmitContractResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitContracts not implemented")
}
func (*UnimplementedEscrowServiceServer) StartEscrow(ctx context.Context, req *EscrowContractRequest) (*SignedStartEscrowResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartEscrow not implemented")
}
func (*UnimplementedEscrowServiceServer) PayIn(ctx context.Context, req *SignedPayinRequest) (*SignedPayinResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PayIn not implemented")
}
func (*UnimplementedEscrowServiceServer) IsPaid(ctx context.Context, req *SignedContractID) (*SignedPayinStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsPaid not implemented")
}
func (*UnimplementedEscrowServiceServer) GetPayOutStatus(ctx context.Context, req *SignedContractID) (*SignedPayoutStatus, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPayOutStatus not implemented")
}
func (*UnimplementedEscrowServiceServer) GetPayOutStatusBatch(ctx context.Context, req *SignedContractIDBatch) (*SignedPayoutStatusBatch, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPayOutStatusBatch not implemented")
}
func (*UnimplementedEscrowServiceServer) GetModifyPayOutStatusBatch(ctx context.Context, req *SignedModifyContractIDBatch) (*SignedPayoutStatusBatch, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetModifyPayOutStatusBatch not implemented")
}
func (*UnimplementedEscrowServiceServer) CancelContracts(ctx context.Context, req *SignedCancelRequest) (*SignedCancelContractResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelContracts not implemented")
}
func (*UnimplementedEscrowServiceServer) MyPayment(ctx context.Context, req *SignedPayoutAddress) (*SignedPaymentResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MyPayment not implemented")
}
func (*UnimplementedEscrowServiceServer) BalanceOf(ctx context.Context, req *ledger.SignedCreateAccountRequest) (*SignedBalanceResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BalanceOf not implemented")
}
func (*UnimplementedEscrowServiceServer) CreateChannel(ctx context.Context, req *ledger.SignedChannelCommit) (*ledger.ChannelID, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateChannel not implemented")
}
func (*UnimplementedEscrowServiceServer) CloseChannel(ctx context.Context, req *ledger.SignedChannelState) (*ledger.ChannelClosed, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CloseChannel not implemented")
}
func (*UnimplementedEscrowServiceServer) Pay(ctx context.Context, req *ledger.SignedTransferRequest) (*ledger.TransferResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Pay not implemented")
}
func (*UnimplementedEscrowServiceServer) Stake(ctx context.Context, req *SignedStakeRequest) (*SignedStakeResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Stake not implemented")
}
func (*UnimplementedEscrowServiceServer) StakePenalty(ctx context.Context, req *SignedStakePenaltyRequest) (*SignedStakePenaltyResult, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StakePenalty not implemented")
}

func RegisterEscrowServiceServer(s *grpc.Server, srv EscrowServiceServer) {
	s.RegisterService(&_EscrowService_serviceDesc, srv)
}

func _EscrowService_SubmitContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EscrowContractRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).SubmitContracts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/SubmitContracts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).SubmitContracts(ctx, req.(*EscrowContractRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_StartEscrow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EscrowContractRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).StartEscrow(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/StartEscrow",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).StartEscrow(ctx, req.(*EscrowContractRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_PayIn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedPayinRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).PayIn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/PayIn",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).PayIn(ctx, req.(*SignedPayinRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_IsPaid_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedContractID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).IsPaid(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/IsPaid",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).IsPaid(ctx, req.(*SignedContractID))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_GetPayOutStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedContractID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).GetPayOutStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/GetPayOutStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).GetPayOutStatus(ctx, req.(*SignedContractID))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_GetPayOutStatusBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedContractIDBatch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).GetPayOutStatusBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/GetPayOutStatusBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).GetPayOutStatusBatch(ctx, req.(*SignedContractIDBatch))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_GetModifyPayOutStatusBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedModifyContractIDBatch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).GetModifyPayOutStatusBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/GetModifyPayOutStatusBatch",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).GetModifyPayOutStatusBatch(ctx, req.(*SignedModifyContractIDBatch))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_CancelContracts_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedCancelRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).CancelContracts(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/CancelContracts",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).CancelContracts(ctx, req.(*SignedCancelRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_MyPayment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedPayoutAddress)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).MyPayment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/MyPayment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).MyPayment(ctx, req.(*SignedPayoutAddress))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

func _EscrowService_Stake_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedStakeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).Stake(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/Stake",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).Stake(ctx, req.(*SignedStakeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _EscrowService_StakePenalty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignedStakePenaltyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EscrowServiceServer).StakePenalty(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/escrow.EscrowService/StakePenalty",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EscrowServiceServer).StakePenalty(ctx, req.(*SignedStakePenaltyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _EscrowService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "escrow.EscrowService",
	HandlerType: (*EscrowServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SubmitContracts",
			Handler:    _EscrowService_SubmitContracts_Handler,
		},
		{
			MethodName: "StartEscrow",
			Handler:    _EscrowService_StartEscrow_Handler,
		},
		{
			MethodName: "PayIn",
			Handler:    _EscrowService_PayIn_Handler,
		},
		{
			MethodName: "IsPaid",
			Handler:    _EscrowService_IsPaid_Handler,
		},
		{
			MethodName: "GetPayOutStatus",
			Handler:    _EscrowService_GetPayOutStatus_Handler,
		},
		{
			MethodName: "GetPayOutStatusBatch",
			Handler:    _EscrowService_GetPayOutStatusBatch_Handler,
		},
		{
			MethodName: "GetModifyPayOutStatusBatch",
			Handler:    _EscrowService_GetModifyPayOutStatusBatch_Handler,
		},
		{
			MethodName: "CancelContracts",
			Handler:    _EscrowService_CancelContracts_Handler,
		},
		{
			MethodName: "MyPayment",
			Handler:    _EscrowService_MyPayment_Handler,
		},
		{
			MethodName: "BalanceOf",
			Handler:    _EscrowService_BalanceOf_Handler,
		},
		{
			MethodName: "CreateChannel",
			Handler:    _EscrowService_CreateChannel_Handler,
		},
		{
			MethodName: "CloseChannel",
			Handler:    _EscrowService_CloseChannel_Handler,
		},
		{
			MethodName: "Pay",
			Handler:    _EscrowService_Pay_Handler,
		},
		{
			MethodName: "Stake",
			Handler:    _EscrowService_Stake_Handler,
		},
		{
			MethodName: "StakePenalty",
			Handler:    _EscrowService_StakePenalty_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "protos/escrow/escrow.proto",
}

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

func (m *ContractID) 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.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ContractIDBatch) 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.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContractId) > 0 {
		for iNdEx := len(m.ContractId) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ContractId[iNdEx])
			copy(dAtA[i:], m.ContractId[iNdEx])
			i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedContractID) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedContractIDBatch) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedModifyContractIDBatch) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x1a
	}
	n3, err3 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.LastModifyTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.LastModifyTime):])
	if err3 != nil {
		return 0, err3
	}
	i -= n3
	i = encodeVarintEscrow(dAtA, i, uint64(n3))
	i--
	dAtA[i] = 0x12
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EscrowContract) 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.ContingentAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.ContingentAmount))
		i--
		dAtA[i] = 0x70
	}
	if m.Type != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x68
	}
	if m.CustomizePayoutPeriod != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.CustomizePayoutPeriod))
		i--
		dAtA[i] = 0x60
	}
	if len(m.Reference) > 0 {
		i -= len(m.Reference)
		copy(dAtA[i:], m.Reference)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.Reference)))
		i--
		dAtA[i] = 0x5a
	}
	if m.NumPayouts != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.NumPayouts))
		i--
		dAtA[i] = 0x50
	}
	if m.PayoutSchedule != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.PayoutSchedule))
		i--
		dAtA[i] = 0x48
	}
	if m.TokenType != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.TokenType))
		i--
		dAtA[i] = 0x40
	}
	if m.WithholdAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.WithholdAmount))
		i--
		dAtA[i] = 0x38
	}
	if m.CollateralAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.CollateralAmount))
		i--
		dAtA[i] = 0x30
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x28
	}
	if len(m.AuthAddress) > 0 {
		i -= len(m.AuthAddress)
		copy(dAtA[i:], m.AuthAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.AuthAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.SellerAddress) > 0 {
		i -= len(m.SellerAddress)
		copy(dAtA[i:], m.SellerAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.SellerAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BuyerAddress) > 0 {
		i -= len(m.BuyerAddress)
		copy(dAtA[i:], m.BuyerAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.BuyerAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedEscrowContract) 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.SellerSignature) > 0 {
		i -= len(m.SellerSignature)
		copy(dAtA[i:], m.SellerSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.SellerSignature)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BuyerSignature) > 0 {
		i -= len(m.BuyerSignature)
		copy(dAtA[i:], m.BuyerSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.BuyerSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Contract != nil {
		{
			size, err := m.Contract.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *EscrowContractRequest) 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.BuyerChannel != nil {
		{
			size, err := m.BuyerChannel.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Contract) > 0 {
		for iNdEx := len(m.Contract) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Contract[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *Escrow) 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.ErrorMessage) > 0 {
		i -= len(m.ErrorMessage)
		copy(dAtA[i:], m.ErrorMessage)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ErrorMessage)))
		i--
		dAtA[i] = 0x42
	}
	if m.ErrorCode != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.ErrorCode))
		i--
		dAtA[i] = 0x38
	}
	if m.CollateralAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.CollateralAmount))
		i--
		dAtA[i] = 0x30
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.FromAddress) > 0 {
		i -= len(m.FromAddress)
		copy(dAtA[i:], m.FromAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.FromAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if m.EscrowId != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.EscrowId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SubmitContractResult) 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.BuyerChannelState != nil {
		{
			size, err := m.BuyerChannelState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	n8, err8 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err8 != nil {
		return 0, err8
	}
	i -= n8
	i = encodeVarintEscrow(dAtA, i, uint64(n8))
	i--
	dAtA[i] = 0x22
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Escrow) > 0 {
		for iNdEx := len(m.Escrow) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Escrow[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.PayinId) > 0 {
		i -= len(m.PayinId)
		copy(dAtA[i:], m.PayinId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.PayinId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedSubmitContractResult) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StartEscrowResult) 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)
	}
	n10, err10 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintEscrow(dAtA, i, uint64(n10))
	i--
	dAtA[i] = 0x1a
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Escrow) > 0 {
		for iNdEx := len(m.Escrow) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Escrow[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedStartEscrowResult) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PayinRequest) 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.BuyerChannelState != nil {
		{
			size, err := m.BuyerChannelState.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BuyerAddress) > 0 {
		i -= len(m.BuyerAddress)
		copy(dAtA[i:], m.BuyerAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.BuyerAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.PayinId) > 0 {
		i -= len(m.PayinId)
		copy(dAtA[i:], m.PayinId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.PayinId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPayinRequest) 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.BuyerSignature) > 0 {
		i -= len(m.BuyerSignature)
		copy(dAtA[i:], m.BuyerSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.BuyerSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Request != nil {
		{
			size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PayinResult) 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)
	}
	n14, err14 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err14 != nil {
		return 0, err14
	}
	i -= n14
	i = encodeVarintEscrow(dAtA, i, uint64(n14))
	i--
	dAtA[i] = 0x2a
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x22
	}
	if m.ChannelId != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.ChannelId))
		i--
		dAtA[i] = 0x18
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x10
	}
	if len(m.PayinId) > 0 {
		i -= len(m.PayinId)
		copy(dAtA[i:], m.PayinId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.PayinId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPayinResult) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PayinStatus) 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)
	}
	n16, err16 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err16 != nil {
		return 0, err16
	}
	i -= n16
	i = encodeVarintEscrow(dAtA, i, uint64(n16))
	i--
	dAtA[i] = 0x22
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ChannelId != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.ChannelId))
		i--
		dAtA[i] = 0x10
	}
	if m.Paid {
		i--
		if m.Paid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPayinStatus) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PayoutStatus) 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)
	}
	n18, err18 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.LastModifyTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.LastModifyTime):])
	if err18 != nil {
		return 0, err18
	}
	i -= n18
	i = encodeVarintEscrow(dAtA, i, uint64(n18))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0xa2
	if len(m.ErrorMsg) > 0 {
		i -= len(m.ErrorMsg)
		copy(dAtA[i:], m.ErrorMsg)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ErrorMsg)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	n19, err19 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignTime):])
	if err19 != nil {
		return 0, err19
	}
	i -= n19
	i = encodeVarintEscrow(dAtA, i, uint64(n19))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x92
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	n20, err20 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.NextPayoutTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.NextPayoutTime):])
	if err20 != nil {
		return 0, err20
	}
	i -= n20
	i = encodeVarintEscrow(dAtA, i, uint64(n20))
	i--
	dAtA[i] = 0x1
	i--
	dAtA[i] = 0x82
	n21, err21 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.LastPayoutTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.LastPayoutTime):])
	if err21 != nil {
		return 0, err21
	}
	i -= n21
	i = encodeVarintEscrow(dAtA, i, uint64(n21))
	i--
	dAtA[i] = 0x7a
	if m.NextAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.NextAmount))
		i--
		dAtA[i] = 0x70
	}
	if m.NumLeft != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.NumLeft))
		i--
		dAtA[i] = 0x68
	}
	if m.LeftAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.LeftAmount))
		i--
		dAtA[i] = 0x60
	}
	if m.NumPaid != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.NumPaid))
		i--
		dAtA[i] = 0x58
	}
	if m.PaidAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.PaidAmount))
		i--
		dAtA[i] = 0x50
	}
	if m.Withhold != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Withhold))
		i--
		dAtA[i] = 0x48
	}
	if m.Collateral != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Collateral))
		i--
		dAtA[i] = 0x40
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x38
	}
	if m.Status != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x30
	}
	if len(m.AuthAddress) > 0 {
		i -= len(m.AuthAddress)
		copy(dAtA[i:], m.AuthAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.AuthAddress)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.FromAddress) > 0 {
		i -= len(m.FromAddress)
		copy(dAtA[i:], m.FromAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.FromAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if m.EscrowId != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.EscrowId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPayoutStatus) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPayoutStatusBatch) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Status) > 0 {
		for iNdEx := len(m.Status) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Status[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *CancelContractRequest) 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)
	}
	n23, err23 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.AuthSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.AuthSignedTime):])
	if err23 != nil {
		return 0, err23
	}
	i -= n23
	i = encodeVarintEscrow(dAtA, i, uint64(n23))
	i--
	dAtA[i] = 0x1a
	if len(m.AuthAddress) > 0 {
		i -= len(m.AuthAddress)
		copy(dAtA[i:], m.AuthAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.AuthAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedCancelRequest) 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.AuthSignature) > 0 {
		i -= len(m.AuthSignature)
		copy(dAtA[i:], m.AuthSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.AuthSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Request != nil {
		{
			size, err := m.Request.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CancelContractResult) 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.Reference) > 0 {
		i -= len(m.Reference)
		copy(dAtA[i:], m.Reference)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.Reference)))
		i--
		dAtA[i] = 0x42
	}
	if m.Paid {
		i--
		if m.Paid {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x30
	}
	n25, err25 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err25 != nil {
		return 0, err25
	}
	i -= n25
	i = encodeVarintEscrow(dAtA, i, uint64(n25))
	i--
	dAtA[i] = 0x2a
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x22
	}
	if m.Canceled {
		i--
		if m.Canceled {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.EscrowId != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.EscrowId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedCancelContractResult) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PayoutAddress) 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)
	}
	n27, err27 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.SignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.SignedTime):])
	if err27 != nil {
		return 0, err27
	}
	i -= n27
	i = encodeVarintEscrow(dAtA, i, uint64(n27))
	i--
	dAtA[i] = 0x12
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPayoutAddress) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Address != nil {
		{
			size, err := m.Address.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Payment) 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.Index != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x30
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x28
	}
	if len(m.ToAddress) > 0 {
		i -= len(m.ToAddress)
		copy(dAtA[i:], m.ToAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ToAddress)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.FromAddress) > 0 {
		i -= len(m.FromAddress)
		copy(dAtA[i:], m.FromAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.FromAddress)))
		i--
		dAtA[i] = 0x1a
	}
	if m.EscrowId != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.EscrowId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ContractId) > 0 {
		i -= len(m.ContractId)
		copy(dAtA[i:], m.ContractId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.ContractId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *PaymentResult) 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)
	}
	n29, err29 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err29 != nil {
		return 0, err29
	}
	i -= n29
	i = encodeVarintEscrow(dAtA, i, uint64(n29))
	i--
	dAtA[i] = 0x1a
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Payment) > 0 {
		for iNdEx := len(m.Payment) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Payment[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedPaymentResult) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *BalanceResult) 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)
	}
	n31, err31 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.EscrowSignedTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime):])
	if err31 != nil {
		return 0, err31
	}
	i -= n31
	i = encodeVarintEscrow(dAtA, i, uint64(n31))
	i--
	dAtA[i] = 0x1a
	if len(m.EscrowAddress) > 0 {
		i -= len(m.EscrowAddress)
		copy(dAtA[i:], m.EscrowAddress)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowAddress)))
		i--
		dAtA[i] = 0x12
	}
	if m.Balance != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Balance))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedBalanceResult) 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.EscrowSignature) > 0 {
		i -= len(m.EscrowSignature)
		copy(dAtA[i:], m.EscrowSignature)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.EscrowSignature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Result != nil {
		{
			size, err := m.Result.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedStakeRequest) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeRequest) 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)
	}
	n34, err34 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.RequestTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.RequestTime):])
	if err34 != nil {
		return 0, err34
	}
	i -= n34
	i = encodeVarintEscrow(dAtA, i, uint64(n34))
	i--
	dAtA[i] = 0x22
	if m.TransferRequest != nil {
		{
			size, err := m.TransferRequest.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.StakeAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.StakeAmount))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakerId) > 0 {
		i -= len(m.StakerId)
		copy(dAtA[i:], m.StakerId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.StakerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeResult) 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.UnfinishLedgers) > 0 {
		for iNdEx := len(m.UnfinishLedgers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.UnfinishLedgers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Ledgers) > 0 {
		for iNdEx := len(m.Ledgers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ledgers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintEscrow(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.PendingAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.PendingAmount))
		i--
		dAtA[i] = 0x20
	}
	if m.MatureAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.MatureAmount))
		i--
		dAtA[i] = 0x18
	}
	if m.Balance != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Balance))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakerId) > 0 {
		i -= len(m.StakerId)
		copy(dAtA[i:], m.StakerId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.StakerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedStakeResult) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakeLedger) 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.OperationLog) > 0 {
		i -= len(m.OperationLog)
		copy(dAtA[i:], m.OperationLog)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.OperationLog)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Type != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x30
	}
	if len(m.OperatorId) > 0 {
		i -= len(m.OperatorId)
		copy(dAtA[i:], m.OperatorId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.OperatorId)))
		i--
		dAtA[i] = 0x2a
	}
	n37, err37 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.MatureTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.MatureTime):])
	if err37 != nil {
		return 0, err37
	}
	i -= n37
	i = encodeVarintEscrow(dAtA, i, uint64(n37))
	i--
	dAtA[i] = 0x22
	n38, err38 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.StartTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.StartTime):])
	if err38 != nil {
		return 0, err38
	}
	i -= n38
	i = encodeVarintEscrow(dAtA, i, uint64(n38))
	i--
	dAtA[i] = 0x1a
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakerId) > 0 {
		i -= len(m.StakerId)
		copy(dAtA[i:], m.StakerId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.StakerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *UnfinishStakeLedger) 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)
	}
	n39, err39 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.FailTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.FailTime):])
	if err39 != nil {
		return 0, err39
	}
	i -= n39
	i = encodeVarintEscrow(dAtA, i, uint64(n39))
	i--
	dAtA[i] = 0x32
	n40, err40 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.SubmitTime):])
	if err40 != nil {
		return 0, err40
	}
	i -= n40
	i = encodeVarintEscrow(dAtA, i, uint64(n40))
	i--
	dAtA[i] = 0x2a
	if len(m.FailReason) > 0 {
		i -= len(m.FailReason)
		copy(dAtA[i:], m.FailReason)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.FailReason)))
		i--
		dAtA[i] = 0x22
	}
	if m.Status != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x18
	}
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakerId) > 0 {
		i -= len(m.StakerId)
		copy(dAtA[i:], m.StakerId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.StakerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedStakePenaltyRequest) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakePenaltyRequest) 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)
	}
	n42, err42 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.SubmitTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.SubmitTime):])
	if err42 != nil {
		return 0, err42
	}
	i -= n42
	i = encodeVarintEscrow(dAtA, i, uint64(n42))
	i--
	dAtA[i] = 0x32
	if m.Amount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Amount))
		i--
		dAtA[i] = 0x28
	}
	if len(m.OperationLog) > 0 {
		i -= len(m.OperationLog)
		copy(dAtA[i:], m.OperationLog)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.OperationLog)))
		i--
		dAtA[i] = 0x22
	}
	if m.Reason != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.Reason))
		i--
		dAtA[i] = 0x18
	}
	if len(m.OperatorId) > 0 {
		i -= len(m.OperatorId)
		copy(dAtA[i:], m.OperatorId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.OperatorId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.StakerId) > 0 {
		i -= len(m.StakerId)
		copy(dAtA[i:], m.StakerId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.StakerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StakePenaltyResult) 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)
	}
	n43, err43 := github_com_bittorrent_protobuf_types.StdTimeMarshalTo(m.ReceiveTime, dAtA[i-github_com_bittorrent_protobuf_types.SizeOfStdTime(m.ReceiveTime):])
	if err43 != nil {
		return 0, err43
	}
	i -= n43
	i = encodeVarintEscrow(dAtA, i, uint64(n43))
	i--
	dAtA[i] = 0x2a
	if len(m.OperatorId) > 0 {
		i -= len(m.OperatorId)
		copy(dAtA[i:], m.OperatorId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.OperatorId)))
		i--
		dAtA[i] = 0x22
	}
	if m.OperatePenaltyAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.OperatePenaltyAmount))
		i--
		dAtA[i] = 0x18
	}
	if m.RequestPenaltyAmount != 0 {
		i = encodeVarintEscrow(dAtA, i, uint64(m.RequestPenaltyAmount))
		i--
		dAtA[i] = 0x10
	}
	if len(m.StakerId) > 0 {
		i -= len(m.StakerId)
		copy(dAtA[i:], m.StakerId)
		i = encodeVarintEscrow(dAtA, i, uint64(len(m.StakerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *SignedStakePenaltyResult) 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 = encodeVarintEscrow(dAtA, i, uint64(len(m.Signature)))
		i--
		dAtA[i] = 0x12
	}
	if m.Data != nil {
		{
			size, err := m.Data.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintEscrow(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintEscrow(dAtA []byte, offset int, v uint64) int {
	offset -= sovEscrow(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *ContractID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ContractIDBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ContractId) > 0 {
		for _, s := range m.ContractId {
			l = len(s)
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *SignedModifyContractIDBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.LastModifyTime)
	n += 1 + l + sovEscrow(uint64(l))
	l = len(m.Signature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EscrowContract) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.BuyerAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.SellerAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.AuthAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.CollateralAmount != 0 {
		n += 1 + sovEscrow(uint64(m.CollateralAmount))
	}
	if m.WithholdAmount != 0 {
		n += 1 + sovEscrow(uint64(m.WithholdAmount))
	}
	if m.TokenType != 0 {
		n += 1 + sovEscrow(uint64(m.TokenType))
	}
	if m.PayoutSchedule != 0 {
		n += 1 + sovEscrow(uint64(m.PayoutSchedule))
	}
	if m.NumPayouts != 0 {
		n += 1 + sovEscrow(uint64(m.NumPayouts))
	}
	l = len(m.Reference)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.CustomizePayoutPeriod != 0 {
		n += 1 + sovEscrow(uint64(m.CustomizePayoutPeriod))
	}
	if m.Type != 0 {
		n += 1 + sovEscrow(uint64(m.Type))
	}
	if m.ContingentAmount != 0 {
		n += 1 + sovEscrow(uint64(m.ContingentAmount))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedEscrowContract) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Contract != nil {
		l = m.Contract.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.BuyerSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.SellerSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EscrowContractRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Contract) > 0 {
		for _, e := range m.Contract {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	if m.BuyerChannel != nil {
		l = m.BuyerChannel.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Escrow) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.EscrowId != 0 {
		n += 1 + sovEscrow(uint64(m.EscrowId))
	}
	l = len(m.FromAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.CollateralAmount != 0 {
		n += 1 + sovEscrow(uint64(m.CollateralAmount))
	}
	if m.ErrorCode != 0 {
		n += 1 + sovEscrow(uint64(m.ErrorCode))
	}
	l = len(m.ErrorMessage)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SubmitContractResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PayinId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if len(m.Escrow) > 0 {
		for _, e := range m.Escrow {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.BuyerChannelState != nil {
		l = m.BuyerChannelState.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedSubmitContractResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StartEscrowResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Escrow) > 0 {
		for _, e := range m.Escrow {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedStartEscrowResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PayinRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PayinId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.BuyerAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.BuyerChannelState != nil {
		l = m.BuyerChannelState.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPayinRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.BuyerSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PayinResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PayinId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.ChannelId != 0 {
		n += 1 + sovEscrow(uint64(m.ChannelId))
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPayinResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PayinStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Paid {
		n += 2
	}
	if m.ChannelId != 0 {
		n += 1 + sovEscrow(uint64(m.ChannelId))
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPayinStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PayoutStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.EscrowId != 0 {
		n += 1 + sovEscrow(uint64(m.EscrowId))
	}
	l = len(m.FromAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.AuthAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovEscrow(uint64(m.Status))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.Collateral != 0 {
		n += 1 + sovEscrow(uint64(m.Collateral))
	}
	if m.Withhold != 0 {
		n += 1 + sovEscrow(uint64(m.Withhold))
	}
	if m.PaidAmount != 0 {
		n += 1 + sovEscrow(uint64(m.PaidAmount))
	}
	if m.NumPaid != 0 {
		n += 1 + sovEscrow(uint64(m.NumPaid))
	}
	if m.LeftAmount != 0 {
		n += 1 + sovEscrow(uint64(m.LeftAmount))
	}
	if m.NumLeft != 0 {
		n += 1 + sovEscrow(uint64(m.NumLeft))
	}
	if m.NextAmount != 0 {
		n += 1 + sovEscrow(uint64(m.NextAmount))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.LastPayoutTime)
	n += 1 + l + sovEscrow(uint64(l))
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.NextPayoutTime)
	n += 2 + l + sovEscrow(uint64(l))
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 2 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignTime)
	n += 2 + l + sovEscrow(uint64(l))
	l = len(m.ErrorMsg)
	if l > 0 {
		n += 2 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.LastModifyTime)
	n += 2 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPayoutStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPayoutStatusBatch) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Status) > 0 {
		for _, e := range m.Status {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CancelContractRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.AuthAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.AuthSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedCancelRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Request != nil {
		l = m.Request.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.AuthSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CancelContractResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.EscrowId != 0 {
		n += 1 + sovEscrow(uint64(m.EscrowId))
	}
	if m.Canceled {
		n += 2
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.Paid {
		n += 2
	}
	l = len(m.Reference)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedCancelContractResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PayoutAddress) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.SignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Payment) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ContractId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.EscrowId != 0 {
		n += 1 + sovEscrow(uint64(m.EscrowId))
	}
	l = len(m.FromAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.ToAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.Index != 0 {
		n += 1 + sovEscrow(uint64(m.Index))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PaymentResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Payment) > 0 {
		for _, e := range m.Payment {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedPaymentResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *BalanceResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Balance != 0 {
		n += 1 + sovEscrow(uint64(m.Balance))
	}
	l = len(m.EscrowAddress)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.EscrowSignedTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *SignedBalanceResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Result != nil {
		l = m.Result.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.EscrowSignature)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *StakeRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakerId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.StakeAmount != 0 {
		n += 1 + sovEscrow(uint64(m.StakeAmount))
	}
	if m.TransferRequest != nil {
		l = m.TransferRequest.Size()
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.RequestTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StakeResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakerId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Balance != 0 {
		n += 1 + sovEscrow(uint64(m.Balance))
	}
	if m.MatureAmount != 0 {
		n += 1 + sovEscrow(uint64(m.MatureAmount))
	}
	if m.PendingAmount != 0 {
		n += 1 + sovEscrow(uint64(m.PendingAmount))
	}
	if len(m.Ledgers) > 0 {
		for _, e := range m.Ledgers {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	if len(m.UnfinishLedgers) > 0 {
		for _, e := range m.UnfinishLedgers {
			l = e.Size()
			n += 1 + l + sovEscrow(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *StakeLedger) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakerId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.StartTime)
	n += 1 + l + sovEscrow(uint64(l))
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.MatureTime)
	n += 1 + l + sovEscrow(uint64(l))
	l = len(m.OperatorId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovEscrow(uint64(m.Type))
	}
	l = len(m.OperationLog)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UnfinishStakeLedger) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakerId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	if m.Status != 0 {
		n += 1 + sovEscrow(uint64(m.Status))
	}
	l = len(m.FailReason)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.SubmitTime)
	n += 1 + l + sovEscrow(uint64(l))
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.FailTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *StakePenaltyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakerId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = len(m.OperatorId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Reason != 0 {
		n += 1 + sovEscrow(uint64(m.Reason))
	}
	l = len(m.OperationLog)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.Amount != 0 {
		n += 1 + sovEscrow(uint64(m.Amount))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.SubmitTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StakePenaltyResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StakerId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	if m.RequestPenaltyAmount != 0 {
		n += 1 + sovEscrow(uint64(m.RequestPenaltyAmount))
	}
	if m.OperatePenaltyAmount != 0 {
		n += 1 + sovEscrow(uint64(m.OperatePenaltyAmount))
	}
	l = len(m.OperatorId)
	if l > 0 {
		n += 1 + l + sovEscrow(uint64(l))
	}
	l = github_com_bittorrent_protobuf_types.SizeOfStdTime(m.ReceiveTime)
	n += 1 + l + sovEscrow(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovEscrow(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozEscrow(x uint64) (n int) {
	return sovEscrow(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *ContractID) 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 ErrIntOverflowEscrow
			}
			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: ContractID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
			if m.Address == nil {
				m.Address = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *ContractIDBatch) 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 ErrIntOverflowEscrow
			}
			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: ContractIDBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ContractIDBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = append(m.ContractId, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
			if m.Address == nil {
				m.Address = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedContractID) 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 ErrIntOverflowEscrow
			}
			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: SignedContractID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedContractID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &ContractID{}
			}
			if err := m.Data.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedContractIDBatch) 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 ErrIntOverflowEscrow
			}
			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: SignedContractIDBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedContractIDBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &ContractIDBatch{}
			}
			if err := m.Data.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedModifyContractIDBatch) 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 ErrIntOverflowEscrow
			}
			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: SignedModifyContractIDBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedModifyContractIDBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &ContractIDBatch{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastModifyTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.LastModifyTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *EscrowContract) 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 ErrIntOverflowEscrow
			}
			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: EscrowContract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EscrowContract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuyerAddress = append(m.BuyerAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.BuyerAddress == nil {
				m.BuyerAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SellerAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SellerAddress = append(m.SellerAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.SellerAddress == nil {
				m.SellerAddress = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthAddress = append(m.AuthAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.AuthAddress == nil {
				m.AuthAddress = []byte{}
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralAmount", wireType)
			}
			m.CollateralAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollateralAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WithholdAmount", wireType)
			}
			m.WithholdAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WithholdAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenType", wireType)
			}
			m.TokenType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TokenType |= TokenType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayoutSchedule", wireType)
			}
			m.PayoutSchedule = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PayoutSchedule |= Schedule(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumPayouts", wireType)
			}
			m.NumPayouts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumPayouts |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reference", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reference = append(m.Reference[:0], dAtA[iNdEx:postIndex]...)
			if m.Reference == nil {
				m.Reference = []byte{}
			}
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomizePayoutPeriod", wireType)
			}
			m.CustomizePayoutPeriod = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CustomizePayoutPeriod |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= ContractType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContingentAmount", wireType)
			}
			m.ContingentAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ContingentAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedEscrowContract) 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 ErrIntOverflowEscrow
			}
			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: SignedEscrowContract: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedEscrowContract: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Contract == nil {
				m.Contract = &EscrowContract{}
			}
			if err := m.Contract.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuyerSignature = append(m.BuyerSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.BuyerSignature == nil {
				m.BuyerSignature = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SellerSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SellerSignature = append(m.SellerSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.SellerSignature == nil {
				m.SellerSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *EscrowContractRequest) 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 ErrIntOverflowEscrow
			}
			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: EscrowContractRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: EscrowContractRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Contract", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Contract = append(m.Contract, &SignedEscrowContract{})
			if err := m.Contract[len(m.Contract)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerChannel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BuyerChannel == nil {
				m.BuyerChannel = &ledger.SignedChannelCommit{}
			}
			if err := m.BuyerChannel.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *Escrow) 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 ErrIntOverflowEscrow
			}
			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: Escrow: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Escrow: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
			}
			m.EscrowId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EscrowId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromAddress = append(m.FromAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.FromAddress == nil {
				m.FromAddress = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToAddress = append(m.ToAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ToAddress == nil {
				m.ToAddress = []byte{}
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CollateralAmount", wireType)
			}
			m.CollateralAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CollateralAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorCode", wireType)
			}
			m.ErrorCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ErrorCode |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorMessage", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorMessage = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SubmitContractResult) 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 ErrIntOverflowEscrow
			}
			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: SubmitContractResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SubmitContractResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayinId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PayinId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Escrow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Escrow = append(m.Escrow, &Escrow{})
			if err := m.Escrow[len(m.Escrow)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerChannelState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BuyerChannelState == nil {
				m.BuyerChannelState = &ledger.SignedChannelState{}
			}
			if err := m.BuyerChannelState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedSubmitContractResult) 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 ErrIntOverflowEscrow
			}
			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: SignedSubmitContractResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedSubmitContractResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &SubmitContractResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *StartEscrowResult) 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 ErrIntOverflowEscrow
			}
			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: StartEscrowResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StartEscrowResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Escrow", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Escrow = append(m.Escrow, &Escrow{})
			if err := m.Escrow[len(m.Escrow)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedStartEscrowResult) 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 ErrIntOverflowEscrow
			}
			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: SignedStartEscrowResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedStartEscrowResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &StartEscrowResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *PayinRequest) 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 ErrIntOverflowEscrow
			}
			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: PayinRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PayinRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayinId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PayinId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuyerAddress = append(m.BuyerAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.BuyerAddress == nil {
				m.BuyerAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerChannelState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.BuyerChannelState == nil {
				m.BuyerChannelState = &ledger.SignedChannelState{}
			}
			if err := m.BuyerChannelState.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPayinRequest) 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 ErrIntOverflowEscrow
			}
			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: SignedPayinRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPayinRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Request == nil {
				m.Request = &PayinRequest{}
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BuyerSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BuyerSignature = append(m.BuyerSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.BuyerSignature == nil {
				m.BuyerSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *PayinResult) 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 ErrIntOverflowEscrow
			}
			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: PayinResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PayinResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayinId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PayinId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPayinResult) 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 ErrIntOverflowEscrow
			}
			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: SignedPayinResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPayinResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &PayinResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *PayinStatus) 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 ErrIntOverflowEscrow
			}
			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: PayinStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PayinStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Paid = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelId", wireType)
			}
			m.ChannelId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPayinStatus) 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 ErrIntOverflowEscrow
			}
			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: SignedPayinStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPayinStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &PayinStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *PayoutStatus) 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 ErrIntOverflowEscrow
			}
			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: PayoutStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PayoutStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
			}
			m.EscrowId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EscrowId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromAddress = append(m.FromAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.FromAddress == nil {
				m.FromAddress = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToAddress = append(m.ToAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ToAddress == nil {
				m.ToAddress = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthAddress = append(m.AuthAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.AuthAddress == nil {
				m.AuthAddress = []byte{}
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= EscrowStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Collateral", wireType)
			}
			m.Collateral = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Collateral |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Withhold", wireType)
			}
			m.Withhold = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Withhold |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PaidAmount", wireType)
			}
			m.PaidAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PaidAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumPaid", wireType)
			}
			m.NumPaid = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumPaid |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeftAmount", wireType)
			}
			m.LeftAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LeftAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumLeft", wireType)
			}
			m.NumLeft = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumLeft |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 14:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextAmount", wireType)
			}
			m.NextAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastPayoutTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.LastPayoutTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextPayoutTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.NextPayoutTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ErrorMsg", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ErrorMsg = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastModifyTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.LastModifyTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPayoutStatus) 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 ErrIntOverflowEscrow
			}
			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: SignedPayoutStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPayoutStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Status == nil {
				m.Status = &PayoutStatus{}
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPayoutStatusBatch) 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 ErrIntOverflowEscrow
			}
			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: SignedPayoutStatusBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPayoutStatusBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = append(m.Status, &PayoutStatus{})
			if err := m.Status[len(m.Status)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *CancelContractRequest) 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 ErrIntOverflowEscrow
			}
			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: CancelContractRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CancelContractRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthAddress = append(m.AuthAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.AuthAddress == nil {
				m.AuthAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.AuthSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedCancelRequest) 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 ErrIntOverflowEscrow
			}
			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: SignedCancelRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedCancelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Request", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Request == nil {
				m.Request = &CancelContractRequest{}
			}
			if err := m.Request.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AuthSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AuthSignature = append(m.AuthSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.AuthSignature == nil {
				m.AuthSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *CancelContractResult) 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 ErrIntOverflowEscrow
			}
			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: CancelContractResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CancelContractResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
			}
			m.EscrowId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EscrowId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Canceled", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Canceled = bool(v != 0)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Paid", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Paid = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reference", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reference = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedCancelContractResult) 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 ErrIntOverflowEscrow
			}
			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: SignedCancelContractResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedCancelContractResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &CancelContractResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *PayoutAddress) 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 ErrIntOverflowEscrow
			}
			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: PayoutAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PayoutAddress: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToAddress = append(m.ToAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ToAddress == nil {
				m.ToAddress = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.SignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPayoutAddress) 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 ErrIntOverflowEscrow
			}
			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: SignedPayoutAddress: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPayoutAddress: 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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Address == nil {
				m.Address = &PayoutAddress{}
			}
			if err := m.Address.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *Payment) 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 ErrIntOverflowEscrow
			}
			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: Payment: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Payment: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContractId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ContractId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowId", wireType)
			}
			m.EscrowId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.EscrowId |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FromAddress = append(m.FromAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.FromAddress == nil {
				m.FromAddress = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ToAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ToAddress = append(m.ToAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.ToAddress == nil {
				m.ToAddress = []byte{}
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *PaymentResult) 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 ErrIntOverflowEscrow
			}
			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: PaymentResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PaymentResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Payment", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Payment = append(m.Payment, &Payment{})
			if err := m.Payment[len(m.Payment)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedPaymentResult) 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 ErrIntOverflowEscrow
			}
			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: SignedPaymentResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedPaymentResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &PaymentResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *BalanceResult) 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 ErrIntOverflowEscrow
			}
			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: BalanceResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: BalanceResult: 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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowAddress", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowAddress = append(m.EscrowAddress[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowAddress == nil {
				m.EscrowAddress = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignedTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.EscrowSignedTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedBalanceResult) 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 ErrIntOverflowEscrow
			}
			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: SignedBalanceResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedBalanceResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Result == nil {
				m.Result = &BalanceResult{}
			}
			if err := m.Result.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EscrowSignature", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EscrowSignature = append(m.EscrowSignature[:0], dAtA[iNdEx:postIndex]...)
			if m.EscrowSignature == nil {
				m.EscrowSignature = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedStakeRequest) 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 ErrIntOverflowEscrow
			}
			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: SignedStakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedStakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &StakeRequest{}
			}
			if err := m.Data.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *StakeRequest) 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 ErrIntOverflowEscrow
			}
			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: StakeRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakeAmount", wireType)
			}
			m.StakeAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StakeAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TransferRequest == nil {
				m.TransferRequest = &ledger.SignedTransferRequest{}
			}
			if err := m.TransferRequest.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.RequestTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *StakeResult) 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 ErrIntOverflowEscrow
			}
			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: StakeResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakerId = string(dAtA[iNdEx:postIndex])
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Balance |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatureAmount", wireType)
			}
			m.MatureAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MatureAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingAmount", wireType)
			}
			m.PendingAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PendingAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ledgers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ledgers = append(m.Ledgers, &StakeLedger{})
			if err := m.Ledgers[len(m.Ledgers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UnfinishLedgers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.UnfinishLedgers = append(m.UnfinishLedgers, &UnfinishStakeLedger{})
			if err := m.UnfinishLedgers[len(m.UnfinishLedgers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedStakeResult) 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 ErrIntOverflowEscrow
			}
			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: SignedStakeResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedStakeResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &StakeResult{}
			}
			if err := m.Data.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *StakeLedger) 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 ErrIntOverflowEscrow
			}
			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: StakeLedger: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakeLedger: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.StartTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatureTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.MatureTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperatorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= OperationType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperationLog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperationLog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *UnfinishStakeLedger) 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 ErrIntOverflowEscrow
			}
			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: UnfinishStakeLedger: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: UnfinishStakeLedger: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= StakeStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailReason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FailReason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmitTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.FailTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedStakePenaltyRequest) 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 ErrIntOverflowEscrow
			}
			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: SignedStakePenaltyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedStakePenaltyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &StakePenaltyRequest{}
			}
			if err := m.Data.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *StakePenaltyRequest) 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 ErrIntOverflowEscrow
			}
			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: StakePenaltyRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakePenaltyRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperatorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			m.Reason = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Reason |= OperationType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperationLog", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperationLog = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Amount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmitTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.SubmitTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *StakePenaltyResult) 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 ErrIntOverflowEscrow
			}
			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: StakePenaltyResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StakePenaltyResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StakerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StakerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequestPenaltyAmount", wireType)
			}
			m.RequestPenaltyAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RequestPenaltyAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatePenaltyAmount", wireType)
			}
			m.OperatePenaltyAmount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OperatePenaltyAmount |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperatorId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				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 ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperatorId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceiveTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_bittorrent_protobuf_types.StdTimeUnmarshal(&m.ReceiveTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 *SignedStakePenaltyResult) 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 ErrIntOverflowEscrow
			}
			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: SignedStakePenaltyResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SignedStakePenaltyResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &StakePenaltyResult{}
			}
			if err := m.Data.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 ErrIntOverflowEscrow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthEscrow
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthEscrow
			}
			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 := skipEscrow(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthEscrow
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthEscrow
			}
			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 skipEscrow(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, ErrIntOverflowEscrow
			}
			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, ErrIntOverflowEscrow
				}
				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, ErrIntOverflowEscrow
				}
				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, ErrInvalidLengthEscrow
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupEscrow
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthEscrow
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthEscrow        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEscrow          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEscrow = fmt.Errorf("proto: unexpected end of group")
)