bertyverifiablecreds.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: verifiablecredstypes/bertyverifiablecreds.proto

package verifiablecredstypes

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type FlowType int32

const (
	FlowType_FlowTypeUndefined FlowType = 0
	// FlowTypeCode asks users a code sent on a side channel
	FlowType_FlowTypeCode FlowType = 1
	// FlowTypeAuth currently unimplemented
	FlowType_FlowTypeAuth FlowType = 2
	// FlowTypeProof currently unimplemented
	FlowType_FlowTypeProof FlowType = 3
)

var FlowType_name = map[int32]string{
	0: "FlowTypeUndefined",
	1: "FlowTypeCode",
	2: "FlowTypeAuth",
	3: "FlowTypeProof",
}

var FlowType_value = map[string]int32{
	"FlowTypeUndefined": 0,
	"FlowTypeCode":      1,
	"FlowTypeAuth":      2,
	"FlowTypeProof":     3,
}

func (x FlowType) String() string {
	return proto.EnumName(FlowType_name, int32(x))
}

func (FlowType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7839fe931fda6b3a, []int{0}
}

type CodeStrategy int32

const (
	CodeStrategy_CodeStrategyUndefined CodeStrategy = 0
	// CodeStrategy6Digits currently unimplemented
	CodeStrategy_CodeStrategy6Digits CodeStrategy = 1
	// CodeStrategy10Chars currently unimplemented
	CodeStrategy_CodeStrategy10Chars CodeStrategy = 2
	// CodeStrategyMocked6Zeroes must only be used in testing
	CodeStrategy_CodeStrategyMocked6Zeroes CodeStrategy = 999
)

var CodeStrategy_name = map[int32]string{
	0:   "CodeStrategyUndefined",
	1:   "CodeStrategy6Digits",
	2:   "CodeStrategy10Chars",
	999: "CodeStrategyMocked6Zeroes",
}

var CodeStrategy_value = map[string]int32{
	"CodeStrategyUndefined":     0,
	"CodeStrategy6Digits":       1,
	"CodeStrategy10Chars":       2,
	"CodeStrategyMocked6Zeroes": 999,
}

func (x CodeStrategy) String() string {
	return proto.EnumName(CodeStrategy_name, int32(x))
}

func (CodeStrategy) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_7839fe931fda6b3a, []int{1}
}

