issuer

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"`
	Expiry      time.Time                 `json:"exp"`
}

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.
	// The publish param indicates if the credendential should be published to the network.
	// The public param instructs the Publisher to publish the param with a certain visibility.
	Issue(ctx context.Context, unsignedCredential vc.VerifiableCredential, publish, public bool) (*vc.VerifiableCredential, error)
	// Revoke revokes a credential by the provided type.
	// It requires access to the private key of the issuer which will be used to sign the revocation.
	// It returns an error when the credential is not issued by this node or is already revoked.
	// The revocation will be published to the network by the issuers Publisher.
	Revoke(ctx context.Context, credentialID 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 MockkeyResolver struct {
	// contains filtered or unexported fields
}

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

type Nonce struct {
	Nonce  string    `json:"nonce"`
	Expiry time.Time `json:"exp"`
}

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, expiry time.Time) 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
	// Close signals the store to close any owned resources.
	Close()
}

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 an ErrNotFound when the credential is not in the store
	// Returns an 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 a revocation for a credential ID
	// Returns an ErrNotFound when the revocation is not in the store
	// Returns an ErrMultipleFound when there are multiple revocations for this credential ID in the store
	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
}