types

type CompoundService map[string]string

type DIDCreationOptions struct {
	// Controllers lists the DIDs that can control the new DID Document. If selfControl = true and controllers is not empty,
	// the newly generated DID will be added to the list of controllers.
	Controllers []did.DID

	// KeyFlags specifies for what purposes the generated key can be used
	KeyFlags DIDKeyFlags

	// SelfControl indicates whether the generated DID Document can be altered with its own capabilityInvocation key.
	// Defaults to true when not given.
	SelfControl bool
}

type DIDKeyFlags uint

type DocCreator interface {
	// Create creates a new DID document and returns it.
	// The ID in the provided DID document will be ignored and a new one will be generated.
	// If something goes wrong an error is returned.
	// Implementors should generate private key and store it in a secure backend
	Create(ctx context.Context, options DIDCreationOptions) (*did.Document, crypto2.Key, error)
}

type DocFinder interface {
	Find(...Predicate) ([]did.Document, error)
}

type DocIterator func(doc did.Document, metadata DocumentMetadata) error

type DocManipulator interface {
	// Deactivate deactivates a DID document
	// Deactivation will be done in such a way that a DID doc cannot be used / activated anymore.
	// Since the deactivation is definitive, no version is required
	// If the DID Document is not found ErrNotFound is returned
	// If the DID Document is not managed by this node, ErrDIDNotManagedByThisNode is returned
	// If the DID Document is already deactivated ErrDeactivated is returned
	Deactivate(ctx context.Context, id did.DID) error

	// RemoveVerificationMethod removes a VerificationMethod from a DID document.
	// It accepts the id DID as identifier for the DID document.
	// It accepts the kid DID as identifier for the VerificationMethod.
	// It returns an ErrNotFound when the DID document could not be found.
	// It returns an ErrNotFound when there is no VerificationMethod with the provided kid in the document.
	// It returns an ErrDeactivated when the DID document has the deactivated state.
	// It returns an ErrDIDNotManagedByThisNode if the DID document is not managed by this node.
	RemoveVerificationMethod(ctx context.Context, id, keyID did.DID) error

	// AddVerificationMethod generates a new key and adds it, wrapped as a VerificationMethod, to a DID document.
	// It accepts a DID as identifier for the DID document.
	// It returns an ErrNotFound when the DID document could not be found.
	// It returns an ErrDeactivated when the DID document has the deactivated state.
	// It returns an ErrDIDNotManagedByThisNode if the DID document is not managed by this node.
	AddVerificationMethod(ctx context.Context, id did.DID, keyUsage DIDKeyFlags) (*did.VerificationMethod, error)
}

type DocResolver interface {
	// Resolve returns a DID Document for the provided DID.
	// If metadata is not provided the latest version is returned.
	// If metadata is provided then the result is filtered or scoped on that metadata.
	// It returns ErrNotFound if there are no corresponding DID documents or when the DID Documents are disjoint with the provided ResolveMetadata
	// It returns ErrDeactivated if the DID Document has been deactivated and metadata is unset or metadata.AllowDeactivated is false.
	// It returns ErrNoActiveController if all of the DID Documents controllers have been deactivated and metadata is unset or metadata.AllowDeactivated is false.
	Resolve(id did.DID, metadata *ResolveMetadata) (*did.Document, *DocumentMetadata, error)
	// ResolveControllers finds the DID Document controllers
	ResolveControllers(input did.Document, metadata *ResolveMetadata) ([]did.Document, error)
}

type DocUpdater interface {
	// Update replaces the DID document identified by DID with the nextVersion
	// If the DID Document is not found, ErrNotFound is returned
	// If the DID Document is not managed by this node, ErrDIDNotManagedByThisNode is returned
	Update(ctx context.Context, id did.DID, next did.Document) error
}

type DocWriter interface {
	// Write writes a DID Document.
	// Returns ErrDIDAlreadyExists when DID already exists
	// When a document already exists, the Update should be used instead
	Write(document did.Document, metadata DocumentMetadata) error
}

type DocumentMetadata struct {
	Created time.Time  `json:"created"`
	Updated *time.Time `json:"updated,omitempty"`
	// Hash of DID document bytes. Is equal to payloadHash in network layer.
	Hash hash.SHA256Hash `json:"hash"`
	// PreviousHash of the previous version of this DID document
	PreviousHash *hash.SHA256Hash `json:"previousHash,omitempty"`
	// SourceTransactions points to the transaction(s) that created the current version of this DID Document.
	// If multiple transactions are listed, the DID Document is conflicted
	SourceTransactions []hash.SHA256Hash `json:"txs"`
	// Deactivated indicates if the document is deactivated
	Deactivated bool `json:"deactivated"`
}

type DocumentOwner interface {
	// IsOwner returns true if the DID Document is owned by the node, meaning there are private keys present for the DID Document.
	IsOwner(context.Context, did.DID) (bool, error)
	// ListOwned returns all the DIDs owned by the node.
	ListOwned(ctx context.Context) ([]did.DID, error)
}

