@velocitycareerlabs/server-webwallet 1.25.0-dev-build.12642c864

package/src/entities/disclosures/schemas/webwallet-presentation-request-input-descriptors.schema.js

@@ -0,0 +1,111 @@
+const webWalletPresentationRequestInputDescriptorsSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-presentation-request-input-descriptors.schema.json',
+  type: 'object',
+  properties: {
+    id: { type: 'string' },
+    name: { type: 'string' },
+    purpose: { type: 'string' },
+    metadata: { type: 'object' },
+    group: {
+      type: 'array',
+      items: { type: 'string' },
+    },
+    schema: {
+      type: 'array',
+      items: {
+        $ref: 'https://velocitycareerlabs.io/webwallet-presentation-request-schema.schema.json',
+      },
+    },
+    constraints: {
+      type: 'object',
+      properties: {
+        limit_disclosure: { type: 'boolean' },
+        statuses: {
+          type: 'object',
+          properties: {
+            active: {
+              type: 'object',
+              properties: {
+                directive: {
+                  type: 'string',
+                  enum: ['required', 'allowed', 'disallowed'],
+                },
+              },
+            },
+            suspended: {
+              type: 'object',
+              properties: {
+                directive: {
+                  type: 'string',
+                  enum: ['required', 'allowed', 'disallowed'],
+                },
+              },
+            },
+            revoked: {
+              type: 'object',
+              properties: {
+                directive: {
+                  type: 'string',
+                  enum: ['required', 'allowed', 'disallowed'],
+                },
+              },
+            },
+          },
+        },
+        fields: {
+          type: 'array',
+          items: {
+            $ref: 'https://velocitycareerlabs.io/webwallet-presentation-request-field.schema.json',
+          },
+        },
+        subject_is_issuer: {
+          type: 'string',
+          enum: ['required', 'preferred'],
+        },
+        is_holder: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              field_id: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              directive: {
+                type: 'string',
+                enum: ['required', 'preferred'],
+              },
+            },
+            required: ['field_id', 'directive'],
+            additionalProperties: false,
+          },
+        },
+        same_subject: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              field_id: {
+                type: 'array',
+                items: { type: 'string' },
+              },
+              directive: {
+                type: 'string',
+                enum: ['required', 'preferred'],
+              },
+            },
+            required: ['field_id', 'directive'],
+            additionalProperties: false,
+          },
+        },
+      },
+      additionalProperties: false,
+    },
+  },
+  required: ['id', 'schema'],
+  additionalProperties: false,
+};
+
+module.exports = {
+  webWalletPresentationRequestInputDescriptorsSchema,
+};

package/src/entities/disclosures/schemas/webwallet-presentation-request-schema.schema.js

@@ -0,0 +1,14 @@
+const webWalletPresentationRequestSchemaSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-presentation-request-schema.schema.json',
+  type: 'object',
+  properties: {
+    uri: { type: 'string' },
+    required: { type: 'boolean' },
+  },
+  required: ['uri'],
+  additionalProperties: false,
+};
+
+module.exports = {
+  webWalletPresentationRequestSchemaSchema,
+};

package/src/entities/disclosures/schemas/webwallet-presentation-request-submission-requirements.schema.js

@@ -0,0 +1,37 @@
+const webWalletPresentationRequestSubmissionRequirementsSchema = {
+  $id: 'https://velocitycareerlabs.io/webwallet-presentation-request-submission-requirements.schema.json',
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    purpose: { type: 'string' },
+    rule: {
+      type: 'string',
+      enum: ['all', 'pick'],
+    },
+    count: { type: 'integer', minimum: 1 },
+    min: { type: 'integer', minimum: 0 },
+    max: { type: 'integer', minimum: 0 },
+    from: { type: 'string' },
+    from_nested: {
+      type: 'array',
+      minItems: 1,
+      items: {
+        $ref: 'https://velocitycareerlabs.io/webwallet-presentation-request-submission-requirements.schema.json',
+      },
+    },
+  },
+  required: ['rule'],
+  oneOf: [
+    {
+      required: ['from'],
+    },
+    {
+      required: ['from_nested'],
+    },
+  ],
+  additionalProperties: false,
+};
+
+module.exports = {
+  webWalletPresentationRequestSubmissionRequirementsSchema,
+};

