@redacto.io/consent-sdk-react 10.0.0-beta.9 → 10.0.0

package/src/RedactoNoticeConsent/api/index.ts

@@ -1,542 +0,0 @@
-import { jwtDecode } from "jwt-decode";
-import { parseApiError } from "../../shared/api-errors";
-import {
-  buildAuthHeaders,
-  resolveRequestAuth,
-  sandboxBodyIdentity,
-  sandboxQueryIdentity,
-} from "./sandbox";
-import type {
-  ConsentContent,
-  ConsentEventPayload,
-  DataElementSelection,
-  FetchConsentContentParams,
-  FetchTTSAudioUrlsParams,
-  InitiateGuardianVerificationParams,
-  InitiateGuardianVerificationResponse,
-  NoticeConsentStatusResponse,
-  PurposeSelection,
-  RedactoJwtPayload,
-  SubmitConsentEventParams,
-  TTSAudioUrlsResponse,
-  VerifyGuardianStatusParams,
-  VerifyGuardianStatusResponse,
-} from "./types";
-
-// The ledger `check-consent` read is shared with RedactoNoticeConsentInline.
-// Re-exported through this barrel so `./api` importers (and the test mock)
-// resolve it here unchanged.
-export { fetchNoticeConsentStatus } from "../../shared/notice-consent-status";
-
-const BASE_URL = "https://api.redacto.io/consent";
-
-// Simple in-memory cache for API responses to reduce calls
-const apiCache = new Map<string, { data: any; timestamp: number; ttl: number }>();
-const CACHE_TTL = 5 * 60 * 1000; // 5 minutes
-
-// Utility function to get cached data
-function getCachedData(key: string): any | null {
-  const cached = apiCache.get(key);
-  if (cached && Date.now() - cached.timestamp < cached.ttl) {
-    return cached.data;
-  }
-  if (cached) {
-    apiCache.delete(key);
-  }
-  return null;
-}
-
-// Utility function to set cached data
-function setCachedData(key: string, data: any, ttl = CACHE_TTL): void {
-  apiCache.set(key, { data, timestamp: Date.now(), ttl });
-}
-
-// Utility function to decode JWT with error handling
-function decodeTokenSafely(token: string): RedactoJwtPayload | null {
-  try {
-    return jwtDecode(token) as RedactoJwtPayload;
-  } catch (error) {
-    console.warn("Failed to decode JWT token:", error);
-    return null;
-  }
-}
-
-// Function to clear API cache (useful for testing or when switching users)
-export const clearApiCache = (): void => {
-  apiCache.clear();
-};
-
-export const fetchConsentContent = async ({
-  noticeId,
-  accessToken,
-  baseUrl,
-  language = "en",
-  specific_uuid,
-  validate_against = "all",
-  include_fully_consented_data = false,
-  signal,
-  ...sandboxParams
-}: FetchConsentContentParams & { signal?: AbortSignal }): Promise<ConsentContent> => {
-  if (!noticeId || !validate_against) {
-    throw new Error("noticeId is required");
-  }
-  if (!accessToken && !sandboxParams.token) {
-    throw new Error("accessToken or token is required");
-  }
-
-  const { organisationUuid: ORGANISATION_UUID, workspaceUuid: WORKSPACE_UUID, sandbox } =
-    resolveRequestAuth(accessToken, sandboxParams, decodeTokenSafely);
-
-  const apiBaseUrl = baseUrl || BASE_URL;
-
-  // Create cache key for this request - include the auth identity (token or
-  // sandbox org/workspace/subject) so different users get different cache
-  // entries. Org + workspace are part of the sandbox identity so two sessions
-  // sharing a subject but scoped to different orgs never collide.
-  const cacheIdentity = sandbox
-    ? `sandbox:${sandbox.organisationUuid}:${sandbox.workspaceUuid}:${sandbox.ucic || sandbox.subject}`
-    : accessToken;
-  const cacheKey = `${cacheIdentity}-${noticeId}-${validate_against}-${language}-${specific_uuid || ''}-${include_fully_consented_data}`;
-
-  if (validate_against === "all" && !specific_uuid) {
-    const cachedData = getCachedData(cacheKey);
-    if (cachedData) {
-      return cachedData;
-    }
-  }
-
-  const url = new URL(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeId}`
-  );
-
-  if (specific_uuid) {
-    url.searchParams.append("specific_uuid", specific_uuid);
-  }
-  url.searchParams.append("validate_against", validate_against);
-  if (include_fully_consented_data) {
-    url.searchParams.append("include_fully_consented_data", "true");
-  }
-  // Sandbox mode: the acting identity travels as query params
-  // (primary_email / primary_mobile); the credential is the X-Consent-Token header.
-  if (sandbox) {
-    for (const [key, value] of Object.entries(sandboxQueryIdentity(sandbox))) {
-      url.searchParams.append(key, value);
-    }
-  }
-
-  const response = await fetch(url.toString(), {
-    method: "GET",
-    headers: {
-      ...buildAuthHeaders(accessToken, sandbox),
-      "Accept-Language": language,
-    },
-    signal,
-  });
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not load the consent notice. Please try again."
-    );
-  }
-
-  const data: ConsentContent = await response.json();
-
-  if (validate_against === "all" && !specific_uuid) {
-    setCachedData(cacheKey, data);
-  }
-
-  return data;
-};
-
-export const submitConsentEvent = async ({
-  accessToken,
-  baseUrl,
-  ledgerBaseUrl,
-  noticeUuid,
-  purposes,
-  declined,
-  language,
-  meta_data,
-  guardianVerificationReference,
-  selfDeclaredAdult,
-  signal,
-  ...sandboxParams
-}: SubmitConsentEventParams & { signal?: AbortSignal }): Promise<void> => {
-  if (!noticeUuid || !Array.isArray(purposes)) {
-    throw new Error("noticeUuid and purposes array are required");
-  }
-  if (!accessToken && !sandboxParams.token) {
-    throw new Error("accessToken or token is required");
-  }
-
-  const { organisationUuid: ORGANISATION_UUID, workspaceUuid: WORKSPACE_UUID, sandbox } =
-    resolveRequestAuth(accessToken, sandboxParams, decodeTokenSafely);
-
-  // Fall back to the consent server when no ledger is configured, so existing
-  // integrations that only pass baseUrl remain backwards compatible. Sandbox
-  // never routes to the Go ledger (no X-Consent-Token support), so a sandbox
-  // session forces the consent-server path even if a ledgerBaseUrl is set.
-  const apiBaseUrl = (sandbox ? null : ledgerBaseUrl) || baseUrl || BASE_URL;
-
-  const validatedPurposes = purposes.map((purpose) => {
-    if (!purpose.uuid) {
-      throw new Error(`Invalid purpose data: missing uuid`);
-    }
-
-    // Only include enabled data elements (disabled elements are not selectable)
-    const dataElements = (purpose.data_elements || [])
-      .filter((element) => element.enabled)
-      .map((element) => ({
-        uuid: element.uuid,
-        selected: element.required ? true : Boolean(element.selected),
-      }));
-
-    return {
-      purpose_uuid: purpose.uuid,
-      selected: Boolean(purpose.selected),
-      data_elements: dataElements.length > 0 ? dataElements : undefined,
-    };
-  });
-
-  const payload: ConsentEventPayload = {
-    notice_uuid: noticeUuid,
-    purposes: validatedPurposes,
-    select_all_mandatory: false,
-    source: "WEB",
-    declined: Boolean(declined),
-    language: language || undefined,
-    meta_data: meta_data ? { specific_uuid: meta_data.specific_uuid, minor_age: meta_data.minor_age } : undefined,
-    guardian_verification_reference: guardianVerificationReference,
-    self_declared_adult: selfDeclaredAdult,
-  };
-
-  // Sandbox mode: merge the acting test identity into the body (the server has
-  // no subject header; it namespaces this identity `test::`).
-  const requestBody = sandbox ? { ...payload, ...sandboxBodyIdentity(sandbox) } : payload;
-
-  const response = await fetch(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/submit-consent`,
-    {
-      method: "POST",
-      headers: {
-        ...buildAuthHeaders(accessToken, sandbox),
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify(requestBody),
-      signal,
-    }
-  );
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not submit your consent. Please try again."
-    );
-  }
-
-  // Clear any cached consent content since user preferences have changed
-  apiCache.clear();
-};
-
-/**
- * Translate the ledger's notice consent status into the
- * `{ purpose_selections, reconsent_required }` shape the banner already
- * consumes, so prior-consent pre-fill and reconsent categorization work off
- * the ledger. Returns null for a first-time principal (no consent record —
- * every purpose INACTIVE), preserving the normal first-time consent flow.
- *
- * `needs_reconsent` is derived from `status` (anything not ACTIVE needs
- * reconsent: expired / withdrawn / declined / inactive). NOTE: notice-version
- * reconsent is NOT covered — the ledger's check-consent has no version
- * awareness yet, so a republished-notice version bump won't re-prompt until
- * that lands on the ledger (tracked fast-follow).
- */
-export const buildLedgerConsentOverlay = (
-  status: NoticeConsentStatusResponse,
-  configPurposes: ConsentContent["detail"]["active_config"]["purposes"]
-): {
-  reconsent_required: boolean;
-  purpose_selections: Record<string, PurposeSelection>;
-} | null => {
-  const byUuid = new Map(status.purposes.map((p) => [p.uuid, p]));
-  const hasHistory = status.purposes.some(
-    (p) => (p.status || "INACTIVE") !== "INACTIVE"
-  );
-  if (!hasHistory) {
-    return null;
-  }
-
-  const purpose_selections: Record<string, PurposeSelection> = {};
-  for (const cp of configPurposes) {
-    const lp = byUuid.get(cp.uuid);
-    const purposeStatus = lp?.status || "INACTIVE";
-    const selectedByUuid = new Map(
-      (lp?.data_elements || []).map((de) => [de.uuid, de.selected])
-    );
-    const data_elements: Record<string, DataElementSelection> = {};
-    for (const de of cp.data_elements) {
-      data_elements[de.uuid] = {
-        selected: selectedByUuid.get(de.uuid) ?? false,
-        enabled: de.enabled,
-        required: de.required,
-      };
-    }
-    purpose_selections[cp.uuid] = {
-      selected: lp?.selected ?? false,
-      status: purposeStatus,
-      needs_reconsent: purposeStatus !== "ACTIVE",
-      data_elements,
-    };
-  }
-
-  const reconsent_required = configPurposes.some(
-    (cp) => (purpose_selections[cp.uuid]?.status || "INACTIVE") !== "ACTIVE"
-  );
-  return { reconsent_required, purpose_selections };
-};
-
-export const fetchTTSAudioUrls = async ({
-  accessToken,
-  baseUrl,
-  noticeUuid,
-  language,
-  signal,
-  ...sandboxParams
-}: FetchTTSAudioUrlsParams & { signal?: AbortSignal }): Promise<TTSAudioUrlsResponse> => {
-  if ((!accessToken && !sandboxParams.token) || !noticeUuid || !language) {
-    throw new Error("accessToken (or token), noticeUuid, and language are required");
-  }
-
-  const { organisationUuid: ORGANISATION_UUID, workspaceUuid: WORKSPACE_UUID, sandbox } =
-    resolveRequestAuth(accessToken, sandboxParams, decodeTokenSafely);
-
-  const apiBaseUrl = baseUrl || BASE_URL;
-
-  const url = new URL(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/audio/${language}`
-  );
-  // Sandbox mode: the acting identity travels as query params
-  // (primary_email / primary_mobile); the credential is the X-Consent-Token header.
-  if (sandbox) {
-    for (const [key, value] of Object.entries(sandboxQueryIdentity(sandbox))) {
-      url.searchParams.append(key, value);
-    }
-  }
-
-  const response = await fetch(url.toString(), {
-    method: "GET",
-    headers: {
-      ...buildAuthHeaders(accessToken, sandbox),
-      Accept: "application/json",
-    },
-    signal,
-  });
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not load audio narration. Please try again."
-    );
-  }
-
-  const data: TTSAudioUrlsResponse = await response.json();
-  return data;
-};
-
-// =============================================================================
-// Guardian Verification API Functions
-// =============================================================================
-
-/**
- * Initiate guardian verification via DigiLocker
- * POST /guardian/initiate-verification
- * 
- * This combines guardian details submission and DigiLocker initiation in one call.
- */
-export const initiateGuardianVerification = async ({
-  accessToken,
-  baseUrl,
-  guardianName,
-  guardianContact,
-  guardianRelationship,
-  frontendCallbackUrl,
-  metadata,
-  signal,
-}: InitiateGuardianVerificationParams): Promise<InitiateGuardianVerificationResponse> => {
-  try {
-    // Guardian verification is JWT-only: sandbox sessions have no minor-notice /
-    // guardian support (the server 403s them, and C1 blocks minor notices at
-    // render), so no sandbox identity is wired through here.
-    if (!accessToken) {
-      throw new Error("accessToken is required");
-    }
-
-    if (!guardianName?.trim()) {
-      throw new Error("Guardian name is required");
-    }
-
-    if (!guardianContact?.trim()) {
-      throw new Error("Guardian contact is required");
-    }
-
-    if (!guardianRelationship?.trim()) {
-      throw new Error("Guardian relationship is required");
-    }
-
-    const decodedToken = decodeTokenSafely(accessToken);
-    if (!decodedToken) {
-      throw new Error("Invalid access token");
-    }
-    const {
-      organisation_uuid: ORGANISATION_UUID,
-      workspace_uuid: WORKSPACE_UUID,
-    } = decodedToken;
-    if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-      throw new Error("Invalid token: missing organization or workspace UUID");
-    }
-
-    const apiBaseUrl = baseUrl || BASE_URL;
-
-    const payload: {
-      guardian_name: string;
-      guardian_contact: string;
-      guardian_relationship: string;
-      frontend_callback_url?: string;
-      metadata?: Record<string, unknown>;
-    } = {
-      guardian_name: guardianName.trim(),
-      guardian_contact: guardianContact.trim(),
-      guardian_relationship: guardianRelationship.trim(),
-    };
-
-    if (frontendCallbackUrl) {
-      payload.frontend_callback_url = frontendCallbackUrl;
-    }
-
-    if (metadata) {
-      payload.metadata = metadata;
-    }
-
-    const response = await fetch(
-      `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/guardian/initiate-verification`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify(payload),
-        signal,
-      }
-    );
-
-    if (!response.ok) {
-      throw await parseApiError(
-        response,
-        "Could not start guardian verification. Please try again."
-      );
-    }
-
-    const responseData = await response.json();
-
-    // Handle response with detail wrapper (backend format: { code, status, detail: {...} })
-    const detail = responseData.detail || responseData;
-
-    // Already verified — skip DigiLocker entirely
-    if (detail.already_verified) {
-      return {
-        success: true,
-        guardian_info_uuid: detail.guardian_info_uuid,
-        already_verified: true,
-        verification_reference: detail.verification_reference,
-      };
-    }
-
-    // New verification flow — needs DigiLocker
-    if (!detail.session_token || !detail.digilocker_redirect_url) {
-      throw new Error("Invalid response: missing session_token or digilocker_redirect_url");
-    }
-
-    return {
-      success: detail.success ?? true,
-      guardian_info_uuid: detail.guardian_info_uuid,
-      already_verified: false,
-      session_token: detail.session_token,
-      digilocker_redirect_url: detail.digilocker_redirect_url,
-      expires_at: detail.expires_at,
-    };
-  } catch (error) {
-    console.error("Error initiating guardian verification:", error instanceof Error ? error.message : error);
-    throw error;
-  }
-};
-
-/**
- * Check guardian verification status
- * POST /guardian/verify-status
- * 
- * Poll this endpoint to check if DigiLocker verification is complete.
- * Returns verification_reference when status is "verified".
- */
-export const verifyGuardianStatus = async ({
-  accessToken,
-  baseUrl,
-  sessionToken,
-  signal,
-}: VerifyGuardianStatusParams): Promise<VerifyGuardianStatusResponse> => {
-  // Guardian verification is JWT-only: sandbox sessions have no minor-notice /
-  // guardian support (the server 403s them, and C1 blocks minor notices at
-  // render), so no sandbox identity is wired through here.
-  if (!accessToken || !sessionToken) {
-    throw new Error("accessToken and sessionToken are required");
-  }
-
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-  const {
-    organisation_uuid: ORGANISATION_UUID,
-    workspace_uuid: WORKSPACE_UUID,
-  } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
-  }
-
-  const apiBaseUrl = baseUrl || BASE_URL;
-
-  const response = await fetch(
-    `${apiBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/guardian/verify-status`,
-    {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${accessToken}`,
-        "Content-Type": "application/json",
-      },
-      body: JSON.stringify({ session_token: sessionToken }),
-      signal,
-    }
-  );
-
-  if (!response.ok) {
-    throw await parseApiError(
-      response,
-      "Could not check verification status. Please try again."
-    );
-  }
-
-  const responseData = await response.json();
-  const detail = responseData.detail || responseData;
-
-  return {
-    status: detail.status ?? "in_progress",
-    guardian_info_uuid: detail.guardian_info_uuid ?? null,
-    verification_reference: detail.verification_reference ?? null,
-    guardian_details: detail.guardian_details ?? null,
-    error: detail.error ?? null,
-    error_code: detail.error_code ?? null,
-    can_retry: detail.can_retry ?? true,
-  };
-};
-

