feature/jarm_sdk

.github/workflows/build-test-publish-on-push.yml

@@ -81,18 +81,25 @@ jobs:
       - name: diff
         run: git diff
 
+      - name: Sets PREID
+        env:
+          name: "${{github.ref_name}}"
+        run: |
+          echo "PRE_ID=${name//[\/_-]/.}" >> $GITHUB_ENV
+
       - name: publish @latest when on main
         if: github.ref == 'refs/heads/main'
-        run: pnpm publish:latest
+        run: lerna publish --conventional-commits --force-publish --include-merged-tags --sync-dist-version --create-release github --yes --dist-tag latest --registry https://registry.npmjs.org
 
       - name: publish @next when on develop
         if: github.ref == 'refs/heads/develop'
-        run: pnpm publish:next
+        run: lerna publish --conventional-prerelease --force-publish --canary --sync-dist-version --no-git-tag-version --include-merged-tags --preid next --pre-dist-tag next --yes --registry https://registry.npmjs.org",
 
-      - name: publish @next when on fix
+      - name: publish @next when on fix branch
         if: startsWith(github.ref, 'refs/heads/fix')
-        run: pnpm publish:next
+        run: lerna publish --conventional-prerelease --force-publish --canary --sync-dist-version --no-git-tag-version --include-merged-tags --preid fix --pre-dist-tag fix --yes --registry https://registry.npmjs.org",
 
       - name: publish @unstable when on unstable branch
         if: startsWith(github.ref, 'refs/heads/feat')
-        run: pnpm publish:unstable
+        run: lerna publish --conventional-prerelease --force-publish --canary --sync-dist-version --no-git-tag-version --include-merged-tags --preid $PRE_ID --pre-dist-tag unstable --yes --throttle-size 75 --registry https://registry.npmjs.org
+

package.json

@@ -67,3 +67,4 @@
     "OID4VP"
   ]
 }
+

packages/callback-example/package.json

@@ -19,7 +19,7 @@
     "@sphereon/oid4vci-client": "workspace:*",
     "@sphereon/oid4vci-common": "workspace:*",
     "@sphereon/oid4vci-issuer": "workspace:*",
-    "@sphereon/ssi-types": "0.29.1-unstable.208",
+    "@sphereon/ssi-types": "0.30.1",
     "jose": "^4.10.0"
   },
   "devDependencies": {

packages/client/lib/OpenID4VCIClientV1_0_13.ts

@@ -447,7 +447,7 @@ export class OpenID4VCIClientV1_0_13 {
           );
         }
         const credentialsSupported = metadata.credential_configurations_supported;
-        if (!metadata.credential_configurations_supported || !credentialsSupported[credentialIdentifier]) {
+        if (!credentialsSupported || !credentialsSupported[credentialIdentifier]) {
           throw new Error(`Credential type ${credentialIdentifier} is not supported by issuer ${this.getIssuer()}`);
         }
       } else if (!types) {
@@ -472,9 +472,19 @@ export class OpenID4VCIClientV1_0_13 {
           console.log(`Not all credential types ${JSON.stringify(credentialTypes)} are present in metadata for ${this.getIssuer()}`);
           // throw Error(`Not all credential types ${JSON.stringify(credentialTypes)} are supported by issuer ${this.getIssuer()}`);
         }
-      } else if (metadata.credential_configurations_supported && !Array.isArray(metadata.credential_configurations_supported)) {
-        const credentialsSupported = metadata.credential_configurations_supported;
-        if (types.some((type) => !metadata.credential_configurations_supported || !credentialsSupported[type])) {
+      } else if (metadata.credential_configurations_supported && typeof(metadata.credential_configurations_supported) === 'object') {
+        let typeSupported = false;
+        Object.values(metadata.credential_configurations_supported).forEach((supportedCredential) => {
+          const subTypes = getTypesFromCredentialSupported(supportedCredential);
+          if (
+            subTypes.every((t, i) => types[i] === t) ||
+            (types.length === 1 && (types[0] === supportedCredential.id || subTypes.includes(types[0])))
+          ) {
+            typeSupported = true;
+          }
+        })
+
+        if (!typeSupported) {
           throw Error(`Not all credential types ${JSON.stringify(credentialTypes)} are supported by issuer ${this.getIssuer()}`);
         }
       }

packages/client/lib/__tests__/SphereonE2E.spec.test.ts

@@ -170,3 +170,4 @@ describe('ismapolis bug report #63, https://github.com/Sphereon-Opensource/OID4V
     console.log(JSON.stringify(credentialResponse.credential));
   });
 });
