@smileid/usesmileid 12.0.0 → 12.0.2

package/src/presentation/flow/validation/__tests__/flow_validator.test.ts

@@ -18,13 +18,21 @@ import {
 import {
   InvalidFieldValueException,
   InvalidJobTypeScreenConfigException,
+  MissingJobTypeException,
   MissingMLConfigurationBlockException,
 } from "../../../../core/exception/job_validation_exceptions";
-import { InvalidDocumentCaptureConfigException } from "../../../../core/exception/capture_validation_exceptions";
 import {
+  AgentModeWithEnhancedLivenessException,
+  InvalidDocumentCaptureConfigException,
+} from "../../../../core/exception/capture_validation_exceptions";
+import {
+  runConsentValidation,
   runDocumentVerificationParamsValidation,
   runEnhancedDocumentVerificationParamsValidation,
+  runUserDetailsValidation,
 } from "../flow_validator";
+import { InvalidConsentInformationException } from "../../../../core/exception/consent_validation_exceptions";
+import type { TokenPayload } from "../../../../data/model/token_payload";
 
 function stubFaceAnalyzer(): FaceAnalyzer {
   return {
@@ -189,6 +197,63 @@ describe("FlowValidator — document capture config", () => {
   });
 });
 
+describe("FlowValidator — selfie capture config", () => {
+  function selfieCaptureIssues(
+    configure: (s: {
+      allowAgentMode: boolean;
+      enableEnhancedLiveness: boolean;
+    }) => void,
+  ) {
+    const config = new CaptureConfigBuilder();
+    config.captureType = CaptureType.selfie;
+    config.selfie(configure);
+    return runFlowValidation({
+      steps: [{ kind: "capture" as const, config }, processingStep()],
+    });
+  }
+
+  function agentModeIssues(
+    configure: (s: {
+      allowAgentMode: boolean;
+      enableEnhancedLiveness: boolean;
+    }) => void,
+  ): AgentModeWithEnhancedLivenessException[] {
+    return selfieCaptureIssues(configure).filter(
+      (i): i is AgentModeWithEnhancedLivenessException =>
+        i instanceof AgentModeWithEnhancedLivenessException,
+    );
+  }
+
+  const rejectsAgentModePair = (
+    configure: Parameters<typeof agentModeIssues>[0],
+  ): boolean => agentModeIssues(configure).length > 0;
+
+  it("rejects agent mode combined with enhanced liveness", () => {
+    const issues = agentModeIssues((s) => {
+      s.allowAgentMode = true;
+      s.enableEnhancedLiveness = true;
+    });
+    expect(issues).toHaveLength(1);
+    // Wire string partner tooling pivots on — a rename is a breaking change.
+    expect(issues[0]?.errorCode).toBe(
+      "BUILDER_AGENT_MODE_WITH_ENHANCED_LIVENESS",
+    );
+  });
+
+  it("accepts agent mode and enhanced liveness on their own", () => {
+    expect(
+      rejectsAgentModePair((s) => {
+        s.allowAgentMode = true;
+      }),
+    ).toBe(false);
+    expect(
+      rejectsAgentModePair((s) => {
+        s.enableEnhancedLiveness = true;
+      }),
+    ).toBe(false);
+  });
+});
+
 describe("FlowValidator — analyzer-per-capture-type", () => {
   for (const { name, value: jobType } of SELFIE_JOB_TYPES) {
     it(`${name}: missing ml block emits "is required" + MissingMLConfigurationBlockException`, () => {
@@ -396,3 +461,156 @@ describe("FlowValidator — document verification params", () => {
     ).toHaveLength(0);
   });
 });
+
+describe("FlowValidator — jobType recognition", () => {
+  const ml: MLConfig = { analyzers: { selfie: stubFaceAnalyzer() } };
+
+  function jobTypeIssue(jobType: JobType) {
+    const issues = runFlowValidation({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      ml,
+      network: validNetwork(jobType),
+      userDetails: validUserDetails,
+    });
+    return issues.find(
+      (i): i is MissingJobTypeException => i instanceof MissingJobTypeException,
+    );
+  }
+
+  it("rejects a jobType that is not one of the SDK's job types", () => {
+    expect(jobTypeIssue(99 as JobType)).toBeInstanceOf(MissingJobTypeException);
+  });
+
+  it("still rejects the unknown sentinel", () => {
+    expect(jobTypeIssue(JobType.unknown)).toBeInstanceOf(
+      MissingJobTypeException,
+    );
+  });
+
+  it("accepts every job type the SDK submits", () => {
+    for (const jobType of Object.values(JobType)) {
+      if (jobType === JobType.unknown) continue;
+      expect(jobTypeIssue(jobType)).toBeUndefined();
+    }
+  });
+});
+
+describe("FlowValidator — token-provided user details (field-level relaxation)", () => {
+  function tokenPayload(overrides: Partial<TokenPayload> = {}): TokenPayload {
+    return {
+      hasGivenNames: false,
+      hasLastName: false,
+      hasEmail: false,
+      hasPhoneNumber: false,
+      ...overrides,
+    };
+  }
+
+  it("accepts contact-only userDetails when the token binds both names", () => {
+    const issues = runUserDetailsValidation(
+      { givenNames: "", lastName: "", email: "ada@example.com" },
+      tokenPayload({ hasGivenNames: true, hasLastName: true }),
+    );
+    expect(issues).toHaveLength(0);
+  });
+
+  it("accepts names-only userDetails when the token binds a contact field", () => {
+    const emailBound = runUserDetailsValidation(
+      { givenNames: "Ada", lastName: "Lovelace" },
+      tokenPayload({ hasEmail: true }),
+    );
+    expect(emailBound).toHaveLength(0);
+
+    const phoneBound = runUserDetailsValidation(
+      { givenNames: "Ada", lastName: "Lovelace" },
+      tokenPayload({ hasPhoneNumber: true }),
+    );
+    expect(phoneBound).toHaveLength(0);
+  });
+
+  it("relaxes per-field — a name the token does not bind still errors with today's message", () => {
+    const issues = runUserDetailsValidation(
+      { givenNames: "", lastName: "", email: "ada@example.com" },
+      tokenPayload({ hasGivenNames: true }),
+    );
+    expect(issues).toHaveLength(1);
+    expect(issues[0]).toBeInstanceOf(InvalidFieldValueException);
+    expect(issues[0]?.message).toContain("userDetails.lastName");
+  });
+
+  it("regression: without a token payload every existing rule fires unchanged", () => {
+    const issues = runUserDetailsValidation({ givenNames: "", lastName: "" });
+    expect(issues).toHaveLength(3);
+    const messages = issues.map((i) => i.message).join("\n");
+    expect(messages).toContain("userDetails.givenNames");
+    expect(messages).toContain("userDetails.lastName");
+    expect(messages).toContain(
+      "at least one of email or phoneNumber must be non blank",
+    );
+  });
+
+  it("threads tokenPayload through runFlowValidation to the field rules", () => {
+    const issues = runFlowValidation({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: { givenNames: "", lastName: "", email: "ada@example.com" },
+      consentInformation: {
+        granted: true,
+        grantedAt: "2026-01-01T00:00:00.000Z",
+        noticeLanguage: "EN",
+        noticePrivacyPolicyUrl: "https://example.com",
+      },
+      tokenPayload: tokenPayload({ hasGivenNames: true, hasLastName: true }),
+    });
+    expect(issues.some((i) => i instanceof InvalidFieldValueException)).toBe(
+      false,
+    );
+  });
+
+  it("a complete token consent skips content validation of the ignored preset", () => {
+    // Token data always wins: the preset is never sent, so its
+    // contents raise no issue even when they would fail on their own.
+    const issues = runFlowValidation({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: {
+        granted: false,
+        grantedAt: "",
+        noticeLanguage: "",
+        noticePrivacyPolicyUrl: "",
+      },
+      tokenPayload: {
+        ...tokenPayload(),
+        consent: {
+          granted: true,
+          grantedAt: "2026-01-01T09:00:00.000Z",
+          noticeLanguage: "EN",
+          noticePrivacyPolicyUrl: "https://partner.test/privacy",
+        },
+      },
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidConsentInformationException),
+    ).toBe(false);
+  });
+
+  it("the standalone pre-flight validator stays strict (no token context)", () => {
+    // `b.validateUserDetails(payload)` has no token context by design —
+    // partners pre-flight the payload they would assign, and blank
+    // names still fail there.
+    expect(
+      runUserDetailsValidation({ givenNames: "", lastName: "Lovelace" }),
+    ).not.toHaveLength(0);
+    expect(
+      runConsentValidation({
+        granted: false,
+        grantedAt: "",
+        noticeLanguage: "",
+        noticePrivacyPolicyUrl: "",
+      }),
+    ).not.toHaveLength(0);
+  });
+});

package/src/presentation/flow/validation/__tests__/job_type_validator.test.ts

@@ -20,10 +20,15 @@ import {
   PreviewConfigBuilder,
 } from "../../dsl/builder/screens_builder";
 import { InvalidJobTypeScreenConfigException } from "../../../../core/exception/job_validation_exceptions";
+import { InvalidFieldValueException } from "../../../../core/exception/invalid_field_value_exception";
 import {
   InvalidScreenOrderException,
   MissingCaptureForPreviewException,
 } from "../../../../core/exception/screen_config_validation_exceptions";
+import type {
+  TokenConsent,
+  TokenPayload,
+} from "../../../../data/model/token_payload";
 
 function stubFaceAnalyzer(): FaceAnalyzer {
   return {
@@ -733,6 +738,201 @@ describe("DocumentJobTypeValidator — Android-parity rules", () => {
   });
 });
 
+describe("JobTypeValidator — token-provided user details & consent", () => {
+  function tokenPayload(overrides: Partial<TokenPayload> = {}): TokenPayload {
+    return {
+      hasGivenNames: false,
+      hasLastName: false,
+      hasEmail: false,
+      hasPhoneNumber: false,
+      ...overrides,
+    };
+  }
+
+  const fullBinding = tokenPayload({
+    hasGivenNames: true,
+    hasLastName: true,
+    hasEmail: true,
+    hasPhoneNumber: true,
+  });
+
+  const completeTokenConsent: TokenConsent = {
+    granted: true,
+    grantedAt: "2026-01-01T09:00:00.000Z",
+    noticeLanguage: "EN",
+    noticePrivacyPolicyUrl: "https://partner.test/privacy",
+  };
+
+  const validConsentInformation = {
+    granted: true,
+    grantedAt: "2024-01-01T00:00:00.000Z",
+    noticeLanguage: "EN",
+    noticePrivacyPolicyUrl: "https://example.com",
+  } as const;
+
+  // Steps + params that make each submitting job type otherwise valid,
+  // so the only variable under test is the userDetails / consent rule.
+  function validInputFor(jobType: JobType): JobTypeValidatorInput {
+    switch (jobType) {
+      case JobType.documentVerification:
+      case JobType.enhancedDocumentVerification:
+        return {
+          steps: [
+            consentStep(),
+            captureStep(CaptureType.selfie),
+            captureStep(CaptureType.document),
+            processingStep(),
+          ],
+          network: validNetwork(jobType),
+          ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+          documentVerificationParams: validDocumentParams,
+          enhancedDocumentVerificationParams: validEnhancedDocumentParams,
+        };
+      case JobType.enhancedKyc:
+        return {
+          steps: [consentStep(), processingStep()],
+          network: validNetwork(jobType),
+          enhancedKYCParams: {
+            idType: "NATIONAL_ID",
+            idNumber: "1",
+            country: "KE",
+          },
+        };
+      default:
+        return {
+          steps: [
+            consentStep(),
+            captureStep(CaptureType.selfie),
+            processingStep(),
+          ],
+          network: validNetwork(jobType),
+          ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+          biometricKYCParams: validBiometricParams,
+        };
+    }
+  }
+
+  const USER_DETAILS_JOB_TYPES: readonly JobType[] = [
+    JobType.smartSelfieEnrollment,
+    JobType.smartSelfieAuthentication,
+    JobType.biometricKyc,
+    JobType.documentVerification,
+    JobType.enhancedDocumentVerification,
+    JobType.enhancedKyc,
+  ];
+
+  for (const jobType of USER_DETAILS_JOB_TYPES) {
+    it(`${jobType}: userDetails may be omitted when the token binds names + a contact field`, () => {
+      const issues = run({
+        ...validInputFor(jobType),
+        tokenPayload: fullBinding,
+      });
+      expect(
+        issues.some(
+          (i) =>
+            i instanceof InvalidJobTypeScreenConfigException &&
+            i.message.includes("userDetails is required"),
+        ),
+      ).toBe(false);
+    });
+  }
+
+  it("a names-only token binding reports the missing contact field by name", () => {
+    const issues = run({
+      ...validInputFor(JobType.smartSelfieEnrollment),
+      tokenPayload: tokenPayload({ hasGivenNames: true, hasLastName: true }),
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidFieldValueException &&
+          i.message.includes("userDetails") &&
+          i.message.includes(
+            "at least one contact field must be bound by the token or supplied on the builder",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("complete token consent satisfies the consent-source rule with no local source", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      tokenPayload: { ...tokenPayload(), consent: completeTokenConsent },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must include either a Consent screen or a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(false);
+  });
+
+  it("a partial token consent fails validation naming the missing subfields", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      tokenPayload: {
+        ...tokenPayload(),
+        consent: {
+          granted: true,
+          grantedAt: "2026-01-01T09:00:00.000Z",
+        },
+      },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "the token's consent binding is incomplete — missing: notice_language, notice_privacy_policy_url",
+          ),
+      ),
+    ).toBe(true);
+  });
+
+  it("complete token consent alongside a consentInformation preset is allowed", () => {
+    const issues = run({
+      steps: [captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: validConsentInformation,
+      tokenPayload: { ...tokenPayload(), consent: completeTokenConsent },
+    });
+    expect(
+      issues.some((i) => i instanceof InvalidJobTypeScreenConfigException),
+    ).toBe(false);
+  });
+
+  it("the consent-source mutex still fires with complete token consent", () => {
+    const issues = run({
+      steps: [consentStep(), captureStep(CaptureType.selfie), processingStep()],
+      network: validNetwork(JobType.smartSelfieEnrollment),
+      ml: { analyzers: { selfie: stubFaceAnalyzer() } },
+      userDetails: validUserDetails,
+      consentInformation: validConsentInformation,
+      tokenPayload: { ...tokenPayload(), consent: completeTokenConsent },
+    });
+    expect(
+      issues.some(
+        (i) =>
+          i instanceof InvalidJobTypeScreenConfigException &&
+          i.message.includes(
+            "must not include both a Consent screen and a pre-supplied consentInformation",
+          ),
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("NonCaptureJobTypeValidator — Android-parity rules", () => {
   it("passes a fully-configured EnhancedKyc flow", () => {
     const issues = run({

package/src/presentation/flow/validation/flow_validator.ts

@@ -9,8 +9,12 @@ import type {
   EnhancedKYCParams,
   UserDetails,
 } from "../../../core/models/params";
-import { JobType } from "../../../core/models/job_type";
-import type { ScreenSpec } from "../dsl/builder/screens_builder";
+import { JobType, jobTypeFromValue } from "../../../core/models/job_type";
+import type {
+  DocumentCaptureConfigBuilder,
+  ScreenSpec,
+  SelfieCaptureConfigBuilder,
+} from "../dsl/builder/screens_builder";
 
 type ConsentScreenStep = Extract<ScreenSpec, { kind: "consent" }>;
 import { IssueSeverity } from "../../../core/exception/issue_severity";
@@ -25,12 +29,15 @@ import {
   MissingNetworkConfigurationBlockException,
 } from "../../../core/exception/job_validation_exceptions";
 import {
+  AgentModeWithEnhancedLivenessException,
   InvalidDocumentCaptureConfigException,
   InvalidMissingCaptureTypeException,
 } from "../../../core/exception/capture_validation_exceptions";
 import { EmptyScreensBlockException } from "../../../core/exception/screen_config_validation_exceptions";
+import type { TokenPayload } from "../../../data/model/token_payload";
 import { ValidationState, type ValidationIssue } from "./validation_state";
 import { collectJobTypeIssues } from "./job_type_validator";
+import { missingUserDetailsFieldIssues } from "./user_details_validator";
 
 /**
  * Pure flow validator — returns typed `UseSmileIDValidationException`
@@ -67,8 +74,59 @@ type FlowValidatorInput = {
     | EnhancedDocumentVerificationParams
     | undefined;
   readonly userDetails?: UserDetails | undefined;
+  /**
+   * User-detail/consent bindings decoded from the JWT `payload` claim.
+   * `undefined` (no token, offline mode, legacy token) keeps every rule
+   * exactly as strict as before token support existed.
+   */
+  readonly tokenPayload?: TokenPayload | undefined;
 };
 
+/**
+ * Agent mode captures on the rear lens while the head-turn challenge is only
+ * validated for front-camera framing, so the pair is refused rather than
+ * silently dropping one of them.
+ */
+function selfieConfigIssues(
+  config: SelfieCaptureConfigBuilder | undefined,
+): ValidationIssue[] {
+  if (config?.allowAgentMode && config.enableEnhancedLiveness) {
+    return [new AgentModeWithEnhancedLivenessException()];
+  }
+  return [];
+}
+
+/** Surfaces at most one issue: missing block > missing type > bad aspect ratio. */
+function documentConfigIssues(
+  config: DocumentCaptureConfigBuilder | undefined,
+): ValidationIssue[] {
+  if (config === undefined) {
+    return [
+      new InvalidDocumentCaptureConfigException({
+        reason: "document is required when mode is Document",
+      }),
+    ];
+  }
+  if (config.documentType === undefined) {
+    return [
+      new InvalidDocumentCaptureConfigException({
+        reason: "documentType is required for document capture",
+      }),
+    ];
+  }
+  if (
+    config.knownIdAspectRatio !== undefined &&
+    config.knownIdAspectRatio <= 0
+  ) {
+    return [
+      new InvalidDocumentCaptureConfigException({
+        reason: "knownIdAspectRatio must be > 0 if provided",
+      }),
+    ];
+  }
+  return [];
+}
+
 /**
  * Quick triage of the in-progress builder state. Today the only rule
  * surfaced is the empty-screens-block error — `b.screens(...)` must
@@ -113,32 +171,11 @@ export function runFlowValidation(
       if (step.config.captureType === undefined) {
         issues.push(new InvalidMissingCaptureTypeException());
       }
-      // Document captures carry required config: surface at most one issue per
-      // step (missing block > missing type > bad aspect ratio).
+      if (step.config.captureType === CaptureType.selfie) {
+        issues.push(...selfieConfigIssues(step.config.selfieConfig));
+      }
       if (step.config.captureType === CaptureType.document) {
-        const documentConfig = step.config.documentConfig;
-        if (documentConfig === undefined) {
-          issues.push(
-            new InvalidDocumentCaptureConfigException({
-              reason: "document is required when mode is Document",
-            }),
-          );
-        } else if (documentConfig.documentType === undefined) {
-          issues.push(
-            new InvalidDocumentCaptureConfigException({
-              reason: "documentType is required for document capture",
-            }),
-          );
-        } else if (
-          documentConfig.knownIdAspectRatio !== undefined &&
-          documentConfig.knownIdAspectRatio <= 0
-        ) {
-          issues.push(
-            new InvalidDocumentCaptureConfigException({
-              reason: "knownIdAspectRatio must be > 0 if provided",
-            }),
-          );
-        }
+        issues.push(...documentConfigIssues(step.config.documentConfig));
       }
     }
   }
@@ -156,9 +193,13 @@ export function runFlowValidation(
   // build (ERROR) whenever it's missing — whether or not a network
   // block was provided. The missing-network WARNING above still fires
   // alongside this when the block is absent.
+  // `jobTypeFromValue` collapses the unknown sentinel and any out-of-enum value, so an unrecognised job_type_id fails the build too.
   if (hasProcessingScreen) {
     const jobType = input.network?.config?.jobType;
-    if (jobType === undefined || jobType === JobType.unknown) {
+    if (
+      jobType === undefined ||
+      jobTypeFromValue(jobType) === JobType.unknown
+    ) {
       issues.push(new MissingJobTypeException());
     }
   }
@@ -209,7 +250,9 @@ export function runFlowValidation(
     );
   }
 
-  if (input.consentInformation) {
+  // A token consent binding supersedes the preset entirely (token data
+  // always wins), so the ignored preset's contents are not validated.
+  if (input.consentInformation && input.tokenPayload?.consent === undefined) {
     issues.push(...runConsentValidation(input.consentInformation));
   }
   if (input.enhancedKYCParams) {
@@ -233,7 +276,9 @@ export function runFlowValidation(
     );
   }
   if (input.userDetails) {
-    issues.push(...runUserDetailsValidation(input.userDetails));
+    issues.push(
+      ...runUserDetailsValidation(input.userDetails, input.tokenPayload),
+    );
   }
 
   // Every flow-composition rule (screen ordering, duplicate screens,
@@ -379,40 +424,23 @@ function runKYCParamsValidation(
  * keep working unchanged after the consolidation away from nesting
  * `userDetails` inside the KYC param shapes.
  *
+ * Each field requirement is evaluated against the union of builder
+ * input and token bindings: a field the token binds (see
+ * `TokenPayload`) never has to be supplied locally — the server
+ * injects it, and the SDK drops the local value from the wire. With
+ * no `tokenPayload` the behavior is exactly the pre-token rule set.
+ *
  * Exposed via `b.validateUserDetails(payload)` so partners can
  * pre-flight a payload before assigning to `b.userDetails`, mirroring
  * the existing `b.validateConsent` / `b.validateEnhancedKYCParams`
- * pattern.
+ * pattern (the pre-flight helper always validates strictly, without
+ * token context).
  */
 export function runUserDetailsValidation(
   userDetails: UserDetails,
+  tokenPayload?: TokenPayload,
 ): ValidationIssue[] {
-  const issues: ValidationIssue[] = [];
-  for (const field of ["givenNames", "lastName"] as const) {
-    const value = userDetails[field];
-    if (!value || !value.trim()) {
-      issues.push(
-        new InvalidFieldValueException({
-          fieldName: `userDetails.${field}`,
-          reason: "must not be blank",
-        }),
-      );
-    }
-  }
-  // At-least-one-of contact rule: email and phoneNumber are each
-  // optional, but the partner must supply one of them.
-  const hasEmail = !!userDetails.email && userDetails.email.trim().length > 0;
-  const hasPhone =
-    !!userDetails.phoneNumber && userDetails.phoneNumber.trim().length > 0;
-  if (!hasEmail && !hasPhone) {
-    issues.push(
-      new InvalidFieldValueException({
-        fieldName: "userDetails",
-        reason: "at least one of email or phoneNumber must be non blank",
-      }),
-    );
-  }
-  return issues;
+  return missingUserDetailsFieldIssues(userDetails, tokenPayload);
 }
 
 /**