@coinbase/cdp-core 0.0.78 → 0.0.80

package/dist/web/index.web33.js

@@ -1,279 +1,10 @@
-import { logOutEndUser as u, refreshAccessToken as c, registerTemporaryWalletSecret as f } from "@coinbase/cdp-api-client";
-import "jose";
-import { SignJWT as S } from "./index.web59.js";
-import { toAuthState as d } from "./index.web47.js";
-import "viem";
-import { getPlatformCrypto as l } from "./index.web4.js";
-import { sortKeys as w } from "./index.web52.js";
-import { getCoreOAuthManager as m } from "./index.web53.js";
-const h = 60 * 1e3, y = {
-  maxRetries: 3,
-  baseDelayMs: 1e3,
-  maxDelayMs: 1e4
+import { Analytics as i } from "./index.web2.js";
+import "./index.web3.js";
+import { MfaError as e } from "./index.web41.js";
+import { rejectPendingMfaVerification as n } from "./index.web34.js";
+const t = () => {
+  i.sendActionCallEvent({ name: "cancel_mfa_verification" }), n(new e("CANCELLED", "MFA verification was cancelled"));
 };
-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;
-  /**
-   * Initializes the token manager.
-   *
-   * @param projectId - The project ID.
-   */
-  constructor(e) {
-    this.projectId = e, this.initPromise = this._doInitialize();
-  }
-  /**
-   * Gets the current user, or null if there is no user signed in.
-   *
-   * @returns The current user.
-   */
-  getUser() {
-    return this.authState?.user ?? null;
-  }
-  /**
-   * 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.
-   */
-  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;
-    }
-  }
-  /**
-   * 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 callback - The function to call when the auth state changes.
-   */
-  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;
-    }
-  }
-}
 export {
-  M as AuthManager
+  t as cancelMfaVerification
 };

package/dist/web/index.web34.js

@@ -1,21 +1,50 @@
-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";
-  }
-}
+import "@coinbase/cdp-api-client";
+import { MfaError as p } from "./index.web41.js";
+const c = "cdp-web-mfa-required", v = () => {
+  let t, r;
+  return { promise: new Promise((o, s) => {
+    t = o, r = s;
+  }), resolve: t, reject: r };
+}, i = /* @__PURE__ */ new Set();
+let e = null;
+const M = (t, r) => {
+  const n = r?.scope, o = n ?? document, s = (l) => {
+    const f = l, { methods: m } = f.detail;
+    n && l.stopPropagation();
+    try {
+      t({ methods: m });
+    } catch (u) {
+      console.error("MFA listener threw an error:", u);
+    }
+  };
+  o.addEventListener(c, s);
+  const a = () => {
+    o.removeEventListener(c, s);
+  }, d = { listener: t, scope: n, cleanup: a };
+  return i.add(d), () => {
+    a(), i.delete(d);
+  };
+}, b = () => i.size > 0, w = (t) => {
+  if (i.size === 0)
+    return Promise.resolve();
+  e && (e.reject(
+    new p("SUPERSEDED", "MFA verification superseded by a newer request")
+  ), e = null), e = v();
+  const r = document.activeElement, n = r && r !== document.body ? r : document.body, o = new CustomEvent(c, {
+    bubbles: !0,
+    // Allow event to bubble up through DOM
+    detail: { methods: t }
+  });
+  return n.dispatchEvent(o), e.promise;
+}, P = () => {
+  e && (e.resolve(), e = null);
+}, L = (t) => {
+  e && (e.reject(t), e = null);
+};
 export {
-  c as APIError,
-  e as CustomAuthError,
-  u as ErrorType,
-  E as HttpErrorType,
-  a as OAuth2ProviderType,
-  d as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  p as SendSolanaTransactionWithEndUserAccountBodyNetwork
+  b as hasRegisteredMfaListeners,
+  M as registerMfaListener,
+  L as rejectPendingMfaVerification,
+  P as resolvePendingMfaVerification,
+  w as triggerMfaVerification
 };

package/dist/web/index.web35.js

