feature/implement did state (#15)

* 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

proto/did/v1/models.proto

@@ -7,13 +7,6 @@ import "gogoproto/gogo.proto";
 
 option go_package = "github.com/onsonr/sonr/x/did/types";
 
-// Alias defines a subject/origin pair
-message Alias {
-  string subject = 1;
-  string origin = 2;
-  string controller = 3;
-}
-
 message Credential {
   string subject = 1;
   string attestation_type = 2;

proto/did/v1/query.proto

@@ -19,13 +19,6 @@ service Query {
     option (google.api.http).get = "/did/{did}";
   }
 
-  // Service returns associated ServiceInfo for a given Origin
-  // if the servie is not found, a fingerprint is generated to be used
-  // as a TXT record in DNS. v=sonr, o=origin, p=protocol
-  rpc Service(QueryRequest) returns (QueryServiceResponse) {
-    option (google.api.http).get = "/service/{origin}";
-  }
-
   // Sync queries the DID document by its id. And returns the required PKL information
   rpc Sync(SyncRequest) returns (SyncResponse) {
     option (google.api.http).post = "/sync";
@@ -54,20 +47,6 @@ message QueryParamsResponse {
   Params params = 1;
 }
 
-// QueryResolveResponse is the response type for the Query/Resolve RPC method.
-message QueryResolveResponse {
-  // document is the DID document
-  Document document = 1;
-}
-
-// QueryLoginOptionsResponse is the response type for the Query/LoginOptions RPC method.
-message QueryServiceResponse {
-  // options is the PublicKeyCredentialAttestationOptions
-  bool existing = 1;
-  ServiceInfo service = 2;
-  string txt_record = 3;
-}
-
 // SyncRequest is the request type for the Sync RPC method.
 message SyncRequest {
   string did = 1;

proto/did/v1/state.proto

@@ -8,29 +8,14 @@ import "did/v1/models.proto";
 
 option go_package = "github.com/onsonr/sonr/x/did/types";
 
-// Account represents a wallet account associated with a DID Controller
+// Alias represents a DID alias
-message Account {
+message Alias {
   option (cosmos.orm.v1.table) = {
     id: 1
     primary_key: {fields: "id"}
     index: {
       id: 1
-      fields: "controller,label"
+      fields: "did,alias"
-      unique: true
-    }
-    index: {
-      id: 2
-      fields: "controller,address"
-      unique: true
-    }
-    index: {
-      id: 3
-      fields: "controller,chain_code,index"
-      unique: true
-    }
-    index: {
-      id: 4
-      fields: "namespace,address"
       unique: true
     }
   };
@@ -38,20 +23,20 @@ message Account {
   // The unique identifier of the alias
   string id = 1;
 
-  // Origin is the  Alias provider
+  // The DID of the alias
-  string address = 2;
+  string did = 2;
 
-  // Subject is the user defined alias
+  // The alias of the DID
-  string label = 3;
+  string alias = 3;
 
-  // Controller of the alias
+  // Origin of the alias
-  string controller = 4;
+  string origin = 4;
 
-  string namespace = 5;
+  // Permissions of the alias
+  repeated string scopes = 5;
 
-  uint32 chain_code = 6;
+  // Expiration of the alias
-
+  int64 expiration = 6;
-  uint32 index = 7;
 }
 
 // Controller represents a Sonr DWN Vault
@@ -69,6 +54,11 @@ message Controller {
       fields: "vault_cid"
       unique: true
     }
+    index: {
+      id: 3
+      fields: "status,vault_cid"
+      unique: true
+    }
   };
 
   // The unique identifier of the controller
@@ -88,80 +78,13 @@ message Controller {
 
   // The Authentications of the controller
   repeated Credential authentication = 6;
-}
 
-// Proof represents a verifiable credential
+  // The Status of the claims for the controller
-message Proof {
+  string status = 7;
-  option (cosmos.orm.v1.table) = {
-    id: 4
-    primary_key: {fields: "id"}
-    index: {
-      id: 1
-      fields: "controller,issuer,property"
-      unique: true
-    }
-  };
-
-  // The unique identifier of the proof
-  string id = 1;
-
-  // The controller of the proof
-  string controller = 2;
-
-  // The value of the linked identifier
-  string issuer = 3;
-
-  // The property of the proof
-  string property = 4;
-
-  // The accumulator of the proof
-  bytes accumulator = 5;
-
-  // The secret key of the proof
-  bytes key = 6;
-}
-
-// ServiceRecord represents a decentralized service in a DID Document
-message ServiceRecord {
-  option (cosmos.orm.v1.table) = {
-    id: 3
-    primary_key: {fields: "id"}
-    index: {
-      id: 1
-      fields: "origin"
-      unique: true
-    }
-    index: {
-      id: 2
-      fields: "authority,origin"
-      unique: true
-    }
-  };
-
-  // The ID of the service
-  string id = 1;
-
-  // The type of the service
-  string service_type = 2;
-
-  // The authority DID of the service
-  string authority = 3;
-
-  // The domain name of the service
-  string origin = 4;
-
-  // The description of the service
-  string description = 5;
-
-  // The service endpoint
-  map<string, string> service_endpoints = 6;
-
-  // Scopes is the Authorization Grants of the service
-  Permissions permissions = 7;
 }
 
 // Verification reprsents a method of verifying membership in a DID
-message VerificationMethod {
+message Verification {
   option (cosmos.orm.v1.table) = {
     id: 5
     primary_key: {fields: "id"}
@@ -189,5 +112,7 @@ message VerificationMethod {
 
   // The public key of the verification
   PubKey public_key = 6;
-  // The controller DID of the service
+
+  // The Verification Kind (Authentication, Assertion, CapabilityDelegation, CapabilityInvocation)
+  string kind = 7;
 }

x/did/builder/api.go

@@ -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

@@ -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 {
+func CreateAuthnVerification(namespace types.DIDNamespace, issuer string, controller string, pubkey *types.PubKey, identifier string) *types.Verification {
-	return &types.VerificationMethod{
+	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 {
+func CreateWalletVerification(namespace types.DIDNamespace, controller string, pubkey *types.PubKey, identifier string) *didv1.Verification {
-	return &didv1.VerificationMethod{
+	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) {
+func NewInitialWalletAccounts(controller string, pubkey *types.PubKey) ([]*didv1.Verification, error) {
-	var verificationMethods []*didv1.VerificationMethod
+	var verificationMethods []*didv1.Verification
 	for method, chain := range types.InitialChainCodes {
 		nk, err := computeBip32AccountPublicKey(pubkey, chain, 0)
 		if err != nil {

x/did/keeper/context.go

@@ -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

@@ -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

@@ -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

@@ -39,8 +39,8 @@ func (k Querier) Service(
 	goCtx context.Context,
 	req *types.QueryRequest,
 ) (*types.QueryServiceResponse, error) {
-	ctx := k.CurrentCtx(goCtx)
+	// ctx := k.CurrentCtx(goCtx)
-	return &types.QueryServiceResponse{Service: ctx.GetServiceInfo(req.GetOrigin())}, nil
+	return &types.QueryServiceResponse{}, nil
 }
 
 // Sync implements types.QueryServer.

x/did/keeper/server.go

@@ -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) {
+	// if ms.k.IsValidServiceOrigin(ctx, msg.Origin) {
-		return nil, types.ErrInvalidServiceOrigin
+	// 	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) {
+	// if !ms.k.IsValidServiceOrigin(ctx, msg.Service.Origin) {
-		return nil, types.ErrInvalidServiceOrigin
+	// 	return nil, types.ErrInvalidServiceOrigin
-	}
+	// }
-	return ms.k.insertService(ctx, msg.Service)
+	return nil, errors.Wrapf(types.ErrInvalidServiceOrigin, "invalid service origin")
 }
 
 // # UpdateParams

x/did/keeper/state.go

@@ -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

@@ -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

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

@@ -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
-}