@coinbase/cdp-api-client 0.0.119 → 0.0.121

package/dist/esm/index3.js

@@ -1,2 +1,2 @@
-import { __require as r } from "./index17.js";
+import { __require as r } from "./index12.js";
 r();

package/dist/esm/index4.js

@@ -1,4 +1,4 @@
-const o = "0.0.119";
+const o = "0.0.121";
 export {
   o as VERSION
 };

package/dist/esm/index6.js

@@ -1,287 +1,302 @@
-import { Analytics as i } from "./index2.js";
+import { Analytics as d } from "./index2.js";
 import "./index3.js";
-import p from "axios";
-import { ERROR_DOCS_PAGE_URL as h } from "./index9.js";
-import { UnknownApiError as g, HttpErrorType as d, isOpenAPIError as y, APIError as l, UnknownError as T } from "./index7.js";
-const v = () => typeof window < "u" && typeof document < "u";
-let n = p.create({
+import w from "axios";
+import { ERROR_DOCS_PAGE_URL as m } from "./index9.js";
+import { isRefreshTokenUnavailableError as y, UnknownApiError as T, HttpErrorType as p, isOpenAPIError as P, APIError as f, UnknownError as S, RefreshTokenUnavailableError as v } from "./index7.js";
+const k = () => typeof window < "u" && typeof document < "u";
+let n = w.create({
   baseURL: "https://api.cdp.coinbase.com/platform"
-}), c = null;
-const N = (t) => {
-  if (n = p.create({
-    baseURL: t.basePath || "https://api.cdp.coinbase.com/platform",
+}), h = null;
+const B = (e) => {
+  if (n = w.create({
+    baseURL: e.basePath || "https://api.cdp.coinbase.com/platform",
     // Only enable cookies in browser environments where they're supported
-    withCredentials: v()
+    withCredentials: k()
   }), n.interceptors.request.use(async (r) => {
-    const e = C(r), s = w(r);
-    if (!c || _(s.pathname) || A(s.pathname) && !await c.isSignedIn() || !O(s.pathname))
+    const t = L(r), s = R(r);
+    if (!h || _(s.pathname) || A(s.pathname) && !await h.isSignedIn() || !X(s.pathname))
       return r;
-    const a = await c.getXWalletAuth({
-      requestMethod: e,
+    const a = await h.getXWalletAuth({
+      requestMethod: t,
       requestHost: s.host,
       requestPath: s.pathname,
       requestData: r.data
     });
     return a && (r.headers["X-Wallet-Auth"] = a), r;
   }), n.interceptors.request.use(async (r) => {
-    const e = w(r);
-    if (!c || _(e.pathname) || A(e.pathname) && !await c.isSignedIn())
+    const t = R(r);
+    if (!h || _(t.pathname) || A(t.pathname) && !await h.isSignedIn())
       return r;
-    const s = await c.getToken();
+    const s = await h.getToken();
     return s && s !== "" && (r.headers.Authorization = `Bearer ${s}`), r;
-  }), !v()) {
-    const r = t.platform ? `CDP/reactnative/${t.platform}` : "CDP/reactnative";
-    n.interceptors.request.use(async (e) => {
-      let s = e.headers["User-Agent"];
-      return s = s ? `${s} ${r}` : r, e.headers["User-Agent"] = s, e;
+  }), !k()) {
+    const r = e.platform ? `CDP/reactnative/${e.platform}` : "CDP/reactnative";
+    n.interceptors.request.use(async (t) => {
+      let s = t.headers["User-Agent"];
+      return s = s ? `${s} ${r}` : r, t.headers["User-Agent"] = s, t;
     });
   }
-  t.refreshTokenStorage && U(t.refreshTokenStorage, t.retryTokenReads ?? !1), t.appAttestation && P(t.appAttestation, t.platform), t.debugging && (n.interceptors.request.use((r) => (console.log("Request:", r), r)), n.interceptors.response.use((r) => (console.log("Response:", r), r)));
-}, z = (t) => {
-  c = t;
-}, P = (t, r) => {
-  n.interceptors.request.use(async (e) => {
-    const s = w(e);
-    if (!x(s.pathname) || !t.isEnabled())
-      return e;
+  e.refreshTokenStorage && I(
+    e.refreshTokenStorage,
+    e.retryTokenReads ?? !1,
+    e.failClosedOnMissingToken ?? !1
+  ), e.appAttestation && b(e.appAttestation, e.platform), e.debugging && (n.interceptors.request.use((r) => (console.log("Request:", r), r)), n.interceptors.response.use((r) => (console.log("Response:", r), r)));
+}, K = (e) => {
+  h = e;
+}, b = (e, r) => {
+  n.interceptors.request.use(async (t) => {
+    const s = R(t);
+    if (!D(s.pathname) || !e.isEnabled())
+      return t;
     try {
       if (r === "ios") {
         const a = s.pathname.match(/\/projects\/([^/]+)\//);
         if (!a || !a[1])
-          return e;
-        const u = `/v2/embedded-wallet-api/projects/${a[1]}/attestation/challenge`, m = (await n.post(u)).data.challenge;
-        if (!m)
-          return console.warn("Failed to fetch assertion challenge"), e;
-        const f = await t.generateAssertion(m);
-        if (!f)
-          return e;
-        e.headers["X-App-Attestation-Assertion"] = f.assertion, e.headers["X-App-Attestation-Key-ID"] = f.keyId, e.headers["X-App-Attestation-Challenge"] = m;
+          return t;
+        const l = `/v2/embedded-wallet-api/projects/${a[1]}/attestation/challenge`, u = (await n.post(l)).data.challenge;
+        if (!u)
+          return console.warn("Failed to fetch assertion challenge"), t;
+        const i = await e.generateAssertion(u);
+        if (!i)
+          return t;
+        t.headers["X-App-Attestation-Assertion"] = i.assertion, t.headers["X-App-Attestation-Key-ID"] = i.keyId, t.headers["X-App-Attestation-Challenge"] = u;
       } else {
-        const a = await t.generateAssertion(JSON.stringify(e.data));
+        const a = await e.generateAssertion(JSON.stringify(t.data));
         if (!a)
-          return e;
-        e.headers["X-Integrity-Token"] = a.assertion, e.headers["X-Package-Name"] = t.appIdentifier;
+          return t;
+        t.headers["X-Integrity-Token"] = a.assertion, t.headers["X-Package-Name"] = e.appIdentifier;
       }
-      return e;
+      return t;
     } catch (a) {
       throw new Error(
         `App attestation required but assertion generation failed: ${a instanceof Error ? a.message : String(a)}`
       );
     }
   });
-}, S = (t, r) => ({
-  ...t,
+}, $ = (e, r) => ({
+  ...e,
   headers: {
-    ...t.headers || {},
+    ...e.headers || {},
     "X-Idempotency-Key": r
   }
-}), H = async (t, r) => {
-  j(t), r && r !== "" && (t = S(t, r));
+}), G = async (e, r) => {
+  x(e), r && r !== "" && (e = $(e, r));
   try {
-    return (await n(t)).data;
-  } catch (e) {
-    if (p.isAxiosError(e) && !e.response)
-      throw new g(
-        d.unknown,
-        e.cause instanceof Error ? e.cause.message : e.message,
-        e.cause
+    return (await n(e)).data;
+  } catch (t) {
+    if (y(t))
+      throw t;
+    if (w.isAxiosError(t) && !t.response)
+      throw new T(
+        p.unknown,
+        t.cause instanceof Error ? t.cause.message : t.message,
+        t.cause
       );
-    if (p.isAxiosError(e) && e.response) {
-      if (y(e.response.data))
-        throw new l(
-          e.response.status,
-          e.response.data.errorType,
-          e.response.data.errorMessage,
-          e.response.data.correlationId,
-          e.response.data.errorLink,
-          e.cause
+    if (w.isAxiosError(t) && t.response) {
+      if (P(t.response.data))
+        throw new f(
+          t.response.status,
+          t.response.data.errorType,
+          t.response.data.errorMessage,
+          t.response.data.correlationId,
+          t.response.data.errorLink,
+          t.cause
         );
       {
-        const s = e.response.status;
+        const s = t.response.status;
         switch (s) {
           case 401:
-            throw new l(
+            throw new f(
               s,
-              d.unauthorized,
+              p.unauthorized,
               "Unauthorized.",
               void 0,
-              `${h}#unauthorized`,
-              e.cause
+              `${m}#unauthorized`,
+              t.cause
             );
           case 404:
-            throw new l(
+            throw new f(
               s,
-              d.not_found,
+              p.not_found,
               "API not found.",
               void 0,
-              `${h}#not_found`,
-              e.cause
+              `${m}#not_found`,
+              t.cause
             );
           case 502:
-            throw new l(
+            throw new f(
               s,
-              d.bad_gateway,
+              p.bad_gateway,
               "Bad gateway.",
               void 0,
-              `${h}`,
-              e.cause
+              `${m}`,
+              t.cause
             );
           case 503:
-            throw new l(
+            throw new f(
               s,
-              d.service_unavailable,
+              p.service_unavailable,
               "Service unavailable. Please try again later.",
               void 0,
-              `${h}`,
-              e.cause
+              `${m}`,
+              t.cause
             );
           default: {
             let a = "";
-            if (e.response.data)
+            if (t.response.data)
               try {
-                a = JSON.stringify(e.response.data);
+                a = JSON.stringify(t.response.data);
               } catch {
-                a = String(e.response.data);
+                a = String(t.response.data);
               }
             const o = a ? `An unexpected error occurred: ${a}` : "An unexpected error occurred.";
-            throw new l(
+            throw new f(
               s,
-              d.unexpected_error,
+              p.unexpected_error,
               o,
               void 0,
-              `${h}`,
-              e.cause
+              `${m}`,
+              t.cause
             );
           }
         }
       }
     }
-    throw new T("Something went wrong.", e instanceof Error ? e : void 0);
+    throw new S("Something went wrong.", t instanceof Error ? t : void 0);
   }
-}, k = 4, b = [25, 50, 100], E = async (t) => {
-  if (t.getRefreshTokenWithOutcome) {
-    const { token: r, outcome: e, errorMessage: s } = await t.getRefreshTokenWithOutcome();
-    return { token: r, outcome: e, errorMessage: s };
+}, E = 4, U = [25, 50, 100], g = async (e) => {
+  if (e.getRefreshTokenWithOutcome) {
+    const { token: r, outcome: t, errorMessage: s } = await e.getRefreshTokenWithOutcome();
+    return { token: r, outcome: t, errorMessage: s };
   }
-  return { token: await t.getRefreshToken() };
-}, $ = async (t) => {
-  let r = null, e, s;
-  for (let a = 0; a < k; a++) {
-    const o = await E(t);
-    if (r = o.token, e = o.outcome, s = o.errorMessage, r)
+  return { token: await e.getRefreshToken() };
+}, q = async (e) => {
+  let r = null, t, s;
+  for (let a = 0; a < E; a++) {
+    const o = await g(e);
+    if (r = o.token, t = o.outcome, s = o.errorMessage, r)
       return {
         token: r,
         attempt: a,
-        outcome: e,
+        outcome: t,
         errorMessage: s
       };
-    const u = b[a];
-    u !== void 0 && await new Promise((R) => setTimeout(R, u));
+    const l = U[a];
+    l !== void 0 && await new Promise((c) => setTimeout(c, l));
   }
   return {
     token: r,
-    attempt: k - 1,
-    outcome: e,
+    attempt: E - 1,
+    outcome: t,
     errorMessage: s
   };
-}, U = (t, r) => {
+}, I = (e, r, t) => {
   n.interceptors.response.use(
-    async (e) => {
+    async (s) => {
       try {
-        if (q(e)) {
-          i.sendSessionRefreshEvent({
+        if (O(s)) {
+          d.sendSessionRefreshEvent({
             name: "refresh_token_response"
           });
-          const s = e.data?.refreshToken;
-          s && (i.sendSessionRefreshEvent({
+          const a = s.data?.refreshToken;
+          a && (d.sendSessionRefreshEvent({
             name: "refresh_token_received"
           }), await Promise.race([
-            t.setRefreshToken(s),
+            e.setRefreshToken(a),
             new Promise(
-              (a, o) => setTimeout(() => o(new Error("setRefreshToken timed out after 5000ms")), 5e3)
+              (o, l) => setTimeout(() => l(new Error("setRefreshToken timed out after 5000ms")), 5e3)
             )
-          ]), i.sendSessionRefreshEvent({
+          ]), d.sendSessionRefreshEvent({
             name: "refresh_token_stored"
           }));
         }
-      } catch (s) {
-        const a = s instanceof Error ? s.message : String(s);
-        i.sendSessionRefreshEvent({
+      } catch (a) {
+        const o = a instanceof Error ? a.message : String(a);
+        d.sendSessionRefreshEvent({
           name: "refresh_token_store_failed",
-          error_message: a
-        }), console.warn("Failed to store refresh token:", s);
+          error_message: o
+        }), console.warn("Failed to store refresh token:", a);
       }
-      return e;
+      return s;
     },
-    (e) => Promise.reject(e)
-  ), n.interceptors.request.use(async (e) => {
-    try {
-      if (M(e.url)) {
-        const {
-          token: s,
-          attempt: a,
-          outcome: o,
-          errorMessage: u
-        } = r ? await $(t) : { ...await E(t), attempt: 0 };
-        s ? (i.sendSessionRefreshEvent({
-          name: "refresh_token_retrieved",
-          attempt: a,
-          read_outcome: o,
-          error_message: u
-        }), e.data = {
-          ...e.data,
-          refreshToken: s
-        }) : i.sendSessionRefreshEvent({
-          name: "refresh_token_missing",
-          attempt: a,
-          read_outcome: o,
+    (s) => Promise.reject(s)
+  ), n.interceptors.request.use(async (s) => {
+    if (j(s.url)) {
+      const a = C(s.url);
+      let o = null, l = 0, c, u;
+      try {
+        const i = r ? await q(e) : { ...await g(e), attempt: 0 };
+        o = i.token, l = i.attempt, c = i.outcome, u = i.errorMessage;
+      } catch (i) {
+        if (u = i instanceof Error ? i.message : String(i), c = "error", d.sendSessionRefreshEvent({
+          name: "refresh_token_retrieve_failed",
           error_message: u
-        });
+        }), console.warn("Failed to retrieve refresh token:", i), a && t)
+          throw new v("error", u);
       }
-      I(e.url) && (i.sendSessionRefreshEvent({
-        name: "refresh_token_removing_token"
-      }), await t.removeRefreshToken());
-    } catch (s) {
-      const a = s instanceof Error ? s.message : String(s);
-      i.sendSessionRefreshEvent({
-        name: "refresh_token_retrieve_failed",
-        error_message: a
-      }), console.warn("Failed to retrieve refresh token:", s);
+      if (o)
+        d.sendSessionRefreshEvent({
+          name: "refresh_token_retrieved",
+          attempt: l,
+          read_outcome: c,
+          error_message: u
+        }), s.data = {
+          ...s.data,
+          refreshToken: o
+        };
+      else if (d.sendSessionRefreshEvent({
+        name: "refresh_token_missing",
+        attempt: l,
+        read_outcome: c,
+        error_message: u
+      }), a && t)
+        throw new v(
+          c === "error" ? "error" : "not_found",
+          u
+        );
     }
-    return e;
+    if (M(s.url))
+      try {
+        d.sendSessionRefreshEvent({
+          name: "refresh_token_removing_token"
+        }), await e.removeRefreshToken();
+      } catch (a) {
+        console.warn("Failed to remove refresh token:", a);
+      }
+    return s;
   });
-}, I = (t) => t ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/logout$/.test(t) : !1, M = (t) => t ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(refresh|logout)$/.test(t) : !1, q = (t) => {
-  const r = t.config.url;
+}, M = (e) => e ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/logout$/.test(e) : !1, j = (e) => e ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(refresh|logout)$/.test(e) : !1, C = (e) => e ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/refresh$/.test(e) : !1, O = (e) => {
+  const r = e.config.url;
   return r ? /^\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(verify\/(email|sms|siwe|oauth\/.*)|refresh)$/.test(
     r
   ) : !1;
-}, j = (t) => {
+}, x = (e) => {
   if (!n.getUri() || n.getUri() === "")
     throw new Error("CDP client URI not configured. Call configure() first.");
-  if (!t.url || t.url === "")
+  if (!e.url || e.url === "")
     throw new Error("AxiosRequestConfig URL is empty. This should never happen.");
-  if (!t.method || t.method === "")
+  if (!e.method || e.method === "")
     throw new Error("AxiosRequestConfig method is empty. This should never happen.");
-}, C = (t) => t.method?.toString().toUpperCase() || "GET", w = (t) => {
-  if (!t.url)
+}, L = (e) => e.method?.toString().toUpperCase() || "GET", R = (e) => {
+  if (!e.url)
     throw new Error("URL is required for authentication");
-  const r = n.getUri() + t.url;
+  const r = n.getUri() + e.url;
   return new URL(r);
-}, _ = (t) => {
-  const r = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(refresh|logout)$/, e = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(mfa)$/, s = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/config$/, a = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/attestation\/(challenge|register)$/;
-  return r.test(t) || e.test(t) || s.test(t) || a.test(t);
-}, O = (t) => !/^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/custom\/authenticate$/.test(t), A = (t) => {
-  const r = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(init)$/, e = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/verify\//;
-  return r.test(t) || e.test(t);
-}, x = (t) => [
+}, _ = (e) => {
+  const r = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(refresh|logout)$/, t = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(mfa)$/, s = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/config$/, a = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/attestation\/(challenge|register)$/;
+  return r.test(e) || t.test(e) || s.test(e) || a.test(e);
+}, X = (e) => !/^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/custom\/authenticate$/.test(e), A = (e) => {
+  const r = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/(init)$/, t = /^\/platform\/v2\/embedded-wallet-api\/projects\/[^/]+\/auth\/verify\//;
+  return r.test(e) || t.test(e);
+}, D = (e) => [
   // Auth flows: prevent account takeover on mobile clients
   /\/auth\/verify\//,
   // VerifyEmailAuthentication, VerifySmsAuthentication, VerifyOAuthCode, VerifyOAuthEndUserIdentity
   /\/auth\/refresh$/
   // RefreshAccessToken
-].some((e) => e.test(t));
+].some((t) => t.test(e));
 export {
-  H as cdpApiClient,
-  N as configureCdpApiClient,
-  z as setAuthManager
+  G as cdpApiClient,
+  B as configureCdpApiClient,
+  K as setAuthManager
 };

package/dist/esm/index7.js

@@ -22,8 +22,8 @@ class a extends Error {
    * @param errorLink - URL to documentation about this error
    * @param cause - The cause of the error
    */
-  constructor(e, o, t, n, s, i) {
-    super(t, { cause: i }), this.name = "APIError", this.statusCode = e, this.errorType = o, this.errorMessage = t, n !== void 0 && (this.correlationId = n), s !== void 0 && (this.errorLink = s);
+  constructor(e, o, n, t, s, i) {
+    super(n, { cause: i }), this.name = "APIError", this.statusCode = e, this.errorType = o, this.errorMessage = n, t !== void 0 && (this.correlationId = t), s !== void 0 && (this.errorLink = s);
   }
   /**
    * Convert the error to a JSON object, excluding undefined properties
@@ -49,11 +49,11 @@ class d extends a {
    * @param errorMessage - The error message
    * @param cause - The cause of the error
    */
-  constructor(e, o, t) {
-    super(0, e, o, void 0, void 0, t), this.name = "UnknownApiError";
+  constructor(e, o, n) {
+    super(0, e, o, void 0, void 0, n), this.name = "UnknownApiError";
   }
 }
-class c extends Error {
+class l extends Error {
   /**
    * Constructor for the UnknownError class
    *
@@ -64,13 +64,36 @@ class c extends Error {
     super(e, { cause: o }), this.name = "UnknownError";
   }
 }
-function p(r) {
+function E(r) {
   return r !== null && typeof r == "object" && "errorType" in r && typeof r.errorType == "string" && "errorMessage" in r && typeof r.errorMessage == "string";
 }
+class h extends Error {
+  /** Stable discriminator used for cross-package detection. */
+  code = "CDP_REFRESH_TOKEN_UNAVAILABLE";
+  /**
+   * The read outcome that produced this error:
+   * - `"not_found"`: storage returned no token (the user may be genuinely signed out).
+   * - `"error"`: the read threw or reported an error (e.g. storage locked / not ready).
+   */
+  outcome;
+  /**
+   * Constructor for the RefreshTokenUnavailableError class
+   *
+   * @param outcome - The read outcome that produced this error.
+   * @param message - An optional human-readable message.
+   */
+  constructor(e, o) {
+    super(o ?? `Refresh token unavailable in local storage (${e})`), this.name = "RefreshTokenUnavailableError", this.outcome = e;
+  }
+}
+const p = (r) => typeof r == "object" && r !== null && r.code === "CDP_REFRESH_TOKEN_UNAVAILABLE", c = /user interaction is not allowed/i, T = (r) => r.outcome === "error" && c.test(r.message ?? "");
 export {
   a as APIError,
   u as HttpErrorType,
+  h as RefreshTokenUnavailableError,
   d as UnknownApiError,
-  c as UnknownError,
-  p as isOpenAPIError
+  l as UnknownError,
+  E as isOpenAPIError,
+  p as isRefreshTokenUnavailableError,
+  T as isTransientTokenReadError
 };

package/dist/types/index.d.ts

@@ -210,6 +210,15 @@ export declare type CdpOptions = {
      * reads are synchronous and have no such race. Defaults to false.
      */
     retryTokenReads?: boolean;
+    /**
+     * Whether an unreadable/missing refresh token should fail closed (throw
+     * {@link RefreshTokenUnavailableError}) instead of proceeding with a token-less
+     * refresh. Enable only where the stored token is the sole transport (native,
+     * which has no cookies). On web the httpOnly cookie is the primary transport and
+     * storage is a supplemental mirror, so an empty mirror must NOT block the refresh.
+     * Defaults to false.
+     */
+    failClosedOnMissingToken?: boolean;
     /**
      * Optional app attestation for native mobile platforms.
      * When provided, adds assertion headers to sensitive API calls to prove app integrity.
@@ -2152,6 +2161,28 @@ export declare const IosAttestationRegistrationResponsePlatform: {
  */
 export declare function isOpenAPIError(obj: unknown): obj is Error_2;
 
+/**
+ * Type guard for {@link RefreshTokenUnavailableError} that is robust to the class
+ * being duplicated across bundled package boundaries by checking a stable `code`
+ * discriminator rather than the prototype chain.
+ *
+ * @param error - The value to check
+ * @returns True if the value is a RefreshTokenUnavailableError
+ */
+export declare const isRefreshTokenUnavailableError: (error: unknown) => error is RefreshTokenUnavailableError;
+
+/**
+ * Determines whether a {@link RefreshTokenUnavailableError} represents a transient
+ * read failure (the token exists but is momentarily unreadable) rather than a
+ * definitive one. Only a locked secure store qualifies, so a later refresh can
+ * recover; a genuinely absent token or any other read error is definitive and
+ * callers should treat it as a hard sign-out condition.
+ *
+ * @param error - The refresh-token-unavailable error to classify.
+ * @returns True if the read failure is transient and the session should be kept.
+ */
+export declare const isTransientTokenReadError: (error: RefreshTokenUnavailableError) => boolean;
+
 export declare interface ListResponse {
     /** The token for the next page of items, if any. */
     nextPageToken?: string;
@@ -2568,6 +2599,38 @@ export declare interface RefreshTokenStorage {
     removeRefreshToken(): Promise<void>;
 }
 
+/**
+ * Error thrown by the request interceptor when a token refresh is attempted but
+ * the refresh token cannot be read from local storage — either genuinely absent
+ * or the read failed (e.g. an OS secure store that is temporarily locked or not
+ * yet ready after an app resume).
+ *
+ * This is deliberately distinct from a server-side rejection of a refresh token
+ * (HTTP 401): when this error is thrown, no request reaches the server. Consumers
+ * should treat it as a recoverable, local condition and avoid destructive actions
+ * (such as signing the user out) on a merely transient read failure.
+ *
+ * Prefer {@link isRefreshTokenUnavailableError} over `instanceof` when detecting
+ * this error, since bundlers can duplicate the class across package boundaries.
+ */
+export declare class RefreshTokenUnavailableError extends Error {
+    /** Stable discriminator used for cross-package detection. */
+    readonly code = "CDP_REFRESH_TOKEN_UNAVAILABLE";
+    /**
+     * The read outcome that produced this error:
+     * - `"not_found"`: storage returned no token (the user may be genuinely signed out).
+     * - `"error"`: the read threw or reported an error (e.g. storage locked / not ready).
+     */
+    readonly outcome: "not_found" | "error";
+    /**
+     * Constructor for the RefreshTokenUnavailableError class
+     *
+     * @param outcome - The read outcome that produced this error.
+     * @param message - An optional human-readable message.
+     */
+    constructor(outcome: "not_found" | "error", message?: string);
+}
+
 /**
  * Verifies an iOS App Attest attestation payload and registers the device's public key for future assertion validation. **This endpoint is iOS-only.** Android devices use a different flow (see below).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-api-client",
-  "version": "0.0.119",
+  "version": "0.0.121",
   "type": "module",
   "files": [
     "dist/**",