@@ -1,124 +1,16 @@
-import { hashTypedData as i, serializeErc6492Signature as u, encodeFunctionData as m, pad as g, getTypesForEIP712Domain as A, hashMessage as d } from "viem";
-import { getCurrentUserSync as h } from "./index.web13.js";
-import { signEvmHash as o, signEvmTypedData as l, signEvmTransaction as f, signEvmMessage as y } from "./index.web9.js";
 import "@coinbase/cdp-api-client";
-import { COINBASE_SMART_WALLET_FACTORY_ADDRESS as p, COINBASE_SMART_WALLET_FACTORY_ABI as v } from "./index.web60.js";
-import { signAndWrapTypedDataForSmartAccount as E } from "./index.web61.js";
-import { toAccount as T } from "./index.web62.js";
-function _(n) {
-  const r = h();
-  if (!r || !r.evmAccountObjects?.length && !r.evmSmartAccountObjects?.length)
-    throw new Error(
-      "No accounts found - user must be authenticated and have at least one EVM account or smart account"
-    );
-  const c = r.evmAccountObjects?.some((e) => e.address === n) ?? !1, s = r.evmSmartAccountObjects?.some((e) => e.address === n) ?? !1;
-  if (!c && !s)
-    throw new Error(`Cannot sign for address ${n} - not authorized for this account`);
-  return T({
-    address: n,
-    /**
-     * Signs a message using CDP's message signing functionality.
-     * Supports string messages, hex strings, and byte arrays.
-     *
-     * @param root0 - The parameters object
-     * @param root0.message - The message to sign, can be a string, hex string, or byte array
-     * @returns The signature as a hex string
-     */
-    async signMessage({ message: e }) {
-      let t;
-      if (typeof e == "string")
-        t = (await y({
-          evmAccount: n,
-          message: e
-        })).signature;
-      else if ("raw" in e) {
-        const a = d(e);
-        t = (await o({
-          evmAccount: n,
-          hash: a
-        })).signature;
-      } else
-        throw new Error("Unsupported message format");
-      return t;
-    },
-    /**
-     * Signs a transaction using CDP's transaction signing functionality.
-     * Converts Viem's transaction format to CDP's AllowedEvmTransactionType.
-     *
-     * @param transaction - The transaction to sign in Viem's format
-     * @returns The signature as a hex string
-     */
-    async signTransaction(e) {
-      const t = {
-        to: e.to,
-        value: e.value,
-        data: e.data,
-        nonce: e.nonce,
-        gas: e.gas,
-        chainId: e.chainId ?? 1
-      };
-      return e.gasPrice !== void 0 ? (t.maxFeePerGas = e.gasPrice, t.maxPriorityFeePerGas = e.gasPrice) : (t.maxFeePerGas = e.maxFeePerGas, t.maxPriorityFeePerGas = e.maxPriorityFeePerGas), (await f({
-        evmAccount: n,
-        transaction: t
-      })).signedTransaction;
-    },
-    /**
-     * Signs EIP-712 typed data using CDP's typed data signing functionality.
-     * Handles domain separation and type encoding according to the EIP-712 specification.
-     * For smart accounts, implements replay-safe hash and signature wrapping.
-     *
-     * @param params - The typed data parameters following the EIP-712 specification
-     * @returns The signature as a hex string
-     */
-    async signTypedData(e) {
-      if (s) {
-        const t = await E({
-          smartAccount: n,
-          ownerAddress: r.evmAccountObjects?.[0]?.address,
-          hash: i(e),
-          chainId: Number(e.domain.chainId)
-        });
-        return u({
-          address: p,
-          data: m({
-            abi: v,
-            functionName: "createAccount",
-            args: [[g(r.evmAccountObjects?.[0]?.address)], 0n]
-          }),
-          signature: t.signature
-        });
-      } else {
-        const t = {
-          domain: e.domain,
-          types: {
-            EIP712Domain: A({
-              domain: e.domain
-            }),
-            ...e.types
-          },
-          primaryType: e.primaryType,
-          message: e.message
-        };
-        return (await l({
-          evmAccount: n,
-          typedData: t
-        })).signature;
-      }
-    },
-    /**
-     * Signs a raw message hash using CDP's message signing functionality.
-     *
-     * @param message - The message hash to sign
-     * @returns The signature as a hex string
-     */
-    async sign(e) {
-      return (await o({
-        evmAccount: n,
-        hash: e.hash
-      })).signature;
-    }
-  });
+import "viem";
+const r = ["totp", "sms"], o = (t, e) => {
+  const n = t.mfaMethods[e]?.enrolledAt;
+  return !!n && Date.now() > new Date(n).getTime();
+};
+function i(t) {
+  return t.mfaMethods ? r.filter((e) => o(t, e)) : [];
+}
+function s(t, e) {
+  return e ? o(t, e) : t.mfaMethods ? r.some((n) => o(t, n)) : !1;
 }
 export {
-  _ as toViemAccount
+  i as getEnrolledMfaMethods,
+  s as isEnrolledInMfa
 };

package/dist/web/index.web36.js

@@ -1,57 +1,51 @@
-class n extends Error {
-  /**
-   * The name of the missing module.
-   */
-  moduleName;
-  /**
-   * The API or feature that requires the missing module.
-   */
-  requiredFor;
-  /**
-   * Creates a new ModuleResolutionError.
-   *
-   * @param moduleName - The name of the missing module.
-   * @param requiredFor - The API or feature that requires the module.
-   * @param message - Optional custom error message.
-   */
-  constructor(r, s, t) {
-    const o = `${s} is not available in this React Native environment. Please ensure ${r} is installed.`;
-    super(t || o), this.name = "ModuleResolutionError", this.moduleName = r, this.requiredFor = s;
+import { APIError as u, ErrorType as l } from "@coinbase/cdp-api-client";
+import { MfaError as m } from "./index.web41.js";
+import { getCoreAuthManager as a } from "./index.web55.js";
+import { hasRegisteredMfaListeners as i, triggerMfaVerification as o } from "./index.web34.js";
+import { isEnrolledInMfa as M, getEnrolledMfaMethods as E } from "./index.web35.js";
+const h = 300, n = () => {
+  const r = a().getUser();
+  return r ? E(r) : [];
+}, s = () => {
+  throw new m(
+    "LISTENER_REQUIRED",
+    "MFA verification is required but no listener is registered."
+  );
+};
+async function A(r) {
+  if (f()) {
+    i() || s();
+    const e = n();
+    await o(e);
   }
-}
-class a extends Error {
-  /**
-   * Creates a new InputValidationError.
-   *
-   * @param message - The validation error message.
-   */
-  constructor(r) {
-    super(r), this.name = "InputValidationError";
+  try {
+    return await r();
+  } catch (e) {
+    if (e instanceof u && e.errorType === l.mfa_required) {
+      i() || s();
+      const t = n();
+      return await o(t), await r();
+    }
+    throw e;
   }
 }
-class i extends Error {
-  /**
-   * Creates a new ValidationError.
-   *
-   * @param message - The validation error message.
-   */
-  constructor(r) {
-    super(r), this.name = "ValidationError";
-  }
+function f() {
+  const r = a().getUser();
+  if (!r || !M(r)) return !1;
+  const t = r?.mfaMethods?.lastVerificationCompletedAt;
+  if (!t) return !0;
+  const d = new Date(t).getTime(), c = h * 1e3;
+  return Date.now() > d + c;
 }
-class l extends Error {
-  /**
-   * Creates a new InternalError.
-   *
-   * @param message - The internal error message.
-   */
-  constructor(r) {
-    super(r), this.name = "InternalError";
-  }
+async function T() {
+  if (!f())
+    return;
+  i() || s();
+  const r = n();
+  await o(r);
 }
 export {
-  a as InputValidationError,
-  l as InternalError,
-  n as ModuleResolutionError,
-  i as ValidationError
+  T as ensureMfaVerified,
+  f as isMfaRequired,
+  A as withMfa
 };

package/dist/web/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
 };