package/src/entities/disclosures/schemas/webwallet-presentation-request.schema.js

@@ -0,0 +1,79 @@
+const webWalletPresentationRequestSchema = {
+  $id: 'https://velocitycareerlabs.io/presentation-request.schema.json',
+  title: 'presentation-request',
+  description: 'the schema for presentation request to disclosure credentials',
+  type: 'object',
+  properties: {
+    exp: {
+      type: 'integer',
+    },
+    iat: {
+      type: 'integer',
+    },
+    iss: {
+      type: 'string',
+    },
+    aud: {
+      type: 'string',
+    },
+    nbf: {
+      type: 'integer',
+    },
+    presentation_definition: {
+      type: 'object',
+      properties: {
+        id: { type: 'string' },
+        name: { type: 'string' },
+        purpose: { type: 'string' },
+        locale: { type: 'string' },
+        format: {
+          $ref: 'https://velocitycareerlabs.io/webwallet-presentation-request-format.schema.json',
+        },
+        submission_requirements: {
+          type: 'array',
+          items: {
+            $ref: 'https://velocitycareerlabs.io/webwallet-presentation-request-submission-requirements.schema.json',
+          },
+        },
+        input_descriptors: {
+          type: 'array',
+          items: {
+            $ref: 'https://velocitycareerlabs.io/webwallet-presentation-request-input-descriptors.schema.json',
+          },
+        },
+      },
+      required: ['id', 'input_descriptors'],
+      additionalProperties: false,
+    },
+    metadata: {
+      type: 'object',
+      properties: {
+        client_name: {
+          type: 'string',
+        },
+        logo_uri: {
+          type: 'string',
+          format: 'uri',
+        },
+        tos_uri: {
+          type: 'string',
+          format: 'uri',
+        },
+        max_retention_period: {
+          type: 'string',
+        },
+        progress_uri: { type: 'string', format: 'uri' },
+        submit_presentation_uri: { type: 'string', format: 'uri' },
+      },
+      required: ['client_name', 'logo_uri', 'tos_uri'],
+    },
+    exchange_id: {
+      type: 'string',
+    },
+  },
+  required: ['metadata', 'exchange_id', 'presentation_definition'],
+};
+
+module.exports = {
+  webWalletPresentationRequestSchema,
+};

package/src/entities/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  ...require('./accounts'),
+  ...require('./credentials'),
+  ...require('./disclosures'),
+  ...require('./issuing'),
+};

package/src/entities/issuing/domain/constants.js

@@ -0,0 +1,8 @@
+const identityClaimTypes = {
+  email: 'EmailV1.0',
+  phone: 'PhoneV1.0',
+};
+
+module.exports = {
+  identityClaimTypes,
+};

package/src/entities/issuing/domain/does-user-have-fresh-pending-verification.js

@@ -0,0 +1,26 @@
+const md5 = require('blueimp-md5');
+const { get } = require('lodash/fp');
+
+/**
+ * @param {import('../../../entities/accounts/repos/accounts.repo').Account} account
+ * @param {string} value
+ * @param {string} credentialType - 'email' | 'phone'
+ */
+const doesUserHaveFreshPendingVerification = (
+  account,
+  value,
+  credentialType
+) => {
+  const { codeSentTo, codeSentAt } =
+    get(`verificationInfo.${credentialType}`, account) || {};
+
+  return (
+    codeSentTo &&
+    codeSentTo === md5(value) &&
+    new Date(codeSentAt) > new Date(new Date().getTime() - 1000 * 60 * 2)
+  );
+};
+
+module.exports = {
+  doesUserHaveFreshPendingVerification,
+};

package/src/entities/issuing/domain/get-credentials-from-offers.js

@@ -0,0 +1,18 @@
+const { jwtDecode } = require('@velocitycareerlabs/jwt');
+const { map } = require('lodash/fp');
+const { offerToCredentialMongoDTO } = require('../../credentials');
+
+const getCredentialsFromOffers = (auth0UserId, userDid, offers) =>
+  map((offer) => {
+    const { encodedJwt } = offer;
+    const decodedJwt = jwtDecode(encodedJwt);
+
+    return offerToCredentialMongoDTO(auth0UserId, userDid, {
+      ...decodedJwt.payload,
+      encodedCredential: encodedJwt,
+    });
+  })(offers);
+
+module.exports = {
+  getCredentialsFromOffers,
+};

