@credo-ts/openid4vc

npm install @credo-ts/openid4vc @credo-ts/core

import { OpenId4VcModule } from '@credo-ts/openid4vc'
import { Agent } from '@credo-ts/core'

const agent = new Agent({
  config: { /* ... */ },
  dependencies: agentDependencies,
  modules: {
    openId4Vc: new OpenId4VcModule({
      issuer: {
        baseUrl: 'https://issuer.example.com',
        endpoints: {
          credential: {
            credentialEndpoint: '/oid4vci/credential',
          },
        },
      },
    }),
  },
})

await agent.initialize()

const agent = new Agent({
  config: { /* ... */ },
  dependencies: agentDependencies,
  modules: {
    openId4Vc: new OpenId4VcModule({
      verifier: {
        baseUrl: 'https://verifier.example.com',
        endpoints: {
          authorization: {
            authorizationEndpoint: '/oid4vp/authorize',
          },
        },
      },
    }),
  },
})

const agent = new Agent({
  config: { /* ... */ },
  dependencies: agentDependencies,
  modules: {
    openId4Vc: new OpenId4VcModule({
      issuer: {
        baseUrl: 'https://example.com',
      },
      verifier: {
        baseUrl: 'https://example.com',
      },
    }),
  },
})

// Holder is always available, no config needed
const agent = new Agent({
  config: { /* ... */ },
  dependencies: agentDependencies,
  modules: {
    openId4Vc: new OpenId4VcModule(),
  },
})

const credentialOffer = await agent.modules.openId4Vc.issuer.createCredentialOffer({
  offeredCredentials: [
    {
      id: 'credential-id',
      format: 'jwt_vc_json',
      credential: {
        '@context': ['https://www.w3.org/2018/credentials/v1'],
        type: ['VerifiableCredential', 'UniversityDegree'],
        issuer: issuerDid,
        credentialSubject: {},
      },
    },
  ],
  preAuthorizedCodeFlowConfig: {
    userPinRequired: false,
  },
})

// Share the credential offer URI
console.log(credentialOffer.credentialOfferUri)
// openid-credential-offer://?credential_offer=...

// The actual credential issuance happens when holder requests
// You can customize the credential before signing:
agent.modules.openId4Vc.issuer.onCredentialRequest(async ({ credentialRequest }) => {
  const credential = {
    '@context': ['https://www.w3.org/2018/credentials/v1'],
    type: ['VerifiableCredential', 'UniversityDegree'],
    issuer: issuerDid,
    issuanceDate: new Date().toISOString(),
    credentialSubject: {
      id: holderDid,
      degree: {
        type: 'BachelorDegree',
        name: 'Bachelor of Science',
      },
    },
  }

  return { credential }
})

// Resolve and accept credential offer
const resolvedOffer = await agent.modules.openId4Vc.holder.resolveCredentialOffer(
  credentialOfferUri
)

// Request credential
const credentials = await agent.modules.openId4Vc.holder.requestCredentials({
  resolvedCredentialOffer: resolvedOffer,
})

console.log('Received credentials:', credentials)

// Resolve authorization request from verifier
const resolved = await agent.modules.openId4Vc.holder.resolveAuthorizationRequest(
  authorizationRequest
)

// Select credentials to present
const selectedCredentials = await agent.modules.openId4Vc.holder.selectCredentialsForRequest(
  resolved.authorizationRequest
)

// Send presentation
const result = await agent.modules.openId4Vc.holder.sendPresentation({
  authorizationRequest: resolved.authorizationRequest,
  selectedCredentials,
})

// Create authorization request
const { authorizationRequest } = await agent.modules.openId4Vc.verifier.createAuthorizationRequest({
  requestSigner: {
    method: 'did',
    didUrl: verifierDid,
  },
  presentationDefinition: {
    id: 'presentation-definition-1',
    input_descriptors: [
      {
        id: 'degree',
        constraints: {
          fields: [
            {
              path: ['$.type'],
              filter: {
                type: 'string',
                pattern: 'UniversityDegree',
              },
            },
          ],
        },
      },
    ],
  },
})

// Share authorization request with holder
console.log(authorizationRequest)

// Verification happens automatically when presentation is received
const presentation = await agent.modules.openId4Vc.verifier.getVerifiedPresentation({
  authorizationResponse,
})

if (presentation.verified) {
  console.log('Presentation verified successfully!')
  console.log('Submitted credentials:', presentation.credentials)
}

interface OpenId4VcIssuerModuleConfigOptions {
  baseUrl: string
  endpoints?: {
    credential?: {
      credentialEndpoint?: string
    }
  }
  // Additional router configuration for custom endpoints
  router?: Router
}

interface OpenId4VcVerifierModuleConfigOptions {
  baseUrl: string
  endpoints?: {
    authorization?: {
      authorizationEndpoint?: string
    }
  }
  router?: Router
}

import express from 'express'

const app = express()
// OpenID4VC endpoints are automatically registered
app.listen(3000)