@docknetwork/wallet-sdk-wasm 1.4.0 → 1.5.6

package/src/services/credential/bound-check.test.ts

@@ -1,16 +1,13 @@
 import {
   applyEnforceBounds,
-  MAX_DATE_PLACEHOLDER,
-  MIN_DATE_PLACEHOLDER,
-  MAX_NUMBER,
   fetchProvingKey,
   isBase64OrDataUrl,
-  MIN_INTEGER,
 } from './bound-check';
 import {PresentationBuilder} from '@docknetwork/crypto-wasm-ts/lib';
 import proofRequest from './proof-request.json';
 import { replaceResponseURL } from '@docknetwork/wallet-sdk-core/src/helpers';
 import assert from 'assert';
+import { MAX_DATE_PLACEHOLDER, MAX_NUMBER, MIN_DATE_PLACEHOLDER, MIN_NUMBER } from './pex-helpers';
 
 const testAPIURL = process.env.TESTING_API_URL || null;
 
@@ -218,7 +215,7 @@ describe('Bound check', () => {
 
     const credIdx = 0;
     const attributeName = 'credentialSubject.income';
-    const min = MIN_INTEGER;
+    const min = MIN_NUMBER;
     const max = 20000;
 
     expect(builder.enforceBounds).toHaveBeenCalledWith(

package/src/services/credential/bound-check.ts

@@ -132,10 +132,5 @@ export async function fetchProvingKey(proofRequest: ProofRequest) {
   return {provingKey, provingKeyId: 'key0'};
 }
 
-export const MAX_DATE_PLACEHOLDER = 884541351600000;
-export const MIN_DATE_PLACEHOLDER = -17592186044415;
-export const MAX_NUMBER = Math.pow(100, 9);
-export const MIN_INTEGER = -4294967295;
-
 export const hasProvingKey = (proofRequest: ProofRequest) =>
   !!proofRequest.boundCheckSnarkKey;

package/src/services/credential/index.test.js

@@ -1,14 +1,31 @@
 import {assertRpcService, getPromiseError} from '../test-utils';
 import {credentialService as service} from './service';
 import {validation} from './config';
-import * as credentialsUtils from '@docknetwork/sdk/utils/vc/credentials';
+import * as credentialUtils from '@docknetwork/credential-sdk/vc';
 import {CredentialServiceRPC} from './service-rpc';
 import {getTestWallet} from '../../test/setup-test-state';
-import BbsPlusPresentation from '@docknetwork/sdk/presentation';
+import {OpenID4VCIClientV1_0_13} from '@sphereon/oid4vci-client';
+import {didService} from '../dids/service';
 
 describe('Credential Service', () => {
   beforeAll(async () => {
     await getTestWallet();
+    const mockAddCredentialToPresent = jest.fn(() => 0);
+    const mockAddAttributeToReveal = jest.fn();
+    const mockCreatePresentation = jest.fn();
+    const mockDeriveCredentials = jest.fn(() => []);
+
+    jest.spyOn(credentialUtils, 'Presentation').mockImplementation(() => {
+      return {
+        addCredentialToPresent: mockAddCredentialToPresent,
+        addAttributeToReveal: mockAddAttributeToReveal,
+        createPresentation: mockCreatePresentation,
+        deriveCredentials: mockDeriveCredentials,
+        presBuilder: {
+          enforceBounds: jest.fn(),
+        },
+      };
+    });
   });
   it('ServiceRpc', () => {
     assertRpcService(CredentialServiceRPC, service, validation);
@@ -19,7 +36,7 @@ describe('Credential Service', () => {
   });
   it('expect to verify credential', async () => {
     jest
-      .spyOn(credentialsUtils, 'verifyCredential')
+      .spyOn(credentialUtils, 'verifyCredential')
       .mockImplementationOnce(async () => ({verified: true}));
     const credential = {
       '@context': [
@@ -71,7 +88,7 @@ describe('Credential Service', () => {
       },
     };
     await service.verifyCredential({credential});
-    expect(credentialsUtils.verifyCredential).toBeCalled();
+    expect(credentialUtils.verifyCredential).toBeCalled();
   });
   it('should create a vc', async () => {
     const subject = {
@@ -296,7 +313,7 @@ describe('Credential Service', () => {
       credentials,
     });
 
-    const bbsPresentation = new BbsPlusPresentation();
+    const bbsPresentation = new credentialUtils.Presentation();
     expect(bbsPresentation.addCredentialToPresent).toBeCalledWith(
       credential,
       expect.any(Object),
@@ -366,7 +383,7 @@ describe('Credential Service', () => {
       credentials,
     });
 
-    const bbsPresentation = new BbsPlusPresentation();
+    const bbsPresentation = new credentialUtils.Presentation();
     expect(bbsPresentation.addCredentialToPresent).toBeCalledWith(
       credential,
       expect.any(Object),
@@ -401,7 +418,7 @@ describe('Credential Service', () => {
           },
         }),
       ).toBe(
-        '0xa632a41f2fbdb681c14b33daae4fcc46af41661b90b35c4ac1545c9bebf0d7cc',
+        'dock:accumulator:0xa632a41f2fbdb681c14b33daae4fcc46af41661b90b35c4ac1545c9bebf0d7cc',
       );
     });
   });
@@ -427,4 +444,128 @@ describe('Credential Service', () => {
       }),
     ).toBe(true);
   });
+
+  describe('acquireOIDCredential', () => {
+    const mockHolderKeyDocument = {
+      id: 'did:example:123#key-1',
+      controller: 'did:example:123',
+    };
+
+    const mockCredential = {
+      '@context': ['https://www.w3.org/2018/credentials/v1'],
+      type: ['VerifiableCredential', 'MyCredential'],
+      issuer:
+        'https://api-testnet.truvera.io/openid/issuers/7eff516f-69fb-4b9d-94dc-e88308ec0c4c',
+      credentialSubject: {
+        id: 'did:example:123',
+        name: 'John Doe',
+      },
+      proof: {
+        type: 'Ed25519Signature2018',
+        created: '2024-03-31T12:00:00Z',
+        proofPurpose: 'assertionMethod',
+        verificationMethod: 'did:example:123#key-1',
+        proofValue: 'mockProofValue',
+      },
+    };
+
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should handle credential_offer parameter', async () => {
+      const uri =
+        'openid-credential-offer://?credential_offer=%7B%22credential_issuer%22%3A%22https%3A%2F%2Fapi-testnet.truvera.io%2Fopenid%2Fissuers%2F7eff516f-69fb-4b9d-94dc-e88308ec0c4c%22%2C%22credentials%22%3A%5B%22ldp_vc%3AMyCredential%22%5D%2C%22grants%22%3A%7B%22urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Apre-authorized_code%22%3A%7B%22pre-authorized_code%22%3A%22AAL4MPpEpWY6daBxVxJ8Q3chxOhvc9qIV3EAyj7dvps%22%2C%22user_pin_required%22%3Afalse%7D%7D%7D';
+
+      const mockClient = {
+        credentialOffer: {
+          preAuthorizedCode: 'AAL4MPpEpWY6daBxVxJ8Q3chxOhvc9qIV3EAyj7dvps',
+        },
+        acquireAccessToken: jest.fn(),
+        acquireCredentials: jest
+          .fn()
+          .mockResolvedValue({credential: mockCredential}),
+        getCredentialsSupported: jest
+          .fn()
+          .mockReturnValue([{scope: 'ldp_vc:MyCredential'}]),
+      };
+
+      jest
+        .spyOn(OpenID4VCIClientV1_0_13, 'fromURI')
+        .mockResolvedValue(mockClient);
+      jest
+        .spyOn(didService, 'createSignedJWT')
+        .mockResolvedValue('mock.jwt.token');
+
+      const result = await service.acquireOIDCredential({
+        uri,
+        holderKeyDocument: mockHolderKeyDocument,
+      });
+
+      expect(result).toEqual({
+        credential: mockCredential,
+      });
+    });
+
+    it('should handle credential_offer_uri parameter', async () => {
+      const uri =
+        'openid-credential-offer://?credential_offer_uri=https://api.truvera.io/openid/credential-offers/6783b6ff-b84d-4e6a-850d-f3828e2c1526';
+
+      // Mock OpenID4VCIClientV1_0_13
+      const mockClient = {
+        credentialOffer: {
+          preAuthorizedCode: 'AAL4MPpEpWY6daBxVxJ8Q3chxOhvc9qIV3EAyj7dvps',
+        },
+        acquireAccessToken: jest.fn(),
+        acquireCredentials: jest
+          .fn()
+          .mockResolvedValue({credential: mockCredential}),
+        getCredentialsSupported: jest
+          .fn()
+          .mockReturnValue([{scope: 'ldp_vc:MyCredential'}]),
+      };
+
+      jest
+        .spyOn(OpenID4VCIClientV1_0_13, 'fromURI')
+        .mockResolvedValue(mockClient);
+      jest
+        .spyOn(didService, 'createSignedJWT')
+        .mockResolvedValue('mock.jwt.token');
+
+      const result = await service.acquireOIDCredential({
+        uri,
+        holderKeyDocument: mockHolderKeyDocument,
+      });
+
+      expect(result).toEqual({
+        credential: mockCredential,
+      });
+    });
+
+    it('should return authorization URL when no pre-authorized code is available', async () => {
+      const uri =
+        'openid-credential-offer://?credential_offer=%7B%22credential_issuer%22%3A%22https%3A%2F%2Fapi-testnet.truvera.io%2Fopenid%2Fissuers%2F7eff516f-69fb-4b9d-94dc-e88308ec0c4c%22%2C%22credentials%22%3A%5B%22ldp_vc%3AMyCredential%22%5D%7D';
+      const mockClient = {
+        credentialOffer: {},
+        authorizationURL:
+          'https://api-testnet.truvera.io/openid/authorize?response_type=code&client_id=dock.wallet&redirect_uri=dock-wallet%3A%2F%2Fcredentials%2Fcallback&scope=ldp_vc%3AMyCredential',
+        getCredentialsSupported: jest
+          .fn()
+          .mockReturnValue([{scope: 'ldp_vc:MyCredential'}]),
+      };
+
+      jest
+        .spyOn(OpenID4VCIClientV1_0_13, 'fromURI')
+        .mockResolvedValue(mockClient);
+
+      const result = await service.acquireOIDCredential({
+        uri,
+        holderKeyDocument: mockHolderKeyDocument,
+      });
+
+      expect(result).toEqual({
+        authorizationURL: mockClient.authorizationURL,
+      });
+    });
+  });
 });

package/src/services/credential/pex-helpers.js

@@ -1,12 +1,14 @@
 import {JSONPath} from '@astronautlabs/jsonpath';
 
-export const EPSILON_NUMBER = 0.0001;
+export const EPSILON_NUMBER = 0.001;
 export const EPSILON_INT = 1;
 
 export const MAX_DATE_PLACEHOLDER = 884541351600000;
 export const MIN_DATE_PLACEHOLDER = -17592186044415;
-export const MAX_NUMBER = 100 ** 9;
-export const MIN_NUMBER = -4294967295;
+export const MAX_INTEGER = 100 ** 9;
+export const MIN_INTEGER = -4294967295;
+export const MAX_NUMBER = 100 ** 5;
+export const MIN_NUMBER = -4294967294;
 
 /*
   PEX Filter rules:
@@ -21,6 +23,15 @@ function correctFieldPath(path) {
   return path.replace('$.', '');
 }
 
+function getNumDecimalPlaces(n) {
+  const parts = n.toString().split('.');
+  return parts.length > 1 && parts[1].length;
+}
+
+function toMaxDecimalPlaces(n, maxDecimalPlaces) {
+  return +n.toFixed(maxDecimalPlaces);
+}
+
 function getAttributeName({field, selectedCredentials, index}) {
   let attributeName;
   if (Array.isArray(field.path) && field.path.length > 1) {
@@ -52,18 +63,40 @@ function getAttributeName({field, selectedCredentials, index}) {
 export function pexToBounds(
   pexRequest,
   selectedCredentials = [],
-  isRawBoundies = false,
+  removeFromRequest = false,
 ) {
   const descriptorBounds = [];
-  const [MIN_DATE_ADJ, MAX_DATE_ADJ, MIN_NUMBER_ADJ, MAX_NUMBER_ADJ] = [
-    MIN_DATE_PLACEHOLDER,
-    MAX_DATE_PLACEHOLDER,
-    MIN_NUMBER,
-    MAX_NUMBER,
-  ].map(value => (isRawBoundies ? undefined : value));
+  const fieldsToRemove = [];
 
   // One list of bounds per descriptor/credential
   pexRequest.input_descriptors.forEach((inputDescriptor, index) => {
+    const selectedCredential = selectedCredentials[index];
+    if (!selectedCredential) {
+      return;
+    }
+
+    // Get embedded schema if existing
+    let decodedSchema = {};
+    if (selectedCredential.credentialSchema) {
+      const schemaStartStr = 'data:application/json;charset=utf-8,';
+
+      if (selectedCredential.credentialSchema.details) {
+        decodedSchema =
+          JSON.parse(selectedCredential.credentialSchema.details).jsonSchema ||
+          {};
+      } else if (
+        selectedCredential.credentialSchema.id &&
+        selectedCredential.credentialSchema.id.startsWith(schemaStartStr)
+      ) {
+        // LEGACY embedded schema handling
+        decodedSchema = JSON.parse(
+          decodeURIComponent(
+            selectedCredential.credentialSchema.id.split(schemaStartStr)[1],
+          ),
+        );
+      }
+    }
+
     const bounds = [];
     inputDescriptor.constraints.fields.forEach(field => {
       const {
@@ -77,6 +110,44 @@ export function pexToBounds(
         type,
       } = field.filter || {};
 
+      if (!field.path || field.path.length === 0) {
+        throw new Error(
+          'Missing or empty field "path" property, expected array or string',
+        );
+      }
+
+      let attributeName;
+      if (Array.isArray(field.path) && field.path.length > 1) {
+        // Must find a path that matches in selectedcredential, and choose that for bounds
+        const pathCount = field.path.length;
+        for (let i = 0; i < pathCount; i++) {
+          const path = field.path[i];
+          const paths = JSONPath.paths(selectedCredential, path);
+          if (paths.length) {
+            // First come first served
+            attributeName = correctFieldPath(JSONPath.stringify(paths[0]));
+            break;
+          }
+        }
+      } else {
+        const path = Array.isArray(field.path) ? field.path[0] : field.path;
+        attributeName = correctFieldPath(path);
+      }
+
+      if (!attributeName) {
+        return;
+      }
+
+      const schemaPath = `$.properties.${attributeName.replaceAll(
+        '.',
+        '.properties.',
+      )}`;
+      const attributeSchema = JSONPath.query(
+        decodedSchema,
+        schemaPath,
+        1,
+      )[0] || {type};
+
       let max =
         maximum === undefined
           ? formatMaximum === undefined
@@ -95,62 +166,89 @@ export function pexToBounds(
         return;
       }
 
+      const attributeType = attributeSchema.type || type;
+
       // Get min/max bounds values, if using exclusive we must apply an epsilon so equality isnt true
       if (format === 'date-time' || format === 'date') {
-        max = max === undefined ? MAX_DATE_ADJ : max;
-        max = max ? new Date(max) : undefined;
-        min = min === undefined ? MIN_DATE_ADJ : min;
-        min = min ? new Date(min) : undefined;
-      } else if (type === 'number') {
+        max = new Date(max === undefined ? MAX_DATE_PLACEHOLDER : max);
+        min = new Date(min === undefined ? MIN_DATE_PLACEHOLDER : min);
+      } else if (attributeType === 'number') {
+        const epsilon = attributeSchema.multipleOf || EPSILON_NUMBER;
+        const attribDecimalPlaces = getNumDecimalPlaces(epsilon);
+
         max =
           max === undefined
-            ? MAX_NUMBER_ADJ
-            : exclusiveMaximum === undefined || isRawBoundies
+            ? attributeSchema.maximum === undefined
+              ? MAX_NUMBER
+              : attributeSchema.maximum
+            : exclusiveMaximum === undefined
             ? max
-            : max - EPSILON_NUMBER;
+            : max - epsilon;
         min =
           min === undefined
-            ? MIN_NUMBER_ADJ
-            : exclusiveMinimum === undefined || isRawBoundies
+            ? attributeSchema.minimum === undefined
+              ? MIN_NUMBER
+              : attributeSchema.minimum
+            : exclusiveMinimum === undefined
             ? min
-            : min + EPSILON_NUMBER;
-      } else if (type === 'integer') {
+            : min + epsilon;
+
+        // Because of floating point math sucks, sometimes we can get extra decimal points
+        // the bounds must also match the same decimal points as the input
+        // for this we read from the embedded schema
+        min = toMaxDecimalPlaces(min, attribDecimalPlaces);
+        max = toMaxDecimalPlaces(max, attribDecimalPlaces);
+      } else if (attributeType === 'integer') {
         max =
           max === undefined
-            ? MAX_NUMBER_ADJ
-            : exclusiveMaximum === undefined || isRawBoundies
+            ? attributeSchema.maximum === undefined
+              ? MAX_INTEGER
+              : attributeSchema.maximum
+            : exclusiveMaximum === undefined
             ? max
             : max - EPSILON_INT;
         min =
           min === undefined
-            ? MIN_NUMBER_ADJ
-            : exclusiveMinimum === undefined || isRawBoundies
+            ? attributeSchema.minimum === undefined
+              ? MIN_INTEGER
+              : attributeSchema.minimum
+            : exclusiveMinimum === undefined
             ? min
             : min + EPSILON_INT;
+
+        // Ensure that input values are not decimals otherwise crypto-wasm-ts will complain
+        min = Math.floor(min);
+        max = Math.floor(max);
       } else {
         throw new Error(
           `Unsupported format ${format} and type ${type} for enforce bounds`,
         );
       }
 
-      const attributeName = getAttributeName({
-        field,
-        selectedCredentials,
-        index,
-      });
+      if (removeFromRequest) {
+        fieldsToRemove.push({
+          fields: inputDescriptor.constraints.fields,
+          field,
+        });
+      }
 
       bounds.push({
         attributeName,
         min,
         max,
-        type,
-        format,
       });
     });
 
     descriptorBounds.push(bounds);
   });
 
+  fieldsToRemove.forEach(({fields, field}) => {
+    const idx = fields.indexOf(field);
+    if (idx !== -1) {
+      fields.splice(idx, 1);
+    }
+  });
+
   return descriptorBounds;
 }
 
@@ -170,7 +268,7 @@ export function getPexRequiredAttributes(pexRequest, selectedCredentials = []) {
     .map((inputDescriptor, index) => {
       return inputDescriptor.constraints.fields
         .filter(field => {
-          if (field.filter) {
+          if (field.filter || field.optional) {
             return false;
           }