package/src/entities/issuing/domain/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./constants'),
+  ...require('./get-credentials-from-offers'),
+  ...require('./does-user-have-fresh-pending-verification'),
+};

package/src/entities/issuing/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+  ...require('./domain'),
+  ...require('./orchestrators'),
+  ...require('./schemas'),
+};

package/src/entities/issuing/orchestrators/build-issuing-input-credentials.js

@@ -0,0 +1,35 @@
+const { map, isEmpty } = require('lodash/fp');
+
+/**
+ *
+ * @param {Array<string>} credentialIds
+ * @param {object} context
+ * @returns {Promise<Array<{id: string, inputDescriptor: string, jwtVc: string}>>}
+ */
+const buildIssuingInputCredentials = async (
+  credentialIds,
+  { repos: { credentials: credentialsRepo }, user }
+) => {
+  if (isEmpty(credentialIds)) return [];
+
+  const credentials = await credentialsRepo.find({
+    filter: {
+      _id: { $in: credentialIds },
+      auth0UserId: user.sub,
+    },
+  });
+
+  const issuingInput = map(
+    (credential) => ({
+      inputDescriptor: credential.type[0],
+      jwtVc: credential.encodedCredential,
+    }),
+    credentials
+  );
+
+  return issuingInput;
+};
+
+module.exports = {
+  buildIssuingInputCredentials,
+};

package/src/entities/issuing/orchestrators/generate-offers-by-deep-link.js

@@ -0,0 +1,74 @@
+const {
+  VCLGenerateOffersDescriptor,
+  VCLCredentialManifest,
+  VCLDeepLink,
+  VCLVerifiedProfile,
+  VCLJwt,
+  VCLDidJwk,
+  VCLVerifiableCredential,
+} = require('@velocitycareerlabs/vnf-nodejs-wallet-sdk');
+
+/**
+ * @param {object} credentialManifest
+ * @param {import('@velocitycareerlabs/vnf-nodejs-wallet-sdk')} issuingType
+ * @param {Array<string>} credentialClaimTypes
+ * @param {Array<{id: string, inputDescriptor: string, jwtVc: string}>} inputCredentials
+ * @param {import('fastify').FastifyRequest} context
+ * @returns {Promise<{offers: Array<any>, credentialManifest: any}>}
+ */
+const generateOffersByDeepLink = async (
+  credentialManifest,
+  issuingType,
+  credentialClaimTypes,
+  inputCredentials,
+  context
+) => {
+  const {
+    vclSdk,
+    config: { careerWalletAdminAccessToken },
+    repos: { accounts },
+    user,
+  } = context;
+
+  const { didKeyMetadatum } = await accounts.findOne({
+    filter: { userId: user.sub },
+  });
+  const didJwk =
+    didKeyMetadatum &&
+    Array.isArray(didKeyMetadatum) &&
+    didKeyMetadatum.length > 0
+      ? VCLDidJwk.fromJSON(didKeyMetadatum[0])
+      : null;
+
+  const deepLink = new VCLDeepLink(credentialManifest.link);
+  const vclCredentialManifest = new VCLCredentialManifest(
+    VCLJwt.fromEncodedJwt(credentialManifest.jwt),
+    deepLink.vendorOriginContext,
+    new VCLVerifiedProfile(credentialManifest.verifiedProfile),
+    deepLink,
+    didJwk,
+    careerWalletAdminAccessToken
+  );
+  const vclGenerateOffersDescriptor = new VCLGenerateOffersDescriptor(
+    vclCredentialManifest,
+    credentialClaimTypes,
+    [],
+    inputCredentials.map(
+      (inputCredential) =>
+        new VCLVerifiableCredential(
+          inputCredential.inputDescriptor,
+          inputCredential.jwtVc
+        )
+    )
+  );
+  const offers = await vclSdk.generateOffers(vclGenerateOffersDescriptor);
+
+  return {
+    offers,
+    vclCredentialManifest,
+  };
+};
+
+module.exports = {
+  generateOffersByDeepLink,
+};

package/src/entities/issuing/orchestrators/get-identity-issuer.js

