go/sonr
1
0
Fork 0
mirror of https://github.com/sonr-io/sonr.git synced 2026-08-04 10:21:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: add vault module

Browse Source
This commit is contained in:
Prad Nukala
2024-09-25 19:49:16 -04:00
parent 94f1a7e581
commit 607af1e76d
354 changed files with 22222 additions and 20921 deletions
Download Patch File Download Diff File Expand all files Collapse all files
x/did/builder/api.go
-251
View File
@@ -1,251 +0,0 @@
package builder
import (
"encoding/base64"
"fmt"
"github.com/go-webauthn/webauthn/protocol"
"github.com/go-webauthn/webauthn/protocol/webauthncose"
didv1 "github.com/onsonr/sonr/api/did/v1"
"github.com/onsonr/sonr/x/did/types"
)
func APIFormatDIDNamespace(namespace types.DIDNamespace) didv1.DIDNamespace {
return didv1.DIDNamespace(namespace)
}
func APIFormatDIDNamespaces(namespaces []types.DIDNamespace) []didv1.DIDNamespace {
var s []didv1.DIDNamespace
for _, namespace := range namespaces {
s = append(s, APIFormatDIDNamespace(namespace))
}
return s
}
func APIFormatKeyRole(role types.KeyRole) didv1.KeyRole {
return didv1.KeyRole(role)
}
func APIFormatKeyAlgorithm(algorithm types.KeyAlgorithm) didv1.KeyAlgorithm {
return didv1.KeyAlgorithm(algorithm)
}
func APIFormatKeyEncoding(encoding types.KeyEncoding) didv1.KeyEncoding {
return didv1.KeyEncoding(encoding)
}
func APIFormatKeyCurve(curve types.KeyCurve) didv1.KeyCurve {
return didv1.KeyCurve(curve)
}
func APIFormatKeyType(keyType types.KeyType) didv1.KeyType {
return didv1.KeyType(keyType)
}
func APIFormatPermissions(permissions *types.Permissions) *didv1.Permissions {
if permissions == nil {
return nil
}
p := didv1.Permissions{
Grants: APIFormatDIDNamespaces(permissions.Grants),
Scopes: APIFormatPermissionScopes(permissions.Scopes),
}
return &p
}
func APIFormatPermissionScope(scope types.PermissionScope) didv1.PermissionScope {
return didv1.PermissionScope(scope)
}
func APIFormatPermissionScopes(scopes []types.PermissionScope) []didv1.PermissionScope {
var s []didv1.PermissionScope
for _, scope := range scopes {
s = append(s, APIFormatPermissionScope(scope))
}
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,
Crv: jwk.Crv,
X: jwk.X,
Y: jwk.Y,
N: jwk.N,
E: jwk.E,
}
}
func APIFormatPubKey(key *types.PubKey) *didv1.PubKey {
return &didv1.PubKey{
Role: APIFormatKeyRole(key.GetRole()),
Algorithm: APIFormatKeyAlgorithm(key.GetAlgorithm()),
Encoding: APIFormatKeyEncoding(key.GetEncoding()),
Curve: APIFormatKeyCurve(key.GetCurve()),
KeyType: APIFormatKeyType(key.GetKeyType()),
Raw: key.GetRaw(),
}
}
func FormatEC2PublicKey(key *webauthncose.EC2PublicKeyData) (*types.PubKey_JWK, error) {
curve, err := GetCOSECurveName(key.Curve)
if err != nil {
return nil, err
}
jwkMap := map[string]interface{}{
"kty": "EC",
"crv": curve,
"x": base64.RawURLEncoding.EncodeToString(key.XCoord),
"y": base64.RawURLEncoding.EncodeToString(key.YCoord),
}
return MapToJWK(jwkMap)
}
func FormatRSAPublicKey(key *webauthncose.RSAPublicKeyData) (*types.PubKey_JWK, error) {
jwkMap := map[string]interface{}{
"kty": "RSA",
"n": base64.RawURLEncoding.EncodeToString(key.Modulus),
"e": base64.RawURLEncoding.EncodeToString(key.Exponent),
}
return MapToJWK(jwkMap)
}
func FormatOKPPublicKey(key *webauthncose.OKPPublicKeyData) (*types.PubKey_JWK, error) {
curve, err := GetOKPCurveName(key.Curve)
if err != nil {
return nil, err
}
jwkMap := map[string]interface{}{
"kty": "OKP",
"crv": curve,
"x": base64.RawURLEncoding.EncodeToString(key.XCoord),
}
return MapToJWK(jwkMap)
}
func MapToJWK(m map[string]interface{}) (*types.PubKey_JWK, error) {
jwk := &types.PubKey_JWK{}
for k, v := range m {
switch k {
case "kty":
jwk.Kty = v.(string)
case "crv":
jwk.Crv = v.(string)
case "x":
jwk.X = v.(string)
case "y":
jwk.Y = v.(string)
case "n":
jwk.N = v.(string)
case "e":
jwk.E = v.(string)
}
}
return jwk, nil
}
func GetCOSECurveName(curveID int64) (string, error) {
switch curveID {
case int64(webauthncose.P256):
return "P-256", nil
case int64(webauthncose.P384):
return "P-384", nil
case int64(webauthncose.P521):
return "P-521", nil
default:
return "", fmt.Errorf("unknown curve ID: %d", curveID)
}
}
func GetOKPCurveName(curveID int64) (string, error) {
switch curveID {
case int64(webauthncose.Ed25519):
return "Ed25519", nil
default:
return "", fmt.Errorf("unknown OKP curve ID: %d", curveID)
}
}
// NormalizeTransports returns the transports as strings
func NormalizeTransports(transports []protocol.AuthenticatorTransport) []string {
tss := make([]string, len(transports))
for i, t := range transports {
tss[i] = string(t)
}
return tss
}
// GetTransports returns the protocol.AuthenticatorTransport
func ModuleTransportsToProtocol(transport []string) []protocol.AuthenticatorTransport {
tss := make([]protocol.AuthenticatorTransport, len(transport))
for i, t := range transport {
tss[i] = protocol.AuthenticatorTransport(t)
}
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
}
p := types.Permissions{
Grants: ModuleFormatAPIDIDNamespaces(permissions.Grants),
Scopes: ModuleFormatAPIPermissionScopes(permissions.Scopes),
}
return &p
}
func ModuleFormatAPIPermissionScope(scope didv1.PermissionScope) types.PermissionScope {
return types.PermissionScope(scope)
}
func ModuleFormatAPIPermissionScopes(scopes []didv1.PermissionScope) []types.PermissionScope {
var s []types.PermissionScope
for _, scope := range scopes {
s = append(s, ModuleFormatAPIPermissionScope(scope))
}
return s
}
func ModuleFormatAPIDIDNamespace(namespace didv1.DIDNamespace) types.DIDNamespace {
return types.DIDNamespace(namespace)
}
func ModuleFormatAPIDIDNamespaces(namespaces []didv1.DIDNamespace) []types.DIDNamespace {
var s []types.DIDNamespace
for _, namespace := range namespaces {
s = append(s, ModuleFormatAPIDIDNamespace(namespace))
}
return s
}
x/did/builder/chains.go
-70
View File
@@ -1,70 +0,0 @@
package builder
import (
"crypto/hmac"
"crypto/sha512"
"encoding/binary"
"errors"
"math/big"
"github.com/btcsuite/btcd/btcec/v2"
"github.com/onsonr/sonr/x/did/types"
)
// ComputeAccountPublicKey computes the public key of a child key given the extended public key, chain code, and index.
func computeBip32AccountPublicKey(extPubKey PublicKey, chainCode types.ChainCode, index int) (*types.PubKey, error) {
// Check if the index is a hardened child key
if chainCode&0x80000000 != 0 && index < 0 {
return nil, errors.New("invalid index")
}
// Serialize the public key
pubKey, err := btcec.ParsePubKey(extPubKey.GetRaw())
if err != nil {
return nil, err
}
pubKeyBytes := pubKey.SerializeCompressed()
// Serialize the index
indexBytes := make([]byte, 4)
binary.BigEndian.PutUint32(indexBytes, uint32(index))
// Compute the HMAC-SHA512
mac := hmac.New(sha512.New, []byte{byte(chainCode)})
mac.Write(pubKeyBytes)
mac.Write(indexBytes)
I := mac.Sum(nil)
// Split I into two 32-byte sequences
IL := I[:32]
// Convert IL to a big integer
ilNum := new(big.Int).SetBytes(IL)
// Check if parse256(IL) >= n
curve := btcec.S256()
if ilNum.Cmp(curve.N) >= 0 {
return nil, errors.New("invalid child key")
}
// Compute the child public key
ilx, ily := curve.ScalarBaseMult(IL)
childX, childY := curve.Add(ilx, ily, pubKey.X(), pubKey.Y())
lx := newBigIntFieldVal(childX)
ly := newBigIntFieldVal(childY)
// Create the child public key
childPubKey := btcec.NewPublicKey(lx, ly)
pk, err := types.NewPublicKey(childPubKey.SerializeCompressed(), types.ChainCodeKeyInfos[chainCode])
if err != nil {
return nil, err
}
return pk, nil
}
// newBigIntFieldVal creates a new field value from a big integer.
func newBigIntFieldVal(val *big.Int) *btcec.FieldVal {
lx := new(btcec.FieldVal)
lx.SetByteSlice(val.Bytes())
return lx
}
x/did/builder/constants.go
-334
View File
@@ -1,334 +0,0 @@
package builder
import (
"github.com/onsonr/sonr/x/did/types"
)
type (
AuthenticatorAttachment string
AuthenticatorTransport string
)
const (
// Platform represents a platform authenticator is attached using a client device-specific transport, called
// platform attachment, and is usually not removable from the client device. A public key credential bound to a
// platform authenticator is called a platform credential.
Platform AuthenticatorAttachment = "platform"
// CrossPlatform represents a roaming authenticator is attached using cross-platform transports, called
// cross-platform attachment. Authenticators of this class are removable from, and can "roam" among, client devices.
// A public key credential bound to a roaming authenticator is called a roaming credential.
CrossPlatform AuthenticatorAttachment = "cross-platform"
)
func ParseAuthenticatorAttachment(s string) AuthenticatorAttachment {
switch s {
case "platform":
return Platform
default:
return CrossPlatform
}
}
const (
// USB indicates the respective authenticator can be contacted over removable USB.
USB AuthenticatorTransport = "usb"
// NFC indicates the respective authenticator can be contacted over Near Field Communication (NFC).
NFC AuthenticatorTransport = "nfc"
// BLE indicates the respective authenticator can be contacted over Bluetooth Smart (Bluetooth Low Energy / BLE).
BLE AuthenticatorTransport = "ble"
// SmartCard indicates the respective authenticator can be contacted over ISO/IEC 7816 smart card with contacts.
//
// WebAuthn Level 3.
SmartCard AuthenticatorTransport = "smart-card"
// Hybrid indicates the respective authenticator can be contacted using a combination of (often separate)
// data-transport and proximity mechanisms. This supports, for example, authentication on a desktop computer using
// a smartphone.
//
// WebAuthn Level 3.
Hybrid AuthenticatorTransport = "hybrid"
// Internal indicates the respective authenticator is contacted using a client device-specific transport, i.e., it
// is a platform authenticator. These authenticators are not removable from the client device.
Internal AuthenticatorTransport = "internal"
)
func ParseAuthenticatorTransport(s string) AuthenticatorTransport {
switch s {
case "usb":
return USB
case "nfc":
return NFC
case "ble":
return BLE
case "smart-card":
return SmartCard
case "hybrid":
return Hybrid
default:
return Internal
}
}
type AuthenticatorFlags byte
const (
// FlagUserPresent Bit 00000001 in the byte sequence. Tells us if user is present. Also referred to as the UP flag.
FlagUserPresent AuthenticatorFlags = 1 << iota // Referred to as UP
// FlagRFU1 is a reserved for future use flag.
FlagRFU1
// FlagUserVerified Bit 00000100 in the byte sequence. Tells us if user is verified
// by the authenticator using a biometric or PIN. Also referred to as the UV flag.
FlagUserVerified
// FlagBackupEligible Bit 00001000 in the byte sequence. Tells us if a backup is eligible for device. Also referred
// to as the BE flag.
FlagBackupEligible // Referred to as BE
// FlagBackupState Bit 00010000 in the byte sequence. Tells us if a backup state for device. Also referred to as the
// BS flag.
FlagBackupState
// FlagRFU2 is a reserved for future use flag.
FlagRFU2
// FlagAttestedCredentialData Bit 01000000 in the byte sequence. Indicates whether
// the authenticator added attested credential data. Also referred to as the AT flag.
FlagAttestedCredentialData
// FlagHasExtensions Bit 10000000 in the byte sequence. Indicates if the authenticator data has extensions. Also
// referred to as the ED flag.
FlagHasExtensions
)
type AttestationFormat string
const (
// AttestationFormatPacked is the "packed" attestation statement format is a WebAuthn-optimized format for
// attestation. It uses a very compact but still extensible encoding method. This format is implementable by
// authenticators with limited resources (e.g., secure elements).
AttestationFormatPacked AttestationFormat = "packed"
// AttestationFormatTPM is the TPM attestation statement format returns an attestation statement in the same format
// as the packed attestation statement format, although the rawData and signature fields are computed differently.
AttestationFormatTPM AttestationFormat = "tpm"
// AttestationFormatAndroidKey is the attestation statement format for platform authenticators on versions "N", and
// later, which may provide this proprietary "hardware attestation" statement.
AttestationFormatAndroidKey AttestationFormat = "android-key"
// AttestationFormatAndroidSafetyNet is the attestation statement format that Android-based platform authenticators
// MAY produce an attestation statement based on the Android SafetyNet API.
AttestationFormatAndroidSafetyNet AttestationFormat = "android-safetynet"
// AttestationFormatFIDOUniversalSecondFactor is the attestation statement format that is used with FIDO U2F
// authenticators.
AttestationFormatFIDOUniversalSecondFactor AttestationFormat = "fido-u2f"
// AttestationFormatApple is the attestation statement format that is used with Apple devices' platform
// authenticators.
AttestationFormatApple AttestationFormat = "apple"
// AttestationFormatNone is the attestation statement format that is used to replace any authenticator-provided
// attestation statement when a WebAuthn Relying Party indicates it does not wish to receive attestation information.
AttestationFormatNone AttestationFormat = "none"
)
func ExtractAttestationFormats(p *types.Params) []AttestationFormat {
var formats []AttestationFormat
for _, v := range p.AttestationFormats {
formats = append(formats, parseAttestationFormat(v))
}
return formats
}
func parseAttestationFormat(s string) AttestationFormat {
switch s {
case "packed":
return AttestationFormatPacked
case "tpm":
return AttestationFormatTPM
case "android-key":
return AttestationFormatAndroidKey
case "android-safetynet":
return AttestationFormatAndroidSafetyNet
case "fido-u2f":
return AttestationFormatFIDOUniversalSecondFactor
case "apple":
return AttestationFormatApple
case "none":
return AttestationFormatNone
default:
return AttestationFormatPacked
}
}
type CredentialType string
const (
CredentialTypePublicKeyCredential CredentialType = "public-key"
)
type ConveyancePreference string
const (
// PreferNoAttestation is a ConveyancePreference value.
//
// This value indicates that the Relying Party is not interested in authenticator attestation. For example, in order
// to potentially avoid having to obtain user consent to relay identifying information to the Relying Party, or to
// save a round trip to an Attestation CA or Anonymization CA.
//
// This is the default value.
//
// Specification: §5.4.7. Attestation Conveyance Preference Enumeration (https://www.w3.org/TR/webauthn/#dom-attestationconveyancepreference-none)
PreferNoAttestation ConveyancePreference = "none"
// PreferIndirectAttestation is a ConveyancePreference value.
//
// This value indicates that the Relying Party prefers an attestation conveyance yielding verifiable attestation
// statements, but allows the client to decide how to obtain such attestation statements. The client MAY replace the
// authenticator-generated attestation statements with attestation statements generated by an Anonymization CA, in
// order to protect the user’s privacy, or to assist Relying Parties with attestation verification in a
// heterogeneous ecosystem.
//
// Note: There is no guarantee that the Relying Party will obtain a verifiable attestation statement in this case.
// For example, in the case that the authenticator employs self attestation.
//
// Specification: §5.4.7. Attestation Conveyance Preference Enumeration (https://www.w3.org/TR/webauthn/#dom-attestationconveyancepreference-indirect)
PreferIndirectAttestation ConveyancePreference = "indirect"
// PreferDirectAttestation is a ConveyancePreference value.
//
// This value indicates that the Relying Party wants to receive the attestation statement as generated by the
// authenticator.
//
// Specification: §5.4.7. Attestation Conveyance Preference Enumeration (https://www.w3.org/TR/webauthn/#dom-attestationconveyancepreference-direct)
PreferDirectAttestation ConveyancePreference = "direct"
// PreferEnterpriseAttestation is a ConveyancePreference value.
//
// This value indicates that the Relying Party wants to receive an attestation statement that may include uniquely
// identifying information. This is intended for controlled deployments within an enterprise where the organization
// wishes to tie registrations to specific authenticators. User agents MUST NOT provide such an attestation unless
// the user agent or authenticator configuration permits it for the requested RP ID.
//
// If permitted, the user agent SHOULD signal to the authenticator (at invocation time) that enterprise
// attestation is requested, and convey the resulting AAGUID and attestation statement, unaltered, to the Relying
// Party.
//
// Specification: §5.4.7. Attestation Conveyance Preference Enumeration (https://www.w3.org/TR/webauthn/#dom-attestationconveyancepreference-enterprise)
PreferEnterpriseAttestation ConveyancePreference = "enterprise"
)
func ExtractConveyancePreference(p *types.Params) ConveyancePreference {
switch p.ConveyancePreference {
case "none":
return PreferNoAttestation
case "indirect":
return PreferIndirectAttestation
case "direct":
return PreferDirectAttestation
case "enterprise":
return PreferEnterpriseAttestation
default:
return PreferNoAttestation
}
}
type PublicKeyCredentialHints string
const (
// PublicKeyCredentialHintSecurityKey is a PublicKeyCredentialHint that indicates that the Relying Party believes
// that users will satisfy this request with a physical security key. For example, an enterprise Relying Party may
// set this hint if they have issued security keys to their employees and will only accept those authenticators for
// registration and authentication.
//
// For compatibility with older user agents, when this hint is used in PublicKeyCredentialCreationOptions, the
// authenticatorAttachment SHOULD be set to cross-platform.
PublicKeyCredentialHintSecurityKey PublicKeyCredentialHints = "security-key"
// PublicKeyCredentialHintClientDevice is a PublicKeyCredentialHint that indicates that the Relying Party believes
// that users will satisfy this request with a platform authenticator attached to the client device.
//
// For compatibility with older user agents, when this hint is used in PublicKeyCredentialCreationOptions, the
// authenticatorAttachment SHOULD be set to platform.
PublicKeyCredentialHintClientDevice PublicKeyCredentialHints = "client-device"
// PublicKeyCredentialHintHybrid is a PublicKeyCredentialHint that indicates that the Relying Party believes that
// users will satisfy this request with general-purpose authenticators such as smartphones. For example, a consumer
// Relying Party may believe that only a small fraction of their customers possesses dedicated security keys. This
// option also implies that the local platform authenticator should not be promoted in the UI.
//
// For compatibility with older user agents, when this hint is used in PublicKeyCredentialCreationOptions, the
// authenticatorAttachment SHOULD be set to cross-platform.
PublicKeyCredentialHintHybrid PublicKeyCredentialHints = "hybrid"
)
func ParsePublicKeyCredentialHints(s string) PublicKeyCredentialHints {
switch s {
case "security-key":
return PublicKeyCredentialHintSecurityKey
case "client-device":
return PublicKeyCredentialHintClientDevice
case "hybrid":
return PublicKeyCredentialHintHybrid
default:
return ""
}
}
type AttestedCredentialData struct {
AAGUID []byte `json:"aaguid"`
CredentialID []byte `json:"credential_id"`
// The raw credential public key bytes received from the attestation data.
CredentialPublicKey []byte `json:"public_key"`
}
type ResidentKeyRequirement string
const (
// ResidentKeyRequirementDiscouraged indicates the Relying Party prefers creating a server-side credential, but will
// accept a client-side discoverable credential. This is the default.
ResidentKeyRequirementDiscouraged ResidentKeyRequirement = "discouraged"
// ResidentKeyRequirementPreferred indicates to the client we would prefer a discoverable credential.
ResidentKeyRequirementPreferred ResidentKeyRequirement = "preferred"
// ResidentKeyRequirementRequired indicates the Relying Party requires a client-side discoverable credential, and is
// prepared to receive an error if a client-side discoverable credential cannot be created.
ResidentKeyRequirementRequired ResidentKeyRequirement = "required"
)
func ParseResidentKeyRequirement(s string) ResidentKeyRequirement {
switch s {
case "discouraged":
return ResidentKeyRequirementDiscouraged
case "preferred":
return ResidentKeyRequirementPreferred
default:
return ResidentKeyRequirementRequired
}
}
type (
AuthenticationExtensions map[string]any
UserVerificationRequirement string
)
const (
// VerificationRequired User verification is required to create/release a credential
VerificationRequired UserVerificationRequirement = "required"
// VerificationPreferred User verification is preferred to create/release a credential
VerificationPreferred UserVerificationRequirement = "preferred" // This is the default
// VerificationDiscouraged The authenticator should not verify the user for the credential
VerificationDiscouraged UserVerificationRequirement = "discouraged"
)
x/did/builder/openid.go
-27
View File
@@ -1,27 +0,0 @@
package builder
import (
"fmt"
"github.com/onsonr/sonr/x/did/types/oidc"
)
func GetDiscovery(origin string) *oidc.DiscoveryDocument {
baseURL := "https://" + origin // Ensure this is the correct base URL for your service
discoveryDoc := &oidc.DiscoveryDocument{
Issuer: baseURL,
AuthorizationEndpoint: fmt.Sprintf("%s/auth", baseURL),
TokenEndpoint: fmt.Sprintf("%s/token", baseURL),
UserinfoEndpoint: fmt.Sprintf("%s/userinfo", baseURL),
JwksUri: fmt.Sprintf("%s/jwks", baseURL),
RegistrationEndpoint: fmt.Sprintf("%s/register", baseURL),
ScopesSupported: []string{"openid", "profile", "email", "web3", "sonr"},
ResponseTypesSupported: []string{"code"},
ResponseModesSupported: []string{"query", "form_post"},
GrantTypesSupported: []string{"authorization_code", "refresh_token"},
AcrValuesSupported: []string{"passkey"},
SubjectTypesSupported: []string{"public"},
ClaimsSupported: []string{"sub", "iss", "name", "email"},
}
return discoveryDoc
}
x/did/builder/options.go
-82
View File
@@ -1,82 +0,0 @@
package builder
import (
"encoding/json"
"github.com/onsonr/sonr/x/did/types"
)
type AuthenticatorResponse struct {
// From the spec https://www.w3.org/TR/webauthn/#dom-authenticatorresponse-clientdatajson
// This attribute contains a JSON serialization of the client data passed to the authenticator
// by the client in its call to either create() or get().
ClientDataJSON URLEncodedBase64 `json:"clientDataJSON"`
}
type AuthenticatorAttestationResponse struct {
// The byte slice of clientDataJSON, which becomes CollectedClientData
AuthenticatorResponse
Transports []string `json:"transports,omitempty"`
AuthenticatorData URLEncodedBase64 `json:"authenticatorData"`
PublicKey URLEncodedBase64 `json:"publicKey"`
PublicKeyAlgorithm int64 `json:"publicKeyAlgorithm"`
// AttestationObject is the byte slice version of attestationObject.
// This attribute contains an attestation object, which is opaque to, and
// cryptographically protected against tampering by, the client. The
// attestation object contains both authenticator data and an attestation
// statement. The former contains the AAGUID, a unique credential ID, and
// the credential public key. The contents of the attestation statement are
// determined by the attestation statement format used by the authenticator.
// It also contains any additional information that the Relying Party's server
// requires to validate the attestation statement, as well as to decode and
// validate the authenticator data along with the JSON-serialized client data.
AttestationObject URLEncodedBase64 `json:"attestationObject"`
}
type PublicKeyCredentialCreationOptions struct {
RelyingParty RelyingPartyEntity `json:"rp"`
User UserEntity `json:"user"`
Challenge URLEncodedBase64 `json:"challenge"`
Parameters []CredentialParameter `json:"pubKeyCredParams,omitempty"`
Timeout int `json:"timeout,omitempty"`
CredentialExcludeList []CredentialDescriptor `json:"excludeCredentials,omitempty"`
AuthenticatorSelection AuthenticatorSelection `json:"authenticatorSelection,omitempty"`
Hints []PublicKeyCredentialHints `json:"hints,omitempty"`
Attestation ConveyancePreference `json:"attestation,omitempty"`
AttestationFormats []AttestationFormat `json:"attestationFormats,omitempty"`
Extensions AuthenticationExtensions `json:"extensions,omitempty"`
}
func GetPublicKeyCredentialCreationOptions(origin string, subject string, vaultCID string, params *types.Params) (*PublicKeyCredentialCreationOptions, error) {
chal, err := CreateChallenge()
if err != nil {
return nil, err
}
return &PublicKeyCredentialCreationOptions{
RelyingParty: NewRelayingParty(origin, subject),
User: NewUserEntity(subject, subject, vaultCID),
Parameters: ExtractCredentialParameters(params),
Timeout: 20,
CredentialExcludeList: nil,
Challenge: chal,
AuthenticatorSelection: AuthenticatorSelection{},
Hints: nil,
Attestation: ExtractConveyancePreference(params),
AttestationFormats: ExtractAttestationFormats(params),
Extensions: nil,
}, nil
}
func UnmarshalAuthenticatorResponse(data []byte) (*AuthenticatorResponse, error) {
var ar AuthenticatorResponse
err := json.Unmarshal(data, &ar)
if err != nil {
return nil, err
}
return &ar, nil
}
x/did/builder/pubkey.go
-81
View File
@@ -1,81 +0,0 @@
package builder
import (
"fmt"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
didv1 "github.com/onsonr/sonr/api/did/v1"
"github.com/onsonr/sonr/x/did/types"
"github.com/go-webauthn/webauthn/protocol/webauthncose"
)
// PublicKey is an interface for a public key
type PublicKey interface {
cryptotypes.PubKey
Clone() cryptotypes.PubKey
GetRaw() []byte
GetRole() types.KeyRole
GetAlgorithm() types.KeyAlgorithm
GetEncoding() types.KeyEncoding
GetCurve() types.KeyCurve
GetKeyType() types.KeyType
}
// 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{
Method: namespace,
Controller: controller,
PublicKey: pubkey,
Id: identifier,
Issuer: issuer,
}
}
// 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{
Method: APIFormatDIDNamespace(namespace),
Controller: controller,
PublicKey: APIFormatPubKey(pubkey),
Id: identifier,
}
}
// ExtractWebAuthnPublicKey parses the raw public key bytes and returns a JWK representation
func ExtractWebAuthnPublicKey(keyBytes []byte) (*types.PubKey_JWK, error) {
key, err := webauthncose.ParsePublicKey(keyBytes)
if err != nil {
return nil, fmt.Errorf("failed to parse public key: %w", err)
}
switch k := key.(type) {
case *webauthncose.EC2PublicKeyData:
return FormatEC2PublicKey(k)
case *webauthncose.RSAPublicKeyData:
return FormatRSAPublicKey(k)
case *webauthncose.OKPPublicKeyData:
return FormatOKPPublicKey(k)
default:
return nil, fmt.Errorf("unsupported key type")
}
}
// 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
for method, chain := range types.InitialChainCodes {
nk, err := computeBip32AccountPublicKey(pubkey, chain, 0)
if err != nil {
return nil, err
}
addr, err := chain.FormatAddress(nk)
if err != nil {
return nil, nil
}
verificationMethods = append(verificationMethods, CreateWalletVerification(method, controller, nk, method.FormatDID(addr)))
}
return verificationMethods, nil
}
x/did/builder/scopes.go
-56
View File
@@ -1,56 +0,0 @@
package builder
import (
"github.com/onsonr/sonr/x/did/types"
"gopkg.in/macaroon-bakery.v2/bakery/checkers"
)
var (
GenericPermissionScopeStrings = [...]string{
"profile.name",
"identifiers.email",
"identifiers.phone",
"transactions.read",
"transactions.write",
"wallets.read",
"wallets.create",
"wallets.subscribe",
"wallets.update",
"transactions.verify",
"transactions.broadcast",
"admin.user",
"admin.validator",
}
StringToModulePermissionScope = map[string]types.PermissionScope{
"PERMISSION_SCOPE_UNSPECIFIED": types.PermissionScope_PERMISSION_SCOPE_UNSPECIFIED,
"PERMISSION_SCOPE_BASIC_INFO": types.PermissionScope_PERMISSION_SCOPE_BASIC_INFO,
"PERMISSION_SCOPE_IDENTIFIERS_EMAIL": types.PermissionScope_PERMISSION_SCOPE_PERMISSIONS_READ,
"PERMISSION_SCOPE_IDENTIFIERS_PHONE": types.PermissionScope_PERMISSION_SCOPE_PERMISSIONS_WRITE,
"PERMISSION_SCOPE_TRANSACTIONS_READ": types.PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_READ,
"PERMISSION_SCOPE_TRANSACTIONS_WRITE": types.PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_WRITE,
"PERMISSION_SCOPE_WALLETS_READ": types.PermissionScope_PERMISSION_SCOPE_WALLETS_READ,
"PERMISSION_SCOPE_WALLETS_CREATE": types.PermissionScope_PERMISSION_SCOPE_WALLETS_CREATE,
"PERMISSION_SCOPE_WALLETS_SUBSCRIBE": types.PermissionScope_PERMISSION_SCOPE_WALLETS_SUBSCRIBE,
"PERMISSION_SCOPE_WALLETS_UPDATE": types.PermissionScope_PERMISSION_SCOPE_WALLETS_UPDATE,
"PERMISSION_SCOPE_TRANSACTIONS_VERIFY": types.PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_VERIFY,
"PERMISSION_SCOPE_TRANSACTIONS_BROADCAST": types.PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_BROADCAST,
"PERMISSION_SCOPE_ADMIN_USER": types.PermissionScope_PERMISSION_SCOPE_ADMIN_USER,
"PERMISSION_SCOPE_ADMIN_VALIDATOR": types.PermissionScope_PERMISSION_SCOPE_ADMIN_VALIDATOR,
}
)
func ResolvePermissionScope(scope string) (types.PermissionScope, bool) {
uriToPrefix := make(map[string]string)
for _, scope := range GenericPermissionScopeStrings {
uriToPrefix["https://example.com/auth/"+scope] = scope
}
PermissionNamespace := checkers.NewNamespace(uriToPrefix)
prefix, ok := PermissionNamespace.Resolve("https://example.com/auth/" + scope)
if !ok {
return 0, false
}
permScope, ok := StringToModulePermissionScope[prefix]
return permScope, ok
}
x/did/builder/service.go
-103
View File
@@ -1,103 +0,0 @@
package builder
import (
"crypto/rand"
"strings"
"github.com/onsonr/sonr/x/did/types"
)
// ChallengeLength - Length of bytes to generate for a challenge.
const ChallengeLength = 32
// CreateChallenge creates a new challenge that should be signed and returned by the authenticator. The spec recommends
// using at least 16 bytes with 100 bits of entropy. We use 32 bytes.
func CreateChallenge() (challenge URLEncodedBase64, err error) {
challenge = make([]byte, ChallengeLength)
if _, err = rand.Read(challenge); err != nil {
return nil, err
}
return challenge, nil
}
type CredentialEntity struct {
// A human-palatable name for the entity. Its function depends on what the PublicKeyCredentialEntity represents:
//
// When inherited by PublicKeyCredentialRpEntity it is a human-palatable identifier for the Relying Party,
// intended only for display. For example, "ACME Corporation", "Wonderful Widgets, Inc." or "ОАО Примертех".
//
// When inherited by PublicKeyCredentialUserEntity, it is a human-palatable identifier for a user account. It is
// intended only for display, i.e., aiding the user in determining the difference between user accounts with similar
// displayNames. For example, "alexm", "alex.p.mueller@example.com" or "+14255551234".
Name string `json:"name"`
}
func NewCredentialEntity(name string) CredentialEntity {
return CredentialEntity{
Name: name,
}
}
type CredentialParameter struct {
Type CredentialType `json:"type"`
Algorithm types.COSEAlgorithmIdentifier `json:"alg"`
}
func NewCredentialParameter(ki *types.KeyInfo) CredentialParameter {
return CredentialParameter{
Type: CredentialTypePublicKeyCredential,
Algorithm: ki.Algorithm.CoseIdentifier(),
}
}
func ExtractCredentialParameters(p *types.Params) []CredentialParameter {
var keys []*types.KeyInfo
for k, v := range p.AllowedPublicKeys {
if strings.Contains(k, "webauthn") {
keys = append(keys, v)
}
}
var cparams []CredentialParameter
for _, ki := range keys {
cparams = append(cparams, NewCredentialParameter(ki))
}
return cparams
}
type RelyingPartyEntity struct {
CredentialEntity
// A unique identifier for the Relying Party entity, which sets the RP ID.
ID string `json:"id"`
}
func NewRelayingParty(name string, origin string) RelyingPartyEntity {
return RelyingPartyEntity{
CredentialEntity: NewCredentialEntity(origin),
ID: origin,
}
}
type UserEntity struct {
CredentialEntity
// A human-palatable name for the user account, intended only for display.
// For example, "Alex P. Müller" or "田中 倫". The Relying Party SHOULD let
// the user choose this, and SHOULD NOT restrict the choice more than necessary.
DisplayName string `json:"displayName"`
// ID is the user handle of the user account entity. To ensure secure operation,
// authentication and authorization decisions MUST be made on the basis of this id
// member, not the displayName nor name members. See Section 6.1 of
// [RFC8266](https://www.w3.org/TR/webauthn/#biblio-rfc8266).
ID any `json:"id"`
}
func NewUserEntity(name string, subject string, cid string) UserEntity {
return UserEntity{
CredentialEntity: NewCredentialEntity(name),
DisplayName: subject,
ID: cid,
}
}
x/did/builder/signer.go
-59
View File
@@ -1,59 +0,0 @@
package builder
import (
"github.com/onsonr/crypto"
"github.com/onsonr/sonr/x/did/types"
)
type Signer interface {
Sign(msg []byte) ([]byte, error)
Verify(msg []byte, sig []byte) error
PublicKey() []byte
}
type signer struct {
user *types.Keyshare
val *types.Keyshare
}
func (k signer) Sign(msg []byte) ([]byte, error) {
valSignFunc, err := crypto.GetSignFunc(k.val, msg)
if err != nil {
return nil, err
}
usrSignFunc, err := crypto.GetSignFunc(k.user, msg)
if err != nil {
return nil, err
}
sig, err := crypto.RunMPCSign(valSignFunc, usrSignFunc)
if err != nil {
return nil, err
}
return crypto.SerializeMPCSignature(sig)
}
func (k signer) Verify(msg []byte, sig []byte) error {
sigMpc, err := crypto.DeserializeMPCSignature(sig)
if err != nil {
return err
}
pk, err := crypto.GetECDSAPublicKey(k.val)
if err != nil {
return err
}
ok := crypto.VerifyMPCSignature(sigMpc, msg, pk)
if !ok {
return types.ErrInvalidSignature
}
return nil
}
func (k signer) PublicKey() []byte {
if k.user != nil {
return k.user.PublicKey
}
if k.val != nil {
return k.val.PublicKey
}
return nil
}
x/did/builder/webauthn.go
-169
View File
@@ -1,169 +0,0 @@
package builder
import (
"bytes"
"encoding/base64"
"reflect"
"github.com/go-webauthn/webauthn/protocol"
)
// Credential contains all needed information about a WebAuthn credential for storage.
type Credential struct {
Subject string `json:"handle"`
AttestationType string `json:"attestationType"`
Origin string `json:"origin"`
CredentialID []byte `json:"id"`
PublicKey []byte `json:"publicKey"`
Transport []string `json:"transport"`
SignCount uint32 `json:"signCount"`
UserPresent bool `json:"userPresent"`
UserVerified bool `json:"userVerified"`
BackupEligible bool `json:"backupEligible"`
BackupState bool `json:"backupState"`
CloneWarning bool `json:"cloneWarning"`
}
// NewCredential will return a credential pointer on successful validation of a registration response.
func NewCredential(c *protocol.ParsedCredentialCreationData, origin, handle string) *Credential {
return &Credential{
Subject: handle,
Origin: origin,
AttestationType: c.Response.AttestationObject.Format,
CredentialID: c.Response.AttestationObject.AuthData.AttData.CredentialID,
PublicKey: c.Response.AttestationObject.AuthData.AttData.CredentialPublicKey,
Transport: NormalizeTransports(c.Response.Transports),
SignCount: c.Response.AttestationObject.AuthData.Counter,
UserPresent: c.Response.AttestationObject.AuthData.Flags.HasUserPresent(),
UserVerified: c.Response.AttestationObject.AuthData.Flags.HasUserVerified(),
BackupEligible: c.Response.AttestationObject.AuthData.Flags.HasBackupEligible(),
BackupState: c.Response.AttestationObject.AuthData.Flags.HasAttestedCredentialData(),
}
}
// Descriptor converts a Credential into a protocol.CredentialDescriptor.
func (c *Credential) Descriptor() protocol.CredentialDescriptor {
return protocol.CredentialDescriptor{
Type: protocol.PublicKeyCredentialType,
CredentialID: c.CredentialID,
Transport: ModuleTransportsToProtocol(c.Transport),
AttestationType: c.AttestationType,
}
}
// This is a signal that the authenticator may be cloned, see CloneWarning above for more information.
func (a *Credential) UpdateCounter(authDataCount uint32) {
if authDataCount <= a.SignCount && (authDataCount != 0 || a.SignCount != 0) {
a.CloneWarning = true
return
}
a.SignCount = authDataCount
}
type CredentialDescriptor struct {
// The valid credential types.
Type CredentialType `json:"type"`
// CredentialID The ID of a credential to allow/disallow.
CredentialID URLEncodedBase64 `json:"id"`
// The authenticator transports that can be used.
Transport []AuthenticatorTransport `json:"transports,omitempty"`
// The AttestationType from the Credential. Used internally only.
AttestationType string `json:"-"`
}
func NewCredentialDescriptor(credentialID string, transports []AuthenticatorTransport, attestationType string) *CredentialDescriptor {
return &CredentialDescriptor{
CredentialID: URLEncodedBase64(credentialID),
Transport: transports,
AttestationType: attestationType,
Type: CredentialTypePublicKeyCredential,
}
}
type AuthenticatorSelection struct {
// AuthenticatorAttachment If this member is present, eligible authenticators are filtered to only
// authenticators attached with the specified AuthenticatorAttachment enum.
AuthenticatorAttachment AuthenticatorAttachment `json:"authenticatorAttachment,omitempty"`
// RequireResidentKey this member describes the Relying Party's requirements regarding resident
// credentials. If the parameter is set to true, the authenticator MUST create a client-side-resident
// public key credential source when creating a public key credential.
RequireResidentKey *bool `json:"requireResidentKey,omitempty"`
// ResidentKey this member describes the Relying Party's requirements regarding resident
// credentials per Webauthn Level 2.
ResidentKey ResidentKeyRequirement `json:"residentKey,omitempty"`
// UserVerification This member describes the Relying Party's requirements regarding user verification for
// the create() operation. Eligible authenticators are filtered to only those capable of satisfying this
// requirement.
UserVerification UserVerificationRequirement `json:"userVerification,omitempty"`
}
type AuthenticatorData struct {
RPIDHash []byte `json:"rpid"`
Flags AuthenticatorFlags `json:"flags"`
Counter uint32 `json:"sign_count"`
AttData AttestedCredentialData `json:"att_data"`
ExtData []byte `json:"ext_data"`
}
type AttestationObject struct {
// The authenticator data, including the newly created public key. See AuthenticatorData for more info
AuthData AuthenticatorData
// The byteform version of the authenticator data, used in part for signature validation
RawAuthData []byte `json:"authData"`
// The format of the Attestation data.
Format string `json:"fmt"`
// The attestation statement data sent back if attestation is requested.
AttStatement map[string]any `json:"attStmt,omitempty"`
}
type URLEncodedBase64 []byte
func (e URLEncodedBase64) String() string {
return base64.RawURLEncoding.EncodeToString(e)
}
// UnmarshalJSON base64 decodes a URL-encoded value, storing the result in the
// provided byte slice.
func (e *URLEncodedBase64) UnmarshalJSON(data []byte) error {
if bytes.Equal(data, []byte("null")) {
return nil
}
// Trim the leading spaces.
data = bytes.Trim(data, "\"")
// Trim the trailing equal characters.
data = bytes.TrimRight(data, "=")
out := make([]byte, base64.RawURLEncoding.DecodedLen(len(data)))
n, err := base64.RawURLEncoding.Decode(out, data)
if err != nil {
return err
}
v := reflect.ValueOf(e).Elem()
v.SetBytes(out[:n])
return nil
}
// MarshalJSON base64 encodes a non URL-encoded value, storing the result in the
// provided byte slice.
func (e URLEncodedBase64) MarshalJSON() ([]byte, error) {
if e == nil {
return []byte("null"), nil
}
return []byte(`"` + base64.RawURLEncoding.EncodeToString(e) + `"`), nil
}
x/did/keeper/context.go
-165
View File
@@ -1,165 +0,0 @@
package keeper
import (
"context"
"crypto/sha256"
"fmt"
"time"
nftkeeper "cosmossdk.io/x/nft/keeper"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/ipfs/boxo/path"
"github.com/ipfs/kubo/client/rpc"
"github.com/ipfs/kubo/core/coreiface/options"
"github.com/onsonr/sonr/pkg/vault"
"github.com/onsonr/sonr/x/did/types"
"google.golang.org/grpc/peer"
"gopkg.in/macaroon.v2"
)
func (k Keeper) UnwrapCtx(goCtx context.Context) Context {
ctx := sdk.UnwrapSDKContext(goCtx)
peer, _ := peer.FromContext(goCtx)
return Context{SDKCtx: ctx, Peer: peer, Keeper: k}
}
type Context struct {
SDKCtx sdk.Context
Keeper Keeper
Peer *peer.Peer
NFTKeeper nftkeeper.Keeper
}
// AssembleVault assembles the initial vault
func (k Keeper) AssembleVault(ctx Context, subject string, origin string) (string, int64, error) {
v, err := vault.New(subject, origin, "sonr-testnet")
if err != nil {
return "", 0, err
}
cid, err := k.ipfsClient.Unixfs().Add(context.Background(), v.FS)
if err != nil {
return "", 0, err
}
return cid.String(), ctx.CalculateExpiration(time.Second * 15), nil
}
// AverageBlockTime returns the average block time in seconds
func (c Context) AverageBlockTime() float64 {
return float64(c.SDK().BlockTime().Sub(c.SDK().BlockTime()).Seconds())
}
// GetExpirationBlockHeight returns the block height at which the given duration will have passed
func (c Context) CalculateExpiration(duration time.Duration) int64 {
return c.SDKCtx.BlockHeight() + int64(duration.Seconds()/c.AverageBlockTime())
}
// IPFSConnected returns true if the IPFS client is initialized
func (c Context) IPFSConnected() bool {
if c.Keeper.ipfsClient == nil {
ipfsClient, err := rpc.NewLocalApi()
if err != nil {
return false
}
c.Keeper.ipfsClient = ipfsClient
}
return c.Keeper.ipfsClient != nil
}
func (c Context) IsAnonymous() bool {
if c.Peer == nil {
return true
}
return c.Peer.Addr == nil
}
// IssueMacaroon creates a macaroon with the specified parameters.
func (c Context) IssueMacaroon(sharedMPCPubKey, location, id string, blockExpiry uint64) (*macaroon.Macaroon, error) {
// Derive the root key by hashing the shared MPC public key
rootKey := sha256.Sum256([]byte(sharedMPCPubKey))
// Create the macaroon
m, err := macaroon.New(rootKey[:], []byte(id), location, macaroon.LatestVersion)
if err != nil {
return nil, err
}
// Add the block expiry caveat
caveat := fmt.Sprintf("block-expiry=%d", blockExpiry)
err = m.AddFirstPartyCaveat([]byte(caveat))
if err != nil {
return nil, err
}
return m, nil
}
func (c Context) Params() *types.Params {
p, err := c.Keeper.Params.Get(c.SDK())
if err != nil {
p = types.DefaultParams()
}
params := p.ActiveParams(c.IPFSConnected())
return &params
}
func (c Context) PeerID() string {
if c.Peer == nil {
return ""
}
return c.Peer.Addr.String()
}
// PinVaultController pins the initial vault to the local IPFS node
func (k Keeper) PinVaultController(_ sdk.Context, cid string, address string) (bool, error) {
// Resolve the path
path, err := path.NewPath(cid)
if err != nil {
return false, err
}
// 1. Initialize vault.db sqlite database in local IPFS with Mount
// 2. Insert the InitialWalletAccounts
// 3. Publish the path to the IPNS
_, err = k.ipfsClient.Name().Publish(context.Background(), path, options.Name.Key(address))
if err != nil {
return false, err
}
// 4. Insert the accounts into x/auth
// 5. Insert the controller into state
return true, nil
}
func (c Context) SDK() sdk.Context {
return c.SDKCtx
}
// ValidateOrigin checks if a service origin is valid
func (c Context) ValidateOrigin(origin string) error {
if origin == "localhost" {
return nil
}
return types.ErrInvalidServiceOrigin
}
// VerifyMinimumStake checks if a validator has a minimum stake
func (c Context) VerifyMinimumStake(addr string) bool {
address, err := sdk.AccAddressFromBech32(addr)
if err != nil {
return false
}
addval, err := sdk.ValAddressFromBech32(addr)
if err != nil {
return false
}
del, err := c.Keeper.StakingKeeper.GetDelegation(c.SDK(), address, addval)
if err != nil {
return false
}
if del.Shares.IsZero() {
return false
}
return del.Shares.IsPositive()
}
x/did/keeper/controller.go
+27
View File
@@ -0,0 +1,27 @@
package keeper
import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/onsonr/crypto/mpc"
"github.com/onsonr/sonr/x/did/types"
)
func (k Keeper) NewController(ctx sdk.Context) (uint64, types.ControllerI, error) {
shares, err := mpc.GenerateKeyshares()
if err != nil {
return 0, nil, err
}
controller, err := types.NewController(shares)
if err != nil {
return 0, nil, err
}
entry, err := controller.GetTableEntry()
if err != nil {
return 0, nil, err
}
num, err := k.OrmDB.ControllerTable().InsertReturningNumber(ctx, entry)
if err != nil {
return 0, nil, err
}
return num, controller, nil
}
x/did/keeper/genesis.go
+6 -33
View File
@@ -2,12 +2,10 @@ package keeper
import (
"context"
"time"
"cosmossdk.io/log"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/ipfs/boxo/path"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/onsonr/sonr/x/did/types"
)
@@ -33,41 +31,16 @@ func (k *Keeper) ExportGenesis(ctx context.Context) *types.GenesisState {
}
// this line is used by starport scaffolding # genesis/module/export
return &types.GenesisState{
Params: params,
}
}
// CheckValidatorExists checks if a validator exists
func (k Keeper) CheckValidatorExists(ctx sdk.Context, addr string) bool {
address, err := sdk.ValAddressFromBech32(addr)
// CurrentSchema returns the current schema
func (k Keeper) CurrentParams(ctx sdk.Context) (*types.Params, error) {
p, err := k.Params.Get(ctx)
if err != nil {
return false
return nil, err
}
ok, err := k.StakingKeeper.Validator(ctx, address)
if err != nil {
return false
}
if ok != nil {
return true
}
return false
}
// HasPathInIPFS checks if a file is in the local IPFS node
func (k Keeper) HasPathInIPFS(ctx sdk.Context, cid string) (bool, error) {
path, err := path.NewPath(cid)
if err != nil {
return false, err
}
v, err := k.ipfsClient.Unixfs().Get(ctx, path)
if err != nil {
return false, err
}
if v == nil {
return false, nil
}
return true, nil
return &p, nil
}
x/did/keeper/ipfs.go
-106
View File
@@ -1,106 +0,0 @@
package keeper
import (
"context"
"fmt"
"time"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/ipfs/boxo/files"
"github.com/ipfs/boxo/path"
"github.com/ipfs/kubo/client/rpc"
"github.com/ipfs/kubo/core/coreiface/options"
"github.com/onsonr/sonr/internal/vfs"
)
// assembleInitialVault assembles the initial vault
func (k Keeper) assembleInitialVault(ctx sdk.Context) (string, int64, error) {
cid, err := k.ipfsClient.Unixfs().Add(context.Background(), vfs.AssembleDirectory())
if err != nil {
return "", 0, err
}
return cid.String(), k.GetExpirationBlockHeight(ctx, time.Second*15), nil
}
// pinInitialVault pins the initial vault to the local IPFS node
func (k Keeper) pinInitialVault(_ sdk.Context, cid string, address string) (bool, error) {
// Resolve the path
path, err := path.NewPath(cid)
if err != nil {
return false, err
}
// 1. Initialize vault.db sqlite database in local IPFS with Mount
// 2. Insert the InitialWalletAccounts
// 3. Publish the path to the IPNS
_, err = k.ipfsClient.Name().Publish(context.Background(), path, options.Name.Key(address))
if err != nil {
return false, err
}
// 4. Insert the accounts into x/auth
// 5. Insert the controller into state
return true, nil
}
// GetFromIPFS gets a file from the local IPFS node
func (k Keeper) GetFromIPFS(ctx sdk.Context, cid string) (files.Directory, error) {
path, err := path.NewPath(cid)
if err != nil {
return nil, err
}
node, err := k.ipfsClient.Unixfs().Get(ctx, path)
if err != nil {
return nil, err
}
dir, ok := node.(files.Directory)
if !ok {
return nil, fmt.Errorf("retrieved node is not a directory")
}
return dir, nil
}
// HasIPFSConnection returns true if the IPFS client is initialized
func (k *Keeper) HasIPFSConnection() bool {
if k.ipfsClient == nil {
ipfsClient, err := rpc.NewLocalApi()
if err != nil {
return false
}
k.ipfsClient = ipfsClient
}
return k.ipfsClient != nil
}
// HasPathInIPFS checks if a file is in the local IPFS node
func (k Keeper) HasPathInIPFS(ctx sdk.Context, cid string) (bool, error) {
path, err := path.NewPath(cid)
if err != nil {
return false, err
}
v, err := k.ipfsClient.Unixfs().Get(ctx, path)
if err != nil {
return false, err
}
if v == nil {
return false, nil
}
return true, nil
}
// PinToIPFS pins a file to the local IPFS node
func (k Keeper) PinToIPFS(ctx sdk.Context, cid string, name string) error {
path, err := path.NewPath(cid)
if err != nil {
return err
}
err = k.ipfsClient.Pin().Add(ctx, path, options.Pin.Name(name))
if err != nil {
return err
}
return nil
}
x/did/keeper/keeper.go
+3 -18
View File
@@ -7,13 +7,11 @@ import (
"cosmossdk.io/orm/model/ormdb"
nftkeeper "cosmossdk.io/x/nft/keeper"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
stakkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
"github.com/ipfs/kubo/client/rpc"
apiv1 "github.com/onsonr/sonr/api/did/v1"
"github.com/onsonr/sonr/x/did/types"
@@ -34,8 +32,7 @@ type Keeper struct {
NftKeeper nftkeeper.Keeper
StakingKeeper *stakkeeper.Keeper
authority string
ipfsClient *rpc.HttpApi
authority string
}
// NewKeeper creates a new poa Keeper instance
@@ -66,11 +63,9 @@ func NewKeeper(
}
// Initialize IPFS client
ipfsClient, _ := rpc.NewLocalApi()
k := Keeper{
ipfsClient: ipfsClient,
cdc: cdc,
logger: logger,
cdc: cdc,
logger: logger,
Params: collections.NewItem(
sb,
types.ParamsKey,
@@ -91,13 +86,3 @@ func NewKeeper(
k.Schema = schema
return k
}
// VerifyServicePermissions checks if a service has permission
func (k Keeper) VerifyServicePermissions(
ctx sdk.Context,
addr string,
service string,
permissions string,
) bool {
return false
}
x/did/keeper/macaroon.go
+29
View File
@@ -0,0 +1,29 @@
package keeper
import (
"crypto/sha256"
"fmt"
sdk "github.com/cosmos/cosmos-sdk/types"
"gopkg.in/macaroon.v2"
)
// IssueMacaroon creates a macaroon with the specified parameters.
func (k Keeper) IssueMacaroon(ctx sdk.Context, sharedMPCPubKey, location, id string, blockExpiry uint64) (*macaroon.Macaroon, error) {
// Derive the root key by hashing the shared MPC public key
rootKey := sha256.Sum256([]byte(sharedMPCPubKey))
// Create the macaroon
m, err := macaroon.New(rootKey[:], []byte(id), location, macaroon.LatestVersion)
if err != nil {
return nil, err
}
// Add the block expiry caveat
caveat := fmt.Sprintf("block-expiry=%d", blockExpiry)
err = m.AddFirstPartyCaveat([]byte(caveat))
if err != nil {
return nil, err
}
return m, nil
}
x/did/keeper/querier.go
+9 -17
View File
@@ -3,6 +3,7 @@ package keeper
import (
"context"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/onsonr/sonr/x/did/types"
)
@@ -17,25 +18,16 @@ func NewQuerier(keeper Keeper) Querier {
}
// Params returns the total set of did parameters.
func (k Querier) Params(
goCtx context.Context,
req *types.QueryRequest,
) (*types.QueryParamsResponse, error) {
ctx := k.UnwrapCtx(goCtx)
return &types.QueryParamsResponse{Params: ctx.Params()}, nil
func (k Querier) Params(goCtx context.Context, req *types.QueryRequest) (*types.QueryParamsResponse, error) {
ctx := sdk.UnwrapSDKContext(goCtx)
p, err := k.Keeper.CurrentParams(ctx)
if err != nil {
return nil, err
}
return &types.QueryParamsResponse{Params: p}, nil
}
// Resolve implements types.QueryServer.
func (k Querier) Resolve(
goCtx context.Context,
req *types.QueryRequest,
) (*types.QueryResolveResponse, error) {
_ = k.UnwrapCtx(goCtx)
func (k Querier) Resolve(goCtx context.Context, req *types.QueryRequest) (*types.QueryResolveResponse, error) {
return &types.QueryResolveResponse{}, nil
}
// Sync implements types.QueryServer.
func (k Querier) Sync(goCtx context.Context, req *types.SyncRequest) (*types.SyncResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.SyncResponse{}, nil
}
x/did/keeper/server.go
+9 -47
View File
@@ -2,7 +2,6 @@ package keeper
import (
"context"
"encoding/json"
"cosmossdk.io/errors"
sdk "github.com/cosmos/cosmos-sdk/types"
@@ -22,50 +21,14 @@ func NewMsgServerImpl(keeper Keeper) types.MsgServer {
return &msgServer{k: keeper}
}
// # AllocateVault
//
// AllocateVault implements types.MsgServer.
func (ms msgServer) AllocateVault(
goCtx context.Context,
msg *types.MsgAllocateVault,
) (*types.MsgAllocateVaultResponse, error) {
// 1.Check if the service origin is valid
ctx := ms.k.UnwrapCtx(goCtx)
if err := ctx.ValidateOrigin(msg.Origin); err != nil {
return nil, err
}
// 2.Allocate the vault
cid, expiryBlock, err := ms.k.AssembleVault(ctx, msg.GetSubject(), msg.GetOrigin())
if err != nil {
return nil, err
}
// 3.Return the response
return &types.MsgAllocateVaultResponse{
ExpiryBlock: expiryBlock,
Cid: cid,
}, nil
}
// # RegisterController
//
// RegisterController implements types.MsgServer.
func (ms msgServer) RegisterController(
goCtx context.Context,
msg *types.MsgRegisterController,
) (*types.MsgRegisterControllerResponse, error) {
func (ms msgServer) RegisterController(goCtx context.Context, msg *types.MsgRegisterController) (*types.MsgRegisterControllerResponse, error) {
_ = sdk.UnwrapSDKContext(goCtx)
return &types.MsgRegisterControllerResponse{}, nil
}
// # RegisterService
//
// RegisterService implements types.MsgServer.
func (ms msgServer) RegisterService(
goCtx context.Context,
msg *types.MsgRegisterService,
) (*types.MsgRegisterServiceResponse, error) {
func (ms msgServer) RegisterService(goCtx context.Context, msg *types.MsgRegisterService) (*types.MsgRegisterServiceResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
// 1.Check if the service origin is valid
@@ -75,8 +38,6 @@ func (ms msgServer) RegisterService(
return nil, errors.Wrapf(types.ErrInvalidServiceOrigin, "invalid service origin")
}
// # AuthorizeService
//
// AuthorizeService implements types.MsgServer.
func (ms msgServer) AuthorizeService(goCtx context.Context, msg *types.MsgAuthorizeService) (*types.MsgAuthorizeServiceResponse, error) {
if ms.k.authority != msg.Controller {
@@ -90,13 +51,8 @@ func (ms msgServer) AuthorizeService(goCtx context.Context, msg *types.MsgAuthor
return &types.MsgAuthorizeServiceResponse{}, nil
}
// # UpdateParams
//
// UpdateParams updates the x/did module parameters.
func (ms msgServer) UpdateParams(
ctx context.Context,
msg *types.MsgUpdateParams,
) (*types.MsgUpdateParamsResponse, error) {
func (ms msgServer) UpdateParams(ctx context.Context, msg *types.MsgUpdateParams) (*types.MsgUpdateParamsResponse, error) {
if ms.k.authority != msg.Authority {
return nil, errors.Wrapf(
govtypes.ErrInvalidSigner,
@@ -107,3 +63,9 @@ func (ms msgServer) UpdateParams(
}
return nil, ms.k.Params.Set(ctx, msg.Params)
}
// ExecuteTx implements types.MsgServer.
func (ms msgServer) ExecuteTx(ctx context.Context, msg *types.MsgExecuteTx) (*types.MsgExecuteTxResponse, error) {
// ctx := sdk.UnwrapSDKContext(goCtx)
return &types.MsgExecuteTxResponse{}, nil
}
x/did/keeper/state.go
-37
View File
@@ -1,37 +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
func (k Keeper) insertAliasFromDisplayName() {
}
func (k Keeper) insertAssertionFromIdentity() {
}
func (k Keeper) insertAuthenticationFromCredential() {
}
func (k Keeper) insertControllerFromMotrVault() {
}
func (k Keeper) insertDelegationFromAccount() {
}
x/did/module.go
+6 -7
View File
@@ -67,8 +67,7 @@ func (a AppModuleBasic) Name() string {
func (a AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage {
return cdc.MustMarshalJSON(&types.GenesisState{
GlobalIntegrity: types.DefaultGlobalIntegrity(),
Params: types.DefaultParams(),
Params: types.DefaultParams(),
})
}
@@ -104,11 +103,11 @@ func (a AppModule) InitGenesis(ctx sdk.Context, marshaler codec.JSONCodec, messa
if err := a.keeper.Params.Set(ctx, didGenesisState.Params); err != nil {
panic(err)
}
nftGenesisState := nft.DefaultGenesisState()
if err := types.DefaultNFTClasses(nftGenesisState); err != nil {
panic(err)
}
a.nftKeeper.InitGenesis(ctx, nftGenesisState)
// nftGenesisState := nft.DefaultGenesisState()
// if err := types.DefaultNFTClasses(nftGenesisState); err != nil {
// panic(err)
// }
// a.nftKeeper.InitGenesis(ctx, nftGenesisState)
return nil
}
x/did/types/account.go
+12
View File
@@ -0,0 +1,12 @@
package types
type SonrAccount struct {
ID string
Name string
Address string
PublicKey string
ChainCode string
Index string
Controller string
CreatedAt string
}
x/did/types/address.go
+55
View File
@@ -1 +1,56 @@
package types
import (
"crypto/ecdsa"
"strings"
"github.com/cosmos/cosmos-sdk/types/bech32"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"golang.org/x/crypto/sha3"
)
// ComputeSonrAddress computes the Sonr address from a public key
func ComputeSonrAddress(pk []byte) (string, error) {
sonrAddr, err := bech32.ConvertAndEncode("idx", pk)
if err != nil {
return "", err
}
return sonrAddr, nil
}
// ComputeBitcoinAddress computes the Bitcoin address from a public key
func ComputeBitcoinAddress(pk []byte) (string, error) {
btcAddr, err := bech32.ConvertAndEncode("bc", pk)
if err != nil {
return "", err
}
return btcAddr, nil
}
// ComputeEthAddress computes the Ethereum address from a public key
func ComputeEthAddress(pk *ecdsa.PublicKey) string {
// Generate Ethereum address
address := ethcrypto.PubkeyToAddress(*pk)
// Apply ERC-55 checksum encoding
addr := address.Hex()
addr = strings.ToLower(addr)
addr = strings.TrimPrefix(addr, "0x")
hash := sha3.NewLegacyKeccak256()
hash.Write([]byte(addr))
hashBytes := hash.Sum(nil)
result := "0x"
for i, c := range addr {
if c >= '0' && c <= '9' {
result += string(c)
} else {
if hashBytes[i/2]>>(4-i%2*4)&0xf >= 8 {
result += strings.ToUpper(string(c))
} else {
result += string(c)
}
}
}
return result
}
x/did/types/codec.go
-37
View File
@@ -1,20 +1,12 @@
package types
import (
"crypto/ecdsa"
"strings"
ethcrypto "github.com/ethereum/go-ethereum/crypto"
"golang.org/x/crypto/sha3"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/codec/types"
cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/msgservice"
"github.com/mr-tron/base58/base58"
"github.com/onsonr/crypto"
// this line is used by starport scaffolding # 1
)
@@ -34,7 +26,6 @@ func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
cdc.RegisterConcrete(&MsgUpdateParams{}, ModuleName+"/MsgUpdateParams", nil)
cdc.RegisterConcrete(&MsgRegisterController{}, ModuleName+"/MsgRegisterController", nil)
cdc.RegisterConcrete(&MsgRegisterService{}, ModuleName+"/MsgRegisterService", nil)
cdc.RegisterConcrete(&MsgAllocateVault{}, ModuleName+"/MsgAllocateVault", nil)
}
func RegisterInterfaces(registry types.InterfaceRegistry) {
@@ -48,34 +39,6 @@ func RegisterInterfaces(registry types.InterfaceRegistry) {
&MsgUpdateParams{},
&MsgRegisterController{},
&MsgRegisterService{},
&MsgAllocateVault{},
)
msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
}
func ComputeEthAddress(pk ecdsa.PublicKey) string {
// Generate Ethereum address
address := ethcrypto.PubkeyToAddress(pk)
// Apply ERC-55 checksum encoding
addr := address.Hex()
addr = strings.ToLower(addr)
addr = strings.TrimPrefix(addr, "0x")
hash := sha3.NewLegacyKeccak256()
hash.Write([]byte(addr))
hashBytes := hash.Sum(nil)
result := "0x"
for i, c := range addr {
if c >= '0' && c <= '9' {
result += string(c)
} else {
if hashBytes[i/2]>>(4-i%2*4)&0xf >= 8 {
result += strings.ToUpper(string(c))
} else {
result += string(c)
}
}
}
return result
}
x/did/types/controller.go
+101
View File
@@ -0,0 +1,101 @@
package types
import (
fmt "fmt"
"github.com/onsonr/crypto/mpc"
didv1 "github.com/onsonr/sonr/api/did/v1"
)
type controller struct {
userKs mpc.Share
valKs mpc.Share
address string
chainID string
ethAddr string
btcAddr string
publicKey []byte
}
func (c *controller) GetTableEntry() (*didv1.Controller, error) {
valKs, err := c.valKs.Marshal()
if err != nil {
return nil, err
}
return &didv1.Controller{
KsVal: valKs,
Did: fmt.Sprintf("did:sonr:%s", c.address),
SonrAddress: c.address,
EthAddress: c.ethAddr,
BtcAddress: c.btcAddr,
PublicKey: c.publicKey,
}, nil
}
func (c *controller) ExportUserKs() (string, error) {
return c.userKs.Marshal()
}
func (c *controller) ChainID() string {
return c.chainID
}
func (c *controller) SonrAddress() string {
return c.address
}
func (c *controller) EthAddress() string {
return c.ethAddr
}
func (c *controller) BtcAddress() string {
return c.btcAddr
}
func (c *controller) PublicKey() []byte {
return c.publicKey
}
type ControllerI interface {
ChainID() string
SonrAddress() string
EthAddress() string
BtcAddress() string
PublicKey() []byte
GetTableEntry() (*didv1.Controller, error)
ExportUserKs() (string, error)
}
func NewController(shares []mpc.Share) (ControllerI, error) {
var (
valKs = shares[0]
userKs = shares[1]
)
pbBz := valKs.GetPublicKey()
sonrAddr, err := ComputeSonrAddress(pbBz)
if err != nil {
return nil, err
}
btcAddr, err := ComputeBitcoinAddress(pbBz)
if err != nil {
return nil, err
}
ecdsaPub, err := valKs.ECDSAPublicKey()
if err != nil {
return nil, err
}
ethAddr := ComputeEthAddress(ecdsaPub)
return &controller{
valKs: valKs,
userKs: userKs,
address: sonrAddr,
btcAddr: btcAddr,
ethAddr: ethAddr,
chainID: "sonr-testnet-1",
publicKey: pbBz,
}, nil
}
x/did/types/genesis.go
+11 -27
View File
@@ -6,12 +6,12 @@ import (
ormv1alpha1 "cosmossdk.io/api/cosmos/orm/v1alpha1"
"cosmossdk.io/collections"
"github.com/onsonr/sonr/internal/orm/assettype"
"github.com/onsonr/sonr/internal/orm/keyalgorithm"
"github.com/onsonr/sonr/internal/orm/keycurve"
"github.com/onsonr/sonr/internal/orm/keyencoding"
"github.com/onsonr/sonr/internal/orm/keyrole"
"github.com/onsonr/sonr/internal/orm/keytype"
"github.com/onsonr/sonr/x/did/types/orm/assettype"
"github.com/onsonr/sonr/x/did/types/orm/keyalgorithm"
"github.com/onsonr/sonr/x/did/types/orm/keycurve"
"github.com/onsonr/sonr/x/did/types/orm/keyencoding"
"github.com/onsonr/sonr/x/did/types/orm/keyrole"
"github.com/onsonr/sonr/x/did/types/orm/keytype"
)
// ParamsKey saves the current module params.
@@ -41,8 +41,7 @@ const DefaultIndex uint64 = 1
func DefaultGenesis() *GenesisState {
return &GenesisState{
// this line is used by starport scaffolding # genesis/types/default
GlobalIntegrity: DefaultGlobalIntegrity(),
Params: DefaultParams(),
Params: DefaultParams(),
}
}
@@ -56,23 +55,13 @@ func (gs GenesisState) Validate() error {
return gs.Params.Validate()
}
// // DefaultNFTClasses configures the Initial DIDNamespace NFT classes
//
// func DefaultNFTClasses(nftGenesis *nft.GenesisState) error {
// for _, n := range DIDNamespace_value {
// nftGenesis.Classes = append(nftGenesis.Classes, DIDNamespace(n).GetNFTClass())
// }
// return nil
// }
//
// DefaultParams returns default module parameters.
func DefaultParams() Params {
return Params{
WhitelistedAssets: DefaultAssets(),
AllowedPublicKeys: DefaultKeyInfos(),
LocalhostRegistrationEnabled: true,
ConveyancePreference: "direct",
AttestationFormats: []string{"packed", "android-key", "fido-u2f", "apple"},
WhitelistedAssets: DefaultAssets(),
AllowedPublicKeys: DefaultKeyInfos(),
ConveyancePreference: "direct",
AttestationFormats: []string{"packed", "android-key", "fido-u2f", "apple"},
}
}
@@ -182,11 +171,6 @@ func DefaultKeyInfos() map[string]*KeyInfo {
}
}
func (p Params) ActiveParams(ipfsActive bool) Params {
p.IpfsActive = ipfsActive
return p
}
// Stringer method for Params.
func (p Params) String() string {
bz, err := json.Marshal(p)
x/did/types/genesis.pb.go
+67 -159
View File
@@ -154,14 +154,10 @@ type Params struct {
WhitelistedAssets []*AssetInfo `protobuf:"bytes,1,rep,name=whitelisted_assets,json=whitelistedAssets,proto3" json:"whitelisted_assets,omitempty"`
// Whitelisted Key Types
AllowedPublicKeys map[string]*KeyInfo `protobuf:"bytes,2,rep,name=allowed_public_keys,json=allowedPublicKeys,proto3" json:"allowed_public_keys,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
// IpfsActive is a flag to enable/disable ipfs
IpfsActive bool `protobuf:"varint,3,opt,name=ipfs_active,json=ipfsActive,proto3" json:"ipfs_active,omitempty"`
// Localhost Registration Enabled
LocalhostRegistrationEnabled bool `protobuf:"varint,4,opt,name=localhost_registration_enabled,json=localhostRegistrationEnabled,proto3" json:"localhost_registration_enabled,omitempty"`
// ConveyancePreference defines the conveyance preference
ConveyancePreference string `protobuf:"bytes,5,opt,name=conveyance_preference,json=conveyancePreference,proto3" json:"conveyance_preference,omitempty"`
ConveyancePreference string `protobuf:"bytes,3,opt,name=conveyance_preference,json=conveyancePreference,proto3" json:"conveyance_preference,omitempty"`
// AttestationFormats defines the attestation formats
AttestationFormats []string `protobuf:"bytes,6,rep,name=attestation_formats,json=attestationFormats,proto3" json:"attestation_formats,omitempty"`
AttestationFormats []string `protobuf:"bytes,4,rep,name=attestation_formats,json=attestationFormats,proto3" json:"attestation_formats,omitempty"`
}
func (m *Params) Reset() { *m = Params{} }
@@ -210,20 +206,6 @@ func (m *Params) GetAllowedPublicKeys() map[string]*KeyInfo {
return nil
}
func (m *Params) GetIpfsActive() bool {
if m != nil {
return m.IpfsActive
}
return false
}
func (m *Params) GetLocalhostRegistrationEnabled() bool {
if m != nil {
return m.LocalhostRegistrationEnabled
}
return false
}
func (m *Params) GetConveyancePreference() string {
if m != nil {
return m.ConveyancePreference
@@ -428,7 +410,8 @@ type KeyInfo struct {
Algorithm string `protobuf:"bytes,2,opt,name=algorithm,proto3" json:"algorithm,omitempty"`
Encoding string `protobuf:"bytes,3,opt,name=encoding,proto3" json:"encoding,omitempty"`
Curve string `protobuf:"bytes,4,opt,name=curve,proto3" json:"curve,omitempty"`
Type string `protobuf:"bytes,5,opt,name=type,proto3" json:"type,omitempty"`
// "Ed25519", "Ed448", "secp256k1"
Type string `protobuf:"bytes,5,opt,name=type,proto3" json:"type,omitempty"`
}
func (m *KeyInfo) Reset() { *m = KeyInfo{} }
@@ -788,69 +771,66 @@ func init() {
func init() { proto.RegisterFile("did/v1/genesis.proto", fileDescriptor_fda181cae44f7c00) }
var fileDescriptor_fda181cae44f7c00 = []byte{
// 983 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x41, 0x6f, 0x1b, 0x45,
0x14, 0xce, 0x7a, 0x1b, 0x3b, 0x7e, 0x8e, 0xd2, 0x64, 0xea, 0x96, 0xad, 0x55, 0x1c, 0x63, 0x51,
0x14, 0x10, 0xb2, 0xd5, 0xf4, 0x82, 0xaa, 0x0a, 0x91, 0x90, 0x80, 0xda, 0x08, 0x29, 0xda, 0x12,
0x55, 0xe2, 0xb2, 0x1a, 0xef, 0xbe, 0xd8, 0x83, 0xd7, 0x33, 0xab, 0x99, 0xb1, 0x93, 0x3d, 0x72,
0xe5, 0x04, 0x37, 0xb8, 0x55, 0xfc, 0x02, 0xf8, 0x17, 0x3d, 0xf6, 0xc8, 0xa9, 0x42, 0xc9, 0x01,
0x7e, 0x06, 0x9a, 0xd9, 0xb1, 0xbd, 0x98, 0x5c, 0xb8, 0x70, 0x59, 0xbf, 0xf7, 0xbd, 0x37, 0xef,
0xbd, 0x79, 0xdf, 0x9b, 0x67, 0x68, 0x26, 0x2c, 0xe9, 0xcf, 0x1e, 0xf5, 0x87, 0xc8, 0x51, 0x31,
0xd5, 0xcb, 0xa4, 0xd0, 0x82, 0x54, 0x13, 0x96, 0xf4, 0x66, 0x8f, 0x5a, 0x3b, 0x74, 0xc2, 0xb8,
0xe8, 0xdb, 0x6f, 0x61, 0x6a, 0x35, 0x87, 0x62, 0x28, 0xac, 0xd8, 0x37, 0x52, 0x81, 0x76, 0x9f,
0xc2, 0xe6, 0x97, 0x45, 0x84, 0x17, 0x9a, 0x6a, 0x24, 0x1f, 0x43, 0x35, 0xa3, 0x92, 0x4e, 0x54,
0xe0, 0x75, 0xbc, 0xbd, 0xc6, 0xfe, 0x56, 0xaf, 0x88, 0xd8, 0x3b, 0xb5, 0xe8, 0xe1, 0xad, 0xd7,
0x6f, 0x77, 0xd7, 0x42, 0xe7, 0xd3, 0x7d, 0xeb, 0x43, 0xb5, 0x30, 0x90, 0xcf, 0x80, 0x5c, 0x8c,
0x98, 0xc6, 0x94, 0x29, 0x8d, 0x49, 0x44, 0x95, 0x42, 0x6d, 0x82, 0xf8, 0x7b, 0x8d, 0xfd, 0x9d,
0x79, 0x90, 0x03, 0x83, 0x3e, 0xe3, 0xe7, 0x22, 0xdc, 0x29, 0x39, 0x5b, 0x54, 0x91, 0x33, 0xb8,
0x43, 0xd3, 0x54, 0x5c, 0x60, 0x12, 0x65, 0xd3, 0x41, 0xca, 0xe2, 0x68, 0x8c, 0xb9, 0x0a, 0x2a,
0x36, 0xc4, 0xc3, 0x7f, 0xd6, 0xd1, 0x3b, 0x28, 0x3c, 0x4f, 0xad, 0xe3, 0x09, 0xe6, 0xea, 0x98,
0x6b, 0x99, 0x87, 0x3b, 0x74, 0x15, 0x27, 0xbb, 0xd0, 0x60, 0xd9, 0xb9, 0x8a, 0x68, 0xac, 0xd9,
0x0c, 0x03, 0xbf, 0xe3, 0xed, 0x6d, 0x84, 0x60, 0xa0, 0x03, 0x8b, 0x90, 0x23, 0x68, 0xa7, 0x22,
0xa6, 0xe9, 0x48, 0x28, 0x1d, 0x49, 0x1c, 0x32, 0xa5, 0x25, 0xd5, 0x4c, 0xf0, 0x08, 0x39, 0x1d,
0xa4, 0x98, 0x04, 0xb7, 0xec, 0x99, 0x07, 0x0b, 0xaf, 0xb0, 0xe4, 0x74, 0x5c, 0xf8, 0x90, 0xc7,
0x70, 0x37, 0x16, 0x7c, 0x86, 0x39, 0xe5, 0x31, 0x46, 0x99, 0xc4, 0x73, 0x94, 0xc8, 0x63, 0x0c,
0xd6, 0x3b, 0xde, 0x5e, 0x3d, 0x6c, 0x2e, 0x8d, 0xa7, 0x0b, 0x1b, 0xe9, 0xc3, 0x1d, 0xaa, 0x35,
0x2a, 0x5d, 0xe4, 0x3b, 0x17, 0x72, 0x42, 0xb5, 0x0a, 0xaa, 0x1d, 0x7f, 0xaf, 0x1e, 0x92, 0x92,
0xe9, 0x8b, 0xc2, 0xd2, 0x3a, 0x83, 0x7b, 0x37, 0xdf, 0x9c, 0x6c, 0x83, 0x3f, 0xc6, 0xdc, 0xb2,
0x56, 0x0f, 0x8d, 0x48, 0x1e, 0xc2, 0xfa, 0x8c, 0xa6, 0x53, 0x0c, 0x2a, 0x96, 0xc9, 0xdb, 0xf3,
0x0e, 0x9e, 0x60, 0x6e, 0x29, 0x28, 0xac, 0x4f, 0x2a, 0x9f, 0x78, 0x4f, 0xde, 0xf9, 0xe9, 0xd5,
0xee, 0xda, 0x5f, 0xaf, 0x76, 0xbd, 0xef, 0xff, 0xfc, 0xf5, 0x23, 0x30, 0x93, 0xe5, 0x08, 0xfe,
0xd9, 0x83, 0xfa, 0x82, 0x34, 0xd2, 0x84, 0x75, 0xc6, 0x13, 0xbc, 0xb4, 0x59, 0xfc, 0xb0, 0x50,
0x4c, 0xe6, 0x91, 0xcc, 0x6c, 0x96, 0x7a, 0x68, 0x44, 0x72, 0x0f, 0xaa, 0x2a, 0x9f, 0x0c, 0x44,
0x6a, 0xbb, 0x5d, 0x0f, 0x9d, 0x46, 0xde, 0x05, 0xb0, 0x73, 0x11, 0xe9, 0x3c, 0x43, 0xdb, 0xd5,
0x7a, 0x58, 0xb7, 0xc8, 0xd7, 0x79, 0x86, 0x84, 0xc0, 0x2d, 0x4e, 0x27, 0xf3, 0x8e, 0x59, 0x99,
0xdc, 0x87, 0x0d, 0x16, 0x0b, 0x1e, 0x4d, 0x65, 0x1a, 0x54, 0x2d, 0x5e, 0x33, 0xfa, 0x99, 0x4c,
0xbb, 0x3f, 0x56, 0x60, 0xe3, 0x48, 0xc4, 0xd3, 0x09, 0x72, 0x4d, 0xb6, 0xa0, 0xc2, 0x12, 0x77,
0xfb, 0x0a, 0x4b, 0x48, 0x1b, 0x20, 0x16, 0x5c, 0x4b, 0x91, 0xa6, 0x28, 0x5d, 0x6d, 0x25, 0x84,
0x7c, 0x00, 0x5b, 0x74, 0xaa, 0x47, 0xc8, 0x35, 0x8b, 0x6d, 0x87, 0x03, 0xdf, 0x36, 0x7d, 0x05,
0x25, 0x1f, 0xc2, 0xb6, 0x29, 0x50, 0x5a, 0x7e, 0x26, 0xa8, 0x47, 0xc2, 0x8c, 0x83, 0xf1, 0xbc,
0xbd, 0xc0, 0xbf, 0xb2, 0xb0, 0x9d, 0x00, 0x9a, 0xd1, 0x01, 0x4b, 0x99, 0xce, 0xa3, 0x04, 0x53,
0x1c, 0x16, 0x91, 0xd7, 0xad, 0x7f, 0x73, 0x69, 0x3c, 0x5a, 0xd8, 0x56, 0x0e, 0x31, 0x3e, 0x13,
0xae, 0x9c, 0xea, 0xea, 0xa1, 0x67, 0x0b, 0x1b, 0x09, 0xa0, 0xa6, 0x50, 0xce, 0x58, 0x8c, 0x41,
0xcd, 0xba, 0xcd, 0xd5, 0xee, 0x77, 0x1e, 0xd4, 0x1c, 0xbf, 0xa6, 0x9d, 0x52, 0xa4, 0xe8, 0x9a,
0x62, 0x65, 0xf2, 0x00, 0xea, 0x34, 0x1d, 0x0a, 0xc9, 0xf4, 0x68, 0xe2, 0xba, 0xb2, 0x04, 0x48,
0x0b, 0x36, 0x90, 0xc7, 0x22, 0x61, 0x7c, 0xe8, 0x98, 0x5b, 0xe8, 0x86, 0xfb, 0x78, 0x2a, 0x67,
0x73, 0xda, 0x0a, 0xc5, 0xe4, 0xb0, 0x5c, 0x3a, 0xca, 0x8c, 0xdc, 0xfd, 0xa5, 0x02, 0xd5, 0xd3,
0xe9, 0xe0, 0x04, 0xf3, 0xff, 0xa5, 0x84, 0xfb, 0xb0, 0x31, 0xc6, 0x3c, 0x2a, 0x95, 0x51, 0x1b,
0x63, 0x6e, 0x07, 0x6a, 0x1b, 0x7c, 0x49, 0x2f, 0xec, 0xdc, 0x6c, 0x86, 0x46, 0x24, 0xef, 0x83,
0xff, 0xed, 0xc5, 0x38, 0xa8, 0xd9, 0x17, 0x41, 0x16, 0x3b, 0xc5, 0x56, 0xdb, 0x7b, 0xfe, 0xf2,
0x24, 0x34, 0xe6, 0x16, 0x05, 0xff, 0xf9, 0xcb, 0x13, 0xfb, 0xa4, 0xf4, 0xf2, 0x49, 0x69, 0xfb,
0xc8, 0x62, 0x39, 0x9b, 0x8f, 0x7a, 0x2c, 0x67, 0x64, 0x13, 0xbc, 0x4b, 0x57, 0xa8, 0x77, 0x69,
0xb4, 0xdc, 0x55, 0xe7, 0xe5, 0x46, 0xe3, 0xae, 0x24, 0x8f, 0x1b, 0x0d, 0xdd, 0x08, 0x7b, 0xd8,
0xfd, 0xcd, 0x87, 0xda, 0x8b, 0x82, 0xb4, 0x7f, 0xcd, 0xee, 0x7b, 0xb0, 0xe9, 0xf8, 0x2c, 0x6e,
0x55, 0xa4, 0x6b, 0x38, 0xcc, 0xde, 0xcc, 0x34, 0x71, 0xaa, 0x47, 0xa6, 0x69, 0xb9, 0x4b, 0xbf,
0x04, 0xcc, 0xfb, 0x13, 0x92, 0x0d, 0x19, 0x77, 0xb5, 0x38, 0x8d, 0x74, 0xa0, 0x91, 0xa0, 0x8a,
0x25, 0xcb, 0xdc, 0x5c, 0xda, 0xb8, 0x25, 0x88, 0x84, 0xb0, 0x33, 0x4f, 0x8d, 0x3c, 0xc9, 0x04,
0xe3, 0x6e, 0x1d, 0x95, 0x36, 0xb0, 0x2b, 0x7b, 0xfe, 0x7b, 0x3c, 0xf7, 0x2b, 0x36, 0xf0, 0xb6,
0x5a, 0x81, 0xc9, 0x21, 0x34, 0x32, 0x94, 0x13, 0xa6, 0x14, 0x13, 0x5c, 0xd9, 0x89, 0x6d, 0xec,
0x77, 0x56, 0xa3, 0x9d, 0x2e, 0x5d, 0x8a, 0x40, 0xe5, 0x43, 0xad, 0xcf, 0xe1, 0xee, 0x8d, 0xe9,
0x6e, 0x58, 0x7b, 0xcd, 0xf2, 0xda, 0xab, 0x97, 0xb6, 0x5c, 0xeb, 0x53, 0xd8, 0x5e, 0xcd, 0xf2,
0x5f, 0xce, 0x1f, 0x3e, 0x7d, 0x7d, 0xd5, 0xf6, 0xde, 0x5c, 0xb5, 0xbd, 0x3f, 0xae, 0xda, 0xde,
0x0f, 0xd7, 0xed, 0xb5, 0x37, 0xd7, 0xed, 0xb5, 0xdf, 0xaf, 0xdb, 0x6b, 0xdf, 0x74, 0x87, 0x4c,
0x8f, 0xa6, 0x83, 0x5e, 0x2c, 0x26, 0x7d, 0xc1, 0x95, 0xe0, 0xb2, 0x6f, 0x3f, 0x97, 0x7d, 0xb3,
0x4b, 0x0d, 0x89, 0x6a, 0x50, 0xb5, 0x7f, 0xb8, 0x8f, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0x96,
0x98, 0xb5, 0xcd, 0xb9, 0x07, 0x00, 0x00,
// 929 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x4f, 0x6f, 0x1b, 0x45,
0x14, 0xcf, 0x7a, 0x13, 0x3b, 0x7e, 0x8e, 0x52, 0x7b, 0xea, 0x96, 0xad, 0x05, 0x8e, 0xb1, 0x28,
0x0a, 0x08, 0xd9, 0x6a, 0x7a, 0x41, 0x55, 0x85, 0x68, 0x68, 0x41, 0xad, 0x85, 0x14, 0x6d, 0x89,
0x2a, 0x71, 0xb1, 0xc6, 0xbb, 0x2f, 0xf6, 0xe0, 0xdd, 0x99, 0xd5, 0xcc, 0xd8, 0xc9, 0x1e, 0xb9,
0x72, 0x82, 0x1b, 0xdc, 0x2a, 0x3e, 0x01, 0x7c, 0x8b, 0x1e, 0x7b, 0xe4, 0x84, 0x50, 0x72, 0x80,
0x6f, 0xc0, 0x15, 0xcd, 0xec, 0xf8, 0x0f, 0x26, 0x17, 0x2e, 0xbd, 0xac, 0xdf, 0xfb, 0xbd, 0x37,
0xef, 0xbd, 0x79, 0xbf, 0xf7, 0xc6, 0xd0, 0x8c, 0x59, 0xdc, 0x9f, 0xdf, 0xeb, 0x8f, 0x91, 0xa3,
0x62, 0xaa, 0x97, 0x49, 0xa1, 0x05, 0x29, 0xc7, 0x2c, 0xee, 0xcd, 0xef, 0xb5, 0x1a, 0x34, 0x65,
0x5c, 0xf4, 0xed, 0xb7, 0x30, 0xb5, 0x9a, 0x63, 0x31, 0x16, 0x56, 0xec, 0x1b, 0xa9, 0x40, 0xbb,
0x0f, 0x61, 0xef, 0x8b, 0x22, 0xc2, 0x73, 0x4d, 0x35, 0x92, 0x8f, 0xa0, 0x9c, 0x51, 0x49, 0x53,
0x15, 0x78, 0x1d, 0xef, 0xb0, 0x76, 0xb4, 0xdf, 0x2b, 0x22, 0xf6, 0x4e, 0x2c, 0x7a, 0xbc, 0xfd,
0xea, 0xf7, 0x83, 0xad, 0xd0, 0xf9, 0x74, 0xff, 0x2e, 0x41, 0xb9, 0x30, 0x90, 0x4f, 0x81, 0x9c,
0x4f, 0x98, 0xc6, 0x84, 0x29, 0x8d, 0xf1, 0x90, 0x2a, 0x85, 0xda, 0x04, 0xf1, 0x0f, 0x6b, 0x47,
0x8d, 0x45, 0x90, 0x47, 0x06, 0x7d, 0xca, 0xcf, 0x44, 0xd8, 0x58, 0x73, 0xb6, 0xa8, 0x22, 0xa7,
0x70, 0x93, 0x26, 0x89, 0x38, 0xc7, 0x78, 0x98, 0xcd, 0x46, 0x09, 0x8b, 0x86, 0x53, 0xcc, 0x55,
0x50, 0xb2, 0x21, 0xee, 0xfe, 0xbb, 0x8e, 0xde, 0xa3, 0xc2, 0xf3, 0xc4, 0x3a, 0x0e, 0x30, 0x57,
0x4f, 0xb8, 0x96, 0x79, 0xd8, 0xa0, 0x9b, 0x38, 0xb9, 0x0f, 0xb7, 0x22, 0xc1, 0xe7, 0x98, 0x53,
0x1e, 0xe1, 0x30, 0x93, 0x78, 0x86, 0x12, 0x79, 0x84, 0x81, 0xdf, 0xf1, 0x0e, 0xab, 0x61, 0x73,
0x65, 0x3c, 0x59, 0xda, 0x48, 0x1f, 0x6e, 0x52, 0xad, 0x51, 0x69, 0xaa, 0x99, 0xe0, 0xc3, 0x33,
0x21, 0x53, 0xaa, 0x55, 0xb0, 0xdd, 0xf1, 0x0f, 0xab, 0x21, 0x59, 0x33, 0x7d, 0x5e, 0x58, 0x5a,
0xa7, 0x70, 0xfb, 0xfa, 0x92, 0x48, 0x1d, 0xfc, 0x29, 0xe6, 0xb6, 0x9d, 0xd5, 0xd0, 0x88, 0xe4,
0x2e, 0xec, 0xcc, 0x69, 0x32, 0xc3, 0xa0, 0x64, 0x5b, 0x7c, 0x63, 0x71, 0xb5, 0x01, 0xe6, 0xb6,
0x37, 0x85, 0xf5, 0x41, 0xe9, 0x63, 0xef, 0xc1, 0x5b, 0x3f, 0xbe, 0x3c, 0xd8, 0xfa, 0xeb, 0xe5,
0x81, 0xf7, 0xdd, 0x9f, 0xbf, 0x7c, 0x08, 0x86, 0x72, 0xd7, 0xf9, 0x9f, 0x3c, 0xa8, 0x2e, 0xbb,
0x49, 0x9a, 0xb0, 0xc3, 0x78, 0x8c, 0x17, 0x36, 0x8b, 0x1f, 0x16, 0x8a, 0xc9, 0x3c, 0x91, 0x99,
0xcd, 0x52, 0x0d, 0x8d, 0x48, 0x6e, 0x43, 0x59, 0xe5, 0xe9, 0x48, 0x24, 0xee, 0xf2, 0x4e, 0x23,
0xef, 0x00, 0x58, 0xc2, 0x86, 0x3a, 0xcf, 0x30, 0xd8, 0xb6, 0xb6, 0xaa, 0x45, 0xbe, 0xca, 0x33,
0x24, 0x04, 0xb6, 0x39, 0x4d, 0x31, 0xd8, 0xb1, 0x06, 0x2b, 0x93, 0x3b, 0xb0, 0xcb, 0x22, 0xc1,
0x87, 0x33, 0x99, 0x04, 0x65, 0x8b, 0x57, 0x8c, 0x7e, 0x2a, 0x93, 0xee, 0x0f, 0x25, 0xd8, 0x7d,
0x2c, 0xa2, 0x59, 0x8a, 0x5c, 0x93, 0x7d, 0x28, 0xb1, 0xd8, 0xdd, 0xbe, 0xc4, 0x62, 0xd2, 0x06,
0x88, 0x04, 0xd7, 0x52, 0x24, 0x09, 0x4a, 0x57, 0xdb, 0x1a, 0x42, 0xde, 0x87, 0x7d, 0x3a, 0xd3,
0x13, 0xe4, 0x9a, 0x45, 0xb6, 0xc3, 0x81, 0x6f, 0x9b, 0xbe, 0x81, 0x92, 0x0f, 0xa0, 0x6e, 0x0a,
0x94, 0x96, 0x9f, 0x14, 0xf5, 0x44, 0xc4, 0x8e, 0x9e, 0x1b, 0x4b, 0xfc, 0x4b, 0x0b, 0xdb, 0x09,
0xa0, 0x19, 0x1d, 0xb1, 0x84, 0xe9, 0x7c, 0x18, 0x63, 0x82, 0xe3, 0x22, 0xf2, 0x8e, 0xf5, 0x6f,
0xae, 0x8c, 0x8f, 0x97, 0xb6, 0x8d, 0x43, 0x8c, 0xcf, 0x85, 0x2b, 0xa7, 0xbc, 0x79, 0xe8, 0xe9,
0xd2, 0x46, 0x02, 0xa8, 0x28, 0x94, 0x73, 0x16, 0x61, 0x50, 0xb1, 0x6e, 0x0b, 0xb5, 0xfb, 0xad,
0x07, 0x15, 0xc7, 0xaf, 0x69, 0xa7, 0x14, 0x09, 0xba, 0xa6, 0x58, 0x99, 0xbc, 0x0d, 0x55, 0x9a,
0x8c, 0x85, 0x64, 0x7a, 0x92, 0xba, 0xae, 0xac, 0x00, 0xd2, 0x82, 0x5d, 0xe4, 0x91, 0x88, 0x19,
0x1f, 0x3b, 0xe6, 0x96, 0xba, 0xe1, 0x3e, 0x9a, 0xc9, 0xf9, 0x82, 0xb6, 0x42, 0x31, 0x39, 0x2c,
0x97, 0x8e, 0x32, 0x23, 0x77, 0x7f, 0x36, 0xdb, 0x3a, 0x1b, 0x0d, 0x30, 0x7f, 0x23, 0x25, 0xdc,
0x81, 0xdd, 0x29, 0xe6, 0xc3, 0xb5, 0x32, 0x2a, 0x53, 0xcc, 0xed, 0x40, 0xd5, 0xc1, 0x97, 0xf4,
0xdc, 0xce, 0xcd, 0x5e, 0x68, 0x44, 0xf2, 0x1e, 0xf8, 0xdf, 0x9c, 0x4f, 0x83, 0x8a, 0xdd, 0x08,
0xb2, 0x5c, 0x76, 0x5b, 0x6d, 0xef, 0xd9, 0x8b, 0x41, 0x68, 0xcc, 0x2d, 0x0a, 0xfe, 0xb3, 0x17,
0x03, 0xbb, 0x52, 0x7a, 0xb5, 0x52, 0xda, 0x2e, 0x59, 0x24, 0xe7, 0x8b, 0x51, 0x8f, 0xe4, 0x9c,
0xec, 0x81, 0x77, 0xe1, 0x0a, 0xf5, 0x2e, 0x8c, 0x96, 0xbb, 0xea, 0xbc, 0xdc, 0x68, 0xdc, 0x95,
0xe4, 0x71, 0xa3, 0xa1, 0x1b, 0x61, 0x0f, 0xbb, 0xbf, 0xfa, 0x50, 0x79, 0x5e, 0x90, 0xf6, 0x9f,
0xd9, 0x7d, 0x17, 0xf6, 0x1c, 0x9f, 0xc5, 0xad, 0x8a, 0x74, 0x35, 0x87, 0xd9, 0x9b, 0x99, 0x26,
0xce, 0xf4, 0xc4, 0x34, 0x2d, 0x77, 0xe9, 0x57, 0x80, 0xd9, 0x3f, 0x21, 0xd9, 0x98, 0x71, 0x57,
0x8b, 0xd3, 0x48, 0x07, 0x6a, 0x31, 0xaa, 0x48, 0xb2, 0xcc, 0xcd, 0xa5, 0x8d, 0xbb, 0x06, 0x91,
0x10, 0x1a, 0x8b, 0xd4, 0xc8, 0xe3, 0x4c, 0x30, 0xae, 0x95, 0x1d, 0xc5, 0xb5, 0xa7, 0xd1, 0x95,
0xbd, 0xf8, 0x7d, 0xb2, 0xf0, 0x2b, 0x9e, 0xc6, 0xba, 0xda, 0x80, 0xc9, 0x31, 0xd4, 0x32, 0x94,
0x29, 0x53, 0x8a, 0x09, 0xae, 0xec, 0xc4, 0xd6, 0x8e, 0x3a, 0x9b, 0xd1, 0x4e, 0x56, 0x2e, 0x45,
0xa0, 0xf5, 0x43, 0xad, 0xcf, 0xe0, 0xd6, 0xb5, 0xe9, 0xae, 0x79, 0xf6, 0x9a, 0xeb, 0xcf, 0x5e,
0x75, 0xed, 0x95, 0x6b, 0x7d, 0x02, 0xf5, 0xcd, 0x2c, 0xff, 0xe7, 0xfc, 0xf1, 0xc3, 0x57, 0x97,
0x6d, 0xef, 0xf5, 0x65, 0xdb, 0xfb, 0xe3, 0xb2, 0xed, 0x7d, 0x7f, 0xd5, 0xde, 0x7a, 0x7d, 0xd5,
0xde, 0xfa, 0xed, 0xaa, 0xbd, 0xf5, 0x75, 0x77, 0xcc, 0xf4, 0x64, 0x36, 0xea, 0x45, 0x22, 0xed,
0x0b, 0xae, 0x04, 0x97, 0x7d, 0xfb, 0xb9, 0xe8, 0x9b, 0xb7, 0xd4, 0x90, 0xa8, 0x46, 0x65, 0xfb,
0x4f, 0x78, 0xff, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x47, 0x39, 0xad, 0x38, 0x52, 0x07, 0x00,
0x00,
}
func (this *Params) Equal(that interface{}) bool {
@@ -888,12 +868,6 @@ func (this *Params) Equal(that interface{}) bool {
return false
}
}
if this.IpfsActive != that1.IpfsActive {
return false
}
if this.LocalhostRegistrationEnabled != that1.LocalhostRegistrationEnabled {
return false
}
if this.ConveyancePreference != that1.ConveyancePreference {
return false
}
@@ -1027,7 +1001,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
copy(dAtA[i:], m.AttestationFormats[iNdEx])
i = encodeVarintGenesis(dAtA, i, uint64(len(m.AttestationFormats[iNdEx])))
i--
dAtA[i] = 0x32
dAtA[i] = 0x22
}
}
if len(m.ConveyancePreference) > 0 {
@@ -1035,27 +1009,7 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
copy(dAtA[i:], m.ConveyancePreference)
i = encodeVarintGenesis(dAtA, i, uint64(len(m.ConveyancePreference)))
i--
dAtA[i] = 0x2a
}
if m.LocalhostRegistrationEnabled {
i--
if m.LocalhostRegistrationEnabled {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x20
}
if m.IpfsActive {
i--
if m.IpfsActive {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x18
dAtA[i] = 0x1a
}
if len(m.AllowedPublicKeys) > 0 {
for k := range m.AllowedPublicKeys {
@@ -1616,12 +1570,6 @@ func (m *Params) Size() (n int) {
n += mapEntrySize + 1 + sovGenesis(uint64(mapEntrySize))
}
}
if m.IpfsActive {
n += 2
}
if m.LocalhostRegistrationEnabled {
n += 2
}
l = len(m.ConveyancePreference)
if l > 0 {
n += 1 + l + sovGenesis(uint64(l))
@@ -2343,46 +2291,6 @@ func (m *Params) Unmarshal(dAtA []byte) error {
m.AllowedPublicKeys[mapkey] = mapvalue
iNdEx = postIndex
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field IpfsActive", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.IpfsActive = bool(v != 0)
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field LocalhostRegistrationEnabled", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowGenesis
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.LocalhostRegistrationEnabled = bool(v != 0)
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field ConveyancePreference", wireType)
}
@@ -2414,7 +2322,7 @@ func (m *Params) Unmarshal(dAtA []byte) error {
}
m.ConveyancePreference = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 6:
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field AttestationFormats", wireType)
}
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/msgs.go
-33
View File
@@ -83,39 +83,6 @@ func (msg *MsgRegisterService) Validate() error {
return nil
}
//
// [AllocateVault]
//
// NewMsgAllocateVault creates a new instance of MsgAllocateVault
func NewMsgAllocateVault(
sender sdk.Address,
) (*MsgAllocateVault, error) {
return &MsgAllocateVault{}, nil
}
// GetSigners returns the expected signers for a MsgUpdateParams message.
func (msg *MsgAllocateVault) GetSigners() []sdk.AccAddress {
addr, _ := sdk.AccAddressFromBech32(msg.Authority)
return []sdk.AccAddress{addr}
}
// Route returns the name of the module
func (msg MsgAllocateVault) Route() string { return ModuleName }
// Type returns the the action
func (msg MsgAllocateVault) Type() string { return "allocate_vault" }
// GetSignBytes implements the LegacyMsg interface.
func (msg MsgAllocateVault) GetSignBytes() []byte {
return sdk.MustSortJSON(AminoCdc.MustMarshalJSON(&msg))
}
// Vaalidate does a sanity check on the provided data.
func (msg *MsgAllocateVault) Validate() error {
return nil
}
//
// [RegisterController]
//
x/did/types/namespace.go
-102
View File
@@ -1,102 +0,0 @@
package types
import (
"cosmossdk.io/x/nft"
)
func (n DIDNamespace) ID() string {
switch n {
case DIDNamespace_DID_NAMESPACE_DWN:
return "did:dwn:0"
case DIDNamespace_DID_NAMESPACE_SONR:
return "did:sonr:0"
case DIDNamespace_DID_NAMESPACE_BITCOIN:
return "did:btc:0"
case DIDNamespace_DID_NAMESPACE_ETHEREUM:
return "did:eth:0"
case DIDNamespace_DID_NAMESPACE_IBC:
return "did:ibc:0"
case DIDNamespace_DID_NAMESPACE_WEBAUTHN:
return "did:authn:0"
case DIDNamespace_DID_NAMESPACE_SERVICE:
return "did:web:0"
case DIDNamespace_DID_NAMESPACE_IPFS:
return "did:ipfs:0"
}
return ""
}
func (n DIDNamespace) Name() string {
switch n {
case DIDNamespace_DID_NAMESPACE_DWN:
return "DecentralizedWebNode"
case DIDNamespace_DID_NAMESPACE_SONR:
return "SonrNetwork"
case DIDNamespace_DID_NAMESPACE_BITCOIN:
return "BitcoinNetwork"
case DIDNamespace_DID_NAMESPACE_ETHEREUM:
return "EthereumNetwork"
case DIDNamespace_DID_NAMESPACE_IBC:
return "IBCNetwork"
case DIDNamespace_DID_NAMESPACE_WEBAUTHN:
return "WebAuthentication"
case DIDNamespace_DID_NAMESPACE_SERVICE:
return "DecentrlizedService"
case DIDNamespace_DID_NAMESPACE_IPFS:
return "IPFSStorage"
}
return ""
}
func (n DIDNamespace) Symbol() string {
switch n {
case DIDNamespace_DID_NAMESPACE_DWN:
return "DWN"
case DIDNamespace_DID_NAMESPACE_SONR:
return "SONR"
case DIDNamespace_DID_NAMESPACE_BITCOIN:
return "BTC"
case DIDNamespace_DID_NAMESPACE_ETHEREUM:
return "ETH"
case DIDNamespace_DID_NAMESPACE_IBC:
return "IBC"
case DIDNamespace_DID_NAMESPACE_WEBAUTHN:
return "WEBAUTHN"
case DIDNamespace_DID_NAMESPACE_SERVICE:
return "SERVICE"
case DIDNamespace_DID_NAMESPACE_IPFS:
return "IPFS"
}
return ""
}
func (n DIDNamespace) Description() string {
switch n {
case DIDNamespace_DID_NAMESPACE_DWN:
return "DWN Service Provider"
case DIDNamespace_DID_NAMESPACE_SONR:
return "Sonr Network Gateway"
case DIDNamespace_DID_NAMESPACE_BITCOIN:
return "Bitcoin Network Gateway"
case DIDNamespace_DID_NAMESPACE_ETHEREUM:
return "Ethereum Network Gateway"
case DIDNamespace_DID_NAMESPACE_IBC:
return "IBC Network Gateway"
case DIDNamespace_DID_NAMESPACE_WEBAUTHN:
return "Web Authentication Key"
case DIDNamespace_DID_NAMESPACE_SERVICE:
return "Decentrlized Service"
case DIDNamespace_DID_NAMESPACE_IPFS:
return "Data Storage on IPFS"
}
return ""
}
func (n DIDNamespace) GetNFTClass() *nft.Class {
return &nft.Class{
Id: n.ID(),
Name: n.Name(),
Symbol: n.Symbol(),
Description: n.Description(),
}
}
x/did/types/oidc/DiscoveryDocument.pkl.go
-34
View File
@@ -1,34 +0,0 @@
// Code generated from Pkl module `oidc`. DO NOT EDIT.
package oidc
type DiscoveryDocument struct {
Issuer string `pkl:"issuer" json:"issuer,omitempty" param:"issuer"`
AuthorizationEndpoint string `pkl:"authorization_endpoint" json:"authorization_endpoint,omitempty" param:"authorization_endpoint"`
TokenEndpoint string `pkl:"token_endpoint" json:"token_endpoint,omitempty" param:"token_endpoint"`
UserinfoEndpoint string `pkl:"userinfo_endpoint" json:"userinfo_endpoint,omitempty" param:"userinfo_endpoint"`
JwksUri string `pkl:"jwks_uri" json:"jwks_uri,omitempty" param:"jwks_uri"`
RegistrationEndpoint string `pkl:"registration_endpoint" json:"registration_endpoint,omitempty" param:"registration_endpoint"`
ScopesSupported []string `pkl:"scopes_supported" json:"scopes_supported,omitempty" param:"scopes_supported"`
ResponseTypesSupported []string `pkl:"response_types_supported" json:"response_types_supported,omitempty" param:"response_types_supported"`
ResponseModesSupported []string `pkl:"response_modes_supported" json:"response_modes_supported,omitempty" param:"response_modes_supported"`
SubjectTypesSupported []string `pkl:"subject_types_supported" json:"subject_types_supported,omitempty" param:"subject_types_supported"`
IdTokenSigningAlgValuesSupported []string `pkl:"id_token_signing_alg_values_supported" json:"id_token_signing_alg_values_supported,omitempty" param:"id_token_signing_alg_values_supported"`
ClaimsSupported []string `pkl:"claims_supported" json:"claims_supported,omitempty" param:"claims_supported"`
GrantTypesSupported []string `pkl:"grant_types_supported" json:"grant_types_supported,omitempty" param:"grant_types_supported"`
AcrValuesSupported []string `pkl:"acr_values_supported" json:"acr_values_supported,omitempty" param:"acr_values_supported"`
TokenEndpointAuthMethodsSupported []string `pkl:"token_endpoint_auth_methods_supported" json:"token_endpoint_auth_methods_supported,omitempty" param:"token_endpoint_auth_methods_supported"`
}
x/did/types/oidc/init.pkl.go
-9
View File
@@ -1,9 +0,0 @@
// Code generated from Pkl module `oidc`. DO NOT EDIT.
package oidc
import "github.com/apple/pkl-go/pkl"
func init() {
pkl.RegisterMapping("oidc", Oidc{})
pkl.RegisterMapping("oidc#DiscoveryDocument", DiscoveryDocument{})
}
x/did/types/orm/Account.pkl.go
+20
View File
@@ -0,0 +1,20 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Account struct {
Id string `pkl:"id" json:"id,omitempty" query:"id"`
Name string `pkl:"name" json:"name,omitempty"`
Address any `pkl:"address" json:"address,omitempty"`
PublicKey string `pkl:"publicKey" json:"publicKey,omitempty"`
ChainCode uint `pkl:"chainCode" json:"chainCode,omitempty"`
Index int `pkl:"index" json:"index,omitempty"`
Controller string `pkl:"controller" json:"controller,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
}
x/did/types/orm/Asset.pkl.go
+16
View File
@@ -0,0 +1,16 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Asset struct {
Id string `pkl:"id" json:"id,omitempty" query:"id"`
Name string `pkl:"name" json:"name,omitempty"`
Symbol string `pkl:"symbol" json:"symbol,omitempty"`
Decimals int `pkl:"decimals" json:"decimals,omitempty"`
ChainCode uint `pkl:"chainCode" json:"chainCode,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
}
x/did/types/orm/Chain.pkl.go
+14
View File
@@ -0,0 +1,14 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Chain struct {
Id string `pkl:"id" json:"id,omitempty" query:"id"`
Name string `pkl:"name" json:"name,omitempty"`
NetworkId string `pkl:"networkId" json:"networkId,omitempty"`
ChainCode uint `pkl:"chainCode" json:"chainCode,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
}
x/did/types/orm/Credential.pkl.go
+40
View File
@@ -0,0 +1,40 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Credential struct {
Id string `pkl:"id" json:"id,omitempty" query:"id"`
Subject string `pkl:"subject" json:"subject,omitempty"`
Controller string `pkl:"controller" json:"controller,omitempty"`
AttestationType string `pkl:"attestationType" json:"attestationType,omitempty"`
Origin string `pkl:"origin" json:"origin,omitempty"`
Label *string `pkl:"label" json:"label,omitempty"`
DeviceId *string `pkl:"deviceId" json:"deviceId,omitempty"`
CredentialId string `pkl:"credentialId" json:"credentialId,omitempty"`
PublicKey string `pkl:"publicKey" json:"publicKey,omitempty"`
Transport []string `pkl:"transport" json:"transport,omitempty"`
SignCount uint `pkl:"signCount" json:"signCount,omitempty"`
UserPresent bool `pkl:"userPresent" json:"userPresent,omitempty"`
UserVerified bool `pkl:"userVerified" json:"userVerified,omitempty"`
BackupEligible bool `pkl:"backupEligible" json:"backupEligible,omitempty"`
BackupState bool `pkl:"backupState" json:"backupState,omitempty"`
CloneWarning bool `pkl:"cloneWarning" json:"cloneWarning,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
UpdatedAt *string `pkl:"updatedAt" json:"updatedAt,omitempty"`
}
x/did/types/orm/Grant.pkl.go
+20
View File
@@ -0,0 +1,20 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Grant struct {
Id uint `pkl:"id" json:"id,omitempty" query:"id"`
Subject string `pkl:"subject" json:"subject,omitempty"`
Controller string `pkl:"controller" json:"controller,omitempty"`
Origin string `pkl:"origin" json:"origin,omitempty"`
Token string `pkl:"token" json:"token,omitempty"`
Scopes []string `pkl:"scopes" json:"scopes,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
UpdatedAt *string `pkl:"updatedAt" json:"updatedAt,omitempty"`
}
x/did/types/orm/JWK.pkl.go
+16
View File
@@ -0,0 +1,16 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type JWK struct {
Kty string `pkl:"kty" json:"kty,omitempty"`
Crv string `pkl:"crv" json:"crv,omitempty"`
X string `pkl:"x" json:"x,omitempty"`
Y string `pkl:"y" json:"y,omitempty"`
N string `pkl:"n" json:"n,omitempty"`
E string `pkl:"e" json:"e,omitempty"`
}
x/did/types/orm/Keyshare.pkl.go
+14
View File
@@ -0,0 +1,14 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Keyshare struct {
Id string `pkl:"id" json:"id,omitempty" query:"id"`
Data string `pkl:"data" json:"data,omitempty"`
Role int `pkl:"role" json:"role,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
LastRefreshed *string `pkl:"lastRefreshed" json:"lastRefreshed,omitempty"`
}
x/did/types/oidc/Oidc.pkl.go → x/did/types/orm/Models.pkl.go
+11 -8
View File
@@ -1,5 +1,5 @@
// Code generated from Pkl module `oidc`. DO NOT EDIT.
package oidc
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
import (
"context"
@@ -7,11 +7,14 @@ import (
"github.com/apple/pkl-go/pkl"
)
type Oidc struct {
type Models struct {
DbName string `pkl:"db_name"`
DbVersion int `pkl:"db_version"`
}
// LoadFromPath loads the pkl module at the given path and evaluates it into a Oidc
func LoadFromPath(ctx context.Context, path string) (ret *Oidc, err error) {
// LoadFromPath loads the pkl module at the given path and evaluates it into a Models
func LoadFromPath(ctx context.Context, path string) (ret *Models, err error) {
evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
if err != nil {
return nil, err
@@ -26,9 +29,9 @@ func LoadFromPath(ctx context.Context, path string) (ret *Oidc, err error) {
return ret, err
}
// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Oidc
func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Oidc, error) {
var ret Oidc
// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Models
func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Models, error) {
var ret Models
if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
return nil, err
}
x/did/types/orm/Profile.pkl.go
+20
View File
@@ -0,0 +1,20 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
type Profile struct {
Id string `pkl:"id" json:"id,omitempty" query:"id"`
Subject string `pkl:"subject" json:"subject,omitempty"`
Controller string `pkl:"controller" json:"controller,omitempty"`
OriginUri *string `pkl:"originUri" json:"originUri,omitempty"`
PublicMetadata *string `pkl:"publicMetadata" json:"publicMetadata,omitempty"`
PrivateMetadata *string `pkl:"privateMetadata" json:"privateMetadata,omitempty"`
CreatedAt *string `pkl:"createdAt" json:"createdAt,omitempty"`
UpdatedAt *string `pkl:"updatedAt" json:"updatedAt,omitempty"`
}
x/did/types/orm/PublicKey.pkl.go
+26
View File
@@ -0,0 +1,26 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
import (
"github.com/onsonr/sonr/x/did/types/orm/keyalgorithm"
"github.com/onsonr/sonr/x/did/types/orm/keycurve"
"github.com/onsonr/sonr/x/did/types/orm/keyencoding"
"github.com/onsonr/sonr/x/did/types/orm/keyrole"
"github.com/onsonr/sonr/x/did/types/orm/keytype"
)
type PublicKey struct {
Role keyrole.KeyRole `pkl:"role" json:"role,omitempty" query:"role"`
Algorithm keyalgorithm.KeyAlgorithm `pkl:"algorithm"`
Encoding keyencoding.KeyEncoding `pkl:"encoding"`
Curve keycurve.KeyCurve `pkl:"curve"`
KeyType keytype.KeyType `pkl:"key_type"`
Raw string `pkl:"raw"`
Jwk *JWK `pkl:"jwk"`
}
x/did/types/orm/assettype/AssetType.pkl.go
+46
View File
@@ -0,0 +1,46 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package assettype
import (
"encoding"
"fmt"
)
type AssetType string
const (
Native AssetType = "native"
Wrapped AssetType = "wrapped"
Staking AssetType = "staking"
Pool AssetType = "pool"
Ibc AssetType = "ibc"
Cw20 AssetType = "cw20"
)
// String returns the string representation of AssetType
func (rcv AssetType) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(AssetType)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for AssetType.
func (rcv *AssetType) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "native":
*rcv = Native
case "wrapped":
*rcv = Wrapped
case "staking":
*rcv = Staking
case "pool":
*rcv = Pool
case "ibc":
*rcv = Ibc
case "cw20":
*rcv = Cw20
default:
return fmt.Errorf(`illegal: "%s" is not a valid AssetType`, str)
}
return nil
}
x/did/types/orm/didmethod/DIDMethod.pkl.go
+52
View File
@@ -0,0 +1,52 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package didmethod
import (
"encoding"
"fmt"
)
type DIDMethod string
const (
Ipfs DIDMethod = "ipfs"
Sonr DIDMethod = "sonr"
Bitcoin DIDMethod = "bitcoin"
Ethereum DIDMethod = "ethereum"
Ibc DIDMethod = "ibc"
Webauthn DIDMethod = "webauthn"
Dwn DIDMethod = "dwn"
Service DIDMethod = "service"
)
// String returns the string representation of DIDMethod
func (rcv DIDMethod) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(DIDMethod)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for DIDMethod.
func (rcv *DIDMethod) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "ipfs":
*rcv = Ipfs
case "sonr":
*rcv = Sonr
case "bitcoin":
*rcv = Bitcoin
case "ethereum":
*rcv = Ethereum
case "ibc":
*rcv = Ibc
case "webauthn":
*rcv = Webauthn
case "dwn":
*rcv = Dwn
case "service":
*rcv = Service
default:
return fmt.Errorf(`illegal: "%s" is not a valid DIDMethod`, str)
}
return nil
}
x/did/types/orm/init.pkl.go
+17
View File
@@ -0,0 +1,17 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package orm
import "github.com/apple/pkl-go/pkl"
func init() {
pkl.RegisterMapping("models", Models{})
pkl.RegisterMapping("models#Account", Account{})
pkl.RegisterMapping("models#Asset", Asset{})
pkl.RegisterMapping("models#Chain", Chain{})
pkl.RegisterMapping("models#Credential", Credential{})
pkl.RegisterMapping("models#JWK", JWK{})
pkl.RegisterMapping("models#Grant", Grant{})
pkl.RegisterMapping("models#Keyshare", Keyshare{})
pkl.RegisterMapping("models#PublicKey", PublicKey{})
pkl.RegisterMapping("models#Profile", Profile{})
}
x/did/types/orm/keyalgorithm/KeyAlgorithm.pkl.go
+46
View File
@@ -0,0 +1,46 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package keyalgorithm
import (
"encoding"
"fmt"
)
type KeyAlgorithm string
const (
Es256 KeyAlgorithm = "es256"
Es384 KeyAlgorithm = "es384"
Es512 KeyAlgorithm = "es512"
Eddsa KeyAlgorithm = "eddsa"
Es256k KeyAlgorithm = "es256k"
Ecdsa KeyAlgorithm = "ecdsa"
)
// String returns the string representation of KeyAlgorithm
func (rcv KeyAlgorithm) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(KeyAlgorithm)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyAlgorithm.
func (rcv *KeyAlgorithm) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "es256":
*rcv = Es256
case "es384":
*rcv = Es384
case "es512":
*rcv = Es512
case "eddsa":
*rcv = Eddsa
case "es256k":
*rcv = Es256k
case "ecdsa":
*rcv = Ecdsa
default:
return fmt.Errorf(`illegal: "%s" is not a valid KeyAlgorithm`, str)
}
return nil
}
x/did/types/orm/keycurve/KeyCurve.pkl.go
+58
View File
@@ -0,0 +1,58 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package keycurve
import (
"encoding"
"fmt"
)
type KeyCurve string
const (
P256 KeyCurve = "p256"
P384 KeyCurve = "p384"
P521 KeyCurve = "p521"
X25519 KeyCurve = "x25519"
X448 KeyCurve = "x448"
Ed25519 KeyCurve = "ed25519"
Ed448 KeyCurve = "ed448"
Secp256k1 KeyCurve = "secp256k1"
Bls12381 KeyCurve = "bls12381"
Keccak256 KeyCurve = "keccak256"
)
// String returns the string representation of KeyCurve
func (rcv KeyCurve) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(KeyCurve)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyCurve.
func (rcv *KeyCurve) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "p256":
*rcv = P256
case "p384":
*rcv = P384
case "p521":
*rcv = P521
case "x25519":
*rcv = X25519
case "x448":
*rcv = X448
case "ed25519":
*rcv = Ed25519
case "ed448":
*rcv = Ed448
case "secp256k1":
*rcv = Secp256k1
case "bls12381":
*rcv = Bls12381
case "keccak256":
*rcv = Keccak256
default:
return fmt.Errorf(`illegal: "%s" is not a valid KeyCurve`, str)
}
return nil
}
x/did/types/orm/keyencoding/KeyEncoding.pkl.go
+37
View File
@@ -0,0 +1,37 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package keyencoding
import (
"encoding"
"fmt"
)
type KeyEncoding string
const (
Raw KeyEncoding = "raw"
Hex KeyEncoding = "hex"
Multibase KeyEncoding = "multibase"
)
// String returns the string representation of KeyEncoding
func (rcv KeyEncoding) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(KeyEncoding)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyEncoding.
func (rcv *KeyEncoding) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "raw":
*rcv = Raw
case "hex":
*rcv = Hex
case "multibase":
*rcv = Multibase
default:
return fmt.Errorf(`illegal: "%s" is not a valid KeyEncoding`, str)
}
return nil
}
x/did/types/orm/keyrole/KeyRole.pkl.go
+40
View File
@@ -0,0 +1,40 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package keyrole
import (
"encoding"
"fmt"
)
type KeyRole string
const (
Authentication KeyRole = "authentication"
Assertion KeyRole = "assertion"
Delegation KeyRole = "delegation"
Invocation KeyRole = "invocation"
)
// String returns the string representation of KeyRole
func (rcv KeyRole) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(KeyRole)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyRole.
func (rcv *KeyRole) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "authentication":
*rcv = Authentication
case "assertion":
*rcv = Assertion
case "delegation":
*rcv = Delegation
case "invocation":
*rcv = Invocation
default:
return fmt.Errorf(`illegal: "%s" is not a valid KeyRole`, str)
}
return nil
}
x/did/types/orm/keysharerole/KeyShareRole.pkl.go
+34
View File
@@ -0,0 +1,34 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package keysharerole
import (
"encoding"
"fmt"
)
type KeyShareRole string
const (
User KeyShareRole = "user"
Validator KeyShareRole = "validator"
)
// String returns the string representation of KeyShareRole
func (rcv KeyShareRole) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(KeyShareRole)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyShareRole.
func (rcv *KeyShareRole) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "user":
*rcv = User
case "validator":
*rcv = Validator
default:
return fmt.Errorf(`illegal: "%s" is not a valid KeyShareRole`, str)
}
return nil
}
x/did/types/orm/keytype/KeyType.pkl.go
+55
View File
@@ -0,0 +1,55 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package keytype
import (
"encoding"
"fmt"
)
type KeyType string
const (
Octet KeyType = "octet"
Elliptic KeyType = "elliptic"
Rsa KeyType = "rsa"
Symmetric KeyType = "symmetric"
Hmac KeyType = "hmac"
Mpc KeyType = "mpc"
Zk KeyType = "zk"
Webauthn KeyType = "webauthn"
Bip32 KeyType = "bip32"
)
// String returns the string representation of KeyType
func (rcv KeyType) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(KeyType)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for KeyType.
func (rcv *KeyType) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "octet":
*rcv = Octet
case "elliptic":
*rcv = Elliptic
case "rsa":
*rcv = Rsa
case "symmetric":
*rcv = Symmetric
case "hmac":
*rcv = Hmac
case "mpc":
*rcv = Mpc
case "zk":
*rcv = Zk
case "webauthn":
*rcv = Webauthn
case "bip32":
*rcv = Bip32
default:
return fmt.Errorf(`illegal: "%s" is not a valid KeyType`, str)
}
return nil
}
x/did/types/orm/permissiongrant/PermissionGrant.pkl.go
+46
View File
@@ -0,0 +1,46 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package permissiongrant
import (
"encoding"
"fmt"
)
type PermissionGrant string
const (
None PermissionGrant = "none"
Read PermissionGrant = "read"
Write PermissionGrant = "write"
Verify PermissionGrant = "verify"
Broadcast PermissionGrant = "broadcast"
Admin PermissionGrant = "admin"
)
// String returns the string representation of PermissionGrant
func (rcv PermissionGrant) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(PermissionGrant)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for PermissionGrant.
func (rcv *PermissionGrant) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "none":
*rcv = None
case "read":
*rcv = Read
case "write":
*rcv = Write
case "verify":
*rcv = Verify
case "broadcast":
*rcv = Broadcast
case "admin":
*rcv = Admin
default:
return fmt.Errorf(`illegal: "%s" is not a valid PermissionGrant`, str)
}
return nil
}
x/did/types/orm/permissionscope/PermissionScope.pkl.go
+49
View File
@@ -0,0 +1,49 @@
// Code generated from Pkl module `models`. DO NOT EDIT.
package permissionscope
import (
"encoding"
"fmt"
)
type PermissionScope string
const (
Profile PermissionScope = "profile"
Metadata PermissionScope = "metadata"
Permissions PermissionScope = "permissions"
Wallets PermissionScope = "wallets"
Transactions PermissionScope = "transactions"
User PermissionScope = "user"
Validator PermissionScope = "validator"
)
// String returns the string representation of PermissionScope
func (rcv PermissionScope) String() string {
return string(rcv)
}
var _ encoding.BinaryUnmarshaler = new(PermissionScope)
// UnmarshalBinary implements encoding.BinaryUnmarshaler for PermissionScope.
func (rcv *PermissionScope) UnmarshalBinary(data []byte) error {
switch str := string(data); str {
case "profile":
*rcv = Profile
case "metadata":
*rcv = Metadata
case "permissions":
*rcv = Permissions
case "wallets":
*rcv = Wallets
case "transactions":
*rcv = Transactions
case "user":
*rcv = User
case "validator":
*rcv = Validator
default:
return fmt.Errorf(`illegal: "%s" is not a valid PermissionScope`, str)
}
return nil
}
x/did/types/pubkey.go
-152
View File
@@ -1,153 +1 @@
package types
import (
"crypto/ecdsa"
"encoding/hex"
cryptotypes "github.com/cosmos/cosmos-sdk/crypto/types"
"github.com/mr-tron/base58/base58"
"github.com/onsonr/crypto"
"github.com/onsonr/crypto/macaroon"
)
var WalletKeyInfo = &KeyInfo{
Role: KeyRole_KEY_ROLE_DELEGATION,
Curve: KeyCurve_KEY_CURVE_SECP256K1,
Algorithm: KeyAlgorithm_KEY_ALGORITHM_ECDSA,
Encoding: KeyEncoding_KEY_ENCODING_HEX,
Type: KeyType_KEY_TYPE_BIP32,
}
var EthKeyInfo = &KeyInfo{
Role: KeyRole_KEY_ROLE_DELEGATION,
Curve: KeyCurve_KEY_CURVE_KECCAK256,
Algorithm: KeyAlgorithm_KEY_ALGORITHM_ECDSA,
Encoding: KeyEncoding_KEY_ENCODING_HEX,
Type: KeyType_KEY_TYPE_BIP32,
}
var SonrKeyInfo = &KeyInfo{
Role: KeyRole_KEY_ROLE_INVOCATION,
Curve: KeyCurve_KEY_CURVE_P256,
Algorithm: KeyAlgorithm_KEY_ALGORITHM_ECDSA,
Encoding: KeyEncoding_KEY_ENCODING_HEX,
Type: KeyType_KEY_TYPE_MPC,
}
var ChainCodeKeyInfos = map[ChainCode]*KeyInfo{
ChainCodeBTC: WalletKeyInfo,
ChainCodeETH: EthKeyInfo,
ChainCodeSNR: SonrKeyInfo,
ChainCodeIBC: WalletKeyInfo,
}
// NewEthPublicKey returns a new ethereum public key
func NewPublicKey(data []byte, keyInfo *KeyInfo) (*PubKey, error) {
encKey, err := keyInfo.Encoding.EncodeRaw(data)
if err != nil {
return nil, err
}
return &PubKey{
Raw: encKey,
Role: keyInfo.Role,
Encoding: keyInfo.Encoding,
Algorithm: keyInfo.Algorithm,
Curve: keyInfo.Curve,
KeyType: keyInfo.Type,
}, nil
}
// Address returns the address of the public key
func (k *PubKey) Address() cryptotypes.Address {
return nil
}
// Bytes returns the raw bytes of the public key
func (k *PubKey) Bytes() []byte {
bz, _ := k.GetEncoding().DecodeRaw(k.GetRaw())
return bz
}
// Clone returns a copy of the public key
func (k *PubKey) Clone() cryptotypes.PubKey {
return &PubKey{
Raw: k.GetRaw(),
Role: k.GetRole(),
Encoding: k.GetEncoding(),
Algorithm: k.GetAlgorithm(),
Curve: k.GetCurve(),
KeyType: k.GetKeyType(),
}
}
// IssueMacaroon returns a macaroon for the public key with the given id and location
func (pk *PubKey) IssueMacaroon(subject string, origin string) (*macaroon.Macaroon, error) {
return macaroon.New(pk.Bytes(), []byte(subject), origin, macaroon.LatestVersion)
}
// ECDSA returns the ECDSA public key
func (k *PubKey) ECDSA() (*ecdsa.PublicKey, error) {
return crypto.ComputeEcdsaPublicKey(k.Bytes())
}
// VerifySignature verifies a signature over the given message
func (k *PubKey) VerifySignature(msg []byte, sig []byte) bool {
pk, err := crypto.ComputeEcdsaPublicKey(k.Bytes())
sigMpc, err := crypto.DeserializeMPCSignature(sig)
if err != nil {
return false
}
return crypto.VerifyMPCSignature(sigMpc, msg, pk)
}
// Equals returns true if two public keys are equal
func (k *PubKey) Equals(k2 cryptotypes.PubKey) bool {
if k == nil && k2 == nil {
return true
}
return false
}
// Type returns the type of the public key
func (k *PubKey) Type() string {
return k.KeyType.String()
}
// DecodePublicKey extracts the public key from the given data
func (k *KeyInfo) DecodePublicKey(data interface{}) ([]byte, error) {
var bz []byte
switch v := data.(type) {
case string:
bz = []byte(v)
case []byte:
bz = v
default:
return nil, ErrUnsupportedKeyEncoding
}
if k.Encoding == KeyEncoding_KEY_ENCODING_RAW {
return bz, nil
}
if k.Encoding == KeyEncoding_KEY_ENCODING_HEX {
return hex.DecodeString(string(bz))
}
if k.Encoding == KeyEncoding_KEY_ENCODING_MULTIBASE {
return base58.Decode(string(bz))
}
return nil, ErrUnsupportedKeyEncoding
}
// EncodePublicKey encodes the public key according to the KeyInfo's encoding
func (k *KeyInfo) EncodePublicKey(data []byte) (string, error) {
if k.Encoding == KeyEncoding_KEY_ENCODING_RAW {
return string(data), nil
}
if k.Encoding == KeyEncoding_KEY_ENCODING_HEX {
return hex.EncodeToString(data), nil
}
if k.Encoding == KeyEncoding_KEY_ENCODING_MULTIBASE {
return base58.Encode(data), nil
}
return "", ErrUnsupportedKeyEncoding
}
x/did/types/query.pb.go
+26 -733
View File
@@ -97,75 +97,6 @@ func (m *QueryRequest) GetAsset() string {
return ""
}
// QueryResolveResponse is the response type for the Query/Resolve RPC method.
type QueryResponse struct {
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
Query string `protobuf:"bytes,2,opt,name=query,proto3" json:"query,omitempty"`
Document *Document `protobuf:"bytes,3,opt,name=document,proto3" json:"document,omitempty"`
Params *Params `protobuf:"bytes,5,opt,name=params,proto3" json:"params,omitempty"`
}
func (m *QueryResponse) Reset() { *m = QueryResponse{} }
func (m *QueryResponse) String() string { return proto.CompactTextString(m) }
func (*QueryResponse) ProtoMessage() {}
func (*QueryResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ae1fa9bb626e2869, []int{1}
}
func (m *QueryResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryResponse.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 *QueryResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryResponse.Merge(m, src)
}
func (m *QueryResponse) XXX_Size() int {
return m.Size()
}
func (m *QueryResponse) XXX_DiscardUnknown() {
xxx_messageInfo_QueryResponse.DiscardUnknown(m)
}
var xxx_messageInfo_QueryResponse proto.InternalMessageInfo
func (m *QueryResponse) GetSuccess() bool {
if m != nil {
return m.Success
}
return false
}
func (m *QueryResponse) GetQuery() string {
if m != nil {
return m.Query
}
return ""
}
func (m *QueryResponse) GetDocument() *Document {
if m != nil {
return m.Document
}
return nil
}
func (m *QueryResponse) GetParams() *Params {
if m != nil {
return m.Params
}
return nil
}
// QueryParamsResponse is the response type for the Query/Params RPC method.
type QueryParamsResponse struct {
// params defines the parameters of the module.
@@ -176,7 +107,7 @@ func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} }
func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
func (*QueryParamsResponse) ProtoMessage() {}
func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ae1fa9bb626e2869, []int{2}
return fileDescriptor_ae1fa9bb626e2869, []int{1}
}
func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -222,7 +153,7 @@ func (m *QueryResolveResponse) Reset() { *m = QueryResolveResponse{} }
func (m *QueryResolveResponse) String() string { return proto.CompactTextString(m) }
func (*QueryResolveResponse) ProtoMessage() {}
func (*QueryResolveResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ae1fa9bb626e2869, []int{3}
return fileDescriptor_ae1fa9bb626e2869, []int{2}
}
func (m *QueryResolveResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@@ -258,137 +189,39 @@ func (m *QueryResolveResponse) GetDocument() *Document {
return nil
}
// SyncRequest is the request type for the Sync RPC method.
type SyncRequest struct {
Did string `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
}
func (m *SyncRequest) Reset() { *m = SyncRequest{} }
func (m *SyncRequest) String() string { return proto.CompactTextString(m) }
func (*SyncRequest) ProtoMessage() {}
func (*SyncRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_ae1fa9bb626e2869, []int{4}
}
func (m *SyncRequest) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SyncRequest.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 *SyncRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_SyncRequest.Merge(m, src)
}
func (m *SyncRequest) XXX_Size() int {
return m.Size()
}
func (m *SyncRequest) XXX_DiscardUnknown() {
xxx_messageInfo_SyncRequest.DiscardUnknown(m)
}
var xxx_messageInfo_SyncRequest proto.InternalMessageInfo
func (m *SyncRequest) GetDid() string {
if m != nil {
return m.Did
}
return ""
}
// SyncResponse is the response type for the Sync RPC method.
type SyncResponse struct {
Success bool `protobuf:"varint,1,opt,name=success,proto3" json:"success,omitempty"`
}
func (m *SyncResponse) Reset() { *m = SyncResponse{} }
func (m *SyncResponse) String() string { return proto.CompactTextString(m) }
func (*SyncResponse) ProtoMessage() {}
func (*SyncResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_ae1fa9bb626e2869, []int{5}
}
func (m *SyncResponse) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *SyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_SyncResponse.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 *SyncResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_SyncResponse.Merge(m, src)
}
func (m *SyncResponse) XXX_Size() int {
return m.Size()
}
func (m *SyncResponse) XXX_DiscardUnknown() {
xxx_messageInfo_SyncResponse.DiscardUnknown(m)
}
var xxx_messageInfo_SyncResponse proto.InternalMessageInfo
func (m *SyncResponse) GetSuccess() bool {
if m != nil {
return m.Success
}
return false
}
func init() {
proto.RegisterType((*QueryRequest)(nil), "did.v1.QueryRequest")
proto.RegisterType((*QueryResponse)(nil), "did.v1.QueryResponse")
proto.RegisterType((*QueryParamsResponse)(nil), "did.v1.QueryParamsResponse")
proto.RegisterType((*QueryResolveResponse)(nil), "did.v1.QueryResolveResponse")
proto.RegisterType((*SyncRequest)(nil), "did.v1.SyncRequest")
proto.RegisterType((*SyncResponse)(nil), "did.v1.SyncResponse")
}
func init() { proto.RegisterFile("did/v1/query.proto", fileDescriptor_ae1fa9bb626e2869) }
var fileDescriptor_ae1fa9bb626e2869 = []byte{
// 446 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x4f, 0x6b, 0xd4, 0x40,
0x14, 0xdf, 0x69, 0xbb, 0xd9, 0xf6, 0x75, 0xab, 0xe5, 0x35, 0x48, 0x58, 0x4b, 0x94, 0x39, 0x48,
0x0f, 0x92, 0xa1, 0xf5, 0xaa, 0x20, 0xd2, 0xa3, 0x07, 0x1b, 0x6f, 0x9e, 0x4c, 0x33, 0x43, 0x1c,
0xda, 0x9d, 0x49, 0x33, 0xc9, 0x62, 0x10, 0x2f, 0x7e, 0x02, 0x41, 0xfc, 0x4e, 0x1e, 0x0b, 0x5e,
0x3c, 0xca, 0xae, 0x27, 0x3f, 0x85, 0x64, 0x66, 0x52, 0x77, 0x85, 0xba, 0x97, 0x65, 0xdf, 0xef,
0xbd, 0xf7, 0xfb, 0xf3, 0x32, 0x80, 0x5c, 0x72, 0x36, 0x3b, 0x66, 0x57, 0x8d, 0xa8, 0xda, 0xa4,
0xac, 0x74, 0xad, 0x31, 0xe0, 0x92, 0x27, 0xb3, 0xe3, 0x49, 0xe8, 0x7b, 0x85, 0x50, 0xc2, 0x48,
0xe3, 0xba, 0x93, 0xc3, 0x42, 0xeb, 0xe2, 0x52, 0xb0, 0xac, 0x94, 0x2c, 0x53, 0x4a, 0xd7, 0x59,
0x2d, 0xb5, 0xf2, 0x5d, 0xfa, 0x16, 0xc6, 0x67, 0x1d, 0x55, 0x2a, 0xae, 0x1a, 0x61, 0x6a, 0xdc,
0x87, 0x4d, 0x2e, 0x79, 0x44, 0x1e, 0x92, 0xa3, 0x9d, 0xb4, 0xfb, 0x8b, 0xf7, 0x20, 0xd0, 0x95,
0x2c, 0xa4, 0x8a, 0x36, 0x2c, 0xe8, 0xab, 0x6e, 0xf2, 0x42, 0xb4, 0xd1, 0xa6, 0x9b, 0xbc, 0x10,
0x2d, 0x86, 0x30, 0xcc, 0x8c, 0x11, 0x75, 0xb4, 0x65, 0x31, 0x57, 0xd0, 0xaf, 0x04, 0xf6, 0xbc,
0x84, 0x29, 0xb5, 0x32, 0x02, 0x23, 0x18, 0x99, 0x26, 0xcf, 0x85, 0x31, 0x56, 0x67, 0x3b, 0xed,
0xcb, 0x8e, 0xc1, 0x06, 0xf3, 0x52, 0xae, 0xc0, 0xc7, 0xb0, 0xcd, 0x75, 0xde, 0x4c, 0x85, 0xaa,
0xad, 0xdc, 0xee, 0xc9, 0x7e, 0xe2, 0x22, 0x27, 0xa7, 0x1e, 0x4f, 0x6f, 0x26, 0xf0, 0x11, 0x04,
0x65, 0x56, 0x65, 0x53, 0x13, 0x0d, 0xed, 0xec, 0x9d, 0x7e, 0xf6, 0x95, 0x45, 0x53, 0xdf, 0xa5,
0xcf, 0xe0, 0xc0, 0xda, 0xf2, 0x70, 0x6f, 0xee, 0xef, 0x3a, 0xf9, 0xef, 0xfa, 0x29, 0x84, 0x7d,
0x2a, 0x7d, 0x39, 0x13, 0x37, 0xfb, 0xcb, 0x66, 0xc9, 0x3a, 0xb3, 0xf4, 0x01, 0xec, 0xbe, 0x6e,
0x55, 0x7e, 0xeb, 0xf5, 0xe9, 0x11, 0x8c, 0xdd, 0xc0, 0xba, 0xdb, 0x9d, 0xfc, 0x26, 0x30, 0xb4,
0x8e, 0xf0, 0x25, 0x04, 0xce, 0x2c, 0x86, 0xbd, 0xf4, 0xf2, 0x37, 0x9e, 0xdc, 0x5f, 0x41, 0x57,
0xf3, 0xd3, 0xbb, 0x9f, 0xbe, 0xff, 0xfa, 0xb2, 0xb1, 0x83, 0x23, 0xe6, 0x82, 0xe2, 0x19, 0x8c,
0x7c, 0xc6, 0x5b, 0xe8, 0x0e, 0xff, 0x41, 0x57, 0xee, 0x41, 0xd1, 0xf2, 0x8d, 0x11, 0x58, 0xf7,
0x3a, 0x3f, 0x70, 0xc9, 0x3f, 0xe2, 0x73, 0xd8, 0xea, 0x42, 0xe1, 0x41, 0xbf, 0xb9, 0x74, 0x83,
0x49, 0xb8, 0x0a, 0x7a, 0x9a, 0x3d, 0x4b, 0x33, 0xa2, 0x43, 0x66, 0x5a, 0x95, 0xbf, 0x78, 0xfa,
0x6d, 0x1e, 0x93, 0xeb, 0x79, 0x4c, 0x7e, 0xce, 0x63, 0xf2, 0x79, 0x11, 0x0f, 0xae, 0x17, 0xf1,
0xe0, 0xc7, 0x22, 0x1e, 0xbc, 0xa1, 0x85, 0xac, 0xdf, 0x35, 0xe7, 0x49, 0xae, 0xa7, 0x4c, 0x2b,
0xa3, 0x55, 0xc5, 0xec, 0xcf, 0x7b, 0xab, 0x5f, 0xb7, 0xa5, 0x30, 0xe7, 0x81, 0x7d, 0xfb, 0x4f,
0xfe, 0x04, 0x00, 0x00, 0xff, 0xff, 0x31, 0x4b, 0x75, 0xe8, 0x4d, 0x03, 0x00, 0x00,
// 362 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x51, 0xc1, 0x4e, 0xea, 0x40,
0x14, 0xa5, 0xf0, 0x28, 0x8f, 0x79, 0xe4, 0x3d, 0x32, 0xaf, 0x31, 0x0d, 0x92, 0xc6, 0x74, 0x61,
0x5c, 0x98, 0x4e, 0xc0, 0xad, 0x6e, 0x0c, 0x4b, 0x17, 0xd2, 0xa5, 0x2b, 0x0b, 0x73, 0x53, 0x27,
0xc0, 0x4c, 0xe9, 0x4c, 0x89, 0x8d, 0x71, 0xe3, 0x17, 0x98, 0xf8, 0x13, 0x7e, 0x8a, 0x4b, 0x12,
0x37, 0x2e, 0x0d, 0xf8, 0x21, 0xa6, 0xd3, 0x81, 0x88, 0x89, 0x9b, 0xa6, 0xf7, 0x9c, 0x73, 0xcf,
0x3d, 0x77, 0x2e, 0xc2, 0x94, 0x51, 0xb2, 0xe8, 0x91, 0x79, 0x06, 0x69, 0x1e, 0x24, 0xa9, 0x50,
0x02, 0xdb, 0x94, 0xd1, 0x60, 0xd1, 0xeb, 0x38, 0x86, 0x8b, 0x81, 0x83, 0x64, 0xb2, 0x64, 0x3b,
0xdd, 0x58, 0x88, 0x78, 0x0a, 0x24, 0x4a, 0x18, 0x89, 0x38, 0x17, 0x2a, 0x52, 0x4c, 0x70, 0xc3,
0xfa, 0xd7, 0xa8, 0x35, 0x2c, 0xac, 0x42, 0x98, 0x67, 0x20, 0x15, 0x6e, 0xa3, 0x1a, 0x65, 0xd4,
0xb5, 0x0e, 0xac, 0xa3, 0x66, 0x58, 0xfc, 0xe2, 0x3d, 0x64, 0x8b, 0x94, 0xc5, 0x8c, 0xbb, 0x55,
0x0d, 0x9a, 0xaa, 0x50, 0x4e, 0x20, 0x77, 0x6b, 0xa5, 0x72, 0x02, 0x39, 0x76, 0x50, 0x3d, 0x92,
0x12, 0x94, 0xfb, 0x4b, 0x63, 0x65, 0xe1, 0x9f, 0xa1, 0xff, 0x7a, 0xc2, 0x65, 0x94, 0x46, 0x33,
0x19, 0x82, 0x4c, 0x04, 0x97, 0x80, 0x0f, 0x91, 0x9d, 0x68, 0x44, 0xcf, 0xfa, 0xd3, 0xff, 0x1b,
0x94, 0x5b, 0x04, 0x46, 0x67, 0x58, 0x7f, 0x80, 0x1c, 0x13, 0x50, 0x8a, 0xe9, 0x02, 0xb6, 0xfd,
0xc7, 0xe8, 0x37, 0x15, 0xe3, 0x6c, 0x06, 0x5c, 0x19, 0x87, 0xf6, 0xc6, 0x61, 0x60, 0xf0, 0x70,
0xab, 0xe8, 0x3f, 0x5b, 0xa8, 0xae, 0x6d, 0xf0, 0x05, 0xb2, 0xcb, 0x09, 0xd8, 0xd9, 0xe8, 0xbf,
0x3e, 0x40, 0x67, 0x7f, 0x07, 0xdd, 0x0d, 0xed, 0xff, 0x7b, 0x78, 0xfd, 0x78, 0xaa, 0x36, 0x71,
0x83, 0x94, 0xe9, 0xf0, 0x10, 0x35, 0x4c, 0xb0, 0x1f, 0xec, 0xba, 0xdf, 0xd0, 0x9d, 0x25, 0x7c,
0xac, 0xfd, 0x5a, 0x18, 0x91, 0xe2, 0x74, 0x77, 0x94, 0xd1, 0xfb, 0xf3, 0xd3, 0x97, 0x95, 0x67,
0x2d, 0x57, 0x9e, 0xf5, 0xbe, 0xf2, 0xac, 0xc7, 0xb5, 0x57, 0x59, 0xae, 0xbd, 0xca, 0xdb, 0xda,
0xab, 0x5c, 0xf9, 0x31, 0x53, 0x37, 0xd9, 0x28, 0x18, 0x8b, 0x19, 0x11, 0x5c, 0x0a, 0x9e, 0x12,
0xfd, 0xb9, 0xd5, 0xdd, 0x2a, 0x4f, 0x40, 0x8e, 0x6c, 0x7d, 0xd6, 0x93, 0xcf, 0x00, 0x00, 0x00,
0xff, 0xff, 0x7d, 0xbe, 0x9f, 0x67, 0x28, 0x02, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@@ -407,8 +240,6 @@ type QueryClient interface {
Params(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
// Resolve queries the DID document by its id.
Resolve(ctx context.Context, in *QueryRequest, opts ...grpc.CallOption) (*QueryResolveResponse, error)
// Sync queries the DID document by its id. And returns the required PKL information
Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (*SyncResponse, error)
}
type queryClient struct {
@@ -437,23 +268,12 @@ func (c *queryClient) Resolve(ctx context.Context, in *QueryRequest, opts ...grp
return out, nil
}
func (c *queryClient) Sync(ctx context.Context, in *SyncRequest, opts ...grpc.CallOption) (*SyncResponse, error) {
out := new(SyncResponse)
err := c.cc.Invoke(ctx, "/did.v1.Query/Sync", in, out, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// QueryServer is the server API for Query service.
type QueryServer interface {
// Params queries all parameters of the module.
Params(context.Context, *QueryRequest) (*QueryParamsResponse, error)
// Resolve queries the DID document by its id.
Resolve(context.Context, *QueryRequest) (*QueryResolveResponse, error)
// Sync queries the DID document by its id. And returns the required PKL information
Sync(context.Context, *SyncRequest) (*SyncResponse, error)
}
// UnimplementedQueryServer can be embedded to have forward compatible implementations.
@@ -466,9 +286,6 @@ func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryRequest)
func (*UnimplementedQueryServer) Resolve(ctx context.Context, req *QueryRequest) (*QueryResolveResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Resolve not implemented")
}
func (*UnimplementedQueryServer) Sync(ctx context.Context, req *SyncRequest) (*SyncResponse, error) {
return nil, status.Errorf(codes.Unimplemented, "method Sync not implemented")
}
func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
s.RegisterService(&_Query_serviceDesc, srv)
@@ -510,24 +327,6 @@ func _Query_Resolve_Handler(srv interface{}, ctx context.Context, dec func(inter
return interceptor(ctx, in, info, handler)
}
func _Query_Sync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(SyncRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(QueryServer).Sync(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: "/did.v1.Query/Sync",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(QueryServer).Sync(ctx, req.(*SyncRequest))
}
return interceptor(ctx, in, info, handler)
}
var _Query_serviceDesc = grpc.ServiceDesc{
ServiceName: "did.v1.Query",
HandlerType: (*QueryServer)(nil),
@@ -540,10 +339,6 @@ var _Query_serviceDesc = grpc.ServiceDesc{
MethodName: "Resolve",
Handler: _Query_Resolve_Handler,
},
{
MethodName: "Sync",
Handler: _Query_Sync_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "did/v1/query.proto",
@@ -600,70 +395,6 @@ func (m *QueryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *QueryResponse) 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 *QueryResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Params != nil {
{
size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x2a
}
if m.Document != nil {
{
size, err := m.Document.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
if len(m.Query) > 0 {
i -= len(m.Query)
copy(dAtA[i:], m.Query)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Query)))
i--
dAtA[i] = 0x12
}
if m.Success {
i--
if m.Success {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@@ -734,69 +465,6 @@ func (m *QueryResolveResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil
}
func (m *SyncRequest) 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 *SyncRequest) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Did) > 0 {
i -= len(m.Did)
copy(dAtA[i:], m.Did)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Did)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *SyncResponse) 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 *SyncResponse) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *SyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if m.Success {
i--
if m.Success {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
offset -= sovQuery(v)
base := offset
@@ -833,30 +501,6 @@ func (m *QueryRequest) Size() (n int) {
return n
}
func (m *QueryResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Success {
n += 2
}
l = len(m.Query)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
if m.Document != nil {
l = m.Document.Size()
n += 1 + l + sovQuery(uint64(l))
}
if m.Params != nil {
l = m.Params.Size()
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func (m *QueryParamsResponse) Size() (n int) {
if m == nil {
return 0
@@ -883,31 +527,6 @@ func (m *QueryResolveResponse) Size() (n int) {
return n
}
func (m *SyncRequest) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Did)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func (m *SyncResponse) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if m.Success {
n += 2
}
return n
}
func sovQuery(x uint64) (n int) {
return (math_bits.Len64(x|1) + 6) / 7
}
@@ -1092,180 +711,6 @@ func (m *QueryRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *QueryResponse) 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 ErrIntOverflowQuery
}
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: QueryResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: QueryResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Success = bool(v != 0)
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Query", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
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 ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Query = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Document", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Document == nil {
m.Document = &Document{}
}
if err := m.Document.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Params == nil {
m.Params = &Params{}
}
if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@@ -1438,158 +883,6 @@ func (m *QueryResolveResponse) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *SyncRequest) 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 ErrIntOverflowQuery
}
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: SyncRequest: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SyncRequest: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Did", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
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 ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Did = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *SyncResponse) 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 ErrIntOverflowQuery
}
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: SyncResponse: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: SyncResponse: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Success = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipQuery(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0
x/did/types/query.pb.gw.go
-83
View File
@@ -141,42 +141,6 @@ func local_request_Query_Resolve_0(ctx context.Context, marshaler runtime.Marsha
}
var (
filter_Query_Sync_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)
func request_Query_Sync_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SyncRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Sync_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := client.Sync(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
return msg, metadata, err
}
func local_request_Query_Sync_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
var protoReq SyncRequest
var metadata runtime.ServerMetadata
if err := req.ParseForm(); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Query_Sync_0); err != nil {
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
}
msg, err := server.Sync(ctx, &protoReq)
return msg, metadata, err
}
// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
// UnaryRPC :call QueryServer directly.
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -229,29 +193,6 @@ func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, serv
})
mux.Handle("POST", pattern_Query_Sync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
var stream runtime.ServerTransportStream
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := local_request_Query_Sync_0(rctx, inboundMarshaler, server, req, pathParams)
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_Sync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@@ -333,26 +274,6 @@ func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, clie
})
mux.Handle("POST", pattern_Query_Sync_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
rctx, err := runtime.AnnotateContext(ctx, mux, req)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
resp, md, err := request_Query_Sync_0(rctx, inboundMarshaler, client, req, pathParams)
ctx = runtime.NewServerMetadataContext(ctx, md)
if err != nil {
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
return
}
forward_Query_Sync_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
})
return nil
}
@@ -360,14 +281,10 @@ var (
pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"params"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_Resolve_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 1, 0, 4, 1, 5, 0}, []string{"did"}, "", runtime.AssumeColonVerbOpt(false)))
pattern_Query_Sync_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0}, []string{"sync"}, "", runtime.AssumeColonVerbOpt(false)))
)
var (
forward_Query_Params_0 = runtime.ForwardResponseMessage
forward_Query_Resolve_0 = runtime.ForwardResponseMessage
forward_Query_Sync_0 = runtime.ForwardResponseMessage
)
x/did/types/scopes.go
-53
View File
@@ -1,53 +0,0 @@
package types
import "gopkg.in/macaroon-bakery.v2/bakery/checkers"
var (
PermissionScopeStrings = [...]string{
"profile.name",
"identifiers.email",
"identifiers.phone",
"transactions.read",
"transactions.write",
"wallets.read",
"wallets.create",
"wallets.subscribe",
"wallets.update",
"transactions.verify",
"transactions.broadcast",
"admin.user",
"admin.validator",
}
StringToPermissionScope = map[string]PermissionScope{
"PERMISSION_SCOPE_UNSPECIFIED": PermissionScope_PERMISSION_SCOPE_UNSPECIFIED,
"PERMISSION_SCOPE_BASIC_INFO": PermissionScope_PERMISSION_SCOPE_BASIC_INFO,
"PERMISSION_SCOPE_IDENTIFIERS_EMAIL": PermissionScope_PERMISSION_SCOPE_PERMISSIONS_READ,
"PERMISSION_SCOPE_IDENTIFIERS_PHONE": PermissionScope_PERMISSION_SCOPE_PERMISSIONS_WRITE,
"PERMISSION_SCOPE_TRANSACTIONS_READ": PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_READ,
"PERMISSION_SCOPE_TRANSACTIONS_WRITE": PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_WRITE,
"PERMISSION_SCOPE_WALLETS_READ": PermissionScope_PERMISSION_SCOPE_WALLETS_READ,
"PERMISSION_SCOPE_WALLETS_CREATE": PermissionScope_PERMISSION_SCOPE_WALLETS_CREATE,
"PERMISSION_SCOPE_WALLETS_SUBSCRIBE": PermissionScope_PERMISSION_SCOPE_WALLETS_SUBSCRIBE,
"PERMISSION_SCOPE_WALLETS_UPDATE": PermissionScope_PERMISSION_SCOPE_WALLETS_UPDATE,
"PERMISSION_SCOPE_TRANSACTIONS_VERIFY": PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_VERIFY,
"PERMISSION_SCOPE_TRANSACTIONS_BROADCAST": PermissionScope_PERMISSION_SCOPE_TRANSACTIONS_BROADCAST,
"PERMISSION_SCOPE_ADMIN_USER": PermissionScope_PERMISSION_SCOPE_ADMIN_USER,
"PERMISSION_SCOPE_ADMIN_VALIDATOR": PermissionScope_PERMISSION_SCOPE_ADMIN_VALIDATOR,
}
)
func ResolvePermissionScope(scope string) (PermissionScope, bool) {
uriToPrefix := make(map[string]string)
for _, scope := range PermissionScopeStrings {
uriToPrefix["https://example.com/auth/"+scope] = scope
}
PermissionNamespace := checkers.NewNamespace(uriToPrefix)
prefix, ok := PermissionNamespace.Resolve("https://example.com/auth/" + scope)
if !ok {
return 0, false
}
permScope, ok := StringToPermissionScope[prefix]
return permScope, ok
}
x/did/types/state.pb.go
+146 -238
View File
@@ -90,23 +90,21 @@ func (m *Alias) GetOrigin() string {
// Controller represents a Sonr DWN Vault
type Controller struct {
// The unique identifier of the controller
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
Number uint64 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
// The unique identifier of the controller
Did string `protobuf:"bytes,2,opt,name=did,proto3" json:"did,omitempty"`
// The DID of the controller
SonrAddress string `protobuf:"bytes,2,opt,name=sonr_address,json=sonrAddress,proto3" json:"sonr_address,omitempty"`
SonrAddress string `protobuf:"bytes,3,opt,name=sonr_address,json=sonrAddress,proto3" json:"sonr_address,omitempty"`
// The DID of the controller
EthAddress string `protobuf:"bytes,3,opt,name=eth_address,json=ethAddress,proto3" json:"eth_address,omitempty"`
EthAddress string `protobuf:"bytes,4,opt,name=eth_address,json=ethAddress,proto3" json:"eth_address,omitempty"`
// The DID of the controller
BtcAddress string `protobuf:"bytes,4,opt,name=btc_address,json=btcAddress,proto3" json:"btc_address,omitempty"`
// Aliases of the controller
Aliases []string `protobuf:"bytes,5,rep,name=aliases,proto3" json:"aliases,omitempty"`
BtcAddress string `protobuf:"bytes,5,opt,name=btc_address,json=btcAddress,proto3" json:"btc_address,omitempty"`
// PubKey is the verification method
PublicKey *PubKey `protobuf:"bytes,6,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
// The vault address or identifier
VaultCid string `protobuf:"bytes,7,opt,name=vault_cid,json=vaultCid,proto3" json:"vault_cid,omitempty"`
// The Authentications of the controller
Authentication []string `protobuf:"bytes,8,rep,name=authentication,proto3" json:"authentication,omitempty"`
PublicKey []byte `protobuf:"bytes,6,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
// Val Keyshare
KsVal string `protobuf:"bytes,7,opt,name=ks_val,json=ksVal,proto3" json:"ks_val,omitempty"`
// The Status of the claims for the controller
Status string `protobuf:"bytes,9,opt,name=status,proto3" json:"status,omitempty"`
Claimed bool `protobuf:"varint,8,opt,name=claimed,proto3" json:"claimed,omitempty"`
}
func (m *Controller) Reset() { *m = Controller{} }
@@ -142,9 +140,16 @@ func (m *Controller) XXX_DiscardUnknown() {
var xxx_messageInfo_Controller proto.InternalMessageInfo
func (m *Controller) GetId() string {
func (m *Controller) GetNumber() uint64 {
if m != nil {
return m.Id
return m.Number
}
return 0
}
func (m *Controller) GetDid() string {
if m != nil {
return m.Did
}
return ""
}
@@ -170,45 +175,31 @@ func (m *Controller) GetBtcAddress() string {
return ""
}
func (m *Controller) GetAliases() []string {
if m != nil {
return m.Aliases
}
return nil
}
func (m *Controller) GetPublicKey() *PubKey {
func (m *Controller) GetPublicKey() []byte {
if m != nil {
return m.PublicKey
}
return nil
}
func (m *Controller) GetVaultCid() string {
func (m *Controller) GetKsVal() string {
if m != nil {
return m.VaultCid
return m.KsVal
}
return ""
}
func (m *Controller) GetAuthentication() []string {
func (m *Controller) GetClaimed() bool {
if m != nil {
return m.Authentication
return m.Claimed
}
return nil
}
func (m *Controller) GetStatus() string {
if m != nil {
return m.Status
}
return ""
return false
}
// Verification reprsents a method of verifying membership in a DID
type Verification struct {
// The unique identifier of the verification
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
Did string `protobuf:"bytes,1,opt,name=did,proto3" json:"did,omitempty"`
// The controller of the verification
Controller string `protobuf:"bytes,2,opt,name=controller,proto3" json:"controller,omitempty"`
// The DIDNamespace of the verification
@@ -219,7 +210,8 @@ type Verification struct {
Subject string `protobuf:"bytes,5,opt,name=subject,proto3" json:"subject,omitempty"`
// The public key of the verification
PublicKey *PubKey `protobuf:"bytes,6,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
// The Verification Type (Authentication, Assertion, CapabilityDelegation, CapabilityInvocation)
// The Verification Type (Authentication, Assertion, CapabilityDelegation,
// CapabilityInvocation)
VerificationType string `protobuf:"bytes,7,opt,name=verification_type,json=verificationType,proto3" json:"verification_type,omitempty"`
}
@@ -256,9 +248,9 @@ func (m *Verification) XXX_DiscardUnknown() {
var xxx_messageInfo_Verification proto.InternalMessageInfo
func (m *Verification) GetId() string {
func (m *Verification) GetDid() string {
if m != nil {
return m.Id
return m.Did
}
return ""
}
@@ -314,42 +306,42 @@ func init() {
func init() { proto.RegisterFile("did/v1/state.proto", fileDescriptor_f44bb702879c34b4) }
var fileDescriptor_f44bb702879c34b4 = []byte{
// 557 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x53, 0xcb, 0x6e, 0xd3, 0x40,
0x14, 0xed, 0xd8, 0x79, 0x34, 0x37, 0x55, 0x70, 0x47, 0x55, 0x19, 0x15, 0x30, 0x21, 0x42, 0x55,
0x25, 0x42, 0xac, 0xc2, 0x2e, 0x62, 0x53, 0xba, 0xac, 0x90, 0x50, 0x85, 0x58, 0xb0, 0x89, 0x6c,
0xcf, 0x90, 0x4c, 0x9b, 0x78, 0x82, 0x67, 0x1c, 0x91, 0x9f, 0x40, 0xac, 0x59, 0xf0, 0x3d, 0x2c,
0x2b, 0xb1, 0x61, 0x83, 0x84, 0x92, 0x3f, 0xe0, 0x0b, 0xd0, 0x3c, 0x92, 0x38, 0xed, 0x8a, 0x8d,
0xa5, 0x7b, 0xe6, 0x78, 0xce, 0xbd, 0xe7, 0xdc, 0x01, 0x4c, 0x39, 0x8d, 0x66, 0xa7, 0x91, 0x54,
0xb1, 0x62, 0xbd, 0x69, 0x2e, 0x94, 0xc0, 0x35, 0xca, 0x69, 0x6f, 0x76, 0x7a, 0x74, 0x3f, 0x15,
0x72, 0x22, 0x64, 0x24, 0xf2, 0x89, 0xa6, 0x88, 0x7c, 0x62, 0x09, 0x47, 0x07, 0xee, 0xa7, 0x21,
0xcb, 0x98, 0xe4, 0xd2, 0xa2, 0x1d, 0x01, 0xd5, 0xb3, 0x31, 0x8f, 0x25, 0x6e, 0x81, 0xc7, 0x29,
0x41, 0x6d, 0x74, 0xd2, 0xb8, 0xf4, 0x38, 0xc5, 0x04, 0xea, 0xb2, 0x48, 0xae, 0x58, 0xaa, 0x88,
0x67, 0xc0, 0x55, 0x89, 0x0f, 0xa1, 0x26, 0x72, 0x3e, 0xe4, 0x19, 0xf1, 0xcd, 0x81, 0xab, 0xfa,
0x4f, 0xff, 0x7e, 0xff, 0xf9, 0xc5, 0x0f, 0xa1, 0xa2, 0x6f, 0xc2, 0x07, 0xd0, 0x72, 0x3f, 0x74,
0xed, 0x79, 0x80, 0x08, 0x22, 0xa8, 0xf3, 0xcd, 0x07, 0x38, 0x17, 0x99, 0xca, 0xc5, 0x78, 0xcc,
0xf2, 0x3b, 0xb2, 0x4f, 0x60, 0x4f, 0x8a, 0x2c, 0x1f, 0xc4, 0x94, 0xe6, 0x4c, 0x4a, 0xa7, 0xdd,
0xd4, 0xd8, 0x99, 0x85, 0xf0, 0x63, 0x68, 0x32, 0x35, 0x5a, 0x33, 0x6c, 0x13, 0xc0, 0xd4, 0xa8,
0x44, 0x48, 0x54, 0xba, 0x26, 0x54, 0x2c, 0x21, 0x51, 0xe9, 0x8a, 0x40, 0xa0, 0x1e, 0xeb, 0xa1,
0x99, 0x24, 0xd5, 0xb6, 0xaf, 0x67, 0x73, 0x25, 0x7e, 0x0e, 0x30, 0x2d, 0x92, 0x31, 0x4f, 0x07,
0xd7, 0x6c, 0x4e, 0x6a, 0x6d, 0x74, 0xd2, 0x7c, 0xd1, 0xea, 0x59, 0x6b, 0x7b, 0x6f, 0x8b, 0xe4,
0x82, 0xcd, 0x2f, 0x1b, 0x96, 0x71, 0xc1, 0xe6, 0xf8, 0x01, 0x34, 0x66, 0x71, 0x31, 0x56, 0x83,
0x94, 0x53, 0x52, 0x37, 0x3a, 0xbb, 0x06, 0x38, 0xe7, 0x14, 0x1f, 0x43, 0x2b, 0x2e, 0xd4, 0x88,
0x65, 0x8a, 0xa7, 0xb1, 0xe2, 0x22, 0x23, 0xbb, 0x46, 0xec, 0x16, 0xaa, 0xfd, 0xd4, 0x41, 0x16,
0x92, 0x34, 0xac, 0x9f, 0xb6, 0xea, 0x7f, 0x32, 0x7e, 0x5e, 0x3b, 0x3f, 0xf1, 0xb6, 0x31, 0xda,
0x4d, 0xbc, 0xbf, 0xe5, 0x44, 0xe0, 0x59, 0xa8, 0x34, 0x7b, 0xe0, 0x13, 0x84, 0xef, 0x95, 0x9a,
0x0c, 0x2a, 0x04, 0xe1, 0x43, 0x08, 0xac, 0x44, 0x77, 0x83, 0x57, 0x09, 0x22, 0x5e, 0xe7, 0xb7,
0x07, 0x7b, 0xef, 0x59, 0xce, 0x3f, 0xae, 0x7a, 0xbb, 0x1d, 0x4f, 0x08, 0x90, 0xae, 0xc3, 0x73,
0xe1, 0x94, 0x10, 0xfc, 0x08, 0x80, 0x72, 0x3a, 0x98, 0x30, 0x35, 0x12, 0xd4, 0x45, 0xd3, 0xa0,
0x9c, 0xbe, 0x31, 0x80, 0x1e, 0x95, 0x4b, 0x59, 0xb0, 0xdc, 0x85, 0xe2, 0xaa, 0xf2, 0xb2, 0x55,
0xb7, 0x97, 0xed, 0x3f, 0x03, 0x79, 0x06, 0xfb, 0xb3, 0x52, 0xff, 0x03, 0x35, 0x9f, 0x32, 0x17,
0x4c, 0x50, 0x3e, 0x78, 0x37, 0x9f, 0xb2, 0xfe, 0xd4, 0x18, 0x7c, 0xb5, 0x59, 0x58, 0xdb, 0x4d,
0xd7, 0x69, 0x1b, 0x8b, 0x3b, 0xf0, 0x70, 0x33, 0x5e, 0x77, 0x33, 0x5b, 0xd7, 0x72, 0x8d, 0xe7,
0xc7, 0xd0, 0xbe, 0x23, 0xba, 0xba, 0x64, 0xc5, 0xf3, 0x09, 0x22, 0xd5, 0xd7, 0xaf, 0x7e, 0x2c,
0x42, 0x74, 0xb3, 0x08, 0xd1, 0x9f, 0x45, 0x88, 0xbe, 0x2e, 0xc3, 0x9d, 0x9b, 0x65, 0xb8, 0xf3,
0x6b, 0x19, 0xee, 0x7c, 0xe8, 0x0c, 0xb9, 0x1a, 0x15, 0x49, 0x2f, 0x15, 0x93, 0x48, 0x64, 0x3a,
0xe9, 0xc8, 0x7c, 0x3e, 0x47, 0xfa, 0xd9, 0xea, 0x1b, 0x65, 0x52, 0x33, 0x4f, 0xf6, 0xe5, 0xbf,
0x00, 0x00, 0x00, 0xff, 0xff, 0x58, 0x8d, 0xb9, 0xaa, 0xff, 0x03, 0x00, 0x00,
// 550 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x64, 0x93, 0xcf, 0x8e, 0xd3, 0x3e,
0x10, 0xc7, 0xd7, 0xe9, 0x9f, 0xdd, 0x4e, 0xab, 0x2a, 0x6b, 0xed, 0xef, 0x87, 0xb5, 0x82, 0x50,
0x2a, 0x84, 0x2a, 0x51, 0x1a, 0x2d, 0xdc, 0x2a, 0x2e, 0x0b, 0xc7, 0x15, 0x12, 0x2a, 0x68, 0x25,
0xb8, 0x54, 0x49, 0x6c, 0x5a, 0xd3, 0x24, 0x2e, 0xb1, 0x53, 0xd1, 0x97, 0x40, 0x3c, 0x01, 0x8f,
0x83, 0x38, 0xae, 0xc4, 0x85, 0xe3, 0xaa, 0x7d, 0x03, 0x9e, 0x00, 0xd9, 0x71, 0xda, 0x54, 0x7b,
0x89, 0x32, 0x5f, 0x7f, 0x3d, 0xe3, 0xf9, 0x78, 0x0c, 0x98, 0x72, 0xea, 0xaf, 0x2e, 0x7c, 0xa9,
0x02, 0xc5, 0x46, 0xcb, 0x4c, 0x28, 0x81, 0x9b, 0x94, 0xd3, 0xd1, 0xea, 0xe2, 0xfc, 0x5e, 0x24,
0x64, 0x22, 0xa4, 0x2f, 0xb2, 0x44, 0x5b, 0x44, 0x96, 0x14, 0x86, 0xf3, 0x33, 0xbb, 0x69, 0xc6,
0x52, 0x26, 0xb9, 0x2c, 0xd4, 0xbe, 0x80, 0xc6, 0x65, 0xcc, 0x03, 0x89, 0xbb, 0xe0, 0x70, 0x4a,
0x50, 0x0f, 0x0d, 0x5a, 0x13, 0x87, 0x53, 0x4c, 0xe0, 0x58, 0xe6, 0xe1, 0x67, 0x16, 0x29, 0xe2,
0x18, 0xb1, 0x0c, 0xf1, 0xff, 0xd0, 0x14, 0x19, 0x9f, 0xf1, 0x94, 0xd4, 0xcc, 0x82, 0x8d, 0xc6,
0x8f, 0xff, 0xfe, 0xf8, 0xfd, 0xad, 0xe6, 0x41, 0x5d, 0x67, 0xc2, 0x67, 0xd0, 0xb5, 0x1b, 0x86,
0xc5, 0xba, 0x8b, 0x08, 0x22, 0xa8, 0xff, 0xd3, 0x01, 0x78, 0x2d, 0x52, 0x95, 0x89, 0x38, 0x66,
0x99, 0x4e, 0x96, 0xe6, 0x49, 0xc8, 0x32, 0x53, 0xba, 0x3e, 0xb1, 0x11, 0x76, 0xa1, 0x46, 0x39,
0xb5, 0xa5, 0xf5, 0x2f, 0x7e, 0x04, 0x1d, 0x29, 0xd2, 0x6c, 0x1a, 0x50, 0x9a, 0x31, 0x29, 0x6d,
0xf1, 0xb6, 0xd6, 0x2e, 0x0b, 0x09, 0x3f, 0x84, 0x36, 0x53, 0xf3, 0x9d, 0xa3, 0x6e, 0x1c, 0xc0,
0xd4, 0xbc, 0x62, 0x08, 0x55, 0xb4, 0x33, 0x34, 0x0a, 0x43, 0xa8, 0xa2, 0xd2, 0xf0, 0x00, 0x60,
0x99, 0x87, 0x31, 0x8f, 0xa6, 0x0b, 0xb6, 0x26, 0xcd, 0x1e, 0x1a, 0x74, 0x26, 0xad, 0x42, 0xb9,
0x62, 0x6b, 0xfc, 0x1f, 0x34, 0x17, 0x72, 0xba, 0x0a, 0x62, 0x72, 0x6c, 0xb6, 0x36, 0x16, 0xf2,
0x3a, 0x88, 0x35, 0xab, 0x28, 0x0e, 0x78, 0xc2, 0x28, 0x39, 0xe9, 0xa1, 0xc1, 0xc9, 0xa4, 0x0c,
0xc7, 0x1f, 0x0c, 0x93, 0x77, 0x00, 0x65, 0x9b, 0x2e, 0xc2, 0xf8, 0xb0, 0x11, 0xcd, 0x05, 0x9f,
0x1e, 0x9c, 0xdc, 0x75, 0x0a, 0xa9, 0x72, 0x56, 0xb7, 0x46, 0x10, 0x6e, 0x19, 0x28, 0x6e, 0x9d,
0x20, 0xe2, 0xf4, 0x6f, 0x1d, 0xe8, 0x5c, 0xb3, 0x8c, 0x7f, 0xe2, 0x51, 0xa0, 0xb8, 0x48, 0x4b,
0x64, 0x68, 0x8f, 0xcc, 0x03, 0x88, 0x76, 0xa8, 0x2d, 0xcb, 0x8a, 0xa2, 0xbb, 0xa5, 0x9c, 0x4e,
0x13, 0xa6, 0xe6, 0x82, 0x5a, 0xa0, 0x2d, 0xca, 0xe9, 0x1b, 0x23, 0xe8, 0xbb, 0xe1, 0x52, 0xe6,
0x2c, 0xb3, 0x24, 0x6d, 0x54, 0x1d, 0x8d, 0xc6, 0xe1, 0x68, 0x3c, 0xbb, 0x83, 0xaf, 0xfd, 0xbc,
0x3b, 0x2a, 0x26, 0x73, 0xf4, 0x36, 0x0f, 0xaf, 0xd8, 0xba, 0x8a, 0xf3, 0x29, 0x9c, 0xae, 0x2a,
0x1d, 0x4c, 0xd5, 0x7a, 0xc9, 0x2c, 0x59, 0xb7, 0xba, 0xf0, 0x7e, 0xbd, 0x64, 0xe3, 0x2f, 0x06,
0xe5, 0x02, 0x1a, 0xa6, 0x4d, 0x3d, 0x5f, 0xc5, 0x71, 0x86, 0xb6, 0xb8, 0xe1, 0xd8, 0x87, 0xfb,
0xfb, 0xfe, 0x86, 0xfb, 0xe6, 0x86, 0x85, 0xd7, 0x80, 0x7d, 0x02, 0xbd, 0x3b, 0x55, 0xcb, 0x24,
0xa5, 0xaf, 0x46, 0x10, 0xa9, 0xbf, 0x7a, 0xf9, 0x6b, 0xe3, 0xa1, 0x9b, 0x8d, 0x87, 0x6e, 0x37,
0x1e, 0xfa, 0xbe, 0xf5, 0x8e, 0x6e, 0xb6, 0xde, 0xd1, 0x9f, 0xad, 0x77, 0xf4, 0xb1, 0x3f, 0xe3,
0x6a, 0x9e, 0x87, 0xa3, 0x48, 0x24, 0xbe, 0x48, 0xf5, 0x75, 0xfa, 0xe6, 0xf3, 0xd5, 0xd7, 0xaf,
0x4c, 0x67, 0x94, 0x61, 0xd3, 0xbc, 0xb0, 0x17, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0x3b, 0x9f,
0x1c, 0x50, 0xae, 0x03, 0x00, 0x00,
}
func (m *Alias) Marshal() (dAtA []byte, err error) {
@@ -416,77 +408,62 @@ func (m *Controller) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i
var l int
_ = l
if len(m.Status) > 0 {
i -= len(m.Status)
copy(dAtA[i:], m.Status)
i = encodeVarintState(dAtA, i, uint64(len(m.Status)))
if m.Claimed {
i--
dAtA[i] = 0x4a
}
if len(m.Authentication) > 0 {
for iNdEx := len(m.Authentication) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Authentication[iNdEx])
copy(dAtA[i:], m.Authentication[iNdEx])
i = encodeVarintState(dAtA, i, uint64(len(m.Authentication[iNdEx])))
i--
dAtA[i] = 0x42
if m.Claimed {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x40
}
if len(m.VaultCid) > 0 {
i -= len(m.VaultCid)
copy(dAtA[i:], m.VaultCid)
i = encodeVarintState(dAtA, i, uint64(len(m.VaultCid)))
if len(m.KsVal) > 0 {
i -= len(m.KsVal)
copy(dAtA[i:], m.KsVal)
i = encodeVarintState(dAtA, i, uint64(len(m.KsVal)))
i--
dAtA[i] = 0x3a
}
if m.PublicKey != nil {
{
size, err := m.PublicKey.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintState(dAtA, i, uint64(size))
}
if len(m.PublicKey) > 0 {
i -= len(m.PublicKey)
copy(dAtA[i:], m.PublicKey)
i = encodeVarintState(dAtA, i, uint64(len(m.PublicKey)))
i--
dAtA[i] = 0x32
}
if len(m.Aliases) > 0 {
for iNdEx := len(m.Aliases) - 1; iNdEx >= 0; iNdEx-- {
i -= len(m.Aliases[iNdEx])
copy(dAtA[i:], m.Aliases[iNdEx])
i = encodeVarintState(dAtA, i, uint64(len(m.Aliases[iNdEx])))
i--
dAtA[i] = 0x2a
}
}
if len(m.BtcAddress) > 0 {
i -= len(m.BtcAddress)
copy(dAtA[i:], m.BtcAddress)
i = encodeVarintState(dAtA, i, uint64(len(m.BtcAddress)))
i--
dAtA[i] = 0x22
dAtA[i] = 0x2a
}
if len(m.EthAddress) > 0 {
i -= len(m.EthAddress)
copy(dAtA[i:], m.EthAddress)
i = encodeVarintState(dAtA, i, uint64(len(m.EthAddress)))
i--
dAtA[i] = 0x1a
dAtA[i] = 0x22
}
if len(m.SonrAddress) > 0 {
i -= len(m.SonrAddress)
copy(dAtA[i:], m.SonrAddress)
i = encodeVarintState(dAtA, i, uint64(len(m.SonrAddress)))
i--
dAtA[i] = 0x1a
}
if len(m.Did) > 0 {
i -= len(m.Did)
copy(dAtA[i:], m.Did)
i = encodeVarintState(dAtA, i, uint64(len(m.Did)))
i--
dAtA[i] = 0x12
}
if len(m.Id) > 0 {
i -= len(m.Id)
copy(dAtA[i:], m.Id)
i = encodeVarintState(dAtA, i, uint64(len(m.Id)))
if m.Number != 0 {
i = encodeVarintState(dAtA, i, uint64(m.Number))
i--
dAtA[i] = 0xa
dAtA[i] = 0x8
}
return len(dAtA) - i, nil
}
@@ -558,10 +535,10 @@ func (m *Verification) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i--
dAtA[i] = 0x12
}
if len(m.Id) > 0 {
i -= len(m.Id)
copy(dAtA[i:], m.Id)
i = encodeVarintState(dAtA, i, uint64(len(m.Id)))
if len(m.Did) > 0 {
i -= len(m.Did)
copy(dAtA[i:], m.Did)
i = encodeVarintState(dAtA, i, uint64(len(m.Did)))
i--
dAtA[i] = 0xa
}
@@ -606,7 +583,10 @@ func (m *Controller) Size() (n int) {
}
var l int
_ = l
l = len(m.Id)
if m.Number != 0 {
n += 1 + sovState(uint64(m.Number))
}
l = len(m.Did)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
@@ -622,30 +602,17 @@ func (m *Controller) Size() (n int) {
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
if len(m.Aliases) > 0 {
for _, s := range m.Aliases {
l = len(s)
n += 1 + l + sovState(uint64(l))
}
}
if m.PublicKey != nil {
l = m.PublicKey.Size()
n += 1 + l + sovState(uint64(l))
}
l = len(m.VaultCid)
l = len(m.PublicKey)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
if len(m.Authentication) > 0 {
for _, s := range m.Authentication {
l = len(s)
n += 1 + l + sovState(uint64(l))
}
}
l = len(m.Status)
l = len(m.KsVal)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
if m.Claimed {
n += 2
}
return n
}
@@ -655,7 +622,7 @@ func (m *Verification) Size() (n int) {
}
var l int
_ = l
l = len(m.Id)
l = len(m.Did)
if l > 0 {
n += 1 + l + sovState(uint64(l))
}
@@ -868,8 +835,27 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Number", wireType)
}
m.Number = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.Number |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Did", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@@ -897,9 +883,9 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Id = string(dAtA[iNdEx:postIndex])
m.Did = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field SonrAddress", wireType)
}
@@ -931,7 +917,7 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
}
m.SonrAddress = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 3:
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field EthAddress", wireType)
}
@@ -963,7 +949,7 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
}
m.EthAddress = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 4:
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field BtcAddress", wireType)
}
@@ -995,43 +981,11 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
}
m.BtcAddress = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 5:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Aliases", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
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 ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Aliases = append(m.Aliases, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
}
var msglen int
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
@@ -1041,31 +995,29 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
if byteLen < 0 {
return ErrInvalidLengthState
}
postIndex := iNdEx + msglen
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
if m.PublicKey == nil {
m.PublicKey = &PubKey{}
}
if err := m.PublicKey.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
m.PublicKey = []byte{}
}
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field VaultCid", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field KsVal", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@@ -1093,13 +1045,13 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.VaultCid = string(dAtA[iNdEx:postIndex])
m.KsVal = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 8:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Authentication", wireType)
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Claimed", wireType)
}
var stringLen uint64
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
@@ -1109,56 +1061,12 @@ func (m *Controller) Unmarshal(dAtA []byte) error {
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Authentication = append(m.Authentication, string(dAtA[iNdEx:postIndex]))
iNdEx = postIndex
case 9:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowState
}
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 ErrInvalidLengthState
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthState
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Status = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
m.Claimed = bool(v != 0)
default:
iNdEx = preIndex
skippy, err := skipState(dAtA[iNdEx:])
@@ -1211,7 +1119,7 @@ func (m *Verification) Unmarshal(dAtA []byte) error {
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
return fmt.Errorf("proto: wrong wireType = %d for field Did", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
@@ -1239,7 +1147,7 @@ func (m *Verification) Unmarshal(dAtA []byte) error {
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Id = string(dAtA[iNdEx:postIndex])
m.Did = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
x/did/types/tx.pb.go
+1339 -1373
View File
File diff suppressed because it is too large Load Diff
x/did/types/txns/Msg.pkl.go
-6
View File
@@ -1,6 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
type Msg interface {
GetTypeUrl() string
}
x/did/types/txns/MsgDidAllocateVault.pkl.go
-44
View File
@@ -1,44 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidAllocateVault interface {
Msg
GetAuthority() string
GetSubject() string
GetToken() *pkl.Object
}
var _ MsgDidAllocateVault = (*MsgDidAllocateVaultImpl)(nil)
type MsgDidAllocateVaultImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Authority string `pkl:"authority"`
Subject string `pkl:"subject"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidAllocateVaultImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidAllocateVaultImpl) GetAuthority() string {
return rcv.Authority
}
func (rcv *MsgDidAllocateVaultImpl) GetSubject() string {
return rcv.Subject
}
func (rcv *MsgDidAllocateVaultImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgDidAuthorize.pkl.go
-60
View File
@@ -1,60 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidAuthorize interface {
Msg
GetAuthority() string
GetController() string
GetAddress() string
GetOrigin() string
GetToken() *pkl.Object
}
var _ MsgDidAuthorize = (*MsgDidAuthorizeImpl)(nil)
type MsgDidAuthorizeImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Authority string `pkl:"authority"`
Controller string `pkl:"controller"`
Address string `pkl:"address"`
Origin string `pkl:"origin"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidAuthorizeImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidAuthorizeImpl) GetAuthority() string {
return rcv.Authority
}
func (rcv *MsgDidAuthorizeImpl) GetController() string {
return rcv.Controller
}
func (rcv *MsgDidAuthorizeImpl) GetAddress() string {
return rcv.Address
}
func (rcv *MsgDidAuthorizeImpl) GetOrigin() string {
return rcv.Origin
}
func (rcv *MsgDidAuthorizeImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgDidProveWitness.pkl.go
-52
View File
@@ -1,52 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidProveWitness interface {
Msg
GetAuthority() string
GetProperty() string
GetWitness() []int
GetToken() *pkl.Object
}
var _ MsgDidProveWitness = (*MsgDidProveWitnessImpl)(nil)
type MsgDidProveWitnessImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Authority string `pkl:"authority"`
Property string `pkl:"property"`
Witness []int `pkl:"witness"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidProveWitnessImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidProveWitnessImpl) GetAuthority() string {
return rcv.Authority
}
func (rcv *MsgDidProveWitnessImpl) GetProperty() string {
return rcv.Property
}
func (rcv *MsgDidProveWitnessImpl) GetWitness() []int {
return rcv.Witness
}
func (rcv *MsgDidProveWitnessImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgDidRegisterController.pkl.go
-60
View File
@@ -1,60 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidRegisterController interface {
Msg
GetAuthority() string
GetCid() string
GetOrigin() string
GetAuthentication() []*pkl.Object
GetToken() *pkl.Object
}
var _ MsgDidRegisterController = (*MsgDidRegisterControllerImpl)(nil)
type MsgDidRegisterControllerImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Authority string `pkl:"authority"`
Cid string `pkl:"cid"`
Origin string `pkl:"origin"`
Authentication []*pkl.Object `pkl:"authentication"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidRegisterControllerImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidRegisterControllerImpl) GetAuthority() string {
return rcv.Authority
}
func (rcv *MsgDidRegisterControllerImpl) GetCid() string {
return rcv.Cid
}
func (rcv *MsgDidRegisterControllerImpl) GetOrigin() string {
return rcv.Origin
}
func (rcv *MsgDidRegisterControllerImpl) GetAuthentication() []*pkl.Object {
return rcv.Authentication
}
func (rcv *MsgDidRegisterControllerImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgDidRegisterService.pkl.go
-76
View File
@@ -1,76 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidRegisterService interface {
Msg
GetController() string
GetOriginUri() string
GetScopes() *pkl.Object
GetDescription() string
GetServiceEndpoints() map[string]string
GetMetadata() *pkl.Object
GetToken() *pkl.Object
}
var _ MsgDidRegisterService = (*MsgDidRegisterServiceImpl)(nil)
type MsgDidRegisterServiceImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Controller string `pkl:"controller"`
OriginUri string `pkl:"originUri"`
Scopes *pkl.Object `pkl:"scopes"`
Description string `pkl:"description"`
ServiceEndpoints map[string]string `pkl:"serviceEndpoints"`
Metadata *pkl.Object `pkl:"metadata"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidRegisterServiceImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidRegisterServiceImpl) GetController() string {
return rcv.Controller
}
func (rcv *MsgDidRegisterServiceImpl) GetOriginUri() string {
return rcv.OriginUri
}
func (rcv *MsgDidRegisterServiceImpl) GetScopes() *pkl.Object {
return rcv.Scopes
}
func (rcv *MsgDidRegisterServiceImpl) GetDescription() string {
return rcv.Description
}
func (rcv *MsgDidRegisterServiceImpl) GetServiceEndpoints() map[string]string {
return rcv.ServiceEndpoints
}
func (rcv *MsgDidRegisterServiceImpl) GetMetadata() *pkl.Object {
return rcv.Metadata
}
func (rcv *MsgDidRegisterServiceImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgDidSyncVault.pkl.go
-36
View File
@@ -1,36 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidSyncVault interface {
Msg
GetController() string
GetToken() *pkl.Object
}
var _ MsgDidSyncVault = (*MsgDidSyncVaultImpl)(nil)
type MsgDidSyncVaultImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Controller string `pkl:"controller"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidSyncVaultImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidSyncVaultImpl) GetController() string {
return rcv.Controller
}
func (rcv *MsgDidSyncVaultImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgDidUpdateParams.pkl.go
-44
View File
@@ -1,44 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgDidUpdateParams interface {
Msg
GetAuthority() string
GetParams() *pkl.Object
GetToken() *pkl.Object
}
var _ MsgDidUpdateParams = (*MsgDidUpdateParamsImpl)(nil)
type MsgDidUpdateParamsImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Authority string `pkl:"authority"`
Params *pkl.Object `pkl:"params"`
Token *pkl.Object `pkl:"token"`
}
// The type URL for the message
func (rcv *MsgDidUpdateParamsImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgDidUpdateParamsImpl) GetAuthority() string {
return rcv.Authority
}
func (rcv *MsgDidUpdateParamsImpl) GetParams() *pkl.Object {
return rcv.Params
}
func (rcv *MsgDidUpdateParamsImpl) GetToken() *pkl.Object {
return rcv.Token
}
x/did/types/txns/MsgGovDeposit.pkl.go
-44
View File
@@ -1,44 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgGovDeposit interface {
Msg
GetProposalId() int
GetDepositor() string
GetAmount() []*pkl.Object
}
var _ MsgGovDeposit = (*MsgGovDepositImpl)(nil)
type MsgGovDepositImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
ProposalId int `pkl:"proposalId"`
Depositor string `pkl:"depositor"`
Amount []*pkl.Object `pkl:"amount"`
}
// The type URL for the message
func (rcv *MsgGovDepositImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgGovDepositImpl) GetProposalId() int {
return rcv.ProposalId
}
func (rcv *MsgGovDepositImpl) GetDepositor() string {
return rcv.Depositor
}
func (rcv *MsgGovDepositImpl) GetAmount() []*pkl.Object {
return rcv.Amount
}
x/did/types/txns/MsgGovSubmitProposal.pkl.go
-45
View File
@@ -1,45 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgGovSubmitProposal interface {
Msg
GetContent() *Proposal
GetInitialDeposit() []*pkl.Object
GetProposer() string
}
var _ MsgGovSubmitProposal = (*MsgGovSubmitProposalImpl)(nil)
// Gov module messages
type MsgGovSubmitProposalImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Content *Proposal `pkl:"content"`
InitialDeposit []*pkl.Object `pkl:"initialDeposit"`
Proposer string `pkl:"proposer"`
}
// The type URL for the message
func (rcv *MsgGovSubmitProposalImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgGovSubmitProposalImpl) GetContent() *Proposal {
return rcv.Content
}
func (rcv *MsgGovSubmitProposalImpl) GetInitialDeposit() []*pkl.Object {
return rcv.InitialDeposit
}
func (rcv *MsgGovSubmitProposalImpl) GetProposer() string {
return rcv.Proposer
}
x/did/types/txns/MsgGovVote.pkl.go
-42
View File
@@ -1,42 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
type MsgGovVote interface {
Msg
GetProposalId() int
GetVoter() string
GetOption() int
}
var _ MsgGovVote = (*MsgGovVoteImpl)(nil)
type MsgGovVoteImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
ProposalId int `pkl:"proposalId"`
Voter string `pkl:"voter"`
Option int `pkl:"option"`
}
// The type URL for the message
func (rcv *MsgGovVoteImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgGovVoteImpl) GetProposalId() int {
return rcv.ProposalId
}
func (rcv *MsgGovVoteImpl) GetVoter() string {
return rcv.Voter
}
func (rcv *MsgGovVoteImpl) GetOption() int {
return rcv.Option
}
x/did/types/txns/MsgGroupCreateGroup.pkl.go
-45
View File
@@ -1,45 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgGroupCreateGroup interface {
Msg
GetAdmin() string
GetMembers() []*pkl.Object
GetMetadata() string
}
var _ MsgGroupCreateGroup = (*MsgGroupCreateGroupImpl)(nil)
// Group module messages
type MsgGroupCreateGroupImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Admin string `pkl:"admin"`
Members []*pkl.Object `pkl:"members"`
Metadata string `pkl:"metadata"`
}
// The type URL for the message
func (rcv *MsgGroupCreateGroupImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgGroupCreateGroupImpl) GetAdmin() string {
return rcv.Admin
}
func (rcv *MsgGroupCreateGroupImpl) GetMembers() []*pkl.Object {
return rcv.Members
}
func (rcv *MsgGroupCreateGroupImpl) GetMetadata() string {
return rcv.Metadata
}
x/did/types/txns/MsgGroupSubmitProposal.pkl.go
-60
View File
@@ -1,60 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgGroupSubmitProposal interface {
Msg
GetGroupPolicyAddress() string
GetProposers() []string
GetMetadata() string
GetMessages() []*pkl.Object
GetExec() int
}
var _ MsgGroupSubmitProposal = (*MsgGroupSubmitProposalImpl)(nil)
type MsgGroupSubmitProposalImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
GroupPolicyAddress string `pkl:"groupPolicyAddress"`
Proposers []string `pkl:"proposers"`
Metadata string `pkl:"metadata"`
Messages []*pkl.Object `pkl:"messages"`
Exec int `pkl:"exec"`
}
// The type URL for the message
func (rcv *MsgGroupSubmitProposalImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgGroupSubmitProposalImpl) GetGroupPolicyAddress() string {
return rcv.GroupPolicyAddress
}
func (rcv *MsgGroupSubmitProposalImpl) GetProposers() []string {
return rcv.Proposers
}
func (rcv *MsgGroupSubmitProposalImpl) GetMetadata() string {
return rcv.Metadata
}
func (rcv *MsgGroupSubmitProposalImpl) GetMessages() []*pkl.Object {
return rcv.Messages
}
func (rcv *MsgGroupSubmitProposalImpl) GetExec() int {
return rcv.Exec
}
x/did/types/txns/MsgGroupVote.pkl.go
-58
View File
@@ -1,58 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
type MsgGroupVote interface {
Msg
GetProposalId() int
GetVoter() string
GetOption() int
GetMetadata() string
GetExec() int
}
var _ MsgGroupVote = (*MsgGroupVoteImpl)(nil)
type MsgGroupVoteImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
ProposalId int `pkl:"proposalId"`
Voter string `pkl:"voter"`
Option int `pkl:"option"`
Metadata string `pkl:"metadata"`
Exec int `pkl:"exec"`
}
// The type URL for the message
func (rcv *MsgGroupVoteImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgGroupVoteImpl) GetProposalId() int {
return rcv.ProposalId
}
func (rcv *MsgGroupVoteImpl) GetVoter() string {
return rcv.Voter
}
func (rcv *MsgGroupVoteImpl) GetOption() int {
return rcv.Option
}
func (rcv *MsgGroupVoteImpl) GetMetadata() string {
return rcv.Metadata
}
func (rcv *MsgGroupVoteImpl) GetExec() int {
return rcv.Exec
}
x/did/types/txns/MsgStakingBeginRedelegate.pkl.go
-52
View File
@@ -1,52 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgStakingBeginRedelegate interface {
Msg
GetDelegatorAddress() string
GetValidatorSrcAddress() string
GetValidatorDstAddress() string
GetAmount() *pkl.Object
}
var _ MsgStakingBeginRedelegate = (*MsgStakingBeginRedelegateImpl)(nil)
type MsgStakingBeginRedelegateImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
DelegatorAddress string `pkl:"delegatorAddress"`
ValidatorSrcAddress string `pkl:"validatorSrcAddress"`
ValidatorDstAddress string `pkl:"validatorDstAddress"`
Amount *pkl.Object `pkl:"amount"`
}
// The type URL for the message
func (rcv *MsgStakingBeginRedelegateImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgStakingBeginRedelegateImpl) GetDelegatorAddress() string {
return rcv.DelegatorAddress
}
func (rcv *MsgStakingBeginRedelegateImpl) GetValidatorSrcAddress() string {
return rcv.ValidatorSrcAddress
}
func (rcv *MsgStakingBeginRedelegateImpl) GetValidatorDstAddress() string {
return rcv.ValidatorDstAddress
}
func (rcv *MsgStakingBeginRedelegateImpl) GetAmount() *pkl.Object {
return rcv.Amount
}
x/did/types/txns/MsgStakingCreateValidator.pkl.go
-77
View File
@@ -1,77 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgStakingCreateValidator interface {
Msg
GetDescription() *pkl.Object
GetCommission() *pkl.Object
GetMinSelfDelegation() string
GetDelegatorAddress() string
GetValidatorAddress() string
GetPubkey() *pkl.Object
GetValue() *pkl.Object
}
var _ MsgStakingCreateValidator = (*MsgStakingCreateValidatorImpl)(nil)
// Staking module messages
type MsgStakingCreateValidatorImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
Description *pkl.Object `pkl:"description"`
Commission *pkl.Object `pkl:"commission"`
MinSelfDelegation string `pkl:"minSelfDelegation"`
DelegatorAddress string `pkl:"delegatorAddress"`
ValidatorAddress string `pkl:"validatorAddress"`
Pubkey *pkl.Object `pkl:"pubkey"`
Value *pkl.Object `pkl:"value"`
}
// The type URL for the message
func (rcv *MsgStakingCreateValidatorImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgStakingCreateValidatorImpl) GetDescription() *pkl.Object {
return rcv.Description
}
func (rcv *MsgStakingCreateValidatorImpl) GetCommission() *pkl.Object {
return rcv.Commission
}
func (rcv *MsgStakingCreateValidatorImpl) GetMinSelfDelegation() string {
return rcv.MinSelfDelegation
}
func (rcv *MsgStakingCreateValidatorImpl) GetDelegatorAddress() string {
return rcv.DelegatorAddress
}
func (rcv *MsgStakingCreateValidatorImpl) GetValidatorAddress() string {
return rcv.ValidatorAddress
}
func (rcv *MsgStakingCreateValidatorImpl) GetPubkey() *pkl.Object {
return rcv.Pubkey
}
func (rcv *MsgStakingCreateValidatorImpl) GetValue() *pkl.Object {
return rcv.Value
}
x/did/types/txns/MsgStakingDelegate.pkl.go
-44
View File
@@ -1,44 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgStakingDelegate interface {
Msg
GetDelegatorAddress() string
GetValidatorAddress() string
GetAmount() *pkl.Object
}
var _ MsgStakingDelegate = (*MsgStakingDelegateImpl)(nil)
type MsgStakingDelegateImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
DelegatorAddress string `pkl:"delegatorAddress"`
ValidatorAddress string `pkl:"validatorAddress"`
Amount *pkl.Object `pkl:"amount"`
}
// The type URL for the message
func (rcv *MsgStakingDelegateImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgStakingDelegateImpl) GetDelegatorAddress() string {
return rcv.DelegatorAddress
}
func (rcv *MsgStakingDelegateImpl) GetValidatorAddress() string {
return rcv.ValidatorAddress
}
func (rcv *MsgStakingDelegateImpl) GetAmount() *pkl.Object {
return rcv.Amount
}
x/did/types/txns/MsgStakingUndelegate.pkl.go
-44
View File
@@ -1,44 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
type MsgStakingUndelegate interface {
Msg
GetDelegatorAddress() string
GetValidatorAddress() string
GetAmount() *pkl.Object
}
var _ MsgStakingUndelegate = (*MsgStakingUndelegateImpl)(nil)
type MsgStakingUndelegateImpl struct {
// The type URL for the message
TypeUrl string `pkl:"typeUrl"`
DelegatorAddress string `pkl:"delegatorAddress"`
ValidatorAddress string `pkl:"validatorAddress"`
Amount *pkl.Object `pkl:"amount"`
}
// The type URL for the message
func (rcv *MsgStakingUndelegateImpl) GetTypeUrl() string {
return rcv.TypeUrl
}
func (rcv *MsgStakingUndelegateImpl) GetDelegatorAddress() string {
return rcv.DelegatorAddress
}
func (rcv *MsgStakingUndelegateImpl) GetValidatorAddress() string {
return rcv.ValidatorAddress
}
func (rcv *MsgStakingUndelegateImpl) GetAmount() *pkl.Object {
return rcv.Amount
}
x/did/types/txns/Proposal.pkl.go
-11
View File
@@ -1,11 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
// Base class for all proposals
type Proposal struct {
// The title of the proposal
Title string `pkl:"title"`
// The description of the proposal
Description string `pkl:"description"`
}
x/did/types/txns/TxBody.pkl.go
-17
View File
@@ -1,17 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
// Represents a transaction body
type TxBody struct {
Messages []Msg `pkl:"messages"`
Memo *string `pkl:"memo"`
TimeoutHeight *int `pkl:"timeoutHeight"`
ExtensionOptions *[]*pkl.Object `pkl:"extensionOptions"`
NonCriticalExtensionOptions *[]*pkl.Object `pkl:"nonCriticalExtensionOptions"`
}
x/did/types/txns/Txns.pkl.go
-36
View File
@@ -1,36 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import (
"context"
"github.com/apple/pkl-go/pkl"
)
type Txns struct {
}
// LoadFromPath loads the pkl module at the given path and evaluates it into a Txns
func LoadFromPath(ctx context.Context, path string) (ret *Txns, err error) {
evaluator, err := pkl.NewEvaluator(ctx, pkl.PreconfiguredOptions)
if err != nil {
return nil, err
}
defer func() {
cerr := evaluator.Close()
if err == nil {
err = cerr
}
}()
ret, err = Load(ctx, evaluator, pkl.FileSource(path))
return ret, err
}
// Load loads the pkl module at the given source and evaluates it with the given evaluator into a Txns
func Load(ctx context.Context, evaluator pkl.Evaluator, source *pkl.ModuleSource) (*Txns, error) {
var ret Txns
if err := evaluator.EvaluateModule(ctx, source, &ret); err != nil {
return nil, err
}
return &ret, nil
}
x/did/types/txns/init.pkl.go
-27
View File
@@ -1,27 +0,0 @@
// Code generated from Pkl module `txns`. DO NOT EDIT.
package txns
import "github.com/apple/pkl-go/pkl"
func init() {
pkl.RegisterMapping("txns", Txns{})
pkl.RegisterMapping("txns#Proposal", Proposal{})
pkl.RegisterMapping("txns#MsgGovSubmitProposal", MsgGovSubmitProposalImpl{})
pkl.RegisterMapping("txns#MsgGovVote", MsgGovVoteImpl{})
pkl.RegisterMapping("txns#MsgGovDeposit", MsgGovDepositImpl{})
pkl.RegisterMapping("txns#MsgGroupCreateGroup", MsgGroupCreateGroupImpl{})
pkl.RegisterMapping("txns#MsgGroupSubmitProposal", MsgGroupSubmitProposalImpl{})
pkl.RegisterMapping("txns#MsgGroupVote", MsgGroupVoteImpl{})
pkl.RegisterMapping("txns#MsgStakingCreateValidator", MsgStakingCreateValidatorImpl{})
pkl.RegisterMapping("txns#MsgStakingDelegate", MsgStakingDelegateImpl{})
pkl.RegisterMapping("txns#MsgStakingUndelegate", MsgStakingUndelegateImpl{})
pkl.RegisterMapping("txns#MsgStakingBeginRedelegate", MsgStakingBeginRedelegateImpl{})
pkl.RegisterMapping("txns#MsgDidUpdateParams", MsgDidUpdateParamsImpl{})
pkl.RegisterMapping("txns#MsgDidAllocateVault", MsgDidAllocateVaultImpl{})
pkl.RegisterMapping("txns#MsgDidProveWitness", MsgDidProveWitnessImpl{})
pkl.RegisterMapping("txns#MsgDidSyncVault", MsgDidSyncVaultImpl{})
pkl.RegisterMapping("txns#MsgDidRegisterController", MsgDidRegisterControllerImpl{})
pkl.RegisterMapping("txns#MsgDidAuthorize", MsgDidAuthorizeImpl{})
pkl.RegisterMapping("txns#MsgDidRegisterService", MsgDidRegisterServiceImpl{})
pkl.RegisterMapping("txns#TxBody", TxBody{})
}
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
}
x/vault/README.md
+15
View File
@@ -0,0 +1,15 @@
# `x/vault`
The Vault module is responsible for the management of IPFS deployed Decentralized Web Nodes (DWNs) and their associated data.
## Concepts
| Concept | Description | Reference |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- |
| Decentralized Web Node (DWN) | A decentralized, distributed, and secure network of nodes that store and share data. It is a decentralized alternative to traditional web hosting services. | |
| Decentralized Identifier (DID) | A unique identifier that is created, owned, and controlled by the user. It is used to establish a secure and verifiable digital identity. | |
| HTMX (Hypertext Markup Language eXtensions) | A set of extensions to HTML that allow for the creation of interactive web pages. It is used to enhance the user experience and provide additional functionality to web applications. | |
| IPFS (InterPlanetary File System) | A decentralized, peer-to-peer network for storing and sharing data. It is a distributed file system that allows for the creation and sharing of content across a network of nodes. | |
| WebAuthn (Web Authentication) | A set of APIs that allow websites to request user authentication using biometric or non-biometric factors. | |
| WebAssembly (Web Assembly) | A binary instruction format for a stack-based virtual machine. | |
| Verifiable Credential (VC) | A digital statement that can be cryptographically verified. | |
x/vault/autocli.go
+31
View File
@@ -0,0 +1,31 @@
package module
import (
autocliv1 "cosmossdk.io/api/cosmos/autocli/v1"
modulev1 "github.com/onsonr/sonr/api/vault/v1"
)
// AutoCLIOptions implements the autocli.HasAutoCLIConfig interface.
func (am AppModule) AutoCLIOptions() *autocliv1.ModuleOptions {
return &autocliv1.ModuleOptions{
Query: &autocliv1.ServiceCommandDescriptor{
Service: modulev1.Query_ServiceDesc.ServiceName,
RpcCommandOptions: []*autocliv1.RpcCommandOptions{
{
RpcMethod: "Params",
Use: "params",
Short: "Query the current consensus parameters",
},
},
},
Tx: &autocliv1.ServiceCommandDescriptor{
Service: modulev1.Msg_ServiceDesc.ServiceName,
RpcCommandOptions: []*autocliv1.RpcCommandOptions{
{
RpcMethod: "UpdateParams",
Skip: false, // set to true if authority gated
},
},
},
}
}
x/vault/client/cli/query.go
+50
View File
@@ -0,0 +1,50 @@
package cli
import (
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/onsonr/sonr/x/vault/types"
)
// !NOTE: Must enable in module.go (disabled in favor of autocli.go)
func GetQueryCmd() *cobra.Command {
queryCmd := &cobra.Command{
Use: types.ModuleName,
Short: "Querying commands for " + types.ModuleName,
DisableFlagParsing: true,
SuggestionsMinimumDistance: 2,
RunE: client.ValidateCmd,
}
queryCmd.AddCommand(
GetCmdParams(),
)
return queryCmd
}
func GetCmdParams() *cobra.Command {
cmd := &cobra.Command{
Use: "params",
Short: "Show all module params",
Args: cobra.ExactArgs(0),
RunE: func(cmd *cobra.Command, args []string) error {
clientCtx, err := client.GetClientQueryContext(cmd)
if err != nil {
return err
}
queryClient := types.NewQueryClient(clientCtx)
res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{})
if err != nil {
return err
}
return clientCtx.PrintProto(res)
},
}
flags.AddQueryFlagsToCmd(cmd)
return cmd
}
x/vault/client/cli/tx.go
+71
View File
@@ -0,0 +1,71 @@
package cli
import (
"strconv"
"github.com/spf13/cobra"
"github.com/cosmos/cosmos-sdk/client"
"github.com/cosmos/cosmos-sdk/client/flags"
"github.com/cosmos/cosmos-sdk/client/tx"
"github.com/onsonr/sonr/x/vault/types"
)
// !NOTE: Must enable in module.go (disabled in favor of autocli.go)
// NewTxCmd returns a root CLI command handler for certain modules
// transaction commands.
func NewTxCmd() *cobra.Command {
txCmd := &cobra.Command{
Use: types.ModuleName,
Short: types.ModuleName + " subcommands.",
DisableFlagParsing: true,
SuggestionsMinimumDistance: 2,
RunE: client.ValidateCmd,
}
txCmd.AddCommand(
MsgUpdateParams(),
)
return txCmd
}
// Returns a CLI command handler for registering a
// contract for the module.
func MsgUpdateParams() *cobra.Command {
cmd := &cobra.Command{
Use: "update-params [some-value]",
Short: "Update the params (must be submitted from the authority)",
Args: cobra.ExactArgs(1),
RunE: func(cmd *cobra.Command, args []string) error {
cliCtx, err := client.GetClientTxContext(cmd)
if err != nil {
return err
}
senderAddress := cliCtx.GetFromAddress()
someValue, err := strconv.ParseBool(args[0])
if err != nil {
return err
}
msg := &types.MsgUpdateParams{
Authority: senderAddress.String(),
Params: types.Params{
IpfsActive: someValue,
},
}
if err := msg.Validate(); err != nil {
return err
}
return tx.GenerateOrBroadcastTxCLI(cliCtx, cmd.Flags(), msg)
},
}
flags.AddTxFlagsToCmd(cmd)
return cmd
}
x/vault/client/dwn/main.go
+145
View File
@@ -0,0 +1,145 @@
//go:build js && wasm
// +build js,wasm
package main
import (
"bytes"
"fmt"
"io"
"net/http"
"net/http/httptest"
"strings"
"syscall/js"
"github.com/labstack/echo/v4"
promise "github.com/nlepage/go-js-promise"
"github.com/onsonr/sonr/nebula/pages"
"github.com/onsonr/sonr/x/vault/client/dwn/middleware"
"github.com/onsonr/sonr/x/vault/client/dwn/state"
)
func main() {
e := echo.New()
e.Use(middleware.UseSession)
e.GET("/home", pages.Home)
e.GET("/login", pages.Login)
e.GET("/register", pages.Register)
e.GET("/profile", pages.Profile)
e.GET("/authorize", pages.Authorize)
state.RegisterHandlers(e)
Serve(e)
}
// Serve serves HTTP requests using handler or http.DefaultServeMux if handler is nil.
func Serve(handler http.Handler) func() {
h := handler
if h == nil {
h = http.DefaultServeMux
}
prefix := js.Global().Get("wasmhttp").Get("path").String()
for strings.HasSuffix(prefix, "/") {
prefix = strings.TrimSuffix(prefix, "/")
}
if prefix != "" {
mux := http.NewServeMux()
mux.Handle(prefix+"/", http.StripPrefix(prefix, h))
h = mux
}
cb := js.FuncOf(func(_ js.Value, args []js.Value) interface{} {
resPromise, resolve, reject := promise.New()
go func() {
defer func() {
if r := recover(); r != nil {
if err, ok := r.(error); ok {
reject(fmt.Sprintf("wasmhttp: panic: %+v\n", err))
} else {
reject(fmt.Sprintf("wasmhttp: panic: %v\n", r))
}
}
}()
res := NewResponseRecorder()
h.ServeHTTP(res, Request(args[0]))
resolve(res.JSResponse())
}()
return resPromise
})
js.Global().Get("wasmhttp").Call("setHandler", cb)
return cb.Release
}
// Request builds and returns the equivalent http.Request
func Request(r js.Value) *http.Request {
jsBody := js.Global().Get("Uint8Array").New(promise.Await(r.Call("arrayBuffer")))
body := make([]byte, jsBody.Get("length").Int())
js.CopyBytesToGo(body, jsBody)
req := httptest.NewRequest(
r.Get("method").String(),
r.Get("url").String(),
bytes.NewBuffer(body),
)
headersIt := r.Get("headers").Call("entries")
for {
e := headersIt.Call("next")
if e.Get("done").Bool() {
break
}
v := e.Get("value")
req.Header.Set(v.Index(0).String(), v.Index(1).String())
}
return req
}
// ResponseRecorder uses httptest.ResponseRecorder to build a JS Response
type ResponseRecorder struct {
*httptest.ResponseRecorder
}
// NewResponseRecorder returns a new ResponseRecorder
func NewResponseRecorder() ResponseRecorder {
return ResponseRecorder{httptest.NewRecorder()}
}
// JSResponse builds and returns the equivalent JS Response
func (rr ResponseRecorder) JSResponse() js.Value {
res := rr.Result()
body := js.Undefined()
if res.ContentLength != 0 {
b, err := io.ReadAll(res.Body)
if err != nil {
panic(err)
}
body = js.Global().Get("Uint8Array").New(len(b))
js.CopyBytesToJS(body, b)
}
init := make(map[string]interface{}, 2)
if res.StatusCode != 0 {
init["status"] = res.StatusCode
}
if len(res.Header) != 0 {
headers := make(map[string]interface{}, len(res.Header))
for k := range res.Header {
headers[k] = res.Header.Get(k)
}
init["headers"] = headers
}
return js.Global().Get("Response").New(body, init)
}
x/vault/client/dwn/middleware/headers.go
+55
View File
@@ -0,0 +1,55 @@
package middleware
type RequestHeaders struct {
Authorization *string `header:"Authorization"`
CacheControl *string `header:"Cache-Control"`
DeviceMemory *string `header:"Device-Memory"`
Forwarded *string `header:"Forwarded"`
From *string `header:"From"`
Host *string `header:"Host"`
Link *string `header:"Link"`
PermissionsPolicy *string `header:"Permissions-Policy"`
ProxyAuthorization *string `header:"Proxy-Authorization"`
Referer *string `header:"Referer"`
UserAgent *string `header:"User-Agent"`
ViewportWidth *string `header:"Viewport-Width"`
Width *string `header:"Width"`
WWWAuthenticate *string `header:"WWW-Authenticate"`
// HTMX Specific
HXBoosted *string `header:"HX-Boosted"`
HXCurrentURL *string `header:"HX-Current-URL"`
HXHistoryRestoreRequest *string `header:"HX-History-Restore-Request"`
HXPrompt *string `header:"HX-Prompt"`
HXRequest *string `header:"HX-Request"`
HXTarget *string `header:"HX-Target"`
HXTriggerName *string `header:"HX-Trigger-Name"`
HXTrigger *string `header:"HX-Trigger"`
}
type ResponseHeaders struct {
AcceptCH *string `header:"Accept-CH"`
AccessControlAllowCredentials *string `header:"Access-Control-Allow-Credentials"`
AccessControlAllowHeaders *string `header:"Access-Control-Allow-Headers"`
AccessControlAllowMethods *string `header:"Access-Control-Allow-Methods"`
AccessControlExposeHeaders *string `header:"Access-Control-Expose-Headers"`
AccessControlRequestHeaders *string `header:"Access-Control-Request-Headers"`
ContentSecurityPolicy *string `header:"Content-Security-Policy"`
CrossOriginEmbedderPolicy *string `header:"Cross-Origin-Embedder-Policy"`
PermissionsPolicy *string `header:"Permissions-Policy"`
ProxyAuthorization *string `header:"Proxy-Authorization"`
WWWAuthenticate *string `header:"WWW-Authenticate"`
// HTMX Specific
HXLocation *string `header:"HX-Location"`
HXPushURL *string `header:"HX-Push-Url"`
HXRedirect *string `header:"HX-Redirect"`
HXRefresh *string `header:"HX-Refresh"`
HXReplaceURL *string `header:"HX-Replace-Url"`
HXReswap *string `header:"HX-Reswap"`
HXRetarget *string `header:"HX-Retarget"`
HXReselect *string `header:"HX-Reselect"`
HXTrigger *string `header:"HX-Trigger"`
HXTriggerAfterSettle *string `header:"HX-Trigger-After-Settle"`
HXTriggerAfterSwap *string `header:"HX-Trigger-After-Swap"`
}
x/did/builder/macroon.go → x/vault/client/dwn/middleware/middleware.go
+22 -7
View File
@@ -1,17 +1,29 @@
package builder
package middleware
import (
"net/http"
"github.com/labstack/echo/v4"
"gopkg.in/macaroon.v2"
"gopkg.in/macaroon-bakery.v2/bakery/checkers"
)
var PermissionNamespace *checkers.Namespace
// GetSession returns the current Session
func GetSession(c echo.Context) *Session {
return c.(*Session)
}
func ValidateMacaroonMiddleware(secretKey []byte, location string) echo.MiddlewareFunc {
// UseSession establishes a Session Cookie.
func UseSession(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
sc := initSession(c)
headers := new(RequestHeaders)
sc.Bind(headers)
return next(sc)
}
}
func MacaroonMiddleware(secretKeyStr string, location string) echo.MiddlewareFunc {
secretKey := []byte(secretKeyStr)
return func(next echo.HandlerFunc) echo.HandlerFunc {
return func(c echo.Context) error {
// Extract the macaroon from the Authorization header
@@ -33,8 +45,11 @@ func ValidateMacaroonMiddleware(secretKey []byte, location string) echo.Middlewa
// Verify the macaroon
err = token.Verify(secretKey, func(caveat string) error {
// Implement your caveat verification logic here
// For example, you might check if the caveat is still valid (e.g., not expired)
for _, c := range MacroonCaveats {
if c.String() == caveat {
return nil
}
}
return nil // Return nil if the caveat is valid
}, nil)
if err != nil {
x/vault/client/dwn/middleware/session.go
+51
View File
@@ -0,0 +1,51 @@
package middleware
import (
"net/http"
"time"
"github.com/donseba/go-htmx"
"github.com/labstack/echo/v4"
"github.com/segmentio/ksuid"
)
type Session struct {
echo.Context
htmx *htmx.HTMX
}
func (c *Session) Htmx() *htmx.HTMX {
return c.htmx
}
func (c *Session) ID() string {
return ReadCookie(c, "session")
}
func initSession(c echo.Context) *Session {
s := &Session{Context: c}
if val := ReadCookie(c, "session"); val == "" {
id := ksuid.New().String()
WriteCookie(c, "session", id)
}
return s
}
func ReadCookie(c echo.Context, key string) string {
cookie, err := c.Cookie(key)
if err != nil {
return ""
}
if cookie == nil {
return ""
}
return cookie.Value
}
func WriteCookie(c echo.Context, key string, value string) {
cookie := new(http.Cookie)
cookie.Name = key
cookie.Value = value
cookie.Expires = time.Now().Add(24 * time.Hour)
c.SetCookie(cookie)
}
x/vault/client/dwn/middleware/token.go
+51
View File
@@ -0,0 +1,51 @@
package middleware
import (
"fmt"
"time"
)
const (
OriginMacroonCaveat MacroonCaveat = "origin"
ScopesMacroonCaveat MacroonCaveat = "scopes"
SubjectMacroonCaveat MacroonCaveat = "subject"
ExpMacroonCaveat MacroonCaveat = "exp"
TokenMacroonCaveat MacroonCaveat = "token"
)
type MacroonCaveat string
func (c MacroonCaveat) Equal(other string) bool {
return string(c) == other
}
func (c MacroonCaveat) String() string {
return string(c)
}
func (c MacroonCaveat) Verify(value string) error {
switch c {
case OriginMacroonCaveat:
return nil
case ScopesMacroonCaveat:
return nil
case SubjectMacroonCaveat:
return nil
case ExpMacroonCaveat:
// Check if the expiration time is still valid
exp, err := time.Parse(time.RFC3339, value)
if err != nil {
return err
}
if time.Now().After(exp) {
return fmt.Errorf("expired")
}
return nil
case TokenMacroonCaveat:
return nil
default:
return fmt.Errorf("unknown caveat: %s", c)
}
}
var MacroonCaveats = []MacroonCaveat{OriginMacroonCaveat, ScopesMacroonCaveat, SubjectMacroonCaveat, ExpMacroonCaveat, TokenMacroonCaveat}
x/vault/client/dwn/state/auth.go
+43
View File
@@ -0,0 +1,43 @@
package state
import (
"encoding/json"
"fmt"
"github.com/go-webauthn/webauthn/protocol"
"github.com/labstack/echo/v4"
)
func checkSubjectIsValid(e echo.Context) error {
credentialID := e.FormValue("credentialID")
return e.JSON(200, credentialID)
}
func handleCredentialAssertion(e echo.Context) error {
return e.JSON(200, "HandleCredentialAssertion")
}
func handleCredentialCreation(e echo.Context) error {
// Get the serialized credential data from the form
credentialDataJSON := e.FormValue("credentialData")
// Deserialize the JSON into a temporary struct
var ccr protocol.CredentialCreationResponse
err := json.Unmarshal([]byte(credentialDataJSON), &ccr)
if err != nil {
return e.JSON(500, err.Error())
}
//
// // Parse the CredentialCreationResponse
// parsedData, err := ccr.Parse()
// if err != nil {
// return e.JSON(500, err.Error())
// }
//
// // Create the Credential
// // credential := orm.NewCredential(parsedData, e.Request().Host, "")
//
// // Set additional fields
// credential.Controller = "" // Set this to the appropriate controller value
return e.JSON(200, fmt.Sprintf("REGISTER: %s", string(ccr.ID)))
}
x/vault/client/dwn/state/manifest.go
+1
View File
@@ -0,0 +1 @@
package state
x/vault/client/dwn/state/openid.go
+23
View File
@@ -0,0 +1,23 @@
package state
import (
"github.com/labstack/echo/v4"
)
func grantAuthorization(e echo.Context) error {
// Implement authorization endpoint using passkey authentication
// Store session data in cache
return nil
}
func getJWKS(e echo.Context) error {
// Implement token endpoint
// Use cached session data for validation
return nil
}
func getToken(e echo.Context) error {
// Implement token endpoint
// Use cached session data for validation
return nil
}
x/vault/client/dwn/state/routes.go
+22
View File
@@ -0,0 +1,22 @@
package state
import (
"github.com/labstack/echo/v4"
middleware "github.com/onsonr/sonr/x/vault/client/dwn/middleware"
)
func RegisterHandlers(e *echo.Echo) {
g := e.Group("state")
g.POST("/login/:identifier", handleCredentialAssertion)
// g.GET("/discovery", state.GetDiscovery)
g.GET("/jwks", getJWKS)
g.GET("/token", getToken)
g.POST("/:origin/grant/:subject", grantAuthorization)
g.POST("/register/:subject", handleCredentialCreation)
g.POST("/register/:subject/check", checkSubjectIsValid)
}
func RegisterSync(e *echo.Echo) {
g := e.Group("sync")
g.Use(middleware.MacaroonMiddleware("test", "test"))
}
x/vault/client/dwn/state/views.go
+1
View File
@@ -0,0 +1 @@
package state
x/vault/client/dwn/state/wellknown.go
+1
View File
@@ -0,0 +1 @@
package state
x/vault/depinject.go
+65
View File
@@ -0,0 +1,65 @@
package module
import (
"os"
"github.com/cosmos/cosmos-sdk/codec"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
slashingkeeper "github.com/cosmos/cosmos-sdk/x/slashing/keeper"
govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
stakingkeeper "github.com/cosmos/cosmos-sdk/x/staking/keeper"
"cosmossdk.io/core/address"
"cosmossdk.io/core/appmodule"
"cosmossdk.io/core/store"
"cosmossdk.io/depinject"
"cosmossdk.io/log"
modulev1 "github.com/onsonr/sonr/api/vault/module/v1"
didkeeper "github.com/onsonr/sonr/x/did/keeper"
"github.com/onsonr/sonr/x/vault/keeper"
)
var _ appmodule.AppModule = AppModule{}
// IsOnePerModuleType implements the depinject.OnePerModuleType interface.
func (am AppModule) IsOnePerModuleType() {}
// IsAppModule implements the appmodule.AppModule interface.
func (am AppModule) IsAppModule() {}
func init() {
appmodule.Register(
&modulev1.Module{},
appmodule.Provide(ProvideModule),
)
}
type ModuleInputs struct {
depinject.In
Cdc codec.Codec
StoreService store.KVStoreService
AddressCodec address.Codec
DidKeeper didkeeper.Keeper
StakingKeeper stakingkeeper.Keeper
SlashingKeeper slashingkeeper.Keeper
}
type ModuleOutputs struct {
depinject.Out
Module appmodule.AppModule
Keeper keeper.Keeper
}
func ProvideModule(in ModuleInputs) ModuleOutputs {
govAddr := authtypes.NewModuleAddress(govtypes.ModuleName).String()
k := keeper.NewKeeper(in.Cdc, in.StoreService, log.NewLogger(os.Stderr), govAddr, in.DidKeeper)
m := NewAppModule(in.Cdc, k)
return ModuleOutputs{Module: m, Keeper: k, Out: depinject.Out{}}
}
x/vault/internal/app.wasm
Executable
BIN
View File
Binary file not shown.
x/vault/internal/embed.go
+113
View File
@@ -0,0 +1,113 @@
package vault
import (
"bytes"
"context"
_ "embed"
"encoding/json"
"github.com/a-h/templ"
"github.com/ipfs/boxo/files"
"github.com/onsonr/sonr/config/dwn"
)
//go:embed app.wasm
var dwnWasmData []byte
//go:embed motr.mjs
var motrMJSData []byte
//go:embed sw.js
var swJSData []byte
var (
dwnWasmFile = files.NewBytesFile(dwnWasmData)
motrMJSFile = files.NewBytesFile(motrMJSData)
swJSFile = files.NewBytesFile(swJSData)
)
// NewConfig uses the config template to generate the dwn config file
func NewConfig(keyshareJSON string, adddress string, chainID string, schema *dwn.Schema) *dwn.Config {
dwnCfg := &dwn.Config{
Motr: createMotrConfig(keyshareJSON, adddress, "sonr.id"),
Ipfs: defaultIPFSConfig(),
Sonr: defaultSonrConfig(chainID),
Schema: schema,
}
return dwnCfg
}
// NewVaultDirectory creates a new directory with the default files
func NewVaultDirectory(cnfg *dwn.Config) (files.Node, error) {
dwnJSON, err := json.Marshal(cnfg)
if err != nil {
return nil, err
}
dwnStr, err := templ.JSONString(cnfg)
if err != nil {
return nil, err
}
w := bytes.NewBuffer(nil)
err = indexFile(dwnStr).Render(context.Background(), w)
if err != nil {
return nil, err
}
fileMap := map[string]files.Node{
"config.json": files.NewBytesFile(dwnJSON),
"motr.mjs": motrMJSFile,
"sw.js": swJSFile,
"app.wasm": dwnWasmFile,
"index.html": files.NewBytesFile(w.Bytes()),
}
return files.NewMapDirectory(fileMap), nil
}
// Use IndexHTML template to generate the index file
func IndexHTMLFile(c *dwn.Config) (files.Node, error) {
str, err := templ.JSONString(c)
if err != nil {
return nil, err
}
w := bytes.NewBuffer(nil)
err = indexFile(str).Render(context.Background(), w)
if err != nil {
return nil, err
}
indexData := w.Bytes()
return files.NewBytesFile(indexData), nil
}
// MarshalConfigFile uses the config template to generate the dwn config file
func MarshalConfigFile(c *dwn.Config) (files.Node, error) {
dwnConfigData, err := json.Marshal(c)
if err != nil {
return nil, err
}
return files.NewBytesFile(dwnConfigData), nil
}
func createMotrConfig(keyshareJSON string, adddress string, origin string) *dwn.Motr {
return &dwn.Motr{
Keyshare: keyshareJSON,
Address: adddress,
Origin: origin,
}
}
func defaultIPFSConfig() *dwn.IPFS {
return &dwn.IPFS{
ApiUrl: "https://api.sonr-ipfs.land",
GatewayUrl: "https://ipfs.sonr.land",
}
}
func defaultSonrConfig(chainID string) *dwn.Sonr {
return &dwn.Sonr{
ApiUrl: "https://api.sonr.land",
GrpcUrl: "https://grpc.sonr.land",
RpcUrl: "https://rpc.sonr.land",
WebSocketUrl: "wss://rpc.sonr.land/ws",
ChainId: chainID,
}
}
x/vault/internal/index.templ
+111
View File
@@ -0,0 +1,111 @@
package vault
var motrHandle = templ.NewOnceHandle()
templ importScripts() {
<script src="https://cdn.sonr.io/js/htmx.min.js"></script>
<script src="https://cdn.tailwindcss.com"></script>
<script src="https://unpkg.com/alpinejs" defer></script>
}
templ indexFile(cfg string) {
<!doctype html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link href="https://cdn.sonr.io/stylesheet.css" rel="stylesheet" />
@importScripts()
<style>
[x-cloak] {
display: none;
}
</style>
<title>Sonr DWN</title>
<script>
if ("serviceWorker" in navigator) {
window.addEventListener("load", function() {
navigator.serviceWorker
.register("/sw.js")
.then(function (registration) {
console.log("Service Worker registered with scope:", registration.scope);
})
.catch(function (error) {
console.log("Service Worker registration failed:", error);
});
});
}
</script>
</head>
<body class="flex items-center justify-center h-full bg-neutral-50 lg:p-24 md:16 p-4">
<main class="flex-row items-center justify-center mx-auto w-fit max-w-screen-sm gap-y-3">
<div id="output">Loading...</div>
</main>
@motrHandle.Once() {
<script src="./motr.mjs" type="module"></script>
@initializeMotr(cfg)
}
</body>
</html>
}
templ serviceWorker() {
<script>
</script>
}
script initializeMotr(config string) {
const motr = new Motr(JSON.parse(config));
async function demo() {
try {
// Insert a new account
const accountId = await motr.insertAccount({
name: 'John Doe',
address: '0x1234567890123456789012345678901234567890',
publicKey: 'sample_public_key',
chainCode: 'SONR',
index: 0,
controller: 'sample_controller',
createdAt: new Date()
});
console.log('Inserted account with ID:', accountId);
// Retrieve the account
const account = await motr.getAccount(accountId);
console.log('Retrieved account:', account);
// Insert a new credential
const credentialId = await motr.insertCredential({
subject: 'john@example.com',
label: 'John\'s Device',
controller: 'sample_controller',
attestationType: 'platform',
origin: 'https://app.sonr.io'
});
console.log('Inserted credential with ID:', credentialId);
// Retrieve the credential
const credential = await motr.getCredential(credentialId);
console.log('Retrieved credential:', credential);
document.getElementById('output').innerHTML = `
<h2>Demo Results:</h2>
<p>Inserted account ID: ${accountId}</p>
<p>Retrieved account name: ${account.name}</p>
<p>Inserted credential ID: ${credentialId}</p>
<p>Retrieved credential subject: ${credential.subject}</p>
`;
} catch (error) {
console.error('Error in demo:', error);
document.getElementById('output').innerHTML = `<p>Error: ${error.message}</p>`;
}
}
// Run the demo when the page loads
window.onload = demo;
}

Some files were not shown because too many files have changed in this diff Show More