@sphereon/ssi-sdk.data-store 0.36.1-next.119 → 0.36.1-next.149

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sphereon/ssi-sdk.data-store",
-  "version": "0.36.1-next.119+86f2dfd2",
+  "version": "0.36.1-next.149+abd25c87",
   "source": "src/index.ts",
   "type": "module",
   "main": "./dist/index.cjs",
@@ -28,13 +28,14 @@
   "dependencies": {
     "@sphereon/kmp-mdoc-core": "0.2.0-SNAPSHOT.26",
     "@sphereon/pex": "5.0.0-unstable.28",
-    "@sphereon/ssi-sdk-ext.did-utils": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk.agent-config": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk.core": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-sdk.data-store-types": "0.36.1-next.119+86f2dfd2",
-    "@sphereon/ssi-types": "0.36.1-next.119+86f2dfd2",
+    "@sphereon/ssi-sdk-ext.did-utils": "0.36.1-next.149+abd25c87",
+    "@sphereon/ssi-sdk-ext.identifier-resolution": "0.36.1-next.149+abd25c87",
+    "@sphereon/ssi-sdk.agent-config": "0.36.1-next.149+abd25c87",
+    "@sphereon/ssi-sdk.core": "0.36.1-next.149+abd25c87",
+    "@sphereon/ssi-sdk.data-store-types": "0.36.1-next.149+abd25c87",
+    "@sphereon/ssi-types": "0.36.1-next.149+abd25c87",
     "@veramo/core": "4.2.0",
+    "@veramo/data-store": "4.2.0",
     "@veramo/utils": "4.2.0",
     "blakejs": "^1.2.1",
     "class-validator": "0.14.1",
@@ -66,5 +67,5 @@
     "PostgreSQL",
     "Contact Store"
   ],
-  "gitHead": "86f2dfd2bac43df28073b4e079a83b85f92c3157"
+  "gitHead": "abd25c87e0155d6b89bff27ac74e721571f83a2f"
 }

package/src/__tests__/contact.entities.test.ts

@@ -18,7 +18,7 @@ import { PartyEntity } from '../entities/contact/PartyEntity'
 import { PartyRelationshipEntity } from '../entities/contact/PartyRelationshipEntity'
 import { PartyTypeEntity } from '../entities/contact/PartyTypeEntity'
 import { PhysicalAddressEntity } from '../entities/contact/PhysicalAddressEntity'