@@ -0,0 +1,35 @@
+const { isEmpty, intersection, values, find } = require('lodash/fp');
+const {
+  VCLOrganizationsSearchDescriptor,
+  VCLFilter,
+} = require('@velocitycareerlabs/vnf-nodejs-wallet-sdk');
+
+const { getAppConfig } = require('../../../fetchers');
+const { identityClaimTypes } = require('../domain');
+
+const getIdentityIssuerService = async (type, context) => {
+  const { emailVerifierDid, phoneVerifierDid } = await getAppConfig(context);
+
+  const { all: [organization] = [] } =
+    await context.vclSdk.searchForOrganizations(
+      new VCLOrganizationsSearchDescriptor(
+        new VCLFilter(type === 'email' ? emailVerifierDid : phoneVerifierDid)
+      )
+    );
+
+  if (!organization) {
+    return null;
+  }
+
+  const idCredentialsService = find(
+    ({ credentialTypes }) =>
+      !isEmpty(intersection(values(identityClaimTypes), credentialTypes)),
+    organization.serviceCredentialAgentIssuers
+  );
+
+  return idCredentialsService;
+};
+
+module.exports = {
+  getIdentityIssuerService,
+};

package/src/entities/issuing/orchestrators/get-identity-offers-by-deeplink.js

@@ -0,0 +1,74 @@
+const { values } = require('lodash/fp');
+const {
+  VCLFinalizeOffersDescriptor,
+  VCLIssuingType,
+  VCLDeepLink,
+  VCLCredentialManifestDescriptorByDeepLink,
+} = require('@velocitycareerlabs/vnf-nodejs-wallet-sdk');
+const { identityClaimTypes } = require('../domain');
+const { generateOffersByDeepLink } = require('./generate-offers-by-deep-link');
+
+const getIdentityOffersByDeepLink = async (deepLink, context) => {
+  const { vclSdk } = context;
+
+  const identityClaimTypesList = values(identityClaimTypes);
+
+  const credentialManifest = await vclSdk.getCredentialManifest(
+    new VCLCredentialManifestDescriptorByDeepLink(
+      new VCLDeepLink(deepLink),
+      VCLIssuingType.Identity,
+      null,
+      null,
+      null
+    )
+  );
+  // TODO: need to be refactored
+  // Transform to weired credential manifest
+  const weiredCredentialManifest = {
+    jwt: credentialManifest.jwt.encodedJwt,
+    vendorOriginContext: credentialManifest.vendorOriginContext,
+    verifiedProfile: credentialManifest.verifiedProfile.payload,
+    link: credentialManifest.deepLink.value,
+  };
+  const { offers, vclCredentialManifest } = await generateOffersByDeepLink(
+    weiredCredentialManifest,
+    VCLIssuingType.Identity,
+    identityClaimTypesList,
+    [],
+    context
+  );
+
+  if (!offers.all.length) {
+    return {
+      passedCredentials: [],
+      failedCredentials: [],
+      offers: [],
+      credentialManifest: {},
+    };
+  }
+
+  const offersPayloadArr = offers.all.map((offer) => offer.payload);
+  const approvedOffersIds = offersPayloadArr.map(
+    (offersPayload) => offersPayload.id
+  );
+
+  const acceptedOffers = await vclSdk.finalizeOffers(
+    new VCLFinalizeOffersDescriptor(
+      vclCredentialManifest,
+      offers.challenge,
+      approvedOffersIds,
+      []
+    ),
+    offers.sessionToken
+  );
+
+  return {
+    acceptedOffers,
+    offersPayloadArr,
+    credentialManifest: vclCredentialManifest,
+  };
+};
+
+module.exports = {
+  getIdentityOffersByDeepLink,
+};

package/src/entities/issuing/orchestrators/index.js

@@ -0,0 +1,6 @@
+module.exports = {
+  ...require('./get-identity-issuer'),
+  ...require('./get-identity-offers-by-deeplink'),
+  ...require('./build-issuing-input-credentials'),
+  ...require('./generate-offers-by-deep-link'),
+};

package/src/entities/issuing/schemas/index.js

@@ -0,0 +1,9 @@
+/**
+ * Created by Michael Avoyan on 31/07/2024.
+ *
+ * Copyright 2022 Velocity Career Labs inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+module.exports = {
+  ...require('./webwallet-credential-manifest.schema'),
+};