+

packages/client/package.json

@@ -17,7 +17,7 @@
   "dependencies": {
     "@sphereon/oid4vc-common": "workspace:*",
     "@sphereon/oid4vci-common": "workspace:*",
-    "@sphereon/ssi-types": "0.29.1-unstable.208",
+    "@sphereon/ssi-types": "0.30.1",
     "cross-fetch": "^3.1.8",
     "debug": "^4.3.5"
   },

packages/common/package.json

@@ -10,7 +10,7 @@
     "build:clean": "tsc --build --clean && tsc --build"
   },
   "dependencies": {
-    "@sphereon/ssi-types": "0.29.1-unstable.208",
+    "@sphereon/ssi-types": "0.30.1",
     "jwt-decode": "^4.0.0",
     "sha.js": "^2.4.11",
     "uint8arrays": "3.1.1",

packages/did-auth-siop-adapter/lib/did/DidJWT.ts

@@ -238,7 +238,7 @@ function assertIssSelfIssuedOrDid(payload: JWTPayload) {
   }
 }
 
-export function getSubDidFromPayload(payload: JWTPayload, header?: JWTHeader): string {
+export function getSubDidFromPayload(payload: JWTPayload, header?: JWTHeader): string | undefined {
   assertIssSelfIssuedOrDid(payload)
 
   if (isIssSelfIssued(payload)) {
@@ -258,9 +258,9 @@ export function getSubDidFromPayload(payload: JWTPayload, header?: JWTHeader): s
 
 export function isIssSelfIssued(payload: JWTPayload): boolean {
   return (
-    (payload.iss && payload.iss.includes(ResponseIss.SELF_ISSUED_V1)) ||
+    (payload.iss && (payload.iss.includes(ResponseIss.SELF_ISSUED_V1)) ||
     (payload.iss && payload.iss.includes(ResponseIss.SELF_ISSUED_V2)) ||
-    payload.iss === payload.sub
+    payload.iss === payload.sub)
   )
 }
 

packages/issuer-rest/package.json

@@ -14,8 +14,8 @@
     "@sphereon/oid4vc-common": "workspace:*",
     "@sphereon/oid4vci-common": "workspace:*",
     "@sphereon/oid4vci-issuer": "workspace:*",
-    "@sphereon/ssi-express-support": "0.29.1-unstable.208",
-    "@sphereon/ssi-types": "0.29.1-unstable.208",
+    "@sphereon/ssi-express-support": "0.30.1",
+    "@sphereon/ssi-types": "0.30.1",
     "body-parser": "^1.20.2",
     "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",

packages/issuer/package.json

@@ -12,7 +12,7 @@
   "dependencies": {
     "@sphereon/oid4vc-common": "workspace:*",
     "@sphereon/oid4vci-common": "workspace:*",
-    "@sphereon/ssi-types": "0.29.1-unstable.208",
+    "@sphereon/ssi-types": "0.30.1",
     "uuid": "^9.0.0"
   },
   "peerDependencies": {

packages/oid4vci-common/package.json

@@ -11,7 +11,7 @@
   },
   "dependencies": {
     "@sphereon/oid4vc-common": "workspace:*",
-    "@sphereon/ssi-types": "0.29.1-unstable.208",
+    "@sphereon/ssi-types": "0.30.1",
     "cross-fetch": "^3.1.8",
     "debug": "^4.3.5",
     "jwt-decode": "^4.0.0",

packages/siop-oid4vp/lib/__tests__/AuthenticationRequest.request.spec.ts

@@ -98,6 +98,26 @@ describe('create Request Uri should', () => {
         response_type: 'id_token',
         request_object_signing_alg_values_supported: [SigningAlgo.EDDSA, SigningAlgo.ES256],
         redirect_uri: EXAMPLE_REDIRECT_URL,
+        claims: {
+          vp_token: {
+            presentation_definition: {
+              id: 'Ontario Health Insurance Plan',
+              name: 'Ontario',
+              purpose: 'purpose',
+              input_descriptors: [
+                {
+                  id: 'Ontario Health Insurance Plan',
+                  name: 'Ontario',
+                  schema: [
+                    {
+                      uri: 'https://did.itsourweb.org:3000/smartcredential/Ontario-Health-Insurance-Plan',
+                    },
+                  ],
+                },
+              ],
+            } as IPresentationDefinition,
+          },
+        },
       },
       requestObject: {
         jwtIssuer: {
@@ -152,7 +172,7 @@ describe('create Request Uri should', () => {
     expect(uriRequest.authorizationRequestPayload).toBeDefined()
 
     const uriDecoded = decodeURIComponent(uriRequest.encodedUri)
-    expect(uriDecoded).toContain(`openid://`)
+    expect(uriDecoded).toContain(`openid4vp://`)
     expect(uriDecoded).toContain(`response_type=${ResponseType.ID_TOKEN}`)
     expect(uriDecoded).toContain(`&redirect_uri=${opts.payload?.redirect_uri}`)
     expect(uriDecoded).toContain(`&scope=${Scope.OPENID}`)
@@ -167,6 +187,33 @@ describe('create Request Uri should', () => {
     expect.assertions(4)
     const opts: CreateAuthorizationRequestOpts = {
       version: SupportedVersion.SIOPv2_ID1,
+      payload: {
+        client_id: WELL_KNOWN_OPENID_FEDERATION,
+        scope: 'test',
+        response_type: 'id_token',
+        request_object_signing_alg_values_supported: [SigningAlgo.ES256, SigningAlgo.EDDSA],
+        redirect_uri: EXAMPLE_REDIRECT_URL,
+        claims: {
+          vp_token: {
+            presentation_definition: {
+              id: 'Ontario Health Insurance Plan',
+              name: 'Ontario',
+              purpose: 'purpose',
+              input_descriptors: [
+                {
+                  id: 'Ontario Health Insurance Plan',
+                  name: 'Ontario',
+                  schema: [
+                    {
+                      uri: 'https://did.itsourweb.org:3000/smartcredential/Ontario-Health-Insurance-Plan',
+                    },
+                  ],
+                },
+              ],
+            } as IPresentationDefinition,
+          },
+        },
+      },
       requestObject: {
         jwtIssuer: { method: 'did', didUrl: KID, alg: SigningAlgo.ES256 },
         passBy: PassBy.REFERENCE,
@@ -184,6 +231,26 @@ describe('create Request Uri should', () => {
           response_type: 'id_token',
           request_object_signing_alg_values_supported: [SigningAlgo.ES256, SigningAlgo.EDDSA],
           redirect_uri: EXAMPLE_REDIRECT_URL,
+          claims: {
+            vp_token: {
+              presentation_definition: {
+                id: 'Ontario Health Insurance Plan',
+                name: 'Ontario',
+                purpose: 'purpose',
+                input_descriptors: [
+                  {
+                    id: 'Ontario Health Insurance Plan',
+                    name: 'Ontario',
+                    schema: [
+                      {
+                        uri: 'https://did.itsourweb.org:3000/smartcredential/Ontario-Health-Insurance-Plan',
+                      },
+                    ],
+                  },
+                ],
+              } as IPresentationDefinition,
+            },
+          },
         },
       },
       clientMetadata: {
@@ -222,6 +289,33 @@ describe('create Request Uri should', () => {
     expect.assertions(3)
     const opts: CreateAuthorizationRequestOpts = {
       version: SupportedVersion.SIOPv2_ID1,
+      payload: {
+        client_id: WELL_KNOWN_OPENID_FEDERATION,
+        scope: 'test',
+        response_type: 'id_token',
+        request_object_signing_alg_values_supported: [SigningAlgo.ES256, SigningAlgo.EDDSA],
+        redirect_uri: EXAMPLE_REDIRECT_URL,
+        claims: {
+          vp_token: {
+            presentation_definition: {
+              id: 'Ontario Health Insurance Plan',
+              name: 'Ontario',
+              purpose: 'purpose',
+              input_descriptors: [
+                {
+                  id: 'Ontario Health Insurance Plan',
+                  name: 'Ontario',
+                  schema: [
+                    {
+                      uri: 'https://did.itsourweb.org:3000/smartcredential/Ontario-Health-Insurance-Plan',
+                    },
+                  ],
+                },
+              ],
+            } as IPresentationDefinition,
+          },
+        },
+      },
       requestObject: {
         passBy: PassBy.VALUE,
         jwtIssuer: {
@@ -268,10 +362,10 @@ describe('create Request Uri should', () => {
     const uriRequest = await URI.fromOpts(opts)
 
     const uriDecoded = decodeURIComponent(uriRequest.encodedUri)
-    expect(uriDecoded).toContain(`openid://?request=eyJhbGciOi`)
+    expect(uriDecoded).toContain(`openid4vp://?client_id=https://www.example.com/`)
 
     const data = URI.parse(uriDecoded)
-    expect(data.scheme).toEqual('openid://')
+    expect(data.scheme).toEqual('openid4vp://')
     expect(data.authorizationRequestPayload.request).toContain(`eyJhbGciOi`)
   })
 })
@@ -511,30 +605,33 @@ describe('create Request JWT should', () => {
   it('succeed when requesting with a valid PD', async () => {
     const opts: CreateAuthorizationRequestOpts = {
       version: SupportedVersion.SIOPv2_ID1,
-      /*payload: {
+      payload: {
         client_id: WELL_KNOWN_OPENID_FEDERATION,
         scope: 'test',
         response_type: 'id_token',
+        request_object_signing_alg_values_supported: [SigningAlgo.ES256, SigningAlgo.EDDSA],
         redirect_uri: EXAMPLE_REDIRECT_URL,
-        request_object_signing_alg_values_supported: [SigningAlgo.EDDSA, SigningAlgo.ES256],
         claims: {
           vp_token: {
             presentation_definition: {
-              id: 'Insurance Plans',
+              id: 'Ontario Health Insurance Plan',
+              name: 'Ontario',
+              purpose: 'purpose',
               input_descriptors: [
                 {
                   id: 'Ontario Health Insurance Plan',
+                  name: 'Ontario',
                   schema: [
                     {
                       uri: 'https://did.itsourweb.org:3000/smartcredential/Ontario-Health-Insurance-Plan',
                     },
                   ],
                 },
               ],
-            },
+            } as IPresentationDefinition,
           },
         },
-      },*/
+      },
       requestObject: {
         jwtIssuer: { method: 'did', didUrl: KID, alg: SigningAlgo.ES256K },
         passBy: PassBy.REFERENCE,
@@ -598,7 +695,7 @@ describe('create Request JWT should', () => {
     const uriRequest = await URI.fromOpts(opts)
 
     const uriDecoded = decodeURIComponent(uriRequest.encodedUri)
-    expect(uriDecoded).toEqual(`openid://?request_uri=https://rp.acme.com/siop/jwts`)
+    expect(uriDecoded).toEqual(`openid4vp://?client_id=https://www.example.com/.well-known/openid-federation&scope=test&response_type=id_token&request_object_signing_alg_values_supported=[\"ES256\",\"EdDSA\"]&redirect_uri=https://acme.com/hello&claims={"vp_token\":{\"presentation_definition":{\"id\":\"Ontario Health Insurance Plan\",\"name\":"Ontario\",\"purpose":"purpose\","input_descriptors":[{\"id":\"Ontario Health Insurance Plan\",\"name":\"Ontario\",\"schema":[{\"uri\":\"https://did.itsourweb.org:3000/smartcredential/Ontario-Health-Insurance-Plan\"}]}]}}}&request_uri=https://rp.acme.com/siop/jwts`)
     expect((await (await uriRequest.toAuthorizationRequest())?.requestObject?.getPayload())?.claims.vp_token).toBeDefined()
   })
 

packages/siop-oid4vp/lib/__tests__/AuthenticationResponse.response.spec.ts

@@ -453,9 +453,9 @@ describe('create JWT from Request JWT should', () => {
       }),
       jwtIssuer: { method: 'did', didUrl: `${mockResEntity.did}#controller`, alg: SigningAlgo.ES256K },
       presentationExchange: {
-        verifiablePresentations: [verifiablePresentationResult.verifiablePresentation],
+        verifiablePresentations: verifiablePresentationResult.verifiablePresentations,
         vpTokenLocation: VPTokenLocation.ID_TOKEN,
-        presentationSubmission: await createPresentationSubmission([verifiablePresentationResult.verifiablePresentation], {
+        presentationSubmission: await createPresentationSubmission(verifiablePresentationResult.verifiablePresentations, {
           presentationDefinitions: [definition],
         }),
       },
@@ -634,8 +634,8 @@ describe('create JWT from Request JWT should', () => {
       }),
       jwtIssuer: { method: 'did', didUrl: `${mockResEntity.did}#controller`, alg: SigningAlgo.ES256K },
       presentationExchange: {
-        verifiablePresentations: [verifiablePresentationResult.verifiablePresentation],
-        presentationSubmission: await createPresentationSubmission([verifiablePresentationResult.verifiablePresentation], {
+        verifiablePresentations: verifiablePresentationResult.verifiablePresentations,
+        presentationSubmission: await createPresentationSubmission(verifiablePresentationResult.verifiablePresentations, {
           presentationDefinitions: [definition],
         }),
         vpTokenLocation: VPTokenLocation.ID_TOKEN,