openid4vci

type Config struct {
	// DefinitionsDIR defines the directory where the additional credential definitions are stored
	DefinitionsDIR string `koanf:"definitionsdir"`
	// Enabled indicates if issuing and receiving credentials over OpenID4VCI is enabled
	Enabled bool `koanf:"enabled"`
	// Timeout defines the timeout for HTTP client operations
	Timeout time.Duration `koanf:"timeout"`
}

type CredentialDefinition struct {
	Context           []ssi.URI               `json:"@context"`
	Type              []ssi.URI               `json:"type"`
	CredentialSubject *map[string]interface{} `json:"credentialSubject,omitempty"` // optional and currently not used
}

type CredentialIssuerMetadata struct {
	// CredentialIssuer defines the identifier of the credential issuer.
	CredentialIssuer string `json:"credential_issuer"`

	// CredentialEndpoint defines where the wallet can send a request to retrieve a credential.
	CredentialEndpoint string `json:"credential_endpoint"`

	// CredentialsSupported defines metadata about which credential types the credential issuer can issue.
	CredentialsSupported []map[string]interface{} `json:"credentials_supported"`
}

type CredentialOffer struct {
	// CredentialIssuer defines the identifier of the credential issuer.
	CredentialIssuer string `json:"credential_issuer"`
	// Credentials defines the credentials offered by the issuer to the wallet.
	Credentials []OfferedCredential `json:"credentials"`
	// Grants defines the grants offered by the issuer to the wallet.
	Grants map[string]interface{} `json:"grants"`
}

type CredentialOfferResponse struct {
	// Status defines the status of the credential offer.
	Status CredentialOfferStatus `json:"status"`
}

type CredentialOfferStatus string

type CredentialRequest struct {
	Format               string                  `json:"format"`
	CredentialDefinition *CredentialDefinition   `json:"credential_definition,omitempty"`
	Proof                *CredentialRequestProof `json:"proof,omitempty"`
}

type CredentialRequestProof struct {
	Jwt       string `json:"jwt"`
	ProofType string `json:"proof_type"`
}

type CredentialResponse struct {
	Format     string                  `json:"format,omitempty"`
	Credential *map[string]interface{} `json:"credential,omitempty"`
	CNonce     *string                 `json:"c_nonce,omitempty"`
}

type DIDIdentifierResolver struct {
	ServiceResolver resolver.ServiceResolver
}

type Error struct {
	// CNonce is a random string that the client must send in the next credential request.
	CNonce *string `json:"c_nonce,omitempty"`
	// CNonceExpiresIn is the number of seconds until the c_nonce expires.
	CNonceExpiresIn *int `json:"c_nonce_expires_in,omitempty"`
	// Code is the error code as defined by the OpenID4VCI spec.
	Code ErrorCode `json:"error"`
	// Err is the underlying error, may be omitted. It is not intended to be returned to the client.
	Err error `json:"-"`
	// StatusCode is the HTTP status code that should be returned to the client.
	StatusCode int `json:"-"`
}

type ErrorCode string

type IdentifierResolver interface {
	Resolve(id did.DID) (string, error)
}

type IssuerAPIClient interface {
	OAuth2Client

	// Metadata returns the Credential Issuer Metadata.
	Metadata() CredentialIssuerMetadata
	// RequestCredential requests a credential from the issuer.
	RequestCredential(ctx context.Context, request CredentialRequest, accessToken string) (*vc.VerifiableCredential, error)
}

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

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

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

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

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

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

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

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

type NoopIdentifierResolver struct{}

type OAuth2Client interface {
	// RequestAccessToken requests an access token from the Authorization Server.
	RequestAccessToken(grantType string, params map[string]string) (*oauth.TokenResponse, error)
}

type OAuth2ClientMetadata struct {
	// CredentialOfferEndpoint defines URL of the verifiable credential wallet's offer endpoint
	CredentialOfferEndpoint string `json:"credential_offer_endpoint"`
}

type OfferedCredential struct {
	// Format specifies the credential format.
	Format string `json:"format"`
	// CredentialDefinition contains the 'credential_definition' for the Verifiable Credential Format flows.
	CredentialDefinition *CredentialDefinition `json:"credential_definition,omitempty"`
}

type ProviderMetadata struct {
	// Issuer defines the authorization server's identifier, which is a URL that uses the "https" scheme and has no query or fragment components.
	Issuer string `json:"issuer"`

	// TokenEndpoint defines the URL of the authorization server's token endpoint [RFC6749].
	TokenEndpoint string `json:"token_endpoint"`

	// PreAuthorizedGrantAnonymousAccessSupported indicates whether anonymous access (requests without client_id)
	// for pre-authorized code grant flows.
	// See https://openid.net/specs/openid-4-verifiable-credential-issuance-1_0.html#name-oauth-20-authorization-serv
	PreAuthorizedGrantAnonymousAccessSupported bool `json:"pre-authorized_grant_anonymous_access_supported"`
}

type WalletAPIClient interface {
	// Metadata returns the OAuth2 client metadata of the remote wallet.
	Metadata() OAuth2ClientMetadata
	// OfferCredential sends a credential offer to the remote wallet.
	OfferCredential(ctx context.Context, offer CredentialOffer) error
}