feat(cheqd): Add CheqdTokenStatusListRegistry and tests

Signed-off-by: DaevMithran <[email protected]>

Author: DaevMithran

packages/cheqd/src/wrappers/CheqdTokenStatusListRegistry.ts

@@ -1,15 +1,17 @@
-import { type AgentContext, Buffer, CredoError, Jwt, utils } from '@credo-ts/core'
 import {
+  type AgentContext,
+  CredoError,
+  Jwt,
   PublishTokenStatusListOptions,
+  SdJwtVcIssuerDid,
   TokenStatusListRegistry,
-} from 'packages/core/src/modules/sd-jwt-vc/credential-status/token-status-list/TokenStatusListRegistry'
+  TokenStatusListResponse,
+  TypedArrayEncoder,
+  utils,
+} from '@credo-ts/core'
 import { parseCheqdDid } from '../anoncreds/utils/identifiers'
 import { CheqdCreateResourceOptions, CheqdDidRegistrar, CheqdDidResolver } from '../dids'
 
-export interface CheqdPublishTokenStatusListOptions extends PublishTokenStatusListOptions {
-  name: string
-}
-
 export class CheqdTokenStatusListRegistry implements TokenStatusListRegistry {
   public readonly supportedMethods = ['cheqd']
   public readonly allowsCaching = true
@@ -19,11 +21,11 @@ export class CheqdTokenStatusListRegistry implements TokenStatusListRegistry {
    */
   async publish(
     agentContext: AgentContext,
-    statusListId: string,
+    issuer: SdJwtVcIssuerDid,
     jwt: string,
-    options: CheqdPublishTokenStatusListOptions
+    options: PublishTokenStatusListOptions
   ): Promise<string> {
-    const parsedDid = parseCheqdDid(statusListId)
+    const parsedDid = parseCheqdDid(issuer.didUrl)
     if (!parsedDid) {
       throw new Error('Invalid did:cheqd')
     }
@@ -48,11 +50,8 @@ export class CheqdTokenStatusListRegistry implements TokenStatusListRegistry {
     const { didDocument } = await didResolver.resolve(agentContext, did, parsedDid)
     if (!didDocument) throw new CredoError(`Unable to resolve DID Document for ${did}`)
 
-    const kid = parsedJwt.header.kid
-    if (!kid) throw new CredoError(`JWT is missing 'kid' header`)
-
-    const method = didDocument.verificationMethod?.find((vm) => vm.id === kid)
-    if (!method) throw new CredoError(`No verification method found for kid ${kid}`)
+    const method = didDocument.verificationMethod?.find((vm) => vm.id === issuer.didUrl)
+    if (!method) throw new CredoError(`No verification method found for issuer ${issuer.didUrl}`)
 
     // Upload to Cheqd
     const cheqdDidRegistrar = agentContext.dependencyManager.resolve(CheqdDidRegistrar)
@@ -62,7 +61,7 @@ export class CheqdTokenStatusListRegistry implements TokenStatusListRegistry {
       id: utils.uuid(),
       name: options.name,
       resourceType: 'TokenStatusList',
-      data: Buffer.from(jwt),
+      data: TypedArrayEncoder.toBase64(TypedArrayEncoder.fromString(jwt)),
       version: options.version ?? utils.uuid(),
     }
 
@@ -71,20 +70,25 @@ export class CheqdTokenStatusListRegistry implements TokenStatusListRegistry {
       throw new CredoError(response.resourceState.reason ?? 'Unknown error')
     }
 
+    // return statusListUri
     return `${did}?resourceName=${options.name}&resourceType=TokenStatusList`
   }
 
   /**
    * Retrieve a token status list JWT from the registry
    */
-  async retrieve(agentContext: AgentContext, statusListId: string): Promise<string> {
+  async retrieve(agentContext: AgentContext, statusListUri: SdJwtVcIssuerDid): Promise<TokenStatusListResponse> {
     const cheqdDidResolver = agentContext.dependencyManager.resolve(CheqdDidResolver)
 
-    const response = await cheqdDidResolver.resolveResource(agentContext, statusListId)
-    if (response.error) {
+    const response = await cheqdDidResolver.resolveResource(agentContext, statusListUri.didUrl)
+    if (response.error || !response.resourceMetadata) {
       throw new CredoError(response.message)
     }
 
-    return response.resource
+    return {
+      jwt: TypedArrayEncoder.fromBase64(response.resource).toString(),
+      name: response.resourceMetadata?.name,
+      version: response.resourceMetadata?.version,
+    }
   }
 }

packages/cheqd/tests/cheqd-token-status-list.e2e.test.ts

@@ -0,0 +1,78 @@
+import type { CheqdDidCreateOptions } from '../src'
+
+import { Agent, SdJwtVcIssuer, TokenStatusListService } from '@credo-ts/core'
+
+import { getAgentOptions } from '../../core/tests/helpers'
+import { getCheqdModules } from './setupCheqdModule'
+
+// biome-ignore lint/suspicious/noExportsInTest: <explanation>
+export const agent = new Agent(
+  getAgentOptions('Cheqd Status List Registry', {}, {}, getCheqdModules(undefined, 'https://rpc.cheqd.network:443'))
+)
+
+describe('Cheqd DID Token Status List Registry', () => {
+  let did: string
+
+  beforeAll(async () => {
+    await agent.initialize()
+    const didResult = await agent.dids.create<CheqdDidCreateOptions>({
+      method: 'cheqd',
+      options: {
+        createKey: { type: { kty: 'OKP', crv: 'Ed25519' } },
+        network: 'testnet',
+        methodSpecificIdAlgo: 'uuid',
+      },
+    })
+
+    if (!didResult.didState.did) {
+      throw new Error('No DID created')
+    }
+    did = didResult.didState.did
+  })
+
+  afterAll(async () => {
+    await agent.shutdown()
+  })
+
+  it('should publish and retreive a token status list in local testnet', async () => {
+    const tokenStatusListService = agent.dependencyManager.resolve(TokenStatusListService)
+    const resolveResult = await agent.dids.resolve(did, {
+      useLocalCreatedDidRecord: false,
+    })
+    expect(resolveResult.didDocument).toBeDefined()
+
+    const issuer: SdJwtVcIssuer = {
+      method: 'did',
+      didUrl: `${did}#key-1`,
+    }
+
+    const result = await tokenStatusListService.createStatusList(agent.context, issuer, {
+      name: 'test-token-status-list',
+      size: 10,
+      publish: true,
+    })
+    expect(result.jwt).toBeDefined()
+    expect(result.uri).toBeDefined()
+    expect(result.uri).toContain(did)
+
+    const statusListUri: SdJwtVcIssuer = {
+      method: 'did',
+      didUrl: result.uri as string,
+    }
+
+    // fetch token status list
+    const statusList = await tokenStatusListService.getStatusList(agent.context, statusListUri)
+    expect(statusList).toBeDefined()
+
+    // verify token status at index 0
+    const status = await tokenStatusListService.getStatus(agent.context, statusListUri, 0)
+    expect(status).toBe(0)
+
+    // revoke index 0
+    await tokenStatusListService.revokeIndex(agent.context, issuer, statusListUri, { indices: [0], publish: true })
+
+    // verify token status at index 0
+    const isRevoked = await tokenStatusListService.getStatus(agent.context, statusListUri, 0)
+    expect(isRevoked).toBe(1)
+  })
+})

packages/cheqd/tests/setupCheqdModule.ts

@@ -1,8 +1,9 @@
 import type { CheqdModuleConfigOptions } from '../src'
 
-import { DidsModule } from '@credo-ts/core'
+import { DidsModule, SdJwtVcModule } from '@credo-ts/core'
 
 import { CheqdDidRegistrar, CheqdDidResolver, CheqdModule } from '../src'
+import { CheqdTokenStatusListRegistry } from '../src/wrappers/CheqdTokenStatusListRegistry'
 
 export const cheqdPayerSeeds = [
   'sketch mountain erode window enact net enrich smoke claim kangaroo another visual write meat latin bacon pulp similar forum guilt father state erase bright',
@@ -36,4 +37,7 @@ export const getCheqdModules = (seed?: string, rpcUrl?: string) => ({
     registrars: [new CheqdDidRegistrar()],
     resolvers: [new CheqdDidResolver()],
   }),
+  sdJwtVc: new SdJwtVcModule({
+    registries: [new CheqdTokenStatusListRegistry()],
+  }),
 })

packages/core/src/modules/sd-jwt-vc/credential-status/index.ts

@@ -0,0 +1 @@
+export * from './token-status-list'