@coinbase/cdp-core 0.0.85 → 0.0.87

package/dist/esm/index.native64.js

@@ -1,75 +1,22 @@
-import { sliceHex as s, encodePacked as c, encodeAbiParameters as p } from "viem";
-import { signEvmTypedData as m } from "./index.native10.js";
-async function b(e) {
-  const { smartAccount: t, hash: a, chainId: n, ownerAddress: r } = e, o = u({
-    hash: a,
-    chainId: n,
-    smartAccountAddress: t
-  }), { signature: i } = await m({
-    evmAccount: r,
-    typedData: o
-  });
-  return {
-    signature: y({
-      signatureHex: i
-    })
-  };
+import { getMfaConfigState as f } from "./index.native56.js";
+import "@coinbase/cdp-api-client";
+import "viem";
+const r = ["totp", "sms"], o = (t, e) => {
+  const n = t.mfaMethods[e]?.enrolledAt;
+  return !!n && Date.now() > new Date(n).getTime();
+};
+function d(t) {
+  return t.mfaMethods ? r.filter((e) => o(t, e)) : [];
 }
-function u({
-  hash: e,
-  chainId: t,
-  smartAccountAddress: a
-}) {
-  return {
-    domain: {
-      name: "Coinbase Smart Wallet",
-      version: "1",
-      chainId: t,
-      verifyingContract: a
-    },
-    types: {
-      EIP712Domain: [
-        { name: "name", type: "string" },
-        { name: "version", type: "string" },
-        { name: "chainId", type: "uint256" },
-        { name: "verifyingContract", type: "address" }
-      ],
-      CoinbaseSmartWalletMessage: [{ name: "hash", type: "bytes32" }]
-    },
-    primaryType: "CoinbaseSmartWalletMessage",
-    message: {
-      hash: e
-    }
-  };
+function s(t, e) {
+  return e ? o(t, e) : t.mfaMethods ? r.some((n) => o(t, n)) : !1;
 }
-function y({ signatureHex: e }) {
-  const t = s(e, 0, 32), a = s(e, 32, 64), n = +`0x${e.slice(130, 132)}`, r = c(["bytes32", "bytes32", "uint8"], [t, a, n]);
-  return p(
-    [d],
-    [
-      {
-        ownerIndex: 0,
-        signatureData: r
-      }
-    ]
-  );
+function M() {
+  const t = f(), e = r.filter((n) => t?.[`${n}Config`]?.enabled);
+  return e.length ? e : ["totp"];
 }
-const d = {
-  components: [
-    {
-      name: "ownerIndex",
-      type: "uint8"
-    },
-    {
-      name: "signatureData",
-      type: "bytes"
-    }
-  ],
-  name: "SignatureWrapper",
-  type: "tuple"
-};
 export {
-  u as createReplaySafeTypedData,
-  y as createSmartAccountSignatureWrapper,
-  b as signAndWrapTypedDataForSmartAccount
+  M as getEnabledMfaMethods,
+  d as getEnrolledMfaMethods,
+  s as isEnrolledInMfa
 };

package/dist/esm/index.native65.js

@@ -1,28 +1,51 @@
-import { InvalidAddressError as s } from "./index.native110.js";
-import { isAddress as a } from "./index.native89.js";
-function r(n) {
-  if (typeof n == "string") {
-    if (!a(n, { strict: !1 }))
-      throw new s({ address: n });
-    return {
-      address: n,
-      type: "json-rpc"
-    };
+import { APIError as u, ErrorType as l } from "@coinbase/cdp-api-client";
+import { MfaError as m } from "./index.native70.js";
+import { getCoreAuthManager as a } from "./index.native56.js";
+import { hasRegisteredMfaListeners as i, triggerMfaVerification as o } from "./index.native63.js";
+import { isEnrolledInMfa as M, getEnrolledMfaMethods as E } from "./index.native64.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);
+  }
+  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;
   }
-  if (!a(n.address, { strict: !1 }))
-    throw new s({ address: n.address });
-  return {
-    address: n.address,
-    nonceManager: n.nonceManager,
-    sign: n.sign,
-    signAuthorization: n.signAuthorization,
-    signMessage: n.signMessage,
-    signTransaction: n.signTransaction,
-    signTypedData: n.signTypedData,
-    source: "custom",
-    type: "local"
-  };
+}
+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;
+}
+async function T() {
+  if (!f())
+    return;
+  i() || s();
+  const r = n();
+  await o(r);
 }
 export {
-  r as toAccount
+  T as ensureMfaVerified,
+  f as isMfaRequired,
+  A as withMfa
 };

package/dist/esm/index.native66.js

@@ -1,162 +1,41 @@
-const H = (m) => (h, n, r) => {
-  const s = r.subscribe;
-  return r.subscribe = (c, i, a) => {
-    let l = c;
-    if (i) {
-      const g = a?.equalityFn || Object.is;
-      let v = c(r.getState());
-      l = (f) => {
-        const u = c(f);
-        if (!g(v, u)) {
-          const y = v;
-          i(v = u, y);
-        }
-      }, a?.fireImmediately && i(v, v);
-    }
-    return s(l);
-  }, m(h, n, r);
-}, R = H;
-function F(m, h) {
-  let n;
-  try {
-    n = m();
-  } catch {
-    return;
-  }
-  return {
-    getItem: (s) => {
-      var e;
-      const c = (a) => a === null ? null : JSON.parse(a, void 0), i = (e = n.getItem(s)) != null ? e : null;
-      return i instanceof Promise ? i.then(c) : c(i);
-    },
-    setItem: (s, e) => n.setItem(s, JSON.stringify(e, void 0)),
-    removeItem: (s) => n.removeItem(s)
-  };
+import { createSolanaKeyExportIframe as t, createEvmKeyExportIframe as m } from "./index.native101.js";
+import "@coinbase/cdp-api-client";
+import "./index.native2.js";
+import "./index.native3.js";
+import "jose";
+import "viem";
+import "./index.native82.js";
+import { signEvmHash as i } from "./index.native25.js";
+import { signEvmTransaction as n } from "./index.native26.js";
+import { signEvmMessage as a } from "./index.native27.js";
+import { signEvmTypedData as e } from "./index.native28.js";
+import { signSolanaTransaction as p } from "./index.native29.js";
+import { signSolanaMessage as s } from "./index.native30.js";
+import { sendEvmTransaction as c } from "./index.native31.js";
+import { sendSolanaTransaction as f } from "./index.native32.js";
+import { sendUserOperation as E } from "./index.native33.js";
+import { exportEvmAccount as T } from "./index.native35.js";
+import { exportSolanaAccount as g } from "./index.native36.js";
+const o = {
+  signEvmHash: i,
+  signEvmTransaction: n,
+  signSolanaTransaction: p,
+  sendEvmTransaction: c,
+  sendSolanaTransaction: f,
+  signEvmMessage: a,
+  signSolanaMessage: s,
+  signEvmTypedData: e,
+  sendUserOperation: E,
+  exportEvmAccount: T,
+  exportSolanaAccount: g,
+  createEvmKeyExportIframe: m,
+  createSolanaKeyExportIframe: t
+}, R = Object.keys(o);
+function U(r) {
+  return r in o;
 }
-const p = (m) => (h) => {
-  try {
-    const n = m(h);
-    return n instanceof Promise ? n : {
-      then(r) {
-        return p(r)(n);
-      },
-      catch(r) {
-        return this;
-      }
-    };
-  } catch (n) {
-    return {
-      then(r) {
-        return this;
-      },
-      catch(r) {
-        return p(r)(n);
-      }
-    };
-  }
-}, O = (m, h) => (n, r, s) => {
-  let e = {
-    storage: F(() => localStorage),
-    partialize: (t) => t,
-    version: 0,
-    merge: (t, S) => ({
-      ...S,
-      ...t
-    }),
-    ...h
-  }, c = !1;
-  const i = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
-  let l = e.storage;
-  if (!l)
-    return m(
-      (...t) => {
-        console.warn(
-          `[zustand persist middleware] Unable to update item '${e.name}', the given storage is currently unavailable.`
-        ), n(...t);
-      },
-      r,
-      s
-    );
-  const g = () => {
-    const t = e.partialize({ ...r() });
-    return l.setItem(e.name, {
-      state: t,
-      version: e.version
-    });
-  }, v = s.setState;
-  s.setState = (t, S) => {
-    v(t, S), g();
-  };
-  const f = m(
-    (...t) => {
-      n(...t), g();
-    },
-    r,
-    s
-  );
-  s.getInitialState = () => f;
-  let u;
-  const y = () => {
-    var t, S;
-    if (!l) return;
-    c = !1, i.forEach((o) => {
-      var d;
-      return o((d = r()) != null ? d : f);
-    });
-    const b = ((S = e.onRehydrateStorage) == null ? void 0 : S.call(e, (t = r()) != null ? t : f)) || void 0;
-    return p(l.getItem.bind(l))(e.name).then((o) => {
-      if (o)
-        if (typeof o.version == "number" && o.version !== e.version) {
-          if (e.migrate) {
-            const d = e.migrate(
-              o.state,
-              o.version
-            );
-            return d instanceof Promise ? d.then((I) => [!0, I]) : [!0, d];
-          }
-          console.error(
-            "State loaded from storage couldn't be migrated since no migrate function was provided"
-          );
-        } else
-          return [!1, o.state];
-      return [!1, void 0];
-    }).then((o) => {
-      var d;
-      const [I, _] = o;
-      if (u = e.merge(
-        _,
-        (d = r()) != null ? d : f
-      ), n(u, !0), I)
-        return g();
-    }).then(() => {
-      b?.(u, void 0), u = r(), c = !0, a.forEach((o) => o(u));
-    }).catch((o) => {
-      b?.(void 0, o);
-    });
-  };
-  return s.persist = {
-    setOptions: (t) => {
-      e = {
-        ...e,
-        ...t
-      }, t.storage && (l = t.storage);
-    },
-    clearStorage: () => {
-      l?.removeItem(e.name);
-    },
-    getOptions: () => e,
-    rehydrate: () => y(),
-    hasHydrated: () => c,
-    onHydrate: (t) => (i.add(t), () => {
-      i.delete(t);
-    }),
-    onFinishHydration: (t) => (a.add(t), () => {
-      a.delete(t);
-    })
-  }, e.skipHydration || y(), u || f;
-}, w = O;
 export {
-  F as createJSONStorage,
-  w as persist,
-  R as subscribeWithSelector
+  R as MFA_PROTECTED_ACTIONS,
+  o as MFA_PROTECTED_FUNCTIONS,
+  U as isMfaProtectedAction
 };

package/dist/esm/index.native67.js

@@ -1,50 +1,279 @@
-class n {
-  events = {};
+import { logOutEndUser as u, refreshAccessToken as c, registerTemporaryWalletSecret as f } from "@coinbase/cdp-api-client";
+import "jose";
+import { SignJWT as S } from "./index.native81.js";
+import { toAuthState as d } from "./index.native78.js";
+import "viem";
+import { getPlatformCrypto as l } from "./index.native8.js";
+import { sortKeys as w } from "./index.native82.js";
+import { getCoreOAuthManager as m } from "./index.native56.js";
+const h = 60 * 1e3, y = {
+  maxRetries: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4
+};
+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;
+  }
   /**
-   * Add an event listener.
+   * Gets the currently registered wallet secret ID. Rejects if the user is not signed in.
    *
-   * @param event - The name of the event to listen for.
-   * @param listener - The function to call when the event is emitted.
+   * @returns The wallet secret ID.
    */
-  on(e, s) {
-    this.events[e] || (this.events[e] = []), this.events[e].push(s);
+  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;
   }
   /**
-   * Remove an event listener.
+   * Gets the X-Wallet-Auth header. Rejects if the user is not signed in.
    *
-   * @param event - The name of the event to remove the listener from.
-   * @param listener - The function to remove from the event listeners.
+   * @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.
    */
-  removeListener(e, s) {
-    if (!this.events[e])
+  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;
-    const t = this.events[e].indexOf(s);
-    t > -1 && this.events[e].splice(t, 1);
+    }
+    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);
   }
   /**
-   * Emit an event.
+   * 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.
    *
-   * @param event - The name of the event to emit.
-   * @param args - The arguments to pass to the event listeners.
+   * @returns The new access token.
    */
-  emit(e, ...s) {
-    this.events[e] && this.events[e].forEach((t) => {
+  async refreshAccessToken() {
+    const { maxRetries: e, baseDelayMs: s, maxDelayMs: r } = y;
+    for (let a = 0; a <= e; a++)
       try {
-        t(...s);
+        const i = await c(this.projectId, {
+          grantType: "refresh_token"
+        }), n = d(
+          i.accessToken,
+          i.validUntil,
+          i.endUser
+        );
+        await this.setAuthState(n);
+        return;
       } catch (i) {
-        console.error(`Error in event listener for ${e}:`, i);
+        if (!p(i)) {
+          await this.signOut();
+          return;
+        }
+        if (a === e)
+          return;
+        const o = g(a, s, r);
+        await T(o);
       }
-    });
   }
   /**
-   * Remove all listeners for an event.
+   * 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.
    *
-   * @param event - The name of the event to remove all listeners from. If not provided, removes all listeners for all events.
+   * @returns The wallet secret.
    */
-  removeAllListeners(e) {
-    e ? delete this.events[e] : this.events = {};
+  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 {
-  n as EventEmitter
+  M as AuthManager
 };