@coinbase/cdp-core 0.0.79 → 0.0.80

package/dist/esm/index.web37.js

@@ -1,50 +1,25 @@
-import { createStore as c } from "zustand";
-import { subscribeWithSelector as p, persist as d, createJSONStorage as h } from "./index.web63.js";
-import { EventEmitter as f } from "./index.web64.js";
-import "./index.web65.js";
-import "viem";
-import "@coinbase/cdp-api-client";
-import { getPlatformStorage as u } from "./index.web4.js";
-import { createProvider as g } from "./index.web66.js";
-import { onAuthStateChange as l } from "./index.web9.js";
-function U(e) {
-  if (e.chains.length === 0)
-    throw new Error("At least one chain must be configured");
-  if (!e.transports)
-    throw new Error("Transports must be provided");
-  const o = e.chains, i = e.transports;
-  if (o.length === 0)
-    throw new Error("No chains found in configuration");
-  const m = new f(), n = u(), a = {
-    getItem: (t) => n.getItem(t),
-    setItem: (t, r) => n.setItem(t, r),
-    removeItem: (t) => n.removeItem(t)
-  }, s = c()(
-    p(
-      d(
-        (t) => ({
-          chainId: o[0].id,
-          setChainId: (r) => t({ chainId: r }),
-          chains: o,
-          user: null,
-          setUser: (r) => t({ user: r })
-        }),
-        {
-          name: "cdp-provider-store",
-          storage: h(() => a)
-        }
-      )
-    )
-  );
-  return s.persist.rehydrate(), l((t) => {
-    s.getState().setUser(t);
-  }), {
-    provider: g(m, s, {
-      chains: o,
-      transports: i
-    })
-  };
+import { createSolanaKeyExportIframe as e, createEvmKeyExportIframe as o } from "./index.web47.js";
+import { exportSolanaAccount as t, exportEvmAccount as s, sendUserOperation as r, signEvmTypedData as i, signSolanaMessage as c, signEvmMessage as m, sendSolanaTransaction as E, sendEvmTransaction as T, signSolanaTransaction as p, signEvmTransaction as g, signEvmHash as v } from "./index.web9.js";
+const n = {
+  signEvmHash: v,
+  signEvmTransaction: g,
+  signSolanaTransaction: p,
+  sendEvmTransaction: T,
+  sendSolanaTransaction: E,
+  signEvmMessage: m,
+  signSolanaMessage: c,
+  signEvmTypedData: i,
+  sendUserOperation: r,
+  exportEvmAccount: s,
+  exportSolanaAccount: t,
+  createEvmKeyExportIframe: o,
+  createSolanaKeyExportIframe: e
+}, A = Object.keys(n);
+function O(a) {
+  return a in n;
 }
 export {
-  U as createCDPEmbeddedWallet
+  A as MFA_PROTECTED_ACTIONS,
+  n as MFA_PROTECTED_FUNCTIONS,
+  O as isMfaProtectedAction
 };

package/dist/esm/index.web38.js

@@ -1,151 +1,279 @@
+import { logOutEndUser as u, refreshAccessToken as c, registerTemporaryWalletSecret as f } from "@coinbase/cdp-api-client";
+import "jose";
+import { SignJWT as S } from "./index.web64.js";
+import { toAuthState as d } from "./index.web53.js";
 import "viem";
-import "zustand";
-import "@coinbase/cdp-api-client";
-import { getCurrentUser as u } from "./index.web9.js";
-const r = {
-  rpc: {
-    invalidInput: -32e3,
-    resourceNotFound: -32001,
-    resourceUnavailable: -32002,
-    transactionRejected: -32003,
-    methodNotSupported: -32004,
-    limitExceeded: -32005,
-    parse: -32700,
-    invalidRequest: -32600,
-    methodNotFound: -32601,
-    invalidParams: -32602,
-    internal: -32603
-  },
-  provider: {
-    userRejectedRequest: 4001,
-    unauthorized: 4100,
-    unsupportedMethod: 4200,
-    disconnected: 4900,
-    chainDisconnected: 4901,
-    unsupportedChain: 4902
-  }
+import { getPlatformCrypto as l } from "./index.web4.js";
+import { sortKeys as w } from "./index.web59.js";
+import { getCoreOAuthManager as m } from "./index.web55.js";
+const h = 60 * 1e3, y = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4
 };
-class o extends Error {
+function g(t, e, s) {
+  const r = e * Math.pow(2, t), a = Math.random() * 0.3 * r;
+  return Math.min(r + a, s);
+}
+function T(t) {
+  return new Promise((e) => setTimeout(e, t));
+}
+function p(t) {
+  if (t instanceof TypeError && t.message.includes("fetch"))
+    return !0;
+  if (t && typeof t == "object" && "status" in t) {
+    const e = t.status;
+    if (e >= 500 && e < 600 || e === 408 || e === 429)
+      return !0;
+    if (e === 401)
+      return !1;
+  }
+  if (t instanceof Error) {
+    const e = t.message.toLowerCase();
+    if (e.includes("network") || e.includes("timeout") || e.includes("econnrefused") || e.includes("enotfound") || e.includes("socket"))
+      return !0;
+  }
+  return !1;
+}
+class M {
+  projectId;
+  authState = null;
+  walletSecret = null;
+  authStateChangeCallbacks = [];
+  initPromise = null;
+  refreshTimeout = null;
   /**
-   * The error code from EIP1193ErrorCode enum.
+   * Initializes the token manager.
+   *
+   * @param projectId - The project ID.
    */
-  code;
+  constructor(e) {
+    this.projectId = e, this.initPromise = this._doInitialize();
+  }
   /**
-   * Creates a new EIP-1193 Provider error.
+   * Gets the current user, or null if there is no user signed in.
    *
-   * @param code - The error code from EIP1193ErrorCode enum.
-   * @param message - The error message.
+   * @returns The current user.
    */
-  constructor(t, n) {
-    super(n), this.code = t;
+  getUser() {
+    return this.authState?.user ?? null;
   }
-}
-class c extends Error {
   /**
-   * The error code from RPCErrorCode type.
+   * Returns whether the user is signed in - i.e., whether there is an unexpired
+   * access token and user. Attempts to refresh the token if it's expired.
+   *
+   * @returns True if the user is signed in, false otherwise.
    */
-  code;
+  async isSignedIn() {
+    if (!this.authState)
+      return !1;
+    if (this.authState.expiresAt > Date.now() + h)
+      return !0;
+    try {
+      return await this.getToken() !== null;
+    } catch {
+      return !1;
+    }
+  }
   /**
-   * Creates a new RPC Invalid Params error.
+   * Signs out the user, clearing all authentication state.
+   */
+  async signOut() {
+    try {
+      await u(this.projectId);
+    } catch {
+    } finally {
+      await this.clearAuthState();
+    }
+  }
+  /**
+   * Adds a callback to be called when the auth state changes.
    *
-   * @param code - The error code from RPCErrorCode type.
-   * @param message - The error message.
+   * @param callback - The function to call when the auth state changes.
    */
-  constructor(t, n) {
-    super(n), this.code = t;
+  addAuthStateChangeCallback(e) {
+    this.authStateChangeCallbacks.push(e), e(this.authState?.user ?? null);
+  }
+  /**
+   * Gets the access token, refreshing it if it is expired. Returns null if the user is not
+   * signed in.
+   *
+   * @param options - The options for getting the token.
+   * @param options.forceRefresh - Whether to force a refresh of the token.
+   * @returns The access token.
+   */
+  async getToken(e) {
+    return (e?.forceRefresh || this.shouldRefreshToken()) && await this.refreshAccessToken(), this.authState?.accessToken ?? null;
+  }
+  /**
+   * Gets the expiration time of the access token, or null if the user is not signed in.
+   *
+   * @returns The expiration time of the access token.
+   */
+  async getTokenExpiration() {
+    return this.authState?.expiresAt ?? null;
+  }
+  /**
+   * Gets the currently registered wallet secret ID. Rejects if the user is not signed in.
+   *
+   * @returns The wallet secret ID.
+   */
+  async getWalletSecretId() {
+    if (!await this.isSignedIn())
+      throw new Error("Cannot get wallet secret ID if the user is not signed in");
+    return this.shouldRefreshWalletSecret() && await this.refreshWalletSecret(), this.walletSecret.walletSecretId;
+  }
+  /**
+   * Gets the X-Wallet-Auth header. Rejects if the user is not signed in.
+   *
+   * @param options - The options for the request.
+   * @param options.requestMethod - The HTTP method of the request.
+   * @param options.requestHost - The host of the request.
+   * @param options.requestPath - The path of the request.
+   * @param options.requestData - The data of the request.
+   * @returns The X-Wallet-Auth header.
+   */
+  async getXWalletAuth(e) {
+    if (!await this.isSignedIn())
+      throw new Error("Cannot get X-Wallet-Auth header if the user is not signed in");
+    this.shouldRefreshWalletSecret() && await this.refreshWalletSecret();
+    const s = `${e.requestMethod} ${e.requestHost}${e.requestPath}`, r = Math.floor(Date.now() / 1e3), a = l(), i = {
+      uris: [s]
+    };
+    if (e.requestData && Object.keys(e.requestData).length > 0) {
+      const n = w(e.requestData);
+      i.reqHash = await a.hash(new TextEncoder().encode(JSON.stringify(n)));
+    }
+    return await new S(i).setProtectedHeader({ alg: "ES256", typ: "JWT" }).setIssuedAt(r).setNotBefore(r).setJti(a.generateRandomId()).sign(this.walletSecret.keyPair.privateKey);
+  }
+  /**
+   * Gets the authentication state.
+   *
+   * @returns The authentication state.
+   */
+  getAuthState() {
+    return this.authState;
+  }
+  /**
+   * Sets the authentication state.
+   *
+   * @param authState - The authentication state.
+   */
+  async setAuthState(e) {
+    this.authState = e, this.authStateChangeCallbacks.forEach((s) => s(this.authState?.user ?? null)), this.scheduleTokenRefresh();
+  }
+  /**
+   * Clears the authentication state.
+   */
+  async clearAuthState() {
+    this.authState = null, this.walletSecret = null, this.cancelTokenRefresh(), this.authStateChangeCallbacks.forEach((e) => e(null));
+  }
+  /**
+   * Ensures the AuthManager is initialized before proceeding.
+   * If initialization is already in progress, waits for it to complete.
+   */
+  async ensureInitialized() {
+    if (this.initPromise) {
+      await this.initPromise;
+      return;
+    }
+    throw new Error("AuthManager not initialized");
+  }
+  /**
+   * Internal async initialization logic.
+   */
+  async _doInitialize() {
+    try {
+      await this.refreshAccessToken(), await m().handleOAuthCode();
+    } catch (e) {
+      console.warn("Failed to refresh access token during initialization:", e);
+    }
+  }
+  /**
+   * Returns whether the token should be refreshed.
+   *
+   * @returns True if the token should be refreshed, false otherwise.
+   */
+  shouldRefreshToken() {
+    return !(this.authState && this.authState.expiresAt > Date.now() + h);
+  }
+  /**
+   * Refreshes the access token and transitions the auth state accordingly.
+   * If a refresh is already in progress, it will wait for that refresh to complete.
+   * Retries with exponential backoff on transient failures only. Unauthorized error
+   * short-circuit immediately since retrying won't help.
+   *
+   * @returns The new access token.
+   */
+  async refreshAccessToken() {
+    const { maxRetries: e, baseDelayMs: s, maxDelayMs: r } = y;
+    for (let a = 0; a <= e; a++)
+      try {
+        const i = await c(this.projectId, {
+          grantType: "refresh_token"
+        }), n = d(
+          i.accessToken,
+          i.validUntil,
+          i.endUser
+        );
+        await this.setAuthState(n);
+        return;
+      } catch (i) {
+        if (!p(i)) {
+          await this.signOut();
+          return;
+        }
+        if (a === e)
+          return;
+        const o = g(a, s, r);
+        await T(o);
+      }
+  }
+  /**
+   * Schedules a token refresh to occur exactly when shouldRefreshToken() would return true.
+   * Uses the same REFRESH_CREDENTIALS_BUFFER_MS timing as the rest of the auth system.
+   */
+  scheduleTokenRefresh() {
+    if (this.cancelTokenRefresh(), !this.authState)
+      return;
+    const s = this.authState.expiresAt - h - Date.now();
+    s <= 0 || (this.refreshTimeout = setTimeout(async () => {
+      await this.refreshAccessToken(), this.scheduleTokenRefresh();
+    }, s));
+  }
+  /**
+   * Cancels any scheduled token refresh.
+   */
+  cancelTokenRefresh() {
+    this.refreshTimeout && (clearTimeout(this.refreshTimeout), this.refreshTimeout = null);
+  }
+  /**
+   * Returns whether the wallet secret should be refreshed.
+   *
+   * @returns True if the wallet secret should be refreshed, false otherwise.
+   */
+  shouldRefreshWalletSecret() {
+    return !(this.walletSecret && this.walletSecret.expiresAt > Date.now() + h);
+  }
+  /**
+   * Refreshes the wallet secret. Assumes the user is signed in.
+   *
+   * @returns The wallet secret.
+   */
+  async refreshWalletSecret() {
+    const e = l(), s = this.walletSecret?.walletSecretId ?? e.generateRandomId(), r = this.walletSecret?.keyPair ?? await e.createKeyPair(), a = this.authState.expiresAt, i = new Date(a).toISOString();
+    this.walletSecret = { walletSecretId: s, keyPair: r, expiresAt: a };
+    try {
+      await f(this.projectId, this.authState.user.userId, {
+        walletSecretId: s,
+        publicKey: r.publicKeyBase64,
+        validUntil: i
+      });
+    } catch (n) {
+      throw this.walletSecret = null, n;
+    }
   }
-}
-const h = /* @__PURE__ */ new Set([
-  "eth_accounts",
-  "eth_requestAccounts",
-  "personal_sign",
-  "eth_sendTransaction",
-  "eth_signTypedData_v4",
-  "eth_chainId",
-  "eth_sign",
-  "wallet_disconnect",
-  "wallet_switchEthereumChain",
-  "wallet_sendCalls",
-  "wallet_getCallsStatus",
-  "wallet_getCapabilities"
-]);
-function v(e, { chains: t }) {
-  const { method: n, params: a } = e;
-  if (typeof n != "string" || n.length === 0)
-    throw new c(
-      r.rpc.invalidParams,
-      "'method' must be a non-empty string."
-    );
-  const i = (a ?? [])[0]?.chainId;
-  if (typeof i == "string" && !t.some((d) => d.id === Number.parseInt(i, 16)))
-    throw new o(
-      r.provider.unsupportedChain,
-      `Chain ${i} not supported - make sure the provider is configured with the correct chains.`
-    );
-  if (a !== void 0 && !Array.isArray(a))
-    throw new c(
-      r.rpc.invalidParams,
-      "'params' must be an array if provided."
-    );
-  if (!h.has(n))
-    throw new o(
-      r.provider.unsupportedMethod,
-      `Method ${e.method} not supported`
-    );
-}
-async function s() {
-  const e = await u();
-  if (!e)
-    throw new o(
-      r.provider.unauthorized,
-      "User not connected"
-    );
-  return e;
-}
-async function f(e) {
-  const t = await s();
-  if (!t.evmAccounts?.includes(e) && !t.evmSmartAccounts?.includes(e))
-    throw new o(
-      r.provider.unauthorized,
-      "Address not owned by user"
-    );
-  return t;
-}
-async function A(e) {
-  const t = await s();
-  if (!t.evmAccounts?.includes(e))
-    throw new o(
-      r.provider.unauthorized,
-      "EOA not owned by user"
-    );
-  return t;
-}
-async function _(e) {
-  const t = await s();
-  if (!t.evmSmartAccounts?.includes(e))
-    throw new o(
-      r.provider.unauthorized,
-      "Smart account not owned by user"
-    );
-  return t;
-}
-async function y() {
-  const e = await s();
-  if (!e.evmSmartAccountObjects?.[0])
-    throw new o(
-      r.provider.unauthorized,
-      "No EVM smart accounts available"
-    );
-  return e;
 }
 export {
-  o as EIP1193ProviderError,
-  c as RPCRequestError,
-  r as STANDARD_ERROR_CODES,
-  v as validateRequest,
-  s as validateUserConnected,
-  y as validateUserHasEvmSmartAccount,
-  f as validateUserOwnsAddress,
-  A as validateUserOwnsEOA,
-  _ as validateUserOwnsSmartAccount
+  M as AuthManager
 };

package/dist/esm/index.web39.js

@@ -1,70 +1,21 @@
-import { InputValidationError as o } from "./index.web36.js";
-import { DEFAULT_SECURE_IFRAME_BASE_PATH as l, DEFAULT_SECURE_IFRAME_THEME as i, SECURE_IFRAME_KEY_EXPORT_EVENT_TYPE as f, SECURE_IFRAME_EVENT_TYPE_PREFIX as u } from "./index.web40.js";
-function s() {
-  if (!document)
-    throw new Error("Document not found. This function must be called in a browser environment.");
-}
-function p(e) {
-  const t = e.basePath || l, n = ["fullWidth"];
-  return e.projectId && n.push(`projectId=${e.projectId.trim()}`), e.label && n.push(`label=${encodeURIComponent(e.label.trim())}`), e.copiedLabel && n.push(`copiedLabel=${encodeURIComponent(e.copiedLabel.trim())}`), e.icon !== !1 && n.push("icon"), `${t}?${n.join("&")}`;
-}
-function S(e, t) {
-  if (!e?.contentWindow || !e?.src) return;
-  const n = E(e.src);
-  n && e.contentWindow.postMessage(t, n);
-}
-function E(e) {
-  try {
-    return new URL(e).origin;
-  } catch (t) {
-    return console.error("Error parsing iframe origin", t), "";
+import { APIError as c, ErrorType as u, HttpErrorType as E, OAuth2ProviderType as a, SendEvmTransactionWithEndUserAccountBodyNetwork as d, SendSolanaTransactionWithEndUserAccountBodyNetwork as p } from "@coinbase/cdp-api-client";
+import "viem";
+class e extends Error {
+  /**
+   * Creates a new CustomAuthError.
+   *
+   * @param message - The error message.
+   */
+  constructor(r) {
+    super(r), this.name = "CustomAuthError";
   }
 }
-function h(e) {
-  if (e instanceof HTMLIFrameElement)
-    throw new o(
-      "target cannot be an iframe element. Pass a container element or CSS selector instead."
-    );
-  s();
-  let t;
-  if (typeof e == "string") {
-    const r = document.querySelector(e);
-    if (!r)
-      throw new o(`No element found for selector "${e}".`);
-    if (r instanceof HTMLIFrameElement)
-      throw new o(
-        `Selector "${e}" resolved to an iframe element. Pass a container element or CSS selector instead.`
-      );
-    t = r;
-  } else
-    t = e;
-  const n = document.createElement("iframe");
-  return t.appendChild(n), n;
-}
-const m = {
-  lg: 1,
-  // 1em top + 1em bottom
-  md: 0.75,
-  // 0.75em top + 0.75em bottom
-  sm: 0.5,
-  // 0.5em top + 0.5em bottom
-  xs: 0.25
-  // 0.25em top + 0.25em bottom
-};
-function _(e) {
-  const t = e?.buttonSize || i.buttonSize, n = e?.buttonFontSize || i.buttonFontSize, r = 1.5, c = 4, a = m[t] * 2 + r;
-  return Math.ceil(a * n + c);
-}
-const b = (e) => typeof e == "object" && e !== null && "type" in e && typeof e.type == "string" && !!f[e.type.replace(
-  u,
-  ""
-)];
 export {
-  p as buildKeyExportIframeUrl,
-  _ as calculateSecureIframeHeight,
-  h as createIframe,
-  E as getSecureIframeOrigin,
-  b as isSecureIframeKeyExportMessage,
-  S as sendSecureIframeMessage,
-  s as validateSecureIframeEnvironment
+  c as APIError,
+  e as CustomAuthError,
+  u as ErrorType,
+  E as HttpErrorType,
+  a as OAuth2ProviderType,
+  d as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  p as SendSolanaTransactionWithEndUserAccountBodyNetwork
 };