issuer

type CredentialOptions struct {
	// Format specifies the proof format for the issued credential. If not set, it defaults to JSON-LD.
	// Valid options are: ldp_vc or jwt_vc
	Format string
	// Publish param indicates if the credential should be published to the network.
	Publish bool
	// Public param instructs the Publisher to publish the param with a certain visibility.
	Public bool
	// WithStatusListRevocation adds a 'revocation' entry to the credential. Requires Publish to be False.
	WithStatusListRevocation bool
}

type CredentialSearcher interface {
	// SearchCredential searches for issued credentials
	// If the passed context is empty, it'll not be part of the search query on the DB.
	SearchCredential(credentialType ssi.URI, issuer did.DID, subject *ssi.URI) ([]vc.VerifiableCredential, error)
}

type Flow struct {
	ID string `json:"id"`
	// IssuerID is the identifier of the credential issuer.
	IssuerID string `json:"issuer_id"`
	// WalletID is the identifier of the wallet.
	WalletID string `json:"wallet_id"`
	// Grants is a list of grants that can be used to acquire an access token.
	Grants []Grant `json:"grants"`
	// Credentials is the list of Verifiable Credentials that be issued to the wallet through this flow.
	// It might be pre-determined (in the issuer-initiated flow) or determined during the flow execution (in the wallet-initiated flow).
	Credentials []vc.VerifiableCredential `json:"credentials"`
}

type Grant struct {
	// Type is the type of grant, e.g. "urn:ietf:params:oauth:grant-type:pre-authorized_code".
	Type string `json:"type"`
	// Params is a map of parameters for the grant, e.g. "pre-authorized_code" for type "urn:ietf:params:oauth:grant-type:pre-authorized_code".
	Params map[string]interface{} `json:"params"`
}

type Issuer interface {
	// Issue issues a credential by signing an unsigned credential.
	Issue(ctx context.Context, template vc.VerifiableCredential, options CredentialOptions) (*vc.VerifiableCredential, error)
	// Revoke credential with credentialID.
	// It returns types.ErrNotFound if the credential is not issued by this node, or types.ErrRevoked if already revoked.
	// The revocation will be published to the network by the issuers Publisher if issuer by did:nuts.
	Revoke(ctx context.Context, credentialID ssi.URI) (*credential.Revocation, error)
	// StatusList returns the StatusList2021Credential tracking status list revocations for this issuer at /iam/issuerID/status/page.
	// Returns types.ErrNotFound when no credential statuses have been published using the issuer and page combination.
	StatusList(ctx context.Context, issuer did.DID, page int) (*vc.VerifiableCredential, error)
	// GetRevocation returns a revocation for a credential ID.
	// Returns nil when no revocation is found.
	GetRevocation(id ssi.URI) (*credential.Revocation, error)
	CredentialSearcher
}

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

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

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

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

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

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

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

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

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

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

type OpenIDHandler interface {
	// ProviderMetadata returns the OpenID Connect provider metadata.
	ProviderMetadata() openid4vci.ProviderMetadata
	// HandleAccessTokenRequest handles an OAuth2 access token request for the given issuer and pre-authorized code.
	// It returns the access token and a c_nonce.
	HandleAccessTokenRequest(ctx context.Context, preAuthorizedCode string) (string, string, error)
	// Metadata returns the OpenID4VCI credential issuer metadata for the given issuer.
	Metadata() openid4vci.CredentialIssuerMetadata
	// OfferCredential sends a credential offer to the specified wallet. It derives the issuer from the credential.
	OfferCredential(ctx context.Context, credential vc.VerifiableCredential, walletIdentifier string) error
	// HandleCredentialRequest requests a credential from the given issuer.
	HandleCredentialRequest(ctx context.Context, request openid4vci.CredentialRequest, accessToken string) (*vc.VerifiableCredential, error)
}

type OpenIDStore interface {
	// Store saves a new Flow in the store.
	Store(ctx context.Context, flow Flow) error
	// StoreReference saves a reference to the given Flow, for looking it up later.
	// This is used for finding a flow given a secret, e.g. pre-authorized code, authorization code or nonce.
	// like a database index. The reference must be unique for all flows.
	// The expiry is the time-to-live for the reference. After this time, the reference is automatically deleted.
	// If the flow does not exist, or the reference does already exist, it returns an error.
	StoreReference(ctx context.Context, flowID string, refType string, reference string) error
	// FindByReference finds a Flow by its reference.
	// If the flow does not exist, it returns nil.
	FindByReference(ctx context.Context, refType string, reference string) (*Flow, error)
	// DeleteReference deletes the reference from the store.
	// It does not return an error if it doesn't exist anymore.
	DeleteReference(ctx context.Context, refType string, reference string) error
}

type Publisher interface {
	// PublishCredential publishes the credential to the outside world.
	// A public flag is used to indicate if everybody can see the credential, or just the involved parties.
	PublishCredential(ctx context.Context, verifiableCredential vc.VerifiableCredential, public bool) error
	// PublishRevocation publishes the revocation to the outside world.
	// It indicates to the network a credential can no longer be used.
	PublishRevocation(ctx context.Context, revocation credential.Revocation) error
}

type Store interface {
	core.Diagnosable
	// GetCredential retrieves an issued credential by ID
	// Returns a types.ErrNotFound when the credential is not in the store
	// Returns a types.ErrMultipleFound when there are multiple credentials with this ID in the store
	GetCredential(id ssi.URI) (*vc.VerifiableCredential, error)
	// StoreCredential writes a VC to storage.
	StoreCredential(vc vc.VerifiableCredential) error
	// GetRevocation returns all revocations for a credential ID.
	// Returns an empty slice when no revocations are found.
	GetRevocation(id ssi.URI) ([]credential.Revocation, error)
	// StoreRevocation writes a revocation to storage.
	StoreRevocation(r credential.Revocation) error
	CredentialSearcher
	// Closer closes and frees the underlying resources the store uses.
	io.Closer
}