go/sonr
1
0
Fork 0
mirror of https://github.com/sonr-io/sonr.git synced 2026-08-02 17:31:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

feature/implement did state (#15)

Browse Source 
* refactor: update model proto

* feat: add status field to Controller

* feat: add Verification.Kind field to state protobuf to support different verification types

* fix: remove QueryService and QueryResolve RPCs from query.proto
This commit is contained in:
Prad Nukala
2024-09-18 17:27:30 -04:00
committed by GitHub
parent 2c1cf56e3c
commit 6d8bd8fc85
18 changed files with 1348 additions and 5998 deletions
Download Patch File Download Diff File Expand all files Collapse all files
x/did/builder/api.go
-25
View File
@@ -66,18 +66,6 @@ func APIFormatPermissionScopes(scopes []types.PermissionScope) []didv1.Permissio
return s
}
func APIFormatServiceRecord(service *types.Service) *didv1.ServiceRecord {
return &didv1.ServiceRecord{
Id: service.Id,
ServiceType: service.ServiceType,
Authority: service.Authority,
Origin: service.Origin,
Description: service.Description,
ServiceEndpoints: service.ServiceEndpoints,
Permissions: APIFormatPermissions(service.Permissions),
}
}
func APIFormatPubKeyJWK(jwk *types.PubKey_JWK) *didv1.PubKey_JWK {
return &didv1.PubKey_JWK{
Kty: jwk.Kty,
@@ -202,19 +190,6 @@ func ModuleTransportsToProtocol(transport []string) []protocol.AuthenticatorTran
return tss
}
// ModuleFormatAPIServiceRecord formats a service record for the module
func ModuleFormatAPIServiceRecord(service *didv1.ServiceRecord) *types.Service {
return &types.Service{
Id: service.Id,
ServiceType: service.ServiceType,
Authority: service.Authority,
Origin: service.Origin,
Description: service.Description,
ServiceEndpoints: service.ServiceEndpoints,
Permissions: ModuleFormatAPIPermissions(service.Permissions),
}
}
func ModuleFormatAPIPermissions(permissions *didv1.Permissions) *types.Permissions {
if permissions == nil {
return nil
x/did/builder/pubkey.go
+6 -6
View File
@@ -23,8 +23,8 @@ type PublicKey interface {
}
// CreateAuthnVerification creates a new verification method for an authn method
func CreateAuthnVerification(namespace types.DIDNamespace, issuer string, controller string, pubkey *types.PubKey, identifier string) *types.VerificationMethod {
return &types.VerificationMethod{
func CreateAuthnVerification(namespace types.DIDNamespace, issuer string, controller string, pubkey *types.PubKey, identifier string) *types.Verification {
return &types.Verification{
Method: namespace,
Controller: controller,
PublicKey: pubkey,
@@ -34,8 +34,8 @@ func CreateAuthnVerification(namespace types.DIDNamespace, issuer string, contro
}
// CreateWalletVerification creates a new verification method for a wallet
func CreateWalletVerification(namespace types.DIDNamespace, controller string, pubkey *types.PubKey, identifier string) *didv1.VerificationMethod {
return &didv1.VerificationMethod{
func CreateWalletVerification(namespace types.DIDNamespace, controller string, pubkey *types.PubKey, identifier string) *didv1.Verification {
return &didv1.Verification{
Method: APIFormatDIDNamespace(namespace),
Controller: controller,
PublicKey: APIFormatPubKey(pubkey),
@@ -63,8 +63,8 @@ func ExtractWebAuthnPublicKey(keyBytes []byte) (*types.PubKey_JWK, error) {
}
// NewInitialWalletAccounts creates a new set of verification methods for a wallet
func NewInitialWalletAccounts(controller string, pubkey *types.PubKey) ([]*didv1.VerificationMethod, error) {
var verificationMethods []*didv1.VerificationMethod
func NewInitialWalletAccounts(controller string, pubkey *types.PubKey) ([]*didv1.Verification, error) {
var verificationMethods []*didv1.Verification
for method, chain := range types.InitialChainCodes {
nk, err := computeBip32AccountPublicKey(pubkey, chain, 0)
if err != nil {
x/did/keeper/context.go
-17
View File
@@ -4,7 +4,6 @@ import (
"context"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/onsonr/sonr/x/did/builder"
"github.com/onsonr/sonr/x/did/types"
"google.golang.org/grpc/peer"
)
@@ -42,19 +41,3 @@ func (c Context) PeerID() string {
}
return c.Peer.Addr.String()
}
func (c Context) GetService(origin string) (*types.Service, error) {
rec, err := c.Keeper.OrmDB.ServiceRecordTable().GetByOrigin(c.SDK(), origin)
if err != nil {
return nil, err
}
return builder.ModuleFormatAPIServiceRecord(rec), nil
}
func (c Context) GetServiceInfo(origin string) *types.ServiceInfo {
rec, _ := c.GetService(origin)
if rec == nil {
return &types.ServiceInfo{Exists: false, Origin: origin, Fingerprint: types.ComputeOriginTXTRecord(origin)}
}
return &types.ServiceInfo{Exists: true, Origin: origin, Fingerprint: types.ComputeOriginTXTRecord(origin), Service: rec}
}
x/did/keeper/genesis.go
-1
View File
@@ -21,7 +21,6 @@ func (k *Keeper) InitGenesis(ctx context.Context, data *types.GenesisState) erro
if err := data.Params.Validate(); err != nil {
return err
}
return k.Params.Set(ctx, data.Params)
}
x/did/keeper/keeper.go
-18
View File
@@ -92,24 +92,6 @@ func NewKeeper(
return k
}
// IsClaimedServiceOrigin checks if a service origin is unclaimed
func (k Keeper) IsUnclaimedServiceOrigin(ctx sdk.Context, origin string) bool {
rec, _ := k.OrmDB.ServiceRecordTable().GetByOrigin(ctx, origin)
return rec == nil
}
// IsValidServiceOrigin checks if a service origin is valid
func (k Keeper) IsValidServiceOrigin(ctx sdk.Context, origin string) bool {
rec, err := k.OrmDB.ServiceRecordTable().GetByOrigin(ctx, origin)
if err != nil {
return false
}
if rec == nil {
return false
}
return true
}
// VerifyMinimumStake checks if a validator has a minimum stake
func (k Keeper) VerifyMinimumStake(ctx sdk.Context, addr string) bool {
address, err := sdk.AccAddressFromBech32(addr)
x/did/keeper/querier.go
+2 -2
View File
@@ -39,8 +39,8 @@ func (k Querier) Service(
goCtx context.Context,
req *types.QueryRequest,
) (*types.QueryServiceResponse, error) {
ctx := k.CurrentCtx(goCtx)
return &types.QueryServiceResponse{Service: ctx.GetServiceInfo(req.GetOrigin())}, nil
// ctx := k.CurrentCtx(goCtx)
return &types.QueryServiceResponse{}, nil
}
// Sync implements types.QueryServer.
x/did/keeper/server.go
+8 -8
View File
@@ -47,9 +47,9 @@ func (ms msgServer) AllocateVault(
) (*types.MsgAllocateVaultResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
// 1.Check if the service origin is valid
if ms.k.IsValidServiceOrigin(ctx, msg.Origin) {
return nil, types.ErrInvalidServiceOrigin
}
// if ms.k.IsValidServiceOrigin(ctx, msg.Origin) {
// return nil, types.ErrInvalidServiceOrigin
// }
cid, expiryBlock, err := ms.k.assembleInitialVault(ctx)
if err != nil {
@@ -92,13 +92,13 @@ func (ms msgServer) RegisterService(
goCtx context.Context,
msg *types.MsgRegisterService,
) (*types.MsgRegisterServiceResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
// ctx := sdk.UnwrapSDKContext(goCtx)
// 1.Check if the service origin is valid
if !ms.k.IsValidServiceOrigin(ctx, msg.Service.Origin) {
return nil, types.ErrInvalidServiceOrigin
}
return ms.k.insertService(ctx, msg.Service)
// if !ms.k.IsValidServiceOrigin(ctx, msg.Service.Origin) {
// return nil, types.ErrInvalidServiceOrigin
// }
return nil, errors.Wrapf(types.ErrInvalidServiceOrigin, "invalid service origin")
}
// # UpdateParams
x/did/keeper/state.go
-24
View File
@@ -1,24 +0,0 @@
package keeper
import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/onsonr/sonr/x/did/builder"
"github.com/onsonr/sonr/x/did/types"
)
// insertService inserts a service record into the database
func (k Keeper) insertService(
ctx sdk.Context,
svc *types.Service,
) (*types.MsgRegisterServiceResponse, error) {
record := builder.APIFormatServiceRecord(svc)
err := k.OrmDB.ServiceRecordTable().Insert(ctx, record)
if err != nil {
return nil, err
}
return &types.MsgRegisterServiceResponse{
Success: true,
Did: record.Id,
}, nil
}
x/did/types/integrity.go
-27
View File
@@ -1,27 +0,0 @@
package types
import "lukechampine.com/blake3"
func (g *GlobalIntegrity) Update(address string) bool {
return true
}
func (g *GlobalIntegrity) getProof() (*Proof, error) {
if g.Accumulator == nil {
return NewProof(g.Controller, g.proofProperty(), g.seedKdf())
}
return &Proof{
Issuer: g.Controller,
Property: g.proofProperty(),
Accumulator: g.Accumulator,
}, nil
}
func (g *GlobalIntegrity) proofProperty() string {
return "did:sonr:integrity"
}
func (g *GlobalIntegrity) seedKdf() []byte {
res := blake3.Sum256([]byte(g.Seed))
return res[:]
}
x/did/types/models.pb.go
+82 -356
View File
@@ -23,67 +23,6 @@ var _ = math.Inf
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
// Alias defines a subject/origin pair
type Alias struct {
Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
Origin string `protobuf:"bytes,2,opt,name=origin,proto3" json:"origin,omitempty"`
Controller string `protobuf:"bytes,3,opt,name=controller,proto3" json:"controller,omitempty"`
}
func (m *Alias) Reset() { *m = Alias{} }
func (m *Alias) String() string { return proto.CompactTextString(m) }
func (*Alias) ProtoMessage() {}
func (*Alias) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{0}
}
func (m *Alias) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *Alias) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_Alias.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 *Alias) XXX_Merge(src proto.Message) {
xxx_messageInfo_Alias.Merge(m, src)
}
func (m *Alias) XXX_Size() int {
return m.Size()
}
func (m *Alias) XXX_DiscardUnknown() {
xxx_messageInfo_Alias.DiscardUnknown(m)
}
var xxx_messageInfo_Alias proto.InternalMessageInfo
func (m *Alias) GetSubject() string {
if m != nil {
return m.Subject
}
return ""
}
func (m *Alias) GetOrigin() string {
if m != nil {
return m.Origin
}
return ""
}
func (m *Alias) GetController() string {
if m != nil {
return m.Controller
}
return ""
}
type Credential struct {
Subject string `protobuf:"bytes,1,opt,name=subject,proto3" json:"subject,omitempty"`
AttestationType string `protobuf:"bytes,2,opt,name=attestation_type,json=attestationType,proto3" json:"attestation_type,omitempty"`
@@ -103,7 +42,7 @@ func (m *Credential) Reset() { *m = Credential{} }
func (m *Credential) String() string { return proto.CompactTextString(m) }
func (*Credential) ProtoMessage() {}
func (*Credential) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{1}
return fileDescriptor_739bb5ab5cb60751, []int{0}
}
func (m *Credential) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -231,7 +170,7 @@ func (m *Document) Reset() { *m = Document{} }
func (m *Document) String() string { return proto.CompactTextString(m) }
func (*Document) ProtoMessage() {}
func (*Document) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{2}
return fileDescriptor_739bb5ab5cb60751, []int{1}
}
func (m *Document) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -323,7 +262,7 @@ func (m *Keyshare) Reset() { *m = Keyshare{} }
func (m *Keyshare) String() string { return proto.CompactTextString(m) }
func (*Keyshare) ProtoMessage() {}
func (*Keyshare) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{3}
return fileDescriptor_739bb5ab5cb60751, []int{2}
}
func (m *Keyshare) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -405,7 +344,7 @@ func (m *Permissions) Reset() { *m = Permissions{} }
func (m *Permissions) String() string { return proto.CompactTextString(m) }
func (*Permissions) ProtoMessage() {}
func (*Permissions) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{4}
return fileDescriptor_739bb5ab5cb60751, []int{3}
}
func (m *Permissions) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -463,7 +402,7 @@ func (m *PubKey) Reset() { *m = PubKey{} }
func (m *PubKey) String() string { return proto.CompactTextString(m) }
func (*PubKey) ProtoMessage() {}
func (*PubKey) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{5}
return fileDescriptor_739bb5ab5cb60751, []int{4}
}
func (m *PubKey) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -555,7 +494,7 @@ func (m *PubKey_JWK) Reset() { *m = PubKey_JWK{} }
func (m *PubKey_JWK) String() string { return proto.CompactTextString(m) }
func (*PubKey_JWK) ProtoMessage() {}
func (*PubKey_JWK) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{5, 0}
return fileDescriptor_739bb5ab5cb60751, []int{4, 0}
}
func (m *PubKey_JWK) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -641,7 +580,7 @@ func (m *Service) Reset() { *m = Service{} }
func (m *Service) String() string { return proto.CompactTextString(m) }
func (*Service) ProtoMessage() {}
func (*Service) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{6}
return fileDescriptor_739bb5ab5cb60751, []int{5}
}
func (m *Service) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -731,7 +670,7 @@ func (m *ServiceInfo) Reset() { *m = ServiceInfo{} }
func (m *ServiceInfo) String() string { return proto.CompactTextString(m) }
func (*ServiceInfo) ProtoMessage() {}
func (*ServiceInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{7}
return fileDescriptor_739bb5ab5cb60751, []int{6}
}
func (m *ServiceInfo) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -800,7 +739,7 @@ func (m *FirstPartyCaveat) Reset() { *m = FirstPartyCaveat{} }
func (m *FirstPartyCaveat) String() string { return proto.CompactTextString(m) }
func (*FirstPartyCaveat) ProtoMessage() {}
func (*FirstPartyCaveat) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{8}
return fileDescriptor_739bb5ab5cb60751, []int{7}
}
func (m *FirstPartyCaveat) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -869,7 +808,7 @@ func (m *ThirdPartyCaveat) Reset() { *m = ThirdPartyCaveat{} }
func (m *ThirdPartyCaveat) String() string { return proto.CompactTextString(m) }
func (*ThirdPartyCaveat) ProtoMessage() {}
func (*ThirdPartyCaveat) Descriptor() ([]byte, []int) {
return fileDescriptor_739bb5ab5cb60751, []int{9}
return fileDescriptor_739bb5ab5cb60751, []int{8}
}
func (m *ThirdPartyCaveat) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -927,7 +866,6 @@ func (m *ThirdPartyCaveat) GetAud() string {
}
func init() {
proto.RegisterType((*Alias)(nil), "did.v1.Alias")
proto.RegisterType((*Credential)(nil), "did.v1.Credential")
proto.RegisterType((*Document)(nil), "did.v1.Document")
proto.RegisterType((*Keyshare)(nil), "did.v1.Keyshare")
@@ -946,123 +884,78 @@ func init() {
func init() { proto.RegisterFile("did/v1/models.proto", fileDescriptor_739bb5ab5cb60751) }
var fileDescriptor_739bb5ab5cb60751 = []byte{
// 1146 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0xcf, 0x6e, 0xdb, 0xc6,
0x13, 0x0e, 0x45, 0x4b, 0x96, 0x46, 0x8a, 0xec, 0xdf, 0xc6, 0xf9, 0x95, 0x30, 0x52, 0x41, 0x51,
0xda, 0x54, 0x29, 0x0a, 0x09, 0x51, 0x50, 0xa0, 0x48, 0x7b, 0x49, 0x6d, 0x17, 0x70, 0x8c, 0x14,
0x06, 0x13, 0x34, 0x68, 0x2f, 0xc2, 0x8a, 0x1c, 0xcb, 0x1b, 0x53, 0x5c, 0x62, 0x77, 0xa9, 0x98,
0xc7, 0x5e, 0x7b, 0x6a, 0x9f, 0xa1, 0x2f, 0xd3, 0x63, 0x8e, 0x3d, 0x16, 0x49, 0xfb, 0x1e, 0xc5,
0xfe, 0xa1, 0x44, 0x2b, 0x4d, 0x8b, 0x5e, 0x7a, 0xb1, 0x77, 0xbe, 0xf9, 0x86, 0x33, 0xfc, 0x66,
0x66, 0x29, 0xb8, 0x11, 0xb3, 0x78, 0xbc, 0xbc, 0x3f, 0x5e, 0xf0, 0x18, 0x13, 0x39, 0xca, 0x04,
0x57, 0x9c, 0x34, 0x62, 0x16, 0x8f, 0x96, 0xf7, 0xf7, 0xf7, 0x9c, 0x73, 0x8e, 0x29, 0x4a, 0xe6,
0xbc, 0xfb, 0x7b, 0x73, 0x3e, 0xe7, 0xe6, 0x38, 0xd6, 0x27, 0x8b, 0x0e, 0xbe, 0x85, 0xfa, 0xa3,
0x84, 0x51, 0x49, 0x02, 0xd8, 0x96, 0xf9, 0xec, 0x05, 0x46, 0x2a, 0xf0, 0xfa, 0xde, 0xb0, 0x15,
0x96, 0x26, 0xf9, 0x3f, 0x34, 0xb8, 0x60, 0x73, 0x96, 0x06, 0x35, 0xe3, 0x70, 0x16, 0xe9, 0x01,
0x44, 0x3c, 0x55, 0x82, 0x27, 0x09, 0x8a, 0xc0, 0x37, 0xbe, 0x0a, 0x32, 0xf8, 0xd9, 0x07, 0x38,
0x10, 0x18, 0x63, 0xaa, 0x18, 0x4d, 0xfe, 0x26, 0xc1, 0x3d, 0xd8, 0xa5, 0x4a, 0xa1, 0x54, 0x54,
0x31, 0x9e, 0x4e, 0x55, 0x91, 0xa1, 0x4b, 0xb5, 0x53, 0xc1, 0x9f, 0x15, 0x19, 0x56, 0x6a, 0xf1,
0xaf, 0xd4, 0x72, 0x07, 0xae, 0x47, 0xab, 0x54, 0x53, 0x16, 0x07, 0x5b, 0x7d, 0x6f, 0xd8, 0x09,
0x3b, 0x6b, 0xf0, 0x38, 0x26, 0xef, 0x03, 0x64, 0xf9, 0x2c, 0x61, 0xd1, 0xf4, 0x02, 0x8b, 0xa0,
0x6e, 0x18, 0x2d, 0x8b, 0x9c, 0x60, 0x41, 0x6e, 0x41, 0x4b, 0x09, 0x9a, 0xca, 0x8c, 0x0b, 0x15,
0x34, 0xfa, 0xfe, 0xb0, 0x15, 0xae, 0x01, 0x1d, 0x2c, 0xd9, 0x3c, 0x9d, 0x46, 0x3c, 0x4f, 0x55,
0xb0, 0xdd, 0xf7, 0x86, 0xd7, 0xc3, 0x96, 0x46, 0x0e, 0x34, 0x40, 0x6e, 0x43, 0x27, 0x97, 0x28,
0xa6, 0x99, 0x40, 0x89, 0xa9, 0x0a, 0x9a, 0x7d, 0x6f, 0xd8, 0x0c, 0xdb, 0x1a, 0x3b, 0xb5, 0x90,
0xae, 0xd1, 0x50, 0x96, 0x28, 0xd8, 0x19, 0xc3, 0x38, 0x68, 0x19, 0x8e, 0x89, 0xfb, 0xc6, 0x61,
0xe4, 0x23, 0xd8, 0x99, 0xd1, 0xe8, 0x22, 0xcf, 0xa6, 0x98, 0xb0, 0x39, 0x9b, 0x25, 0x18, 0x80,
0xa1, 0x75, 0x2d, 0x7c, 0xe4, 0x50, 0x9d, 0xd0, 0x11, 0xb5, 0x3e, 0x18, 0xb4, 0x6d, 0x42, 0x8b,
0x3d, 0xd5, 0x90, 0x11, 0x25, 0xe1, 0x29, 0x4e, 0x5f, 0x52, 0x91, 0xb2, 0x74, 0x1e, 0x74, 0x6c,
0x42, 0x03, 0x3e, 0xb7, 0xd8, 0xe0, 0xa7, 0x1a, 0x34, 0x0f, 0x79, 0x94, 0x2f, 0x74, 0x89, 0x5d,
0xa8, 0xb1, 0xd8, 0xb5, 0xa7, 0xc6, 0xe2, 0x8d, 0x16, 0xd7, 0x36, 0x5b, 0x4c, 0xee, 0x42, 0x97,
0xe6, 0xea, 0x5c, 0x2b, 0x1c, 0x99, 0x26, 0x05, 0xbe, 0xd1, 0x6d, 0x03, 0x35, 0x1d, 0x96, 0x12,
0x85, 0xe9, 0xef, 0x02, 0xd5, 0x39, 0xd7, 0x1d, 0xf2, 0x4d, 0x87, 0x4b, 0xfc, 0x89, 0x81, 0xc9,
0x03, 0xb8, 0x19, 0xd1, 0x8c, 0xce, 0x58, 0xc2, 0x54, 0x31, 0x8d, 0x31, 0xc1, 0xb9, 0x7d, 0x72,
0xdd, 0xf0, 0xf7, 0xd6, 0xce, 0xc3, 0x95, 0x6f, 0x23, 0x88, 0xa5, 0x4b, 0xee, 0xca, 0x69, 0x6c,
0x06, 0x1d, 0xaf, 0x7c, 0x66, 0x20, 0x51, 0x2c, 0x59, 0x84, 0xc1, 0xb6, 0xa1, 0x95, 0xe6, 0xe0,
0x8f, 0x1a, 0x34, 0x4f, 0xb0, 0x90, 0xe7, 0x54, 0x20, 0x79, 0x08, 0xcd, 0x05, 0x2a, 0x1a, 0x53,
0x45, 0x03, 0xaf, 0xef, 0x0f, 0xdb, 0x93, 0xde, 0xc8, 0x2e, 0xda, 0xa8, 0xe4, 0x8c, 0x9e, 0x38,
0xc2, 0x51, 0xaa, 0x44, 0x11, 0xae, 0xf8, 0x3a, 0x36, 0xa3, 0x45, 0xc2, 0x69, 0x2c, 0x83, 0xda,
0x3b, 0x62, 0x4f, 0x1d, 0xc1, 0xc5, 0x96, 0x7c, 0xb2, 0x0f, 0x4d, 0xb3, 0xa2, 0x11, 0x4f, 0xdc,
0xb0, 0xaf, 0xec, 0x8d, 0x49, 0xde, 0xda, 0x9c, 0xe4, 0x00, 0xb6, 0x97, 0x28, 0xa4, 0x55, 0x4d,
0x0f, 0x6a, 0x69, 0x12, 0x02, 0x5b, 0x82, 0x27, 0x18, 0x34, 0xfa, 0xde, 0xb0, 0x1e, 0x9a, 0xf3,
0xfe, 0xe7, 0x70, 0xfd, 0x4a, 0xfd, 0x64, 0x17, 0x7c, 0xfd, 0x58, 0x3b, 0x06, 0xfa, 0x48, 0xf6,
0xa0, 0xbe, 0xa4, 0x49, 0x5e, 0xae, 0xa5, 0x35, 0x1e, 0xd6, 0x3e, 0xf3, 0x74, 0xf0, 0x95, 0x17,
0xf8, 0xa7, 0xe0, 0x4e, 0x25, 0x78, 0x90, 0x40, 0xfb, 0x14, 0xc5, 0x82, 0x49, 0x5d, 0x9b, 0x24,
0x9f, 0x40, 0x63, 0x2e, 0x68, 0xaa, 0xa4, 0xd1, 0xb9, 0x3b, 0xd9, 0x2b, 0xb5, 0x3a, 0x3c, 0x3e,
0xfc, 0x9a, 0x2e, 0x50, 0x66, 0x34, 0xc2, 0xd0, 0x71, 0xc8, 0x18, 0x1a, 0x32, 0xe2, 0x19, 0x5a,
0x65, 0xbb, 0x93, 0xf7, 0x4a, 0xf6, 0xfa, 0x91, 0x4f, 0xb5, 0x3f, 0x74, 0xb4, 0xc1, 0xf7, 0x3e,
0x34, 0x4e, 0xf3, 0x99, 0x16, 0xe8, 0x8e, 0x93, 0x41, 0x57, 0xd9, 0x9d, 0xec, 0x54, 0x7a, 0x12,
0xf2, 0x04, 0xad, 0x2e, 0x64, 0x02, 0x2d, 0x9a, 0xcc, 0xb9, 0x60, 0xea, 0x7c, 0x61, 0x6a, 0xaf,
0x54, 0x74, 0x82, 0xc5, 0xa3, 0xd2, 0x17, 0xae, 0x69, 0x64, 0x0c, 0x4d, 0x4c, 0x23, 0x1e, 0xeb,
0x6d, 0xf3, 0x4d, 0xc8, 0x8d, 0x4a, 0xc8, 0x91, 0x73, 0x85, 0x2b, 0x12, 0xb9, 0x0b, 0xf5, 0x28,
0x17, 0x4b, 0x34, 0x4d, 0xec, 0x4e, 0x76, 0x2b, 0xec, 0x03, 0x8d, 0x87, 0xd6, 0x4d, 0x3e, 0x86,
0xe6, 0x05, 0x16, 0xf6, 0x6e, 0xac, 0xbf, 0x55, 0xb5, 0xbe, 0x1b, 0xc3, 0xed, 0x0b, 0x7b, 0xd0,
0x2d, 0x10, 0xf4, 0xa5, 0xe9, 0x71, 0x27, 0xd4, 0x47, 0xf2, 0x01, 0xf8, 0x2f, 0x5e, 0x5e, 0x98,
0x5b, 0xab, 0x3d, 0x21, 0x2b, 0xa1, 0x8c, 0x18, 0xa3, 0xc7, 0xcf, 0x4f, 0x42, 0xed, 0xde, 0xa7,
0xe0, 0x3f, 0x7e, 0x7e, 0x62, 0x3a, 0xa8, 0xd6, 0x1d, 0x54, 0xa6, 0xa7, 0x91, 0x58, 0xba, 0xe6,
0xeb, 0x23, 0xe9, 0x80, 0x77, 0xe9, 0xa6, 0xd2, 0xbb, 0xd4, 0x96, 0x9d, 0xc2, 0x56, 0xe8, 0x15,
0xda, 0xb2, 0x73, 0xd7, 0x0a, 0xbd, 0x54, 0x5b, 0x76, 0xdc, 0x5a, 0xa1, 0x87, 0x83, 0xdf, 0x6b,
0xb0, 0xfd, 0xd4, 0x6e, 0xd9, 0x5b, 0x97, 0xcd, 0x6d, 0xe8, 0xb8, 0x05, 0xac, 0x7e, 0x02, 0xda,
0x0e, 0x33, 0x6f, 0x76, 0x0b, 0x5a, 0xfa, 0x66, 0xd1, 0x62, 0x17, 0x2e, 0xfd, 0x1a, 0xa8, 0x7c,
0x1c, 0xb6, 0xae, 0x7c, 0x1c, 0xfa, 0xd0, 0x8e, 0x51, 0x46, 0x82, 0x65, 0xaa, 0x5c, 0x89, 0x56,
0x58, 0x85, 0x48, 0x08, 0xff, 0x2b, 0x53, 0x63, 0x1a, 0x67, 0x9c, 0xe9, 0x21, 0x6c, 0x98, 0x85,
0xfd, 0xb0, 0x54, 0xcb, 0x95, 0x5d, 0xfe, 0x3f, 0x2a, 0x79, 0x76, 0x6f, 0x77, 0xe5, 0x06, 0x4c,
0x3e, 0x85, 0x76, 0xb6, 0x1e, 0x6e, 0xa7, 0xfd, 0x8d, 0xb7, 0x87, 0x54, 0x86, 0x55, 0xde, 0xfe,
0x01, 0xdc, 0xfc, 0xcb, 0x0c, 0xff, 0x66, 0x2b, 0x07, 0x3f, 0x78, 0xd0, 0x76, 0x4f, 0x39, 0x4e,
0xcf, 0xb8, 0x56, 0x06, 0x2f, 0x99, 0x34, 0x9b, 0xa5, 0x3f, 0x01, 0xce, 0x7a, 0xe7, 0xa7, 0xbd,
0x0f, 0xed, 0x33, 0x96, 0xce, 0x51, 0x64, 0x82, 0xa5, 0xca, 0x29, 0x5d, 0x85, 0xc8, 0xbd, 0xf5,
0xe5, 0xb9, 0x65, 0xde, 0x6c, 0x67, 0x43, 0xa7, 0xf5, 0x6d, 0x2a, 0x61, 0xf7, 0x2b, 0x26, 0xa4,
0x3a, 0xa5, 0x42, 0x15, 0x07, 0x74, 0x89, 0x54, 0x87, 0xd7, 0xcd, 0x56, 0x9a, 0x7a, 0xde, 0x21,
0x8b, 0x65, 0xe8, 0xf7, 0xc6, 0xcb, 0xcc, 0x14, 0xe8, 0x87, 0xfa, 0x68, 0xc6, 0x31, 0x3d, 0x73,
0x55, 0xe9, 0xa3, 0x46, 0x68, 0x1e, 0xbb, 0xb6, 0xeb, 0xa3, 0x4e, 0xfa, 0xec, 0x9c, 0x89, 0xf8,
0xbf, 0x4c, 0xfa, 0xe5, 0x17, 0xbf, 0xbc, 0xee, 0x79, 0xaf, 0x5e, 0xf7, 0xbc, 0xdf, 0x5e, 0xf7,
0xbc, 0x1f, 0xdf, 0xf4, 0xae, 0xbd, 0x7a, 0xd3, 0xbb, 0xf6, 0xeb, 0x9b, 0xde, 0xb5, 0xef, 0x06,
0x73, 0xa6, 0xce, 0xf3, 0xd9, 0x28, 0xe2, 0x8b, 0x31, 0x4f, 0x25, 0x4f, 0xc5, 0xd8, 0xfc, 0xb9,
0x1c, 0xeb, 0xdf, 0x6a, 0x7a, 0xdc, 0xe5, 0xac, 0x61, 0xae, 0xf7, 0x07, 0x7f, 0x06, 0x00, 0x00,
0xff, 0xff, 0x38, 0x84, 0xad, 0x32, 0xdc, 0x09, 0x00, 0x00,
}
func (m *Alias) 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 *Alias) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *Alias) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Controller) > 0 {
i -= len(m.Controller)
copy(dAtA[i:], m.Controller)
i = encodeVarintModels(dAtA, i, uint64(len(m.Controller)))
i--
dAtA[i] = 0x1a
}
if len(m.Origin) > 0 {
i -= len(m.Origin)
copy(dAtA[i:], m.Origin)
i = encodeVarintModels(dAtA, i, uint64(len(m.Origin)))
i--
dAtA[i] = 0x12
}
if len(m.Subject) > 0 {
i -= len(m.Subject)
copy(dAtA[i:], m.Subject)
i = encodeVarintModels(dAtA, i, uint64(len(m.Subject)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
// 1125 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x56, 0x4f, 0x6f, 0x1b, 0x45,
0x14, 0xef, 0x7a, 0x63, 0xc7, 0x3b, 0x76, 0x9d, 0x30, 0x4d, 0x61, 0x15, 0x15, 0xcb, 0x75, 0xa1,
0xb8, 0x08, 0xd9, 0xaa, 0x2b, 0x24, 0x54, 0xb8, 0x40, 0x12, 0xa4, 0x34, 0x2a, 0x8a, 0xb6, 0x15,
0x95, 0xb8, 0x58, 0xe3, 0xdd, 0x97, 0xf5, 0x34, 0xeb, 0x99, 0xd5, 0xcc, 0xac, 0x9b, 0x3d, 0x72,
0xe5, 0x04, 0x9f, 0x81, 0x2f, 0xc3, 0xb1, 0x47, 0x8e, 0xa8, 0x85, 0xef, 0x81, 0xe6, 0xcf, 0xda,
0x5b, 0x97, 0x0a, 0x71, 0xe1, 0x92, 0xbc, 0xf7, 0x7b, 0xbf, 0xb7, 0xf3, 0xf6, 0xf7, 0xde, 0x9b,
0x35, 0xba, 0x91, 0xd0, 0x64, 0xb2, 0xba, 0x3f, 0x59, 0xf2, 0x04, 0x32, 0x39, 0xce, 0x05, 0x57,
0x1c, 0xb7, 0x12, 0x9a, 0x8c, 0x57, 0xf7, 0x0f, 0x0f, 0x5c, 0x30, 0x05, 0x06, 0x92, 0xba, 0xe8,
0xe1, 0x41, 0xca, 0x53, 0x6e, 0xcc, 0x89, 0xb6, 0x2c, 0x3a, 0xfc, 0xd5, 0x47, 0xe8, 0x48, 0x40,
0x02, 0x4c, 0x51, 0x92, 0xe1, 0x10, 0xed, 0xca, 0x62, 0xfe, 0x1c, 0x62, 0x15, 0x7a, 0x03, 0x6f,
0x14, 0x44, 0x95, 0x8b, 0xef, 0xa1, 0x7d, 0xa2, 0x14, 0x48, 0x45, 0x14, 0xe5, 0x6c, 0xa6, 0xca,
0x1c, 0xc2, 0x86, 0xa1, 0xec, 0xd5, 0xf0, 0xa7, 0x65, 0x0e, 0xf8, 0x7d, 0xd4, 0xe2, 0x82, 0xa6,
0x94, 0x85, 0xbe, 0x21, 0x38, 0x0f, 0xdf, 0x41, 0xd7, 0xe3, 0xf5, 0x51, 0x33, 0x9a, 0x84, 0x3b,
0x03, 0x6f, 0xd4, 0x8d, 0xba, 0x1b, 0xf0, 0x34, 0xc1, 0x1f, 0x22, 0x94, 0x17, 0xf3, 0x8c, 0xc6,
0xb3, 0x4b, 0x28, 0xc3, 0xa6, 0x61, 0x04, 0x16, 0x39, 0x83, 0x12, 0xdf, 0x42, 0x81, 0x12, 0x84,
0xc9, 0x9c, 0x0b, 0x15, 0xb6, 0x06, 0xfe, 0x28, 0x88, 0x36, 0x80, 0x4e, 0x96, 0x34, 0x65, 0xb3,
0x98, 0x17, 0x4c, 0x85, 0xbb, 0x03, 0x6f, 0x74, 0x3d, 0x0a, 0x34, 0x72, 0xa4, 0x01, 0x7c, 0x1b,
0x75, 0x0b, 0x09, 0x62, 0x96, 0x0b, 0x90, 0xc0, 0x54, 0xd8, 0x1e, 0x78, 0xa3, 0x76, 0xd4, 0xd1,
0xd8, 0xb9, 0x85, 0x74, 0x8d, 0x86, 0xb2, 0x02, 0x41, 0x2f, 0x28, 0x24, 0x61, 0x60, 0x38, 0x26,
0xef, 0x7b, 0x87, 0xe1, 0x4f, 0xd0, 0xde, 0x9c, 0xc4, 0x97, 0x45, 0x3e, 0x83, 0x8c, 0xa6, 0x74,
0x9e, 0x41, 0x88, 0x0c, 0xad, 0x67, 0xe1, 0x13, 0x87, 0xea, 0x03, 0x1d, 0x51, 0xeb, 0x03, 0x61,
0xc7, 0x1e, 0x68, 0xb1, 0x27, 0x1a, 0x32, 0xa2, 0x64, 0x9c, 0xc1, 0xec, 0x05, 0x11, 0x8c, 0xb2,
0x34, 0xec, 0xda, 0x03, 0x0d, 0xf8, 0xcc, 0x62, 0xc3, 0x5f, 0x1a, 0xa8, 0x7d, 0xcc, 0xe3, 0x62,
0xa9, 0x4b, 0xec, 0xa1, 0x06, 0x4d, 0x5c, 0x7b, 0x1a, 0x34, 0xc1, 0x7d, 0x84, 0x62, 0xce, 0x94,
0xe0, 0x59, 0x06, 0xc2, 0xf5, 0xa4, 0x86, 0xe0, 0xbb, 0xa8, 0x47, 0x0a, 0xb5, 0xd0, 0x0a, 0xc7,
0xa6, 0x49, 0xa1, 0x6f, 0x74, 0xdb, 0x42, 0x4d, 0x87, 0xa5, 0x04, 0x61, 0xfa, 0xbb, 0x04, 0xb5,
0xe0, 0xba, 0x43, 0xbe, 0xe9, 0x70, 0x85, 0x3f, 0x36, 0x30, 0x7e, 0x80, 0x6e, 0xc6, 0x24, 0x27,
0x73, 0x9a, 0x51, 0x55, 0xce, 0x12, 0xc8, 0x20, 0xb5, 0x4f, 0x6e, 0x1a, 0xfe, 0xc1, 0x26, 0x78,
0xbc, 0x8e, 0x6d, 0x25, 0x51, 0xb6, 0xe2, 0xae, 0x9c, 0xd6, 0x76, 0xd2, 0xe9, 0x3a, 0x66, 0x06,
0x12, 0xc4, 0x8a, 0xc6, 0x10, 0xee, 0x1a, 0x5a, 0xe5, 0x0e, 0xff, 0x6a, 0xa0, 0xf6, 0x19, 0x94,
0x72, 0x41, 0x04, 0xe0, 0x87, 0xa8, 0xbd, 0x04, 0x45, 0x12, 0xa2, 0x48, 0xe8, 0x0d, 0xfc, 0x51,
0x67, 0xda, 0x1f, 0xdb, 0x6d, 0x18, 0x57, 0x9c, 0xf1, 0x63, 0x47, 0x38, 0x61, 0x4a, 0x94, 0xd1,
0x9a, 0xaf, 0x73, 0x73, 0x52, 0x66, 0x9c, 0x24, 0x32, 0x6c, 0xbc, 0x23, 0xf7, 0xdc, 0x11, 0x5c,
0x6e, 0xc5, 0xc7, 0x87, 0xa8, 0x6d, 0xf6, 0x28, 0xe6, 0x99, 0x1b, 0xf6, 0xb5, 0xbf, 0x35, 0xc9,
0x3b, 0xdb, 0x93, 0x1c, 0xa2, 0xdd, 0x15, 0x08, 0x69, 0x55, 0xd3, 0x83, 0x5a, 0xb9, 0x18, 0xa3,
0x1d, 0xc1, 0x33, 0x08, 0x5b, 0x03, 0x6f, 0xd4, 0x8c, 0x8c, 0x7d, 0xf8, 0x25, 0xba, 0xfe, 0x46,
0xfd, 0x78, 0x1f, 0xf9, 0xfa, 0xb1, 0x76, 0x0c, 0xb4, 0x89, 0x0f, 0x50, 0x73, 0x45, 0xb2, 0xa2,
0x5a, 0x4b, 0xeb, 0x3c, 0x6c, 0x7c, 0xe1, 0xe9, 0xe4, 0x37, 0x5e, 0xe0, 0xdf, 0x92, 0xbb, 0xb5,
0xe4, 0x61, 0x86, 0x3a, 0xe7, 0x20, 0x96, 0x54, 0xea, 0xda, 0x24, 0xfe, 0x0c, 0xb5, 0x52, 0x41,
0x98, 0x92, 0x46, 0xe7, 0xde, 0xf4, 0xa0, 0xd2, 0xea, 0xf8, 0xf4, 0xf8, 0x3b, 0xb2, 0x04, 0x99,
0x93, 0x18, 0x22, 0xc7, 0xc1, 0x13, 0xd4, 0x92, 0x31, 0xcf, 0xc1, 0x2a, 0xdb, 0x9b, 0x7e, 0x50,
0xb1, 0x37, 0x8f, 0x7c, 0xa2, 0xe3, 0x91, 0xa3, 0x0d, 0x7f, 0xf4, 0x51, 0xeb, 0xbc, 0x98, 0x6b,
0x81, 0xee, 0x38, 0x19, 0x74, 0x95, 0xbd, 0xe9, 0x5e, 0xad, 0x27, 0x11, 0xcf, 0xc0, 0xea, 0x82,
0xa7, 0x28, 0x20, 0x59, 0xca, 0x05, 0x55, 0x8b, 0xa5, 0xa9, 0xbd, 0x56, 0xd1, 0x19, 0x94, 0x5f,
0x57, 0xb1, 0x68, 0x43, 0xc3, 0x13, 0xd4, 0x06, 0x16, 0xf3, 0x44, 0x6f, 0x9b, 0x6f, 0x52, 0x6e,
0xd4, 0x52, 0x4e, 0x5c, 0x28, 0x5a, 0x93, 0xf0, 0x5d, 0xd4, 0x8c, 0x0b, 0xb1, 0x02, 0xd3, 0xc4,
0xde, 0x74, 0xbf, 0xc6, 0x3e, 0xd2, 0x78, 0x64, 0xc3, 0xf8, 0x53, 0xd4, 0xbe, 0x84, 0xd2, 0xde,
0x8d, 0xcd, 0xb7, 0xaa, 0xd6, 0x77, 0x63, 0xb4, 0x7b, 0x69, 0x0d, 0xdd, 0x02, 0x41, 0x5e, 0x98,
0x1e, 0x77, 0x23, 0x6d, 0xe2, 0x8f, 0x90, 0xff, 0xfc, 0xc5, 0xa5, 0xb9, 0xb5, 0x3a, 0x53, 0xbc,
0x16, 0xca, 0x88, 0x31, 0x7e, 0xf4, 0xec, 0x2c, 0xd2, 0xe1, 0x43, 0x82, 0xfc, 0x47, 0xcf, 0xce,
0x4c, 0x07, 0xd5, 0xa6, 0x83, 0xca, 0xf4, 0x34, 0x16, 0x2b, 0xd7, 0x7c, 0x6d, 0xe2, 0x2e, 0xf2,
0xae, 0xdc, 0x54, 0x7a, 0x57, 0xda, 0xb3, 0x53, 0x18, 0x44, 0x5e, 0xa9, 0x3d, 0x3b, 0x77, 0x41,
0xe4, 0x31, 0xed, 0xd9, 0x71, 0x0b, 0x22, 0x0f, 0x86, 0x7f, 0x36, 0xd0, 0xee, 0x13, 0xbb, 0x65,
0x6f, 0x5d, 0x36, 0xb7, 0x51, 0xd7, 0x2d, 0x60, 0xfd, 0x13, 0xd0, 0x71, 0x98, 0x79, 0xb3, 0x5b,
0x28, 0xd0, 0x37, 0x8b, 0x16, 0xbb, 0x74, 0xc7, 0x6f, 0x80, 0xda, 0xc7, 0x61, 0xe7, 0x8d, 0x8f,
0xc3, 0x00, 0x75, 0x12, 0x90, 0xb1, 0xa0, 0xb9, 0xaa, 0x56, 0x22, 0x88, 0xea, 0x10, 0x8e, 0xd0,
0x7b, 0xd5, 0xd1, 0xc0, 0x92, 0x9c, 0x53, 0x3d, 0x84, 0x2d, 0xb3, 0xb0, 0x1f, 0x57, 0x6a, 0xb9,
0xb2, 0xab, 0xff, 0x27, 0x15, 0xcf, 0xee, 0xed, 0xbe, 0xdc, 0x82, 0xf1, 0xe7, 0xa8, 0x93, 0x6f,
0x86, 0xdb, 0x69, 0x7f, 0xe3, 0xed, 0x21, 0x95, 0x51, 0x9d, 0x77, 0x78, 0x84, 0x6e, 0xfe, 0xe3,
0x09, 0xff, 0x65, 0x2b, 0x87, 0x3f, 0x79, 0xa8, 0xe3, 0x9e, 0x72, 0xca, 0x2e, 0xb8, 0x56, 0x06,
0xae, 0xa8, 0x34, 0x9b, 0xa5, 0x3f, 0x01, 0xce, 0xab, 0x29, 0xd6, 0xd8, 0x56, 0xec, 0x82, 0xb2,
0x14, 0x44, 0x2e, 0x28, 0x53, 0x4e, 0xe9, 0x3a, 0x84, 0xef, 0x6d, 0x2e, 0xcf, 0x1d, 0xf3, 0x66,
0x7b, 0x5b, 0x3a, 0x6d, 0x6e, 0x53, 0x89, 0xf6, 0xbf, 0xa5, 0x42, 0xaa, 0x73, 0x22, 0x54, 0x79,
0x44, 0x56, 0x40, 0x74, 0x7a, 0xd3, 0x6c, 0xa5, 0xa9, 0xe7, 0x1d, 0xb2, 0x58, 0x86, 0x7e, 0x6f,
0xb8, 0xca, 0x4d, 0x81, 0x7e, 0xa4, 0x4d, 0x33, 0x8e, 0xec, 0xc2, 0x55, 0xa5, 0x4d, 0x8d, 0x90,
0x22, 0x71, 0x6d, 0xd7, 0xa6, 0x3e, 0xf4, 0xe9, 0x82, 0x8a, 0xe4, 0xff, 0x3c, 0xf4, 0x9b, 0xaf,
0x7e, 0x7b, 0xd5, 0xf7, 0x5e, 0xbe, 0xea, 0x7b, 0x7f, 0xbc, 0xea, 0x7b, 0x3f, 0xbf, 0xee, 0x5f,
0x7b, 0xf9, 0xba, 0x7f, 0xed, 0xf7, 0xd7, 0xfd, 0x6b, 0x3f, 0x0c, 0x53, 0xaa, 0x16, 0xc5, 0x7c,
0x1c, 0xf3, 0xe5, 0x84, 0x33, 0xc9, 0x99, 0x98, 0x98, 0x3f, 0x57, 0x13, 0xfd, 0x83, 0x4a, 0x8f,
0xbb, 0x9c, 0xb7, 0xcc, 0xf5, 0xfe, 0xe0, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xcf, 0x9b, 0xe9,
0xda, 0x81, 0x09, 0x00, 0x00,
}
func (m *Credential) Marshal() (dAtA []byte, err error) {
@@ -1814,27 +1707,6 @@ func encodeVarintModels(dAtA []byte, offset int, v uint64) int {
dAtA[offset] = uint8(v)
return base
}
func (m *Alias) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Subject)
if l > 0 {
n += 1 + l + sovModels(uint64(l))
}
l = len(m.Origin)
if l > 0 {
n += 1 + l + sovModels(uint64(l))
}
l = len(m.Controller)
if l > 0 {
n += 1 + l + sovModels(uint64(l))
}
return n
}
func (m *Credential) Size() (n int) {
if m == nil {
return 0
@@ -2185,152 +2057,6 @@ func sovModels(x uint64) (n int) {
func sozModels(x uint64) (n int) {
return sovModels(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Alias) 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 ErrIntOverflowModels
}
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: Alias: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: Alias: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Subject", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowModels
}
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 ErrInvalidLengthModels
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthModels
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Subject = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Origin", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowModels
}
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 ErrInvalidLengthModels
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthModels
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Origin = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Controller", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowModels
}
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 ErrInvalidLengthModels
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthModels
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Controller = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipModels(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthModels
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *Credential) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
x/did/types/state.pb.go
+222 -1204
View File
File diff suppressed because it is too large Load Diff
x/did/types/zkprop.go
-155
View File
@@ -1,155 +0,0 @@
package types
import (
"fmt"
"github.com/onsonr/crypto/accumulator"
"github.com/onsonr/crypto/core/curves"
)
// Accumulator is the accumulator for the ZKP
type Accumulator []byte
// Element is the element for the BLS scheme
type Element = accumulator.Element
// Witness is the witness for the ZKP
type Witness []byte
// NewProof creates a new Proof which is used for ZKP
func NewProof(issuer, property string, pubKey []byte) (*Proof, error) {
input := append(pubKey, []byte(property)...)
hash := []byte(input)
curve := curves.BLS12381(&curves.PointBls12381G1{})
key, err := new(accumulator.SecretKey).New(curve, hash[:])
if err != nil {
return nil, fmt.Errorf("failed to create secret key: %w", err)
}
keyBytes, err := key.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("failed to marshal secret key: %w", err)
}
return &Proof{
Issuer: issuer,
Property: property,
Accumulator: keyBytes,
}, nil
}
// CreateAccumulator creates a new accumulator for a Proof
func CreateAccumulator(proof *Proof, values ...string) error {
curve := curves.BLS12381(&curves.PointBls12381G1{})
acc, err := new(accumulator.Accumulator).New(curve)
if err != nil {
return err
}
secretKey := new(accumulator.SecretKey)
if err := secretKey.UnmarshalBinary(proof.Accumulator); err != nil {
return err
}
fin, _, err := acc.Update(secretKey, ConvertValuesToZeroKnowledgeElements(values), nil)
if err != nil {
return err
}
accBytes, err := fin.MarshalBinary()
if err != nil {
return fmt.Errorf("failed to marshal accumulator: %w", err)
}
proof.Accumulator = accBytes
return nil
}
// CreateWitness creates a witness for the accumulator in a Proof for a given value
func CreateWitness(proof *Proof, value string) ([]byte, error) {
curve := curves.BLS12381(&curves.PointBls12381G1{})
element := curve.Scalar.Hash([]byte(value))
secretKey := new(accumulator.SecretKey)
if err := secretKey.UnmarshalBinary(proof.Accumulator); err != nil {
return nil, err
}
accObj := new(accumulator.Accumulator)
if err := accObj.UnmarshalBinary(proof.Accumulator); err != nil {
return nil, fmt.Errorf("failed to unmarshal accumulator: %w", err)
}
mw, err := new(accumulator.MembershipWitness).New(element, accObj, secretKey)
if err != nil {
return nil, err
}
witnessBytes, err := mw.MarshalBinary()
if err != nil {
return nil, fmt.Errorf("failed to marshal witness: %w", err)
}
return witnessBytes, nil
}
// VerifyWitness proves that a value is a member of the accumulator
func VerifyWitness(proof *Proof, acc Accumulator, witness Witness) error {
secretKey := new(accumulator.SecretKey)
if err := secretKey.UnmarshalBinary([]byte(proof.Id)); err != nil {
return err
}
curve := curves.BLS12381(&curves.PointBls12381G1{})
publicKey, err := secretKey.GetPublicKey(curve)
if err != nil {
return err
}
accObj := new(accumulator.Accumulator)
if err := accObj.UnmarshalBinary(proof.Accumulator); err != nil {
return fmt.Errorf("failed to unmarshal accumulator: %w", err)
}
witnessObj := new(accumulator.MembershipWitness)
if err := witnessObj.UnmarshalBinary(witness); err != nil {
return fmt.Errorf("failed to unmarshal witness: %w", err)
}
return witnessObj.Verify(publicKey, accObj)
}
// UpdateAccumulator updates the accumulator in a Proof with new values
func UpdateAccumulator(proof *Proof, addValues []string, removeValues []string) error {
secretKey := new(accumulator.SecretKey)
if err := secretKey.UnmarshalBinary(proof.Accumulator); err != nil {
return err
}
accObj := new(accumulator.Accumulator)
if err := accObj.UnmarshalBinary(proof.Accumulator); err != nil {
return fmt.Errorf("failed to unmarshal accumulator: %w", err)
}
updatedAcc, _, err := accObj.Update(secretKey, ConvertValuesToZeroKnowledgeElements(addValues), ConvertValuesToZeroKnowledgeElements(removeValues))
if err != nil {
return err
}
updatedAccBytes, err := updatedAcc.MarshalBinary()
if err != nil {
return fmt.Errorf("failed to marshal updated accumulator: %w", err)
}
proof.Accumulator = updatedAccBytes
return nil
}
// ConvertValuesToZeroKnowledgeElements converts a slice of strings to a slice of accumulator elements
func ConvertValuesToZeroKnowledgeElements(values []string) []Element {
curve := curves.BLS12381(&curves.PointBls12381G1{})
elements := make([]accumulator.Element, len(values))
for i, value := range values {
elements[i] = curve.Scalar.Hash([]byte(value))
}
return elements
}