package/src/RedactoNoticeConsent/api/sandbox.ts

@@ -1,150 +0,0 @@
-/**
- * Sandbox-mode auth primitives for the consent PoC.
- *
- * In sandbox mode the SDK talks to the consent-server with a pasted static
- * token and an explicit test subject, bypassing the JWT entirely. Org/workspace
- * UUIDs come from props (they still build the `/public/organisations/{org}/
- * workspaces/{ws}/...` URL paths) instead of being decoded from a token.
- *
- * Auth is the single `X-Consent-Token` header carrying the static token; its
- * presence alone marks the request as `environment=test`. There is no subject
- * header. The acting identity (the test subject) rides the request's own
- * payload: query params (`primary_email` / `primary_mobile`) on GET/query reads,
- * and the body on POSTs. The server normalizes and namespaces it `test::`
- * server-side. Call sites resolve the credential via {@link buildAuthHeaders}
- * and the identity via {@link sandboxQueryIdentity} / {@link sandboxBodyIdentity}.
- *
- * This file exists so every API call site resolves its org/workspace UUIDs and
- * builds its auth header through one place, keeping sandbox vs. JWT branching
- * from drifting across the ~6 fetch sites.
- */
-import { SANDBOX_TOKEN_HEADER } from "../../shared/sandbox";
-import type {
-  RedactoJwtPayload,
-  ResolvedRequestAuth,
-  SandboxAuth,
-  SandboxAuthParams,
-  SandboxIdentityPayload,
-} from "./types";
-
-export { SANDBOX_TOKEN_HEADER };
-
-/**
- * Resolve a {@link SandboxAuth} from the raw sandbox props, or return null when
- * sandbox mode is not active (no token).
- *
- * @throws Error when a sandbox token is provided but org/workspace or the acting
- *   identity are incomplete — sandbox mode cannot build URLs or identify the
- *   acting principal without them, so failing loudly beats a silent malformed
- *   request.
- */
-export const resolveSandboxAuth = (
-  params: SandboxAuthParams
-): SandboxAuth | null => {
-  const token = params.token?.trim();
-  if (!token) {
-    return null;
-  }
-
-  const organisationUuid = params.organisationUuid?.trim();
-  const workspaceUuid = params.workspaceUuid?.trim();
-  const ucic = params.sandboxUcic?.trim();
-  const subject = params.sandboxSubject?.trim();
-
-  if (!organisationUuid || !workspaceUuid) {
-    throw new Error(
-      "Sandbox mode requires organisationUuid and workspaceUuid props"
-    );
-  }
-  if (!ucic && !subject) {
-    throw new Error("Sandbox mode requires a UCIC, email, or mobile");
-  }
-
-  return { token, ucic, subject: subject ?? "", organisationUuid, workspaceUuid };
-};
-
-/**
- * Resolve the org/workspace UUIDs and sandbox auth for a request. In sandbox
- * mode these come straight from props; otherwise they are decoded from the JWT
- * (preserving the pre-sandbox behavior and error messages exactly). The JWT
- * decoder is injected so this module stays free of a direct jwt-decode import.
- *
- * @throws Error when neither a valid sandbox config nor a decodable token with
- *   org/workspace UUIDs is available.
- */
-export const resolveRequestAuth = (
-  accessToken: string | undefined,
-  sandboxParams: SandboxAuthParams,
-  decodeTokenSafely: (token: string) => RedactoJwtPayload | null
-): ResolvedRequestAuth => {
-  const sandbox = resolveSandboxAuth(sandboxParams);
-  if (sandbox) {
-    return {
-      organisationUuid: sandbox.organisationUuid,
-      workspaceUuid: sandbox.workspaceUuid,
-      sandbox,
-    };
-  }
-
-  const decodedToken = accessToken ? decodeTokenSafely(accessToken) : null;
-  if (!decodedToken) {
-    throw new Error("Invalid access token");
-  }
-  const { organisation_uuid, workspace_uuid } = decodedToken;
-  if (!organisation_uuid || !workspace_uuid) {
-    throw new Error("Invalid token: missing organization or workspace UUID");
-  }
-  return {
-    organisationUuid: organisation_uuid,
-    workspaceUuid: workspace_uuid,
-    sandbox: null,
-  };
-};
-
-/**
- * Build the request headers for an authenticated call. In sandbox mode this is
- * the single `X-Consent-Token` credential (its presence marks the request as
- * `environment=test`); otherwise the standard `Authorization: Bearer`. There is
- * no subject header — the acting identity travels in the request's own payload
- * (see {@link sandboxQueryIdentity} for reads, {@link sandboxBodyIdentity} for
- * POSTs).
- */
-export const buildAuthHeaders = (
-  accessToken: string | undefined,
-  sandbox: SandboxAuth | null
-): Record<string, string> => {
-  if (sandbox) {
-    return { [SANDBOX_TOKEN_HEADER]: sandbox.token };
-  }
-  return { Authorization: `Bearer ${accessToken}` };
-};
-
-/**
- * The identity payload fragment for the sandbox acting principal:
- * `{ org_user_id }` when a UCIC is set (it takes precedence), else
- * `{ primary_email }` when the subject looks like an email (contains "@"),
- * otherwise `{ primary_mobile }`. Merge this into a JSON request body (POST) or
- * into query params (GET) so the server can resolve the acting test identity.
- */
-export const sandboxBodyIdentity = (
-  sandbox: SandboxAuth
-): SandboxIdentityPayload => {
-  if (sandbox.ucic) {
-    return { org_user_id: sandbox.ucic };
-  }
-  return sandbox.subject.includes("@")
-    ? { primary_email: sandbox.subject }
-    : { primary_mobile: sandbox.subject };
-};
-
-/**
- * The identity query fragment for GET/query reads: `{ org_user_id }` when a UCIC
- * is set (it takes precedence), else `{ primary_email }` when the subject looks
- * like an email (contains "@"), otherwise `{ primary_mobile }`. Append these to
- * the request's query string so the server can resolve the acting test identity
- * (the server reads `org_user_id` / `primary_email` / `primary_mobile` query
- * params on sandbox reads).
- */
-export const sandboxQueryIdentity = (
-  sandbox: SandboxAuth
-): SandboxIdentityPayload => sandboxBodyIdentity(sandbox);