-import { contactMetadataItemEntityFrom, DataStoreContactEntities, DataStoreMigrations, identityMetadataItemEntityFrom, partyTypeFrom } from '../index'
+import { contactMetadataItemEntityFrom, DataStoreEntitiesWithVeramo, DataStoreMigrationsWithVeramo, identityMetadataItemEntityFrom, partyTypeFrom } from '../index'
 import {
   IdentityOrigin,
   MetadataTypes,
@@ -64,9 +64,9 @@ describe('Database entities tests', (): void => {
       database: ':memory:',
       logging: ['info'],
       migrationsRun: false,
-      migrations: DataStoreMigrations,
+      migrations: DataStoreMigrationsWithVeramo,
       synchronize: false,
-      entities: DataStoreContactEntities,
+      entities: DataStoreEntitiesWithVeramo,
     }).initialize()
     await dbConnection.runMigrations()
     expect(await dbConnection.showMigrations()).toBeFalsy()

package/src/__tests__/contact.store.test.ts

@@ -31,7 +31,7 @@ import { CredentialRole } from '@sphereon/ssi-types'
 import { DataSource } from 'typeorm'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { ContactStore } from '../contact/ContactStore'
-import { DataStoreContactEntities, DataStoreMigrations } from '../index'
+import { DataStoreEntitiesWithVeramo, DataStoreMigrationsWithVeramo } from '../index'
 
 describe('Contact store tests', (): void => {
   let dbConnection: DataSource
@@ -44,9 +44,9 @@ describe('Contact store tests', (): void => {
       database: ':memory:',
       logging: ['info'],
       migrationsRun: false,
-      migrations: DataStoreMigrations,
+      migrations: DataStoreMigrationsWithVeramo,
       synchronize: false,
-      entities: DataStoreContactEntities,
+      entities: DataStoreEntitiesWithVeramo,
     }).initialize()
     await dbConnection.runMigrations()
     expect(await dbConnection.showMigrations()).toBeFalsy()

package/src/__tests__/issuanceBranding.entities.test.ts

@@ -6,7 +6,7 @@ import {
   credentialBrandingEntityFrom,
   CredentialLocaleBrandingEntity,
   credentialLocaleBrandingEntityFrom,
-  DataStoreIssuanceBrandingEntities,
+  DataStoreIssuanceBrandingEntities, DataStoreEntitiesWithVeramo,
   IBasicCredentialBranding,
   IBasicCredentialLocaleBranding,
   IBasicIssuerBranding,
@@ -16,7 +16,7 @@ import {
   IssuerLocaleBrandingEntity,
   issuerLocaleBrandingEntityFrom,
 } from '../index'
-import { DataStoreMigrations } from '../migrations'
+import { DataStoreMigrationsWithVeramo } from '../migrations'
 
 describe('Database entities tests', (): void => {
   let dbConnection: DataSource
@@ -28,9 +28,9 @@ describe('Database entities tests', (): void => {
       database: ':memory:',
       //logging: ['info'],
       migrationsRun: false,
-      migrations: DataStoreMigrations,
+      migrations: DataStoreMigrationsWithVeramo,
       synchronize: false,
-      entities: DataStoreIssuanceBrandingEntities,
+      entities: DataStoreEntitiesWithVeramo,
     }).initialize()
     await dbConnection.runMigrations()
     expect(await dbConnection.showMigrations()).toBeFalsy()
@@ -823,7 +823,7 @@ describe('Database entities tests', (): void => {
     }
 
     const issuerLocaleBrandingEntity: IssuerLocaleBrandingEntity = issuerLocaleBrandingEntityFrom(localeBranding)
-    const fromDb: IssuerLocaleBrandingEntity = await dbConnection.getRepository(CredentialLocaleBrandingEntity).save(issuerLocaleBrandingEntity)
+    const fromDb: IssuerLocaleBrandingEntity = await dbConnection.getRepository(IssuerLocaleBrandingEntity).save(issuerLocaleBrandingEntity)
 
     expect(fromDb).toBeDefined()
     expect(fromDb?.alias).toEqual(localeBranding.alias)

package/src/__tests__/issuanceBranding.store.test.ts

@@ -4,7 +4,7 @@ import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import {
   BackgroundAttributesEntity,
   CredentialLocaleBrandingEntity,
-  DataStoreIssuanceBrandingEntities,
+  DataStoreIssuanceBrandingEntities, DataStoreEntitiesWithVeramo,
   IAddCredentialLocaleBrandingArgs,
   IAddIssuerLocaleBrandingArgs,
   IBasicCredentialBranding,
@@ -26,7 +26,7 @@ import {
   TextAttributesEntity,
 } from '../index'
 import { IssuanceBrandingStore } from '../issuanceBranding/IssuanceBrandingStore'
-import { DataStoreMigrations } from '../migrations'
+import { DataStoreMigrationsWithVeramo } from '../migrations'
 
 describe('Issuance branding store tests', (): void => {
   let dbConnection: DataSource
@@ -39,9 +39,9 @@ describe('Issuance branding store tests', (): void => {
       database: ':memory:',
       //logging: ['info'],
       migrationsRun: false,
-      migrations: DataStoreMigrations,
+      migrations: DataStoreMigrationsWithVeramo,
       synchronize: false,
-      entities: DataStoreIssuanceBrandingEntities,
+      entities: DataStoreEntitiesWithVeramo,
     }).initialize()
     await dbConnection.runMigrations()
     expect(await dbConnection.showMigrations()).toBeFalsy()
@@ -1884,4 +1884,314 @@ describe('Issuance branding store tests', (): void => {
     expect(result?.localeBranding[0].background!.image!.alt).toBeUndefined()
     expect(result?.localeBranding[0].text!.color).toBeUndefined()
   })
+
+  // State-related tests
+
+  it('should populate state field when adding credential branding', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const result: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+
+    expect(result).toBeDefined()
+    expect(result.state).toBeDefined()
+    expect(typeof result.state).toBe('string')
+    expect(result.state.length).toBeGreaterThan(0)
+    expect(result.localeBranding[0].state).toBeDefined()
+    expect(typeof result.localeBranding[0].state).toBe('string')
+    expect(result.localeBranding[0].state.length).toBeGreaterThan(0)
+  })
+
+  it('should generate different states for different credential brandings', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId1',
+      vcHash: 'vcHash1',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias1',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId2',
+      vcHash: 'vcHash2',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias2',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const result1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+    const result2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+
+    expect(result1.state).toBeDefined()
+    expect(result2.state).toBeDefined()
+    expect(result1.state).not.toEqual(result2.state)
+    expect(result1.localeBranding[0].state).not.toEqual(result2.localeBranding[0].state)
+  })
+
+  it('should keep same state when credential branding content does not change', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          description: 'Description',
+        },
+      ],
+    }
+
+    const original: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const originalState: string = original.state
+    const originalLocaleState: string = original.localeBranding[0].state
+
+    const retrieved: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ filter: [{ id: original.id }] })
+
+    expect(retrieved).toBeDefined()
+    expect(retrieved.length).toEqual(1)
+    expect(retrieved[0].state).toEqual(originalState)
+    expect(retrieved[0].localeBranding[0].state).toEqual(originalLocaleState)
+  })
+
+  it('should filter credential branding by knownStates when all states match', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const knownStates: Record<string, string> = {
+      [saved.id]: saved.state,
+    }
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(0)
+  })
+
+  it('should return credential branding when knownStates differs', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const knownStates: Record<string, string> = {
+      [saved.id]: 'differentState',
+    }
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(1)
+    expect(result[0].id).toEqual(saved.id)
+  })
+
+  it('should return credential branding when not in knownStates map', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+    const knownStates: Record<string, string> = {}
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(1)
+    expect(result[0].id).toEqual(saved.id)
+  })
+
+  it('should filter multiple credential brandings correctly with knownStates', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId1',
+      vcHash: 'vcHash1',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias1',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId2',
+      vcHash: 'vcHash2',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias2',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const credentialBranding3: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId3',
+      vcHash: 'vcHash3',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias3',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+    const saved2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+    const saved3: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding3)
+
+    const knownStates: Record<string, string> = {
+      [saved1.id]: saved1.state,
+      [saved2.id]: 'differentState',
+    }
+
+    const result: Array<ICredentialBranding> = await issuanceBrandingStore.getCredentialBranding({ knownStates })
+
+    expect(result.length).toEqual(2)
+    const resultIds: Array<string> = result.map((r: ICredentialBranding) => r.id)
+    expect(resultIds).toContain(saved2.id)
+    expect(resultIds).toContain(saved3.id)
+    expect(resultIds).not.toContain(saved1.id)
+  })
+
+  it('should add new locale branding with state field populated', async (): Promise<void> => {
+    const credentialBranding: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+        },
+      ],
+    }
+
+    const saved: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding)
+
+    const addLocaleBrandingArgs: IAddCredentialLocaleBrandingArgs = {
+      credentialBrandingId: saved.id,
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-GB',
+        },
+      ],
+    }
+
+    const result: ICredentialBranding = await issuanceBrandingStore.addCredentialLocaleBranding(addLocaleBrandingArgs)
+
+    expect(result.localeBranding.length).toEqual(2)
+    expect(result.localeBranding[0].state).toBeDefined()
+    expect(result.localeBranding[1].state).toBeDefined()
+    expect(result.localeBranding[0].state).not.toEqual(result.localeBranding[1].state)
+  })
+
+  it('should compute state based on locale branding claims', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash1',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          claims: [
+            {
+              key: 'name',
+              name: 'Full Name',
+            },
+          ],
+        },
+      ],
+    }
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash2',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          claims: [
+            {
+              key: 'email',
+              name: 'Email Address',
+            },
+          ],
+        },
+      ],
+    }
+
+    const saved1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+    const saved2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+
+    expect(saved1.localeBranding[0].state).toBeDefined()
+    expect(saved2.localeBranding[0].state).toBeDefined()
+    expect(saved1.localeBranding[0].state).not.toEqual(saved2.localeBranding[0].state)
+  })
+
+  it('should compute deterministic state for same content', async (): Promise<void> => {
+    const credentialBranding1: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          description: 'Test description',
+        },
+      ],
+    }
+
+    const saved1: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding1)
+
+    await issuanceBrandingStore.removeCredentialBranding({ filter: [{ id: saved1.id }] })
+
+    const credentialBranding2: IBasicCredentialBranding = {
+      issuerCorrelationId: 'issuerCorrelationId',
+      vcHash: 'vcHash',
+      localeBranding: [
+        {
+          alias: 'credentialTypeAlias',
+          locale: 'en-US',
+          description: 'Test description',
+        },
+      ],
+    }
+
+    const saved2: ICredentialBranding = await issuanceBrandingStore.addCredentialBranding(credentialBranding2)
+
+    expect(saved1.state).toEqual(saved2.state)
+    expect(saved1.localeBranding[0].state).toEqual(saved2.localeBranding[0].state)
+  })
 })