type KeyResolver interface {
	// ResolveSigningKeyID looks up a signing key of the specified holder. It returns the ID
	// of the found key. Typically used to find a key for signing one's own documents. If no suitable keys
	// are found an error is returned.
	ResolveSigningKeyID(holder did.DID, validAt *time.Time) (string, error)
	// ResolveSigningKey looks up a specific signing key and returns it as crypto.PublicKey. If the key can't be found
	// or isn't meant for signing an error is returned.
	ResolveSigningKey(keyID string, validAt *time.Time) (crypto.PublicKey, error)
	// ResolveAssertionKeyID look for a valid assertion key for the give DID. If multiple keys are valid, the first one is returned.
	// An ErrKeyNotFound is returned when no key is found.
	ResolveAssertionKeyID(id did.DID) (ssi.URI, error)
	// ResolveKeyAgreementKey look for a valid keyAgreement key for the give DID. If multiple keys are valid, the first one is returned.
	// An ErrKeyNotFound is returned when no key is found.
	ResolveKeyAgreementKey(id did.DID) (crypto.PublicKey, error)
	// ResolvePublicKey loads the key from a DID Document where the DID Document
	// was created with one of the given tx refs
	// It returns ErrKeyNotFound when the key could not be found in the DID Document.
	// It returns ErrNotFound when the DID Document can't be found.
	ResolvePublicKey(kid string, sourceTransactionsRefs []hash.SHA256Hash) (crypto.PublicKey, error)
	// ResolveRelationKey looks up a specific key of the given RelationType and returns it as crypto.PublicKey.
	// If the key can't be found or isn't meant for signing an error is returned.
	ResolveRelationKey(keyID string, validAt *time.Time, relationType RelationType) (crypto.PublicKey, error)
	// ResolveRelationKeyID look for a valid key of the given RelationType for the give DID.
	// If multiple keys are valid, the first one is returned.
	// An ErrKeyNotFound is returned when no key is found.
	ResolveRelationKeyID(id did.DID, relationType RelationType) (ssi.URI, error)
}

type MockDocCreator struct {
	// contains filtered or unexported fields
}

type MockDocCreatorMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDocFinder struct {
	// contains filtered or unexported fields
}

type MockDocFinderMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDocManipulator struct {
	// contains filtered or unexported fields
}

type MockDocManipulatorMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDocResolver struct {
	// contains filtered or unexported fields
}

type MockDocResolverMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDocUpdater struct {
	// contains filtered or unexported fields
}

type MockDocUpdaterMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDocWriter struct {
	// contains filtered or unexported fields
}

type MockDocWriterMockRecorder struct {
	// contains filtered or unexported fields
}

type MockDocumentOwner struct {
	// contains filtered or unexported fields
}

type MockDocumentOwnerMockRecorder struct {
	// contains filtered or unexported fields
}

type MockKeyResolver struct {
	// contains filtered or unexported fields
}

type MockKeyResolverMockRecorder struct {
	// contains filtered or unexported fields
}

type MockPredicate struct {
	// contains filtered or unexported fields
}

type MockPredicateMockRecorder struct {
	// contains filtered or unexported fields
}

type MockServiceResolver struct {
	// contains filtered or unexported fields
}

type MockServiceResolverMockRecorder struct {
	// contains filtered or unexported fields
}

type MockVDR struct {
	// contains filtered or unexported fields
}

type MockVDRMockRecorder struct {
	// contains filtered or unexported fields
}

type Predicate interface {
	// Match returns true if the given DID Document passes the predicate condition
	Match(did.Document, DocumentMetadata) bool
}

type RelationType uint

type ResolveMetadata struct {
	// Resolve the version which is valid at this time
	ResolveTime *time.Time
	// if provided, use the version which matches this exact hash
	Hash *hash.SHA256Hash
	// SourceTransaction must match a TX hash from the metadata.SourceTransaction field, if provided
	SourceTransaction *hash.SHA256Hash
	// Allow DIDs which are deactivated
	AllowDeactivated bool
}

type ServiceResolver interface {
	// Resolve looks up the DID document of the specified query and then tries to find the service with the specified type.
	// The query must be in the form of a service query, e.g. `did:nuts:12345/serviceEndpoint?type=some-type`.
	// The maxDepth indicates how deep references are followed. If maxDepth = 0, no references are followed (and an error is returned if the given query resolves to a reference).
	// If the DID document or service is not found, a reference can't be resolved or the references exceed maxDepth, an error is returned.
	Resolve(query ssi.URI, maxDepth int) (did.Service, error)

	// ResolveEx tries to resolve a DID service from the given endpoint URI, following references (URIs that begin with 'did:').
	// When the endpoint is a reference it resolves it up until the (per spec) max reference depth. When resolving a reference it recursively calls itself with depth + 1.
	// The documentCache map is used to avoid resolving the same document over and over again, which might be a (slightly more) expensive operation.
	ResolveEx(endpoint ssi.URI, depth int, maxDepth int, documentCache map[string]*did.Document) (did.Service, error)
}

type VDR interface {
	DocumentOwner
	DocCreator
	DocUpdater

	// ConflictedDocuments returns the DID Document and metadata of all documents with a conflict.
	ConflictedDocuments() ([]did.Document, []DocumentMetadata, error)
}