// StateChallenge serialized and signed state used when requesting a challenge
type StateChallenge struct {
	Timestamp            []byte   `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Nonce                []byte   `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty"`
	BertyLink            string   `protobuf:"bytes,3,opt,name=berty_link,json=bertyLink,proto3" json:"berty_link,omitempty"`
	RedirectURI          string   `protobuf:"bytes,4,opt,name=redirect_uri,json=redirectUri,proto3" json:"redirect_uri,omitempty"`
	State                string   `protobuf:"bytes,5,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StateChallenge proto.InternalMessageInfo

func (m *StateChallenge) GetTimestamp() []byte {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *StateChallenge) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

func (m *StateChallenge) GetBertyLink() string {
	if m != nil {
		return m.BertyLink
	}
	return ""
}

func (m *StateChallenge) GetRedirectURI() string {
	if m != nil {
		return m.RedirectURI
	}
	return ""
}

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

// StateCode serialized and signed state used when requesting a code
type StateCode struct {
	Timestamp            []byte       `protobuf:"bytes,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	BertyLink            string       `protobuf:"bytes,2,opt,name=berty_link,json=bertyLink,proto3" json:"berty_link,omitempty"`
	CodeStrategy         CodeStrategy `protobuf:"varint,3,opt,name=code_strategy,json=codeStrategy,proto3,enum=weshnet.account.v1.CodeStrategy" json:"code_strategy,omitempty"`
	Identifier           string       `protobuf:"bytes,4,opt,name=identifier,proto3" json:"identifier,omitempty"`
	Code                 string       `protobuf:"bytes,5,opt,name=code,proto3" json:"code,omitempty"`
	RedirectURI          string       `protobuf:"bytes,6,opt,name=redirect_uri,json=redirectUri,proto3" json:"redirect_uri,omitempty"`
	State                string       `protobuf:"bytes,7,opt,name=state,proto3" json:"state,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_StateCode proto.InternalMessageInfo

func (m *StateCode) GetTimestamp() []byte {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *StateCode) GetBertyLink() string {
	if m != nil {
		return m.BertyLink
	}
	return ""
}

func (m *StateCode) GetCodeStrategy() CodeStrategy {
	if m != nil {
		return m.CodeStrategy
	}
	return CodeStrategy_CodeStrategyUndefined
}

func (m *StateCode) GetIdentifier() string {
	if m != nil {
		return m.Identifier
	}
	return ""
}

func (m *StateCode) GetCode() string {
	if m != nil {
		return m.Code
	}
	return ""
}

func (m *StateCode) GetRedirectURI() string {
	if m != nil {
		return m.RedirectURI
	}
	return ""
}

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

type AccountCryptoChallenge struct {
	Challenge            string   `protobuf:"bytes,1,opt,name=challenge,proto3" json:"challenge,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_AccountCryptoChallenge proto.InternalMessageInfo

func (m *AccountCryptoChallenge) GetChallenge() string {
	if m != nil {
		return m.Challenge
	}
	return ""
}

func init() {
	proto.RegisterEnum("weshnet.account.v1.FlowType", FlowType_name, FlowType_value)
	proto.RegisterEnum("weshnet.account.v1.CodeStrategy", CodeStrategy_name, CodeStrategy_value)
	proto.RegisterType((*StateChallenge)(nil), "weshnet.account.v1.StateChallenge")
	proto.RegisterType((*StateCode)(nil), "weshnet.account.v1.StateCode")
	proto.RegisterType((*AccountCryptoChallenge)(nil), "weshnet.account.v1.AccountCryptoChallenge")
}

func init() {
	proto.RegisterFile("verifiablecredstypes/bertyverifiablecreds.proto", fileDescriptor_7839fe931fda6b3a)
}

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

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

func (m *StateChallenge) 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.State) > 0 {
		i -= len(m.State)
		copy(dAtA[i:], m.State)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.State)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.RedirectURI) > 0 {
		i -= len(m.RedirectURI)
		copy(dAtA[i:], m.RedirectURI)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.RedirectURI)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.BertyLink) > 0 {
		i -= len(m.BertyLink)
		copy(dAtA[i:], m.BertyLink)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.BertyLink)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Nonce) > 0 {
		i -= len(m.Nonce)
		copy(dAtA[i:], m.Nonce)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.Nonce)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Timestamp) > 0 {
		i -= len(m.Timestamp)
		copy(dAtA[i:], m.Timestamp)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.Timestamp)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StateCode) 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.State) > 0 {
		i -= len(m.State)
		copy(dAtA[i:], m.State)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.State)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.RedirectURI) > 0 {
		i -= len(m.RedirectURI)
		copy(dAtA[i:], m.RedirectURI)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.RedirectURI)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Code) > 0 {
		i -= len(m.Code)
		copy(dAtA[i:], m.Code)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.Code)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Identifier) > 0 {
		i -= len(m.Identifier)
		copy(dAtA[i:], m.Identifier)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.Identifier)))
		i--
		dAtA[i] = 0x22
	}
	if m.CodeStrategy != 0 {
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(m.CodeStrategy))
		i--
		dAtA[i] = 0x18
	}
	if len(m.BertyLink) > 0 {
		i -= len(m.BertyLink)
		copy(dAtA[i:], m.BertyLink)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.BertyLink)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Timestamp) > 0 {
		i -= len(m.Timestamp)
		copy(dAtA[i:], m.Timestamp)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.Timestamp)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AccountCryptoChallenge) 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.Challenge) > 0 {
		i -= len(m.Challenge)
		copy(dAtA[i:], m.Challenge)
		i = encodeVarintBertyverifiablecreds(dAtA, i, uint64(len(m.Challenge)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintBertyverifiablecreds(dAtA []byte, offset int, v uint64) int {
	offset -= sovBertyverifiablecreds(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *StateChallenge) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Timestamp)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.Nonce)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.BertyLink)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.RedirectURI)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StateCode) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Timestamp)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.BertyLink)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	if m.CodeStrategy != 0 {
		n += 1 + sovBertyverifiablecreds(uint64(m.CodeStrategy))
	}
	l = len(m.Identifier)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.Code)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.RedirectURI)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	l = len(m.State)
	if l > 0 {
		n += 1 + l + sovBertyverifiablecreds(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func sovBertyverifiablecreds(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBertyverifiablecreds(x uint64) (n int) {
	return sovBertyverifiablecreds(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *StateChallenge) 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 ErrIntOverflowBertyverifiablecreds
			}
			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: StateChallenge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StateChallenge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamp = append(m.Timestamp[:0], dAtA[iNdEx:postIndex]...)
			if m.Timestamp == nil {
				m.Timestamp = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nonce = append(m.Nonce[:0], dAtA[iNdEx:postIndex]...)
			if m.Nonce == nil {
				m.Nonce = []byte{}
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BertyLink", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BertyLink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedirectURI", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RedirectURI = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertyverifiablecreds(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			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 *StateCode) 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 ErrIntOverflowBertyverifiablecreds
			}
			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: StateCode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StateCode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Timestamp = append(m.Timestamp[:0], dAtA[iNdEx:postIndex]...)
			if m.Timestamp == nil {
				m.Timestamp = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BertyLink", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BertyLink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CodeStrategy", wireType)
			}
			m.CodeStrategy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CodeStrategy |= CodeStrategy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Identifier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Identifier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Code = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RedirectURI", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RedirectURI = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertyverifiablecreds(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			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 *AccountCryptoChallenge) 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 ErrIntOverflowBertyverifiablecreds
			}
			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: AccountCryptoChallenge: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AccountCryptoChallenge: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Challenge", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertyverifiablecreds
				}
				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 ErrInvalidLengthBertyverifiablecreds
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Challenge = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertyverifiablecreds(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertyverifiablecreds
			}
			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 skipBertyverifiablecreds(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, ErrIntOverflowBertyverifiablecreds
			}
			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, ErrIntOverflowBertyverifiablecreds
				}
				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, ErrIntOverflowBertyverifiablecreds
				}
				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, ErrInvalidLengthBertyverifiablecreds
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupBertyverifiablecreds
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthBertyverifiablecreds
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthBertyverifiablecreds        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBertyverifiablecreds          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBertyverifiablecreds = fmt.Errorf("proto: unexpected end of group")
)