Issue and verify BBS+ verifiable credentials using ASP.NET Core and trinsic.id

var diploma = await _universityServices.GetUniversityDiploma(DiplomaTemplateId);

var tid = Convert.ToInt32(DiplomaTemplateId, CultureInfo.InvariantCulture);

var response = await _universityServices
	.IssuerStudentDiplomaCredentialOffer(diploma, tid);

CredentialOfferUrl = response!.ShareUrl;

public async Task<CreateCredentialOfferResponse?> IssuerStudentDiplomaCredentialOffer
	(Diploma diploma, int universityDiplomaTemplateId)
{
	var templateId = await 
		GetUniversityDiplomaTemplateId(universityDiplomaTemplateId);
	// get the template from the id-tech solution
	var templateResponse = await GetUniversityDiplomaTemplate(templateId!);

	// Auth token from University issuer wallet
	_trinsicService.Options.AuthToken = 
		_configuration["TrinsicOptions:IssuerAuthToken"];

	var response = await _trinsicService
		.Credential.CreateCredentialOfferAsync(
			new CreateCredentialOfferRequest
			{
				TemplateId = templateResponse.Template.Id,
				ValuesJson = JsonSerializer.Serialize(diploma),
				GenerateShareUrl = true
			});

	return response;
}

public class GenerateProofService
{
    private readonly TrinsicService _trinsicService;
    private readonly IConfiguration _configuration;

    public List<SelectListItem> Universities = new();

    public GenerateProofService(TrinsicService trinsicService, IConfiguration configuration)
    {
        _trinsicService = trinsicService;
        _configuration = configuration;

        Universities = _configuration.GetSection("Universities")!.Get<List<SelectListItem>>()!;
    }

    public async Task<List<SelectListItem>> GetItemsInWallet(string userAuthToken)
    {
        var results = new List<SelectListItem>();
        // Auth token from user 
        _trinsicService.Options.AuthToken = userAuthToken;

        // get all items
        var items = await _trinsicService.Wallet.SearchWalletAsync(new SearchRequest());
        foreach (var item in items.Items)
        {
            var jsonObject = JsonNode.Parse(item)!;
            var id = jsonObject["id"];
            var vcArray = jsonObject["data"]!["type"];
            var vc = string.Empty;
            foreach (var i in vcArray!.AsArray())
            {
                var val = i!.ToString();
                if (val != "VerifiableCredential")
                {
                    vc = val!.ToString();
                    break;
                }
            }

            results.Add(new SelectListItem(vc, id!.ToString()));
        }

        return results;
    }

    public async Task<CreateProofResponse> CreateProof(string userAuthToken, string credentialItemId)
    {
        // Auth token from user 
        _trinsicService.Options.AuthToken = userAuthToken;

        var selectiveProof = await _trinsicService.Credential.CreateProofAsync(new()
        {
            ItemId = credentialItemId,
            RevealTemplate = new()
            {
                TemplateAttributes = { "firstName", "lastName", "dateOfBirth", "diplomaTitle" }
            }
        });

        return selectiveProof;
    }

    public AuthenticateInitResponse AuthenticateInit(string userId, string universityEcosystemId)
    {
        var requestInit = new AuthenticateInitRequest
        {
            Identity = userId,
            Provider = IdentityProvider.Email,
            EcosystemId = universityEcosystemId
        };

        var authenticateInitResponse = _trinsicService.Wallet.AuthenticateInit(requestInit);

        return authenticateInitResponse;
    }

    public AuthenticateConfirmResponse AuthenticateConfirm(string code, string challenge)
    {
        var requestConfirm = new AuthenticateConfirmRequest
        {
            Challenge = challenge,
            Response = code
        };
        var authenticateConfirmResponse = _trinsicService.Wallet.AuthenticateConfirm(requestConfirm);

        return authenticateConfirmResponse;
    }
}

public class DiplomaVerifyService
{
    private readonly TrinsicService _trinsicService;
    private readonly IConfiguration _configuration;

 
    public List<SelectListItem> TrustedUniversities = new();
    public List<SelectListItem> TrustedCredentials = new();

    public DiplomaVerifyService(TrinsicService trinsicService, IConfiguration configuration)
    {
        _trinsicService = trinsicService;
        _configuration = configuration;

        TrustedUniversities = _configuration.GetSection("TrustedUniversities")!.Get<List<SelectListItem>>()!;
        TrustedCredentials = _configuration.GetSection("TrustedCredentials")!.Get<List<SelectListItem>>()!;
    }

    public async Task<(VerifyProofResponse? Proof, bool IsValid)> Verify(string studentProof, string universityIssuer)
    {
        // Verifiers auth token
        // Auth token from trinsic.id root API KEY provider
        _trinsicService.Options.AuthToken = _configuration["TrinsicCompanyXHumanResourcesOptions:ApiKey"];

        var verifyProofResponse = await _trinsicService.Credential.VerifyProofAsync(new VerifyProofRequest
        {
            ProofDocumentJson = studentProof,
        });

        var jsonObject = JsonNode.Parse(studentProof)!;
        var issuer = jsonObject["issuer"];

        // check issuer
        if (universityIssuer != issuer!.ToString())
        {
            return (null, false);
        }

        return (verifyProofResponse, true);
    }
}