package/src/contact/ContactStore.ts

@@ -109,9 +109,21 @@ export class ContactStore extends AbstractContactStore {
     const initialResult = await partyRepository.find({ select: ['id'], where: filterConditions })
 
     // Fetch the complete entities based on the initial result IDs
-    const result = await partyRepository.find({ where: { id: In(initialResult.map((party) => party.id)) } })
+    const result = await partyRepository.find({
+      where: { id: In(initialResult.map((party) => party.id)) },
+      relations: ['contact'], // Explicit load prevents eager loading issues
+    })
     debug(`getParties() resulted in ${result.length} parties`)
-    return result.map(partyFrom)
+    return result
+      .filter((party) => {
+        // Do not crash fetching the entire contacts list over one missing contact relation
+        if (!party.contact) {
+          console.warn(`party ${party.id} does not have an associated contact`)
+          return false
+        }
+        return true
+      })
+      .map(partyFrom)
   }
 
   addParty = async (args: AddPartyArgs): Promise<Party> => {
@@ -237,10 +249,45 @@ export class ContactStore extends AbstractContactStore {
       }
     }
 
-    const identityEntity: IdentityEntity = identityEntityFrom(identity)
+    const identityRepository = (await this.dbConnection).getRepository(IdentityEntity)
+    const correlationIdentifierRepository = (await this.dbConnection).getRepository(CorrelationIdentifierEntity)
+
+    // First check if an identity with the same correlationId already exists
+    const existingCorrelationIdentifier = await correlationIdentifierRepository.findOne({
+      where: { correlationId: identity.identifier.correlationId },
+    })
+
+    if (existingCorrelationIdentifier) {
+      // The same identifier already exists, return the existing identity
+      const existingIdentity = await identityRepository.findOne({
+        where: { identifier: { id: existingCorrelationIdentifier.id } },
+      })
+      if (existingIdentity) {
+        debug('Identity with same correlationId already exists, returning existing identity', identity.identifier.correlationId)
+        return identityFrom(existingIdentity)
+      }
+    }
+
+    // Check if an identity with the same alias exists (but different correlationId)
+    const existingAlias = await identityRepository.findOne({
+      where: { alias: identity.alias },
+    })
+
+    let uniqueAlias = identity.alias
+    if (existingAlias) {
+      // Generate a unique alias by appending a counter
+      let counter = 1
+      while (await identityRepository.findOne({ where: { alias: `${identity.alias}_${counter}` } })) {
+        counter++
+      }
+      uniqueAlias = `${identity.alias}_${counter}`
+      debug('Alias collision detected, using unique alias', { original: identity.alias, unique: uniqueAlias })
+    }
+
+    const identityEntity: IdentityEntity = identityEntityFrom({ ...identity, alias: uniqueAlias })
     identityEntity.party = party
     debug('Adding identity', identity)
