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

package/.turbo/turbo-build.log

@@ -7,16 +7,16 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.js          514.08 KB
+CJS dist/index.js          516.41 KB
 CJS dist/privacy-center.js 2.21 MB
-CJS ⚡️ Build success in 219ms
-ESM dist/index.mjs          499.63 KB
+CJS ⚡️ Build success in 179ms
 ESM dist/chunk-6A665OPR.mjs 841.00 B
+ESM dist/index.mjs          501.90 KB
 ESM dist/privacy-center.mjs 2.17 MB
-ESM ⚡️ Build success in 232ms
+ESM ⚡️ Build success in 184ms
 DTS Build start
-DTS ⚡️ Build success in 7326ms
-DTS dist/index.d.mts          8.27 KB
+DTS ⚡️ Build success in 3448ms
+DTS dist/index.d.mts          8.42 KB
 DTS dist/privacy-center.d.mts 33.31 KB
-DTS dist/index.d.ts           8.27 KB
+DTS dist/index.d.ts           8.42 KB
 DTS dist/privacy-center.d.ts  33.31 KB

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @redacto.io/consent-sdk-react
 
+## 10.0.0-beta.6
+
+### Patch Changes
+
+- minor bug fix in beta version
+
+## 10.0.0-beta.5
+
+### Major Changes
+
+- M3 Version
+
+### Minor Changes
+
+- 1a11423: RedactoNoticeAssisted: add `ledgerBaseUrl` support with the standard fallback, for parity with RedactoNoticeConsent and RedactoNoticeConsentInline. When `ledgerBaseUrl` is set, the consent write is routed through `ledgerBaseUrl || baseUrl || BASE_URL` (only `submit-consent` moves to the ledger; the public notice / OTP / TTS endpoints stay on `baseUrl`). After OTP verification the widget also runs a ledger `check-consent` read and, if the principal has already fully consented, hands off via `onComplete` without writing a duplicate consent event — the ledger equivalent of the legacy Python 409 `CONSENT_ALREADY_PROVIDED`, which no longer fires once consent records live in the ledger. Without `ledgerBaseUrl` the behavior is unchanged (write to the legacy consent server, reactive 409-as-success). The ledger `check-consent` network read is now shared across all three notice components.
+
+### Patch Changes
+
+- 1a11423: RedactoNoticeConsentInline: detect already-consented principals via the Go ledger after the consent cutover. Previously the embedded widget only recognized an already-consented user through Python's 409 `CONSENT_ALREADY_PROVIDED` on `get-notice`; once consent records move to the ledger, Python stops returning that 409, so the widget would re-render the notice and could auto-submit a duplicate consent. When `ledgerBaseUrl` is configured (and outside the magic-link `specific_uuid` flow), the widget now runs the same ledger `check-consent` read the banner uses and short-circuits to the already-consented state, gating auto-submit until that read settles. Without `ledgerBaseUrl` the legacy Python-409 path is unchanged. The ledger `check-consent` read is now shared between `RedactoNoticeConsent` and `RedactoNoticeConsentInline`.
+
 ## 10.0.0-beta.4
 
 ### Patch Changes

package/README.md

@@ -249,6 +249,7 @@ A modal popup component for consent collection. Displays a full-screen modal wit
 | `accessToken`     | `string`                 | Yes      | -       | Authentication token for API calls  |
 | `refreshToken`    | `string`                 | Yes      | -       | Refresh token for token renewal     |
 | `baseUrl`         | `string`                 | No       | -       | Base URL for the consent API        |
+| `ledgerBaseUrl`   | `string`                 | No       | -       | Go ledger base URL. When set, consent writes and prior-consent checks route through the ledger (falls back: ledger → baseUrl → default). Omit to keep the legacy consent-server path. |
 | `blockUI`         | `boolean`                | No       | `true`  | Whether to block UI interaction     |
 | `language`        | `string`                 | No       | `"en"`  | Language code                       |
 | `settings`        | `object`                 | No       | -       | Custom styling options              |
@@ -335,6 +336,7 @@ The component automatically submits consent when all of the following conditions
 | `accessToken`        | `string`                     | No       | -       | Authentication token                   |
 | `refreshToken`       | `string`                     | No       | -       | Refresh token                          |
 | `baseUrl`            | `string`                     | No       | -       | Base URL for the consent API           |
+| `ledgerBaseUrl`      | `string`                     | No       | -       | Go ledger base URL. When set, consent writes and already-consented checks route through the ledger. Omit for legacy behavior. |
 | `language`           | `string`                     | No       | `"en"`  | Language code                          |
 | `settings`           | `object`                     | No       | -       | Custom styling options                 |
 | `applicationId`      | `string`                     | No       | -       | Application-specific UUID              |
@@ -365,6 +367,7 @@ A modal, agent-assisted consent widget for collecting consent from an end-user w
 | `workspaceUuid`    | `string`     | Yes      | -                        | Workspace UUID (path segment of the public notice endpoint)           |
 | `noticeUuid`       | `string`     | Yes      | -                        | Notice UUID to fetch and render                                       |
 | `baseUrl`          | `string`     | No       | Production consent API   | Base URL for the consent API                                          |
+| `ledgerBaseUrl`    | `string`     | No       | -                        | Go ledger base URL. When set, the consent write routes through the ledger (falls back: ledger → baseUrl → default). Notice fetch, OTP, and TTS always stay on `baseUrl`. Omit for legacy behavior. |
 | `onDecline`        | `() => void` | No       | Logs and resets the flow | Called when the agent/customer declines (host should unmount the modal) |
 | `onComplete`       | `() => void` | No       | Logs and resets the flow | Called when the agent clicks "Proceed" on the confirmed screen        |
 
@@ -761,6 +764,7 @@ import { RedactoPrivacyCenter } from "@redacto.io/consent-sdk-react/privacy-cent
 | Prop           | Type                                                                                                                       | Required | Default              | Description                                              |
 | -------------- | -------------------------------------------------------------------------------------------------------------------------- | -------- | -------------------- | -------------------------------------------------------- |
 | `baseUrl`      | `string`                                                                                                                   | Yes      | -                    | Consent server base URL                                  |
+| `ledgerBaseUrl` | `string`                                                                                                                  | No       | -                    | Go ledger base URL. When set, user consents, group purposes, receipts, and manage-consent route through the ledger, and the DSAR form's product picker is overlaid from ledger-served consents. Omit to use the legacy `/dsar/privacy-center/*` routes. |
 | `slug`         | `string`                                                                                                                   | Yes      | -                    | Workspace slug                                           |
 | `accessToken`  | `string`                                                                                                                   | Yes      | -                    | JWT access token                                         |
 | `refreshToken` | `string`                                                                                                                   | Yes      | -                    | JWT refresh token                                        |