-    const result: IdentityEntity = await (await this.dbConnection).getRepository(IdentityEntity).save(identityEntity, {
+    const result: IdentityEntity = await identityRepository.save(identityEntity, {
       transaction: true,
     })
 

package/src/entities/issuanceBranding/CredentialBrandingEntity.ts

@@ -12,7 +12,8 @@ import {
   PrimaryGeneratedColumn,
   UpdateDateColumn,
 } from 'typeorm'
-import { CredentialLocaleBrandingEntity } from './CredentialLocaleBrandingEntity'
+import { CredentialLocaleBrandingEntity, computeCredentialLocaleBrandingState } from './CredentialLocaleBrandingEntity'
+import { computeCompactHash } from '../../utils/issuanceBranding/HashUtils'
 
 @Entity('CredentialBranding')
 @Index('IDX_CredentialBrandingEntity_vcHash', ['vcHash'])
@@ -29,6 +30,9 @@ export class CredentialBrandingEntity extends BaseEntity {
   @IsNotEmpty({ message: 'Blank issuerCorrelationIds are not allowed' })
   issuerCorrelationId!: string
 
+  @Column('varchar', { name: 'state', length: 255, nullable: false })
+  state!: string
+
   @OneToMany(
     () => CredentialLocaleBrandingEntity,
     (credentialLocaleBrandingEntity: CredentialLocaleBrandingEntity) => credentialLocaleBrandingEntity.credentialBranding,
@@ -55,6 +59,14 @@ export class CredentialBrandingEntity extends BaseEntity {
     this.lastUpdatedAt = new Date()
   }
 
+  @BeforeInsert()
+  @BeforeUpdate()
+  setState(): void {
+    if (this.localeBranding && Array.isArray(this.localeBranding)) {
+      this.state = this.computeState()
+    }
+  }
+
   @BeforeInsert()
   @BeforeUpdate()
   async validate(): Promise<undefined> {
@@ -64,4 +76,35 @@ export class CredentialBrandingEntity extends BaseEntity {
     }
     return
   }
+
+  private computeState(): string {
+    const localeStates: Array<{ locale: string; alias: string; id: string; state: string }> = (this.localeBranding ?? []).map(
+      (localeBranding: CredentialLocaleBrandingEntity) => ({
+        locale: localeBranding.locale ?? '',
+        alias: localeBranding.alias ?? '',
+        id: localeBranding.id ?? '',
+        state: computeCredentialLocaleBrandingState(localeBranding),
+      }),
+    )
+
+    localeStates.sort((first, second) => {
+      const localeCompare: number = first.locale.localeCompare(second.locale)
+      if (localeCompare !== 0) {
+        return localeCompare
+      }
+      const aliasCompare: number = first.alias.localeCompare(second.alias)
+      if (aliasCompare !== 0) {
+        return aliasCompare
+      }
+      return first.id.localeCompare(second.id)
+    })
+
+    const payload = {
+      issuerCorrelationId: this.issuerCorrelationId,
+      vcHash: this.vcHash,
+      localeBranding: localeStates.map((entry) => entry.state),
+    }
+
+    return computeCompactHash(JSON.stringify(payload))
+  }
 }

package/src/entities/issuanceBranding/CredentialLocaleBrandingEntity.ts

@@ -1,4 +1,5 @@
-import { ChildEntity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm'
+import { BeforeInsert, BeforeUpdate, ChildEntity, Column, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm'
+import { computeCompactHash } from '../../utils/issuanceBranding/HashUtils'
 import { BaseLocaleBrandingEntity } from './BaseLocaleBrandingEntity'
 import { CredentialBrandingEntity } from './CredentialBrandingEntity'
 import { CredentialClaimsEntity } from './CredentialClaimsEntity'
@@ -23,4 +24,66 @@ export class CredentialLocaleBrandingEntity extends BaseLocaleBrandingEntity {
 
   @Column('uuid', { name: 'credentialBrandingId', nullable: false })
   credentialBrandingId!: string
+
+  @Column('varchar', { name: 'state', length: 255, nullable: false })
+  state!: string
+
+  @BeforeInsert()
+  @BeforeUpdate()
+  setState(): void {
+    this.state = computeCredentialLocaleBrandingState(this)
+  }
+}
+
+export const computeCredentialLocaleBrandingState = (localeBranding: CredentialLocaleBrandingEntity): string => {
+  const sortedClaims: Array<{ key: string; name: string }> = (localeBranding.claims ?? [])
+    .map((claim: CredentialClaimsEntity) => ({ key: claim.key, name: claim.name }))
+    .sort((first: { key: string }, second: { key: string }) => first.key.localeCompare(second.key))
+
+  const payload = {
+    alias: localeBranding.alias ?? null,
+    locale: localeBranding.locale ?? null,
+    description: localeBranding.description ?? null,
+    logo: localeBranding.logo
+      ? {
+          uri: localeBranding.logo.uri ?? null,
+          dataUri: localeBranding.logo.dataUri ?? null,
+          mediaType: localeBranding.logo.mediaType ?? null,
+          alt: localeBranding.logo.alt ?? null,
+          dimensions: localeBranding.logo.dimensions
+            ? {
+                width: localeBranding.logo.dimensions.width,
+                height: localeBranding.logo.dimensions.height,
+              }
+            : null,
+        }
+      : null,
+    background: localeBranding.background
+      ? {
+          color: localeBranding.background.color ?? null,
+          image: localeBranding.background.image
+            ? {
+                uri: localeBranding.background.image.uri ?? null,
+                dataUri: localeBranding.background.image.dataUri ?? null,
+                mediaType: localeBranding.background.image.mediaType ?? null,
+                alt: localeBranding.background.image.alt ?? null,
+                dimensions: localeBranding.background.image.dimensions
+                  ? {
+                      width: localeBranding.background.image.dimensions.width,
+                      height: localeBranding.background.image.dimensions.height,
+                    }
+                  : null,
+              }
+            : null,
+        }
+      : null,
+    text: localeBranding.text
+      ? {
+          color: localeBranding.text.color ?? null,
+        }
+      : null,
+    claims: sortedClaims,
+  }
+
+  return computeCompactHash(JSON.stringify(payload))
 }