package/dist/index.d.mts

@@ -139,6 +139,8 @@ type RedactoNoticeAssistedProps = {
     noticeUuid: string;
     /** API base URL (defaults to the production consent API). */
     baseUrl?: string;
+    /** Go ledger base URL — routes the consent write to the ledger; omit to use the legacy consent server. */
+    ledgerBaseUrl?: string;
     /** Called when the agent/customer declines (host should unmount the modal). */
     onDecline?: () => void;
     /** Called when the agent clicks "Proceed" on the confirmed screen. */
@@ -159,7 +161,7 @@ type RedactoNoticeAssistedProps = {
  * submit, `onComplete` fires immediately with no confirmation screen (mirroring
  * RedactoNoticeConsent's `onAccept`). Steps: `notice` → `verify` (with `otpSent`).
  */
-declare const RedactoNoticeAssisted: ({ organisationUuid, workspaceUuid, noticeUuid, baseUrl, onDecline, onComplete, }: RedactoNoticeAssistedProps) => react.JSX.Element;
+declare const RedactoNoticeAssisted: ({ organisationUuid, workspaceUuid, noticeUuid, baseUrl, ledgerBaseUrl, onDecline, onComplete, }: RedactoNoticeAssistedProps) => react.JSX.Element;
 
 /**
  * DigiLockerCallback Component

package/dist/index.d.ts

@@ -139,6 +139,8 @@ type RedactoNoticeAssistedProps = {
     noticeUuid: string;
     /** API base URL (defaults to the production consent API). */
     baseUrl?: string;
+    /** Go ledger base URL — routes the consent write to the ledger; omit to use the legacy consent server. */
+    ledgerBaseUrl?: string;
     /** Called when the agent/customer declines (host should unmount the modal). */
     onDecline?: () => void;
     /** Called when the agent clicks "Proceed" on the confirmed screen. */
@@ -159,7 +161,7 @@ type RedactoNoticeAssistedProps = {
  * submit, `onComplete` fires immediately with no confirmation screen (mirroring
  * RedactoNoticeConsent's `onAccept`). Steps: `notice` → `verify` (with `otpSent`).
  */
-declare const RedactoNoticeAssisted: ({ organisationUuid, workspaceUuid, noticeUuid, baseUrl, onDecline, onComplete, }: RedactoNoticeAssistedProps) => react.JSX.Element;
+declare const RedactoNoticeAssisted: ({ organisationUuid, workspaceUuid, noticeUuid, baseUrl, ledgerBaseUrl, onDecline, onComplete, }: RedactoNoticeAssistedProps) => react.JSX.Element;
 
 /**
  * DigiLockerCallback Component

package/dist/index.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(src_exports);
 var import_react2 = require("react");
 
 // src/RedactoNoticeConsent/api/index.ts
-var import_jwt_decode = require("jwt-decode");
+var import_jwt_decode2 = require("jwt-decode");
 
 // src/shared/api-errors.ts
 var ApiError = class extends Error {
@@ -92,6 +92,83 @@ async function parseApiError(response, fallbackMessage) {
   });
 }
 
+// src/shared/notice-consent-status.ts
+var import_jwt_decode = require("jwt-decode");
+var decodeNoticeConsentToken = (token) => {
+  try {
+    return (0, import_jwt_decode.jwtDecode)(token);
+  } catch {
+    return null;
+  }
+};
+var fetchNoticeConsentStatusForScope = async ({
+  accessToken,
+  ledgerBaseUrl,
+  organisationUuid,
+  workspaceUuid,
+  noticeUuid,
+  signal
+}) => {
+  if (!accessToken || !ledgerBaseUrl || !organisationUuid || !workspaceUuid || !noticeUuid) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `${ledgerBaseUrl}/public/organisations/${organisationUuid}/workspaces/${workspaceUuid}/notices/${noticeUuid}/check-consent`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: "{}",
+        signal
+      }
+    );
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const body = data && typeof data === "object" && "detail" in data && data.detail ? data.detail : data;
+    if (!body || !Array.isArray(body.purposes)) {
+      return null;
+    }
+    return body;
+  } catch {
+    return null;
+  }
+};
+var fetchNoticeConsentStatus = async ({
+  accessToken,
+  ledgerBaseUrl,
+  noticeUuid,
+  signal
+}) => {
+  if (!accessToken || !ledgerBaseUrl || !noticeUuid) {
+    return null;
+  }
+  const decodedToken = decodeNoticeConsentToken(accessToken);
+  if (!decodedToken) {
+    return null;
+  }
+  const {
+    organisation_uuid: ORGANISATION_UUID,
+    workspace_uuid: WORKSPACE_UUID
+  } = decodedToken;
+  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
+    return null;
+  }
+  return fetchNoticeConsentStatusForScope({
+    accessToken,
+    ledgerBaseUrl,
+    organisationUuid: ORGANISATION_UUID,
+    workspaceUuid: WORKSPACE_UUID,
+    noticeUuid,
+    signal
+  });
+};
+var isNoticeFullyConsented = (status) => status.consented && status.all_mandatory_active;
+
 // src/RedactoNoticeConsent/api/index.ts
 var BASE_URL = "https://api.redacto.io/consent";
 var apiCache = /* @__PURE__ */ new Map();
@@ -111,7 +188,7 @@ function setCachedData(key, data, ttl = CACHE_TTL) {
 }
 function decodeTokenSafely(token) {
   try {
-    return (0, import_jwt_decode.jwtDecode)(token);
+    return (0, import_jwt_decode2.jwtDecode)(token);
   } catch (error) {
     console.warn("Failed to decode JWT token:", error);
     return null;
@@ -249,49 +326,6 @@ var submitConsentEvent = async ({
   }
   apiCache.clear();
 };
-var fetchNoticeConsentStatus = async ({
-  accessToken,
-  ledgerBaseUrl,
-  noticeUuid,
-  signal
-}) => {
-  if (!accessToken || !ledgerBaseUrl || !noticeUuid) {
-    return null;
-  }
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    return null;
-  }
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    return null;
-  }
-  try {
-    const response = await fetch(
-      `${ledgerBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/check-consent`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json"
-        },
-        body: "{}",
-        signal
-      }
-    );
-    if (!response.ok) {
-      return null;
-    }
-    const data = await response.json();
-    const body = data && typeof data === "object" && "detail" in data && data.detail ? data.detail : data;
-    if (!body || !Array.isArray(body.purposes)) {
-      return null;
-    }
-    return body;
-  } catch {
-    return null;
-  }
-};
 var buildLedgerConsentOverlay = (status, configPurposes) => {
   var _a, _b;
   const byUuid = new Map(status.purposes.map((p) => [p.uuid, p]));
@@ -5250,6 +5284,9 @@ var RedactoConsentInlineComponent = ({
   const [selectedPurposes, setSelectedPurposes] = (0, import_react4.useState)({});
   const [selectedDataElements, setSelectedDataElements] = (0, import_react4.useState)({});
   const [hasAlreadyConsented, setHasAlreadyConsented] = (0, import_react4.useState)(false);
+  const [isCheckingConsent, setIsCheckingConsent] = (0, import_react4.useState)(
+    Boolean(ledgerBaseUrl) && !applicationId
+  );
   const [fetchError, setFetchError] = (0, import_react4.useState)(null);
   const [errorMessage, setErrorMessage] = (0, import_react4.useState)(null);
   const hasSubmittedRef = (0, import_react4.useRef)(false);
@@ -5392,6 +5429,38 @@ var RedactoConsentInlineComponent = ({
   (0, import_react4.useEffect)(() => {
     fetchNotice();
   }, [org_uuid, workspace_uuid, notice_uuid, language, applicationId]);
+  (0, import_react4.useEffect)(() => {
+    if (!ledgerBaseUrl || applicationId) {
+      return;
+    }
+    if (!accessToken || !content) {
+      return;
+    }
+    let active = true;
+    const controller = new AbortController();
+    const checkLedgerConsent = async () => {
+      try {
+        const ledgerStatus = await fetchNoticeConsentStatus({
+          accessToken,
+          ledgerBaseUrl,
+          noticeUuid: notice_uuid,
+          signal: controller.signal
+        });
+        if (active && ledgerStatus && isNoticeFullyConsented(ledgerStatus)) {
+          setHasAlreadyConsented(true);
+        }
+      } finally {
+        if (active) {
+          setIsCheckingConsent(false);
+        }
+      }
+    };
+    checkLedgerConsent();
+    return () => {
+      active = false;
+      controller.abort();
+    };
+  }, [ledgerBaseUrl, applicationId, accessToken, content, notice_uuid]);
   const togglePurposeCollapse = (purposeUuid) => {
     setCollapsedPurposes((prev) => ({
       ...prev,
@@ -5515,7 +5584,7 @@ var RedactoConsentInlineComponent = ({
     ]
   );
   (0, import_react4.useEffect)(() => {
-    if (accessToken && content && areAllRequiredElementsChecked && !isSubmitting && !hasSubmittedRef.current) {
+    if (accessToken && content && areAllRequiredElementsChecked && !isSubmitting && !isCheckingConsent && !hasAlreadyConsented && !hasSubmittedRef.current) {
       hasSubmittedRef.current = true;
       const autoSubmit = async () => {
         try {
@@ -5532,6 +5601,8 @@ var RedactoConsentInlineComponent = ({
     content,
     areAllRequiredElementsChecked,
     isSubmitting,
+    isCheckingConsent,
+    hasAlreadyConsented,
     handleAcceptWithToken
   ]);
   (0, import_react4.useEffect)(() => {
@@ -6792,6 +6863,7 @@ var submitAssistedConsent = async ({
   organisationUuid,
   workspaceUuid,
   baseUrl,
+  ledgerBaseUrl,
   noticeUuid,
   purposes,
   language,
@@ -6822,7 +6894,7 @@ var submitAssistedConsent = async ({
     declined: false,
     language: language || void 0
   };
-  const url = `${publicScope(baseUrl, organisationUuid, workspaceUuid)}/submit-consent`;
+  const url = `${publicScope(ledgerBaseUrl || baseUrl, organisationUuid, workspaceUuid)}/submit-consent`;
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -8257,6 +8329,7 @@ var RedactoNoticeAssisted = ({
   workspaceUuid,
   noticeUuid,
   baseUrl,
+  ledgerBaseUrl,
   onDecline,
   onComplete
 }) => {
@@ -8992,6 +9065,19 @@ var RedactoNoticeAssisted = ({
         return;
       }
       const token = verifyDetail.access_token;
+      if (ledgerBaseUrl) {
+        const ledgerStatus = await fetchNoticeConsentStatusForScope({
+          accessToken: token,
+          ledgerBaseUrl,
+          organisationUuid,
+          workspaceUuid,
+          noticeUuid: content.notice_uuid
+        });
+        if (ledgerStatus && isNoticeFullyConsented(ledgerStatus)) {
+          handleSuccess();
+          return;
+        }
+      }
       const submitPurposes = content.purposes.map((purpose) => ({
         ...purpose,
         selected: selectedPurposes[purpose.uuid] || false,
@@ -9005,6 +9091,7 @@ var RedactoNoticeAssisted = ({
         organisationUuid,
         workspaceUuid,
         baseUrl,
+        ledgerBaseUrl,
         noticeUuid: content.notice_uuid,
         purposes: submitPurposes,
         language: toBcp47Code(selectedLanguage)
@@ -9028,6 +9115,7 @@ var RedactoNoticeAssisted = ({
     otpUuid,
     otpValue,
     baseUrl,
+    ledgerBaseUrl,
     selectedPurposes,
     selectedDataElements,
     selectedLanguage,

package/dist/index.mjs

@@ -6,7 +6,7 @@ import {
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 // src/RedactoNoticeConsent/api/index.ts
-import { jwtDecode } from "jwt-decode";
+import { jwtDecode as jwtDecode2 } from "jwt-decode";
 
 // src/shared/api-errors.ts
 var ApiError = class extends Error {
@@ -66,6 +66,83 @@ async function parseApiError(response, fallbackMessage) {
   });
 }
 
+// src/shared/notice-consent-status.ts
+import { jwtDecode } from "jwt-decode";
+var decodeNoticeConsentToken = (token) => {
+  try {
+    return jwtDecode(token);
+  } catch {
+    return null;
+  }
+};
+var fetchNoticeConsentStatusForScope = async ({
+  accessToken,
+  ledgerBaseUrl,
+  organisationUuid,
+  workspaceUuid,
+  noticeUuid,
+  signal
+}) => {
+  if (!accessToken || !ledgerBaseUrl || !organisationUuid || !workspaceUuid || !noticeUuid) {
+    return null;
+  }
+  try {
+    const response = await fetch(
+      `${ledgerBaseUrl}/public/organisations/${organisationUuid}/workspaces/${workspaceUuid}/notices/${noticeUuid}/check-consent`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: "{}",
+        signal
+      }
+    );
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    const body = data && typeof data === "object" && "detail" in data && data.detail ? data.detail : data;
+    if (!body || !Array.isArray(body.purposes)) {
+      return null;
+    }
+    return body;
+  } catch {
+    return null;
+  }
+};
+var fetchNoticeConsentStatus = async ({
+  accessToken,
+  ledgerBaseUrl,
+  noticeUuid,
+  signal
+}) => {
+  if (!accessToken || !ledgerBaseUrl || !noticeUuid) {
+    return null;
+  }
+  const decodedToken = decodeNoticeConsentToken(accessToken);
+  if (!decodedToken) {
+    return null;
+  }
+  const {
+    organisation_uuid: ORGANISATION_UUID,
+    workspace_uuid: WORKSPACE_UUID
+  } = decodedToken;
+  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
+    return null;
+  }
+  return fetchNoticeConsentStatusForScope({
+    accessToken,
+    ledgerBaseUrl,
+    organisationUuid: ORGANISATION_UUID,
+    workspaceUuid: WORKSPACE_UUID,
+    noticeUuid,
+    signal
+  });
+};
+var isNoticeFullyConsented = (status) => status.consented && status.all_mandatory_active;
+
 // src/RedactoNoticeConsent/api/index.ts
 var BASE_URL = "https://api.redacto.io/consent";
 var apiCache = /* @__PURE__ */ new Map();
@@ -85,7 +162,7 @@ function setCachedData(key, data, ttl = CACHE_TTL) {
 }
 function decodeTokenSafely(token) {
   try {
-    return jwtDecode(token);
+    return jwtDecode2(token);
   } catch (error) {
     console.warn("Failed to decode JWT token:", error);
     return null;
@@ -223,49 +300,6 @@ var submitConsentEvent = async ({
   }
   apiCache.clear();
 };
-var fetchNoticeConsentStatus = async ({
-  accessToken,
-  ledgerBaseUrl,
-  noticeUuid,
-  signal
-}) => {
-  if (!accessToken || !ledgerBaseUrl || !noticeUuid) {
-    return null;
-  }
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    return null;
-  }
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    return null;
-  }
-  try {
-    const response = await fetch(
-      `${ledgerBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/check-consent`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json"
-        },
-        body: "{}",
-        signal
-      }
-    );
-    if (!response.ok) {
-      return null;
-    }
-    const data = await response.json();
-    const body = data && typeof data === "object" && "detail" in data && data.detail ? data.detail : data;
-    if (!body || !Array.isArray(body.purposes)) {
-      return null;
-    }
-    return body;
-  } catch {
-    return null;
-  }
-};
 var buildLedgerConsentOverlay = (status, configPurposes) => {
   var _a, _b;
   const byUuid = new Map(status.purposes.map((p) => [p.uuid, p]));
@@ -5197,6 +5231,9 @@ var RedactoConsentInlineComponent = ({
   const [selectedPurposes, setSelectedPurposes] = useState3({});
   const [selectedDataElements, setSelectedDataElements] = useState3({});
   const [hasAlreadyConsented, setHasAlreadyConsented] = useState3(false);
+  const [isCheckingConsent, setIsCheckingConsent] = useState3(
+    Boolean(ledgerBaseUrl) && !applicationId
+  );
   const [fetchError, setFetchError] = useState3(null);
   const [errorMessage, setErrorMessage] = useState3(null);
   const hasSubmittedRef = useRef2(false);
@@ -5339,6 +5376,38 @@ var RedactoConsentInlineComponent = ({
   useEffect3(() => {
     fetchNotice();
   }, [org_uuid, workspace_uuid, notice_uuid, language, applicationId]);
+  useEffect3(() => {
+    if (!ledgerBaseUrl || applicationId) {
+      return;
+    }
+    if (!accessToken || !content) {
+      return;
+    }
+    let active = true;
+    const controller = new AbortController();
+    const checkLedgerConsent = async () => {
+      try {
+        const ledgerStatus = await fetchNoticeConsentStatus({
+          accessToken,
+          ledgerBaseUrl,
+          noticeUuid: notice_uuid,
+          signal: controller.signal
+        });
+        if (active && ledgerStatus && isNoticeFullyConsented(ledgerStatus)) {
+          setHasAlreadyConsented(true);
+        }
+      } finally {
+        if (active) {
+          setIsCheckingConsent(false);
+        }
+      }
+    };
+    checkLedgerConsent();
+    return () => {
+      active = false;
+      controller.abort();
+    };
+  }, [ledgerBaseUrl, applicationId, accessToken, content, notice_uuid]);
   const togglePurposeCollapse = (purposeUuid) => {
     setCollapsedPurposes((prev) => ({
       ...prev,
@@ -5462,7 +5531,7 @@ var RedactoConsentInlineComponent = ({
     ]
   );
   useEffect3(() => {
-    if (accessToken && content && areAllRequiredElementsChecked && !isSubmitting && !hasSubmittedRef.current) {
+    if (accessToken && content && areAllRequiredElementsChecked && !isSubmitting && !isCheckingConsent && !hasAlreadyConsented && !hasSubmittedRef.current) {
       hasSubmittedRef.current = true;
       const autoSubmit = async () => {
         try {
@@ -5479,6 +5548,8 @@ var RedactoConsentInlineComponent = ({
     content,
     areAllRequiredElementsChecked,
     isSubmitting,
+    isCheckingConsent,
+    hasAlreadyConsented,
     handleAcceptWithToken
   ]);
   useEffect3(() => {
@@ -6739,6 +6810,7 @@ var submitAssistedConsent = async ({
   organisationUuid,
   workspaceUuid,
   baseUrl,
+  ledgerBaseUrl,
   noticeUuid,
   purposes,
   language,
@@ -6769,7 +6841,7 @@ var submitAssistedConsent = async ({
     declined: false,
     language: language || void 0
   };
-  const url = `${publicScope(baseUrl, organisationUuid, workspaceUuid)}/submit-consent`;
+  const url = `${publicScope(ledgerBaseUrl || baseUrl, organisationUuid, workspaceUuid)}/submit-consent`;
   const response = await fetch(url, {
     method: "POST",
     headers: {
@@ -8204,6 +8276,7 @@ var RedactoNoticeAssisted = ({
   workspaceUuid,
   noticeUuid,
   baseUrl,
+  ledgerBaseUrl,
   onDecline,
   onComplete
 }) => {
@@ -8939,6 +9012,19 @@ var RedactoNoticeAssisted = ({
         return;
       }
       const token = verifyDetail.access_token;
+      if (ledgerBaseUrl) {
+        const ledgerStatus = await fetchNoticeConsentStatusForScope({
+          accessToken: token,
+          ledgerBaseUrl,
+          organisationUuid,
+          workspaceUuid,
+          noticeUuid: content.notice_uuid
+        });
+        if (ledgerStatus && isNoticeFullyConsented(ledgerStatus)) {
+          handleSuccess();
+          return;
+        }
+      }
       const submitPurposes = content.purposes.map((purpose) => ({
         ...purpose,
         selected: selectedPurposes[purpose.uuid] || false,
@@ -8952,6 +9038,7 @@ var RedactoNoticeAssisted = ({
         organisationUuid,
         workspaceUuid,
         baseUrl,
+        ledgerBaseUrl,
         noticeUuid: content.notice_uuid,
         purposes: submitPurposes,
         language: toBcp47Code(selectedLanguage)
@@ -8975,6 +9062,7 @@ var RedactoNoticeAssisted = ({
     otpUuid,
     otpValue,
     baseUrl,
+    ledgerBaseUrl,
     selectedPurposes,
     selectedDataElements,
     selectedLanguage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redacto.io/consent-sdk-react",
-  "version": "10.0.0-beta.4",
+  "version": "10.0.0-beta.6",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",

package/src/RedactoNoticeAssisted/RedactoNoticeAssisted.test.tsx

@@ -18,6 +18,7 @@ import {
 } from "./api";
 import type { ConsentContent, TTSAudioUrlsResponse } from "./api/types";
 import { ApiError } from "../shared/api-errors";
+import { fetchNoticeConsentStatusForScope } from "../shared/notice-consent-status";
 import { makeStaticT } from "./i18n";
 
 vi.mock("./api", () => ({
@@ -28,12 +29,26 @@ vi.mock("./api", () => ({
   submitAssistedConsent: vi.fn(),
 }));
 
+// Mock only the ledger check-consent network read; keep the real
+// isNoticeFullyConsented predicate so the already-consented decision is exercised.
+vi.mock("../shared/notice-consent-status", async (importActual) => {
+  const actual =
+    await importActual<typeof import("../shared/notice-consent-status")>();
+  return {
+    ...actual,
+    fetchNoticeConsentStatusForScope: vi.fn(),
+  };
+});
+
+const LEDGER_BASE_URL = "https://ledger.example.test/consent-ledger";
+
 const otpLength = ASSISTED_CONFIG.otpLength;
 const mockedFetch = vi.mocked(fetchAssistedNotice);
 const mockedFetchTTS = vi.mocked(fetchAssistedTTSAudioUrls);
 const mockedCreateOtp = vi.mocked(createOtp);
 const mockedVerifyOtp = vi.mocked(verifyOtp);
 const mockedSubmitConsent = vi.mocked(submitAssistedConsent);
+const mockedFetchScope = vi.mocked(fetchNoticeConsentStatusForScope);
 
 const OTP_DETAIL = {
   uuid: "otp-1",
@@ -226,6 +241,9 @@ describe("RedactoNoticeAssisted", () => {
     mockedCreateOtp.mockResolvedValue(OTP_DETAIL);
     mockedVerifyOtp.mockResolvedValue(VERIFY_DETAIL);
     mockedSubmitConsent.mockResolvedValue(null);
+    // Default: ledger reports no prior full consent, so flows proceed to submit.
+    mockedFetchScope.mockReset();
+    mockedFetchScope.mockResolvedValue(null);
   });
 
   it("fetches with the public-notice props (no auth)", async () => {
@@ -604,6 +622,75 @@ describe("RedactoNoticeAssisted", () => {
     ).not.toBeInTheDocument();
   });
 
+  // ── Go ledger (ledgerBaseUrl) ─────────────────────────────────────────────
+  // Drives the full notice → OTP → Confirm flow with a notice that carries a
+  // notice_uuid (so the check-consent read runs), and returns the onComplete spy.
+  const runConfirmFlow = async (extraProps: Record<string, unknown>) => {
+    mockedFetch.mockResolvedValue(NOTICE_WITH_AUDIO);
+    const onComplete = vi.fn();
+    render(
+      <RedactoNoticeAssisted {...PROPS} onComplete={onComplete} {...extraProps} />,
+    );
+    await screen.findByRole("heading", { name: "EA Sports" });
+    selectRequired();
+    fireEvent.click(screen.getByRole("button", { name: "Agree" }));
+    fireEvent.change(screen.getByLabelText("Mobile number"), {
+      target: { value: "9876543210" },
+    });
+    fireEvent.click(screen.getByRole("button", { name: "Send OTP" }));
+    await screen.findByText(/OTP sent to/);
+    typeOtp("1".repeat(otpLength));
+    fireEvent.click(screen.getByRole("button", { name: "Confirm OTP" }));
+    return onComplete;
+  };
+
+  it("routes the write through ledgerBaseUrl and submits when not already consented", async () => {
+    const onComplete = await runConfirmFlow({ ledgerBaseUrl: LEDGER_BASE_URL });
+
+    await waitFor(() => expect(mockedSubmitConsent).toHaveBeenCalledTimes(1));
+    // The check-consent read runs with props org/workspace + the OTP token.
+    expect(mockedFetchScope).toHaveBeenCalledWith(
+      expect.objectContaining({
+        accessToken: "access-token-1",
+        ledgerBaseUrl: LEDGER_BASE_URL,
+        organisationUuid: "org-1",
+        workspaceUuid: "ws-1",
+        noticeUuid: "ntc-1",
+      }),
+    );
+    // The submit carries ledgerBaseUrl so the api layer routes it to the ledger.
+    expect(mockedSubmitConsent).toHaveBeenCalledWith(
+      expect.objectContaining({ ledgerBaseUrl: LEDGER_BASE_URL }),
+    );
+    await waitFor(() => expect(onComplete).toHaveBeenCalledTimes(1));
+  });
+
+  it("short-circuits an already fully-consented principal via the ledger (no submit)", async () => {
+    mockedFetchScope.mockResolvedValue({
+      consented: true,
+      all_mandatory_active: true,
+      purposes: [],
+    });
+    const onComplete = await runConfirmFlow({ ledgerBaseUrl: LEDGER_BASE_URL });
+
+    await waitFor(() => expect(onComplete).toHaveBeenCalledTimes(1));
+    expect(mockedSubmitConsent).not.toHaveBeenCalled();
+  });
+
+  it("skips the ledger check-consent and stays on baseUrl when ledgerBaseUrl is absent", async () => {
+    const onComplete = await runConfirmFlow({});
+
+    await waitFor(() => expect(mockedSubmitConsent).toHaveBeenCalledTimes(1));
+    expect(mockedFetchScope).not.toHaveBeenCalled();
+    expect(mockedSubmitConsent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        ledgerBaseUrl: undefined,
+        baseUrl: "https://api.example.test/consent",
+      }),
+    );
+    await waitFor(() => expect(onComplete).toHaveBeenCalledTimes(1));
+  });
+
   // The verify endpoint returns English copy with no error_code, so the SDK
   // localizes by HTTP status + the `should_request_new` flag instead of echoing
   // the server message.

package/src/RedactoNoticeAssisted/RedactoNoticeAssisted.tsx

@@ -23,6 +23,10 @@ import type {
   TTSAudioUrlsResponse,
 } from "./api/types";
 import { ApiError } from "../shared/api-errors";
+import {
+  fetchNoticeConsentStatusForScope,
+  isNoticeFullyConsented,
+} from "../shared/notice-consent-status";
 import {
   toNativeLabel,
   toBcp47Code,
@@ -251,6 +255,7 @@ export const RedactoNoticeAssisted = ({
   workspaceUuid,
   noticeUuid,
   baseUrl,
+  ledgerBaseUrl,
   onDecline,
   onComplete,
 }: RedactoNoticeAssistedProps) => {
@@ -1207,6 +1212,26 @@ export const RedactoNoticeAssisted = ({
       }
       const token = verifyDetail.access_token;
 
+      // Post-cutover, consent records live in the Go ledger, so Python's 409
+      // CONSENT_ALREADY_PROVIDED can no longer be relied on. When a ledger is
+      // configured, ask it directly (org/workspace from props, OTP token as
+      // bearer) whether this principal has already fully consented and, if so,
+      // hand off without writing a duplicate consent event. Any failure returns
+      // null and falls through to the normal submit (graceful degradation).
+      if (ledgerBaseUrl) {
+        const ledgerStatus = await fetchNoticeConsentStatusForScope({
+          accessToken: token,
+          ledgerBaseUrl,
+          organisationUuid,
+          workspaceUuid,
+          noticeUuid: content.notice_uuid,
+        });
+        if (ledgerStatus && isNoticeFullyConsented(ledgerStatus)) {
+          handleSuccess();
+          return;
+        }
+      }
+
       // Map current selection onto the submit payload shape (required → selected).
       const submitPurposes = content.purposes.map((purpose) => ({
         ...purpose,
@@ -1224,6 +1249,7 @@ export const RedactoNoticeAssisted = ({
         organisationUuid,
         workspaceUuid,
         baseUrl,
+        ledgerBaseUrl,
         noticeUuid: content.notice_uuid,
         purposes: submitPurposes,
         language: toBcp47Code(selectedLanguage),
@@ -1255,6 +1281,7 @@ export const RedactoNoticeAssisted = ({
     otpUuid,
     otpValue,
     baseUrl,
+    ledgerBaseUrl,
     selectedPurposes,
     selectedDataElements,
     selectedLanguage,

package/src/RedactoNoticeAssisted/api/index.ts

@@ -160,6 +160,7 @@ export const submitAssistedConsent = async ({
   organisationUuid,
   workspaceUuid,
   baseUrl,
+  ledgerBaseUrl,
   noticeUuid,
   purposes,
   language,
@@ -196,7 +197,12 @@ export const submitAssistedConsent = async ({
     language: language || undefined,
   };
 
-  const url = `${publicScope(baseUrl, organisationUuid, workspaceUuid)}/submit-consent`;
+  // Route the write to the Go ledger when configured, else the legacy consent
+  // server. publicScope already applies `|| BASE_URL`, so this yields the
+  // standard `ledgerBaseUrl || baseUrl || BASE_URL` fallback used by the other
+  // notice components. Only submit-consent routes to the ledger; notice/OTP/TTS
+  // stay on baseUrl.
+  const url = `${publicScope(ledgerBaseUrl || baseUrl, organisationUuid, workspaceUuid)}/submit-consent`;
 
   const response = await fetch(url, {
     method: "POST",

package/src/RedactoNoticeAssisted/api/types.ts

@@ -94,6 +94,8 @@ export type SubmitAssistedConsentParams = {
   organisationUuid: string;
   workspaceUuid: string;
   baseUrl?: string;
+  /** Go ledger base URL — routes the write to the ledger; omit to use the legacy consent server. */
+  ledgerBaseUrl?: string;
   /** `notice_uuid` from the fetched active_config. */
   noticeUuid: string;
   /** Purposes carrying their current `selected` state + data elements. */

package/src/RedactoNoticeAssisted/types.ts

@@ -17,6 +17,8 @@ export type RedactoNoticeAssistedProps = {
   noticeUuid: string;
   /** API base URL (defaults to the production consent API). */
   baseUrl?: string;
+  /** Go ledger base URL — routes the consent write to the ledger; omit to use the legacy consent server. */
+  ledgerBaseUrl?: string;
   /** Called when the agent/customer declines (host should unmount the modal). */
   onDecline?: () => void;
   /** Called when the agent clicks "Proceed" on the confirmed screen. */

package/src/RedactoNoticeConsent/api/index.ts

@@ -5,7 +5,6 @@ import type {
   ConsentEventPayload,
   DataElementSelection,
   FetchConsentContentParams,
-  FetchNoticeConsentStatusParams,
   FetchTTSAudioUrlsParams,
   InitiateGuardianVerificationParams,
   InitiateGuardianVerificationResponse,
@@ -18,6 +17,11 @@ import type {
   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
@@ -216,71 +220,6 @@ export const submitConsentEvent = async ({
   apiCache.clear();
 };
 
-/**
- * Fetch the principal's current consent status for a notice from the Go
- * ledger (`check-consent`). The principal resolves from the JWT, so the body
- * is empty. Returns null on any failure so the caller can fall back to the
- * Python-provided overlay (graceful degradation). This is how the banner
- * learns prior-consent / reconsent state post-cutover, since Python's notice
- * validation reads its own (now-empty) consent DB.
- */
-export const fetchNoticeConsentStatus = async ({
-  accessToken,
-  ledgerBaseUrl,
-  noticeUuid,
-  signal,
-}: FetchNoticeConsentStatusParams): Promise<NoticeConsentStatusResponse | null> => {
-  if (!accessToken || !ledgerBaseUrl || !noticeUuid) {
-    return null;
-  }
-
-  const decodedToken = decodeTokenSafely(accessToken);
-  if (!decodedToken) {
-    return null;
-  }
-
-  const { organisation_uuid: ORGANISATION_UUID, workspace_uuid: WORKSPACE_UUID } = decodedToken;
-  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
-    return null;
-  }
-
-  try {
-    const response = await fetch(
-      `${ledgerBaseUrl}/public/organisations/${ORGANISATION_UUID}/workspaces/${WORKSPACE_UUID}/notices/${noticeUuid}/check-consent`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${accessToken}`,
-          "Content-Type": "application/json",
-        },
-        body: "{}",
-        signal,
-      }
-    );
-
-    if (!response.ok) {
-      return null;
-    }
-
-    const data = (await response.json()) as
-      | NoticeConsentStatusResponse
-      | { detail?: NoticeConsentStatusResponse };
-    // The ledger returns the response directly; tolerate a {detail} envelope too.
-    const body =
-      data && typeof data === "object" && "detail" in data && data.detail
-        ? data.detail
-        : (data as NoticeConsentStatusResponse);
-
-    if (!body || !Array.isArray(body.purposes)) {
-      return null;
-    }
-    return body;
-  } catch {
-    // Network / abort / parse failure — degrade to the Python overlay.
-    return null;
-  }
-};
-
 /**
  * Translate the ledger's notice consent status into the
  * `{ purpose_selections, reconsent_required }` shape the banner already

package/src/RedactoNoticeConsent/api/types.ts

@@ -20,36 +20,15 @@ export type DataElementSelection = {
 };
 
 // ─── Ledger notice check-consent ────────────────────────────────────────────
-// Mirrors the Go ledger's `NoticeConsentStatusResponse`. Used to overlay the
-// banner's prior-consent / reconsent state from the ledger, since Python's
-// notice-validation overlay is empty after the consent cutover.
-export type NoticeConsentStatusDataElement = {
-  uuid: string;
-  name: string;
-  selected: boolean;
-};
-
-export type NoticeConsentStatusPurpose = {
-  uuid: string;
-  name: string;
-  selected: boolean;
-  status: string; // ACTIVE | EXPIRED | WITHDRAW | DECLINED | INACTIVE
-  expiry_datetime?: string | null;
-  data_elements: NoticeConsentStatusDataElement[];
-};
-
-export type NoticeConsentStatusResponse = {
-  consented: boolean;
-  all_mandatory_active: boolean;
-  purposes: NoticeConsentStatusPurpose[];
-};
-
-export type FetchNoticeConsentStatusParams = {
-  accessToken: string;
-  ledgerBaseUrl?: string;
-  noticeUuid: string;
-  signal?: AbortSignal;
-};
+// These types moved to the shared module so the banner and the inline widget
+// consume one definition; re-exported here so existing `./types` importers
+// keep working unchanged.
+export type {
+  FetchNoticeConsentStatusParams,
+  NoticeConsentStatusDataElement,
+  NoticeConsentStatusPurpose,
+  NoticeConsentStatusResponse,
+} from "../../shared/notice-consent-status";
 
 export type ConsentContent = {
   code: number;

package/src/RedactoNoticeConsentInline/RedactoNoticeConsentInline.tsx

@@ -1,5 +1,9 @@
 import { useEffect, useMemo, useState, useRef, useCallback, memo } from "react";
 import { fetchConsentContent, submitConsentEvent } from "./api";
+import {
+  fetchNoticeConsentStatus,
+  isNoticeFullyConsented,
+} from "../shared/notice-consent-status";
 import type { ConsentContent } from "./api/types";
 import type { Props, TranslationObject } from "./types";
 import { styles } from "./styles";
@@ -36,6 +40,14 @@ const RedactoConsentInlineComponent = ({
     Record<string, boolean>
   >({});
   const [hasAlreadyConsented, setHasAlreadyConsented] = useState(false);
+  // When a ledger is configured, block the auto-submit effect until the ledger
+  // check-consent read settles, so an already-consented principal is not
+  // re-submitted. Starts true only when a ledger check will actually run
+  // (skipped for the magic-link specific_uuid flow); stays false otherwise so
+  // the legacy Python-409 path is unaffected.
+  const [isCheckingConsent, setIsCheckingConsent] = useState<boolean>(
+    Boolean(ledgerBaseUrl) && !applicationId
+  );
   const [fetchError, setFetchError] = useState<Error | null>(null);
   const [errorMessage, setErrorMessage] = useState<string | null>(null);
 
@@ -220,6 +232,45 @@ const RedactoConsentInlineComponent = ({
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [org_uuid, workspace_uuid, notice_uuid, language, applicationId]);
 
+  // Post-cutover, consent records live in the Go ledger, so Python's
+  // get-notice no longer returns 409 CONSENT_ALREADY_PROVIDED. When a ledger
+  // is configured, ask it directly whether this principal has already fully
+  // consented — the same check-consent read the banner uses. Skipped for the
+  // magic-link specific_uuid flow (which always re-submits against a specific
+  // application) and when no ledger is set (the legacy 409 path governs).
+  useEffect(() => {
+    if (!ledgerBaseUrl || applicationId) {
+      return;
+    }
+    if (!accessToken || !content) {
+      return;
+    }
+    let active = true;
+    const controller = new AbortController();
+    const checkLedgerConsent = async () => {
+      try {
+        const ledgerStatus = await fetchNoticeConsentStatus({
+          accessToken,
+          ledgerBaseUrl,
+          noticeUuid: notice_uuid,
+          signal: controller.signal,
+        });
+        if (active && ledgerStatus && isNoticeFullyConsented(ledgerStatus)) {
+          setHasAlreadyConsented(true);
+        }
+      } finally {
+        if (active) {
+          setIsCheckingConsent(false);
+        }
+      }
+    };
+    checkLedgerConsent();
+    return () => {
+      active = false;
+      controller.abort();
+    };
+  }, [ledgerBaseUrl, applicationId, accessToken, content, notice_uuid]);
+
   const togglePurposeCollapse = (purposeUuid: string) => {
     setCollapsedPurposes((prev) => ({
       ...prev,
@@ -392,13 +443,18 @@ const RedactoConsentInlineComponent = ({
     ]
   );
 
-  // Auto-submit consent when all conditions are met
+  // Auto-submit consent when all conditions are met. Waits for the ledger
+  // check-consent read to settle (isCheckingConsent) and never fires for an
+  // already-consented principal, so the cutover cannot trigger a duplicate
+  // submission.
   useEffect(() => {
     if (
       accessToken &&
       content &&
       areAllRequiredElementsChecked &&
       !isSubmitting &&
+      !isCheckingConsent &&
+      !hasAlreadyConsented &&
       !hasSubmittedRef.current
     ) {
       hasSubmittedRef.current = true;
@@ -417,6 +473,8 @@ const RedactoConsentInlineComponent = ({
     content,
     areAllRequiredElementsChecked,
     isSubmitting,
+    isCheckingConsent,
+    hasAlreadyConsented,
     handleAcceptWithToken,
   ]);
 

package/src/shared/notice-consent-status.ts

@@ -0,0 +1,190 @@
+import { jwtDecode } from "jwt-decode";
+
+/**
+ * Shared Go-ledger notice `check-consent` read for the consent-sdk-react
+ * package.
+ *
+ * Post-cutover, consent records live in the Go ledger, so the Python
+ * `get-notice` endpoint no longer knows whether a principal has already
+ * consented (it used to answer that with a 409 `CONSENT_ALREADY_PROVIDED`).
+ * Both the banner (`RedactoNoticeConsent`) and the embedded widget
+ * (`RedactoNoticeConsentInline`) ask the ledger directly instead — this module
+ * is the single implementation they share.
+ *
+ * Every failure mode (no ledger configured, undecodable token, non-OK
+ * response, network/abort/parse error) degrades to `null` so callers can fall
+ * back to the legacy Python-driven flow.
+ */
+
+type NoticeConsentJwtPayload = {
+  organisation_uuid: string;
+  workspace_uuid: string;
+};
+
+// Mirrors the Go ledger's `NoticeConsentStatusResponse`. Used to overlay the
+// prior-consent / reconsent state from the ledger, since Python's
+// notice-validation overlay is empty after the consent cutover.
+export type NoticeConsentStatusDataElement = {
+  uuid: string;
+  name: string;
+  selected: boolean;
+};
+
+export type NoticeConsentStatusPurpose = {
+  uuid: string;
+  name: string;
+  selected: boolean;
+  status: string; // ACTIVE | EXPIRED | WITHDRAW | DECLINED | INACTIVE
+  expiry_datetime?: string | null;
+  data_elements: NoticeConsentStatusDataElement[];
+};
+
+export type NoticeConsentStatusResponse = {
+  consented: boolean;
+  all_mandatory_active: boolean;
+  purposes: NoticeConsentStatusPurpose[];
+};
+
+export type FetchNoticeConsentStatusParams = {
+  accessToken: string;
+  ledgerBaseUrl?: string;
+  noticeUuid: string;
+  signal?: AbortSignal;
+};
+
+// Same read, but with org/workspace supplied explicitly instead of decoded from
+// the JWT. Used by flows that already hold authoritative org/workspace (props)
+// and whose token may be opaque — e.g. RedactoNoticeAssisted, whose OTP access
+// token carries no org/workspace claims.
+export type FetchNoticeConsentStatusForScopeParams = {
+  accessToken: string;
+  ledgerBaseUrl?: string;
+  organisationUuid: string;
+  workspaceUuid: string;
+  noticeUuid: string;
+  signal?: AbortSignal;
+};
+
+// Decode the JWT to resolve the org/workspace the ledger path is scoped to.
+// Returns null on any decode failure so the caller degrades gracefully.
+const decodeNoticeConsentToken = (
+  token: string
+): NoticeConsentJwtPayload | null => {
+  try {
+    return jwtDecode(token) as NoticeConsentJwtPayload;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Fetch the principal's current consent status for a notice from the Go
+ * ledger (`check-consent`), with org/workspace supplied explicitly. The
+ * principal resolves from the bearer token server-side, so the body is empty.
+ * Returns null on any failure so the caller can fall back to the Python-driven
+ * flow (graceful degradation). This holds the single network implementation;
+ * {@link fetchNoticeConsentStatus} decodes the JWT and delegates here.
+ */
+export const fetchNoticeConsentStatusForScope = async ({
+  accessToken,
+  ledgerBaseUrl,
+  organisationUuid,
+  workspaceUuid,
+  noticeUuid,
+  signal,
+}: FetchNoticeConsentStatusForScopeParams): Promise<NoticeConsentStatusResponse | null> => {
+  if (
+    !accessToken ||
+    !ledgerBaseUrl ||
+    !organisationUuid ||
+    !workspaceUuid ||
+    !noticeUuid
+  ) {
+    return null;
+  }
+
+  try {
+    const response = await fetch(
+      `${ledgerBaseUrl}/public/organisations/${organisationUuid}/workspaces/${workspaceUuid}/notices/${noticeUuid}/check-consent`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json",
+        },
+        body: "{}",
+        signal,
+      }
+    );
+
+    if (!response.ok) {
+      return null;
+    }
+
+    const data = (await response.json()) as
+      | NoticeConsentStatusResponse
+      | { detail?: NoticeConsentStatusResponse };
+    // The ledger returns the response directly; tolerate a {detail} envelope too.
+    const body =
+      data && typeof data === "object" && "detail" in data && data.detail
+        ? data.detail
+        : (data as NoticeConsentStatusResponse);
+
+    if (!body || !Array.isArray(body.purposes)) {
+      return null;
+    }
+    return body;
+  } catch {
+    // Network / abort / parse failure — degrade to the Python-driven flow.
+    return null;
+  }
+};
+
+/**
+ * Fetch the principal's current consent status for a notice from the Go
+ * ledger (`check-consent`). The org/workspace are resolved by decoding the
+ * JWT. Returns null on any failure so the caller can fall back to the
+ * Python-provided overlay (graceful degradation).
+ */
+export const fetchNoticeConsentStatus = async ({
+  accessToken,
+  ledgerBaseUrl,
+  noticeUuid,
+  signal,
+}: FetchNoticeConsentStatusParams): Promise<NoticeConsentStatusResponse | null> => {
+  if (!accessToken || !ledgerBaseUrl || !noticeUuid) {
+    return null;
+  }
+
+  const decodedToken = decodeNoticeConsentToken(accessToken);
+  if (!decodedToken) {
+    return null;
+  }
+
+  const {
+    organisation_uuid: ORGANISATION_UUID,
+    workspace_uuid: WORKSPACE_UUID,
+  } = decodedToken;
+  if (!ORGANISATION_UUID || !WORKSPACE_UUID) {
+    return null;
+  }
+
+  return fetchNoticeConsentStatusForScope({
+    accessToken,
+    ledgerBaseUrl,
+    organisationUuid: ORGANISATION_UUID,
+    workspaceUuid: WORKSPACE_UUID,
+    noticeUuid,
+    signal,
+  });
+};
+
+/**
+ * Whether the principal has already fully consented to this notice with no
+ * reconsent needed — the ledger equivalent of Python's 409
+ * `CONSENT_ALREADY_PROVIDED`. Requires an active consent record with every
+ * mandatory purpose still ACTIVE.
+ */
+export const isNoticeFullyConsented = (
+  status: NoticeConsentStatusResponse
+): boolean => status.consented && status.all_mandatory_active;