@coinbase/cdp-core 0.0.85 → 0.0.86

package/dist/esm/index.web49.js

@@ -1,34 +1,30 @@
-function a(e) {
-  if (typeof btoa < "u")
-    return btoa(
-      Array.from(e).map((t) => String.fromCharCode(t)).join("")
-    );
-  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  let r = "";
-  for (let t = 0; t < e.length; t += 3) {
-    const h = e[t], n = t + 1 < e.length ? e[t + 1] : 0, s = t + 2 < e.length ? e[t + 2] : 0, o = h << 16 | n << 8 | s;
-    r += c.charAt(o >> 18 & 63), r += c.charAt(o >> 12 & 63), r += t + 1 < e.length ? c.charAt(o >> 6 & 63) : "=", r += t + 2 < e.length ? c.charAt(o & 63) : "=";
-  }
-  return r;
-}
-function g(e) {
-  if (typeof atob < "u") {
-    const n = atob(e), s = new Uint8Array(n.length);
-    for (let o = 0; o < n.length; o++)
-      s[o] = n.charCodeAt(o);
-    return s;
-  }
-  const c = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", r = {};
-  for (let n = 0; n < c.length; n++)
-    r[c[n]] = n;
-  const t = e.replace(/[^A-Za-z0-9+/]/g, ""), h = [];
-  for (let n = 0; n < t.length; n += 4) {
-    const s = r[t[n]] || 0, o = r[t[n + 1]] || 0, l = r[t[n + 2]] || 0, f = r[t[n + 3]] || 0, i = s << 18 | o << 12 | l << 6 | f;
-    h.push(i >> 16 & 255), n + 2 < t.length && h.push(i >> 8 & 255), n + 3 < t.length && h.push(i & 255);
-  }
-  return new Uint8Array(h);
-}
+import { sendEvmAssetWithEndUserAccount as o } from "@coinbase/cdp-api-client";
+import { Analytics as c } from "./index.web2.js";
+import "./index.web3.js";
+import { withAuth as s } from "./index.web76.js";
+import { getConfig as n, getCoreAuthManager as m } from "./index.web74.js";
+const A = async (t) => (c.sendActionCallEvent({ name: "send_evm_eoa_usdc" }), n().useMock ? {
+  transactionHash: "0x0"
+} : s(t, m(), async ({ user: e, walletSecretId: a }) => {
+  const r = await o(
+    n().projectId,
+    e.userId,
+    t.evmAccount,
+    "usdc",
+    {
+      to: t.to,
+      amount: t.amount,
+      network: t.network,
+      walletSecretId: a
+    },
+    t.idempotencyKey
+  );
+  if (!r.transactionHash)
+    throw new Error("Expected transaction hash for EOA account");
+  return {
+    transactionHash: r.transactionHash
+  };
+}));
 export {
-  g as decodeBase64,
-  a as encodeBase64
+  A as sendEvmEoaUsdc
 };

package/dist/esm/index.web5.js

@@ -1,4 +1,4 @@
-import { decodeBase64 as y, encodeBase64 as a } from "./index.web49.js";
+import { decodeBase64 as y, encodeBase64 as a } from "./index.web75.js";
 import "@coinbase/cdp-api-client";
 import "viem";
 const p = {

package/dist/esm/index.web50.js

@@ -1,5 +1,32 @@
-import { __require as r } from "./index.web72.js";
-var f = r();
+import { sendEvmAssetWithEndUserAccount as m } from "@coinbase/cdp-api-client";
+import { Analytics as n } from "./index.web2.js";
+import "./index.web3.js";
+import { withAuth as c } from "./index.web76.js";
+import { getConfig as t, getCoreAuthManager as u } from "./index.web74.js";
+const A = async (r) => (n.sendActionCallEvent({ name: "send_evm_smart_account_usdc" }), t().useMock ? {
+  userOpHash: "0x0"
+} : c(r, u(), async ({ user: a, walletSecretId: s }) => {
+  const e = await m(
+    t().projectId,
+    a.userId,
+    r.evmSmartAccount,
+    "usdc",
+    {
+      to: r.to,
+      amount: r.amount,
+      network: r.network,
+      useCdpPaymaster: r.useCdpPaymaster,
+      paymasterUrl: r.paymasterUrl,
+      walletSecretId: s
+    },
+    r.idempotencyKey
+  );
+  if (!e.userOpHash)
+    throw new Error("Expected user operation hash for Smart Account");
+  return {
+    userOpHash: e.userOpHash
+  };
+}));
 export {
-  f as b
+  A as sendEvmSmartAccountUsdc
 };

package/dist/esm/index.web51.js

@@ -1,11 +1,32 @@
-import { AuthManager as r } from "./index.web38.js";
-import { CustomAuthManager as o } from "./index.web52.js";
-import "@coinbase/cdp-api-client";
-import "viem";
-import { getConfig as n } from "./index.web48.js";
-function a(t) {
-  return n().customAuth?.getJwt ? new o(t) : new r(t);
-}
+import { sendSolanaAssetWithEndUserAccount as o } from "@coinbase/cdp-api-client";
+import { Analytics as c } from "./index.web2.js";
+import "./index.web3.js";
+import { withAuth as s } from "./index.web76.js";
+import { getConfig as e, getCoreAuthManager as i } from "./index.web74.js";
+const f = async (t) => {
+  c.sendActionCallEvent({ name: "send_solana_usdc" });
+  const n = t.network ?? "solana";
+  return e().useMock ? {
+    transactionSignature: "mock-signature"
+  } : s(t, i(), async ({ user: a, walletSecretId: r }) => ({
+    transactionSignature: (await o(
+      e().projectId,
+      a.userId,
+      t.solanaAccount,
+      "usdc",
+      // Asset type - currently only "usdc" is supported
+      {
+        to: t.to,
+        amount: t.amount,
+        network: n,
+        createRecipientAta: t.createRecipientAta ?? !1,
+        // Default to false to avoid unexpected costs
+        walletSecretId: r
+      },
+      t.idempotencyKey
+    )).transactionSignature
+  }));
+};
 export {
-  a as createAuthManager
+  f as sendSolanaUsdc
 };

package/dist/esm/index.web52.js

@@ -1,67 +1,119 @@
-import { AuthManager as a } from "./index.web38.js";
-import { getConfig as o } from "./index.web48.js";
-import { CustomAuthError as s } from "./index.web39.js";
-const n = 60 * 60 * 1e3;
-class l extends a {
-  /**
-   * Signs out the user, clearing all authentication state.
-   * For custom auth, we only clear local state without calling the CDP logout API,
-   * as authentication is managed by the external identity provider.
-   */
-  async signOut() {
-    await this.clearAuthState();
-  }
-  /**
-   * Gets the access token by calling the customAuth.getJwt callback.
-   * Returns null if the user is not signed in.
-   *
-   * @returns The access token from the custom auth provider.
-   */
-  async getToken() {
-    const e = o();
-    if (!e.customAuth)
-      return console.error("Custom auth configuration not found"), await this.clearAuthState(), null;
-    try {
-      const t = await e.customAuth.getJwt();
-      return t ? (this.authState && (this.authState.accessToken = t, this.authState.expiresAt = Date.now() + n), t) : (await this.clearAuthState(), null);
-    } catch (t) {
-      const r = new s(
-        t instanceof Error ? t.message : "Failed to get custom auth JWT"
-      );
-      return console.error(r), await this.clearAuthState(), null;
-    }
-  }
-  /**
-   * Internal async initialization logic for custom auth.
-   * No-op for custom auth since tokens are provided via customAuth.getJwt callback.
-   * Unlike standard CDP auth, custom auth doesn't need token refresh or OAuth handling.
-   */
-  async _doInitialize() {
-  }
-  /**
-   * Custom auth always fetches fresh tokens, so never needs to "refresh" in the traditional sense.
-   *
-   * @returns Always false since custom auth doesn't use token refresh logic.
-   */
-  shouldRefreshToken() {
-    return !1;
+import { Analytics as m } from "./index.web2.js";
+import "./index.web3.js";
+import { getCurrentUserSync as u } from "./index.web39.js";
+import { sendEvmEoaUsdc as l } from "./index.web49.js";
+import { sendEvmSmartAccountUsdc as f } from "./index.web50.js";
+import { sendSolanaUsdc as w } from "./index.web51.js";
+const C = async (t) => {
+  m.sendActionCallEvent({ name: "send_usdc" });
+  const { to: a, amount: o } = t, r = u();
+  if (!r)
+    throw new Error("User must be authenticated to send USDC");
+  const e = "from" in t && t.from ? t.from : v(r), n = t.network, { fromIsSolana: s } = E(e, a);
+  return A(n, s), y(r, e, s), s ? {
+    type: "solana",
+    transactionSignature: (await w({
+      solanaAccount: e,
+      to: a,
+      amount: o,
+      network: n,
+      createRecipientAta: "createRecipientAta" in t ? t.createRecipientAta : void 0,
+      idempotencyKey: t.idempotencyKey
+    })).transactionSignature,
+    from: e,
+    network: n
+  } : r.evmAccountObjects?.some((c) => c.address === e) ? {
+    type: "evm-eoa",
+    transactionHash: (await l({
+      evmAccount: e,
+      to: a,
+      amount: o,
+      network: n,
+      idempotencyKey: t.idempotencyKey
+    })).transactionHash,
+    from: e,
+    network: n
+  } : {
+    type: "evm-smart",
+    userOpHash: (await f({
+      evmSmartAccount: e,
+      to: a,
+      amount: o,
+      network: n,
+      useCdpPaymaster: "useCdpPaymaster" in t ? t.useCdpPaymaster : void 0,
+      paymasterUrl: "paymasterUrl" in t ? t.paymasterUrl : void 0,
+      idempotencyKey: t.idempotencyKey
+    })).userOpHash,
+    from: e,
+    network: n
+  };
+};
+function i(t) {
+  return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(t);
+}
+function d(t) {
+  return /^0x[0-9a-fA-F]{40}$/.test(t);
+}
+function h(t) {
+  return t === "solana" || t === "solana-devnet";
+}
+function v(t) {
+  const a = t.solanaAccountObjects?.length || 0, o = t.evmSmartAccountObjects?.length || 0, r = t.evmAccountObjects?.length || 0, e = o > 0 || r > 0, n = a > 0;
+  if (!e && !n)
+    throw new Error(
+      "No accounts available. User must have at least one Solana, EVM Smart Account, or EVM Account."
+    );
+  if (e && n)
+    throw new Error(
+      "Multiple account types detected (EVM and Solana). Please specify 'from' address to select which account to send from."
+    );
+  if (e) {
+    if (o === 1 && r === 1)
+      return t.evmSmartAccountObjects[0].address;
+    if (r === 1 && o === 0)
+      return t.evmAccountObjects[0].address;
+    throw new Error(
+      "Multiple EVM accounts available. Please specify 'from' address to select which account to send from."
+    );
   }
-  /**
-   * Custom auth doesn't use CDP's token refresh mechanism.
-   * Tokens are always provided fresh from the customAuth.getJwt callback.
-   * This method should never be called, but we override it as a defensive measure.
-   */
-  async refreshAccessToken() {
+  if (n) {
+    if (a === 1)
+      return t.solanaAccountObjects[0].address;
+    throw new Error(
+      "Multiple Solana accounts available. Please specify 'from' address to select which account to send from."
+    );
   }
-  /**
-   * Custom auth provides fresh tokens on each request via customAuth.getJwt,
-   * so no scheduled refresh is needed. This method is a no-op for custom auth.
-   */
-  scheduleTokenRefresh() {
-    this.cancelTokenRefresh();
+  throw new Error("Unable to auto-select account");
+}
+function E(t, a) {
+  const o = i(t), r = d(t), e = i(a), n = d(a);
+  if (!o && !r)
+    throw new Error(`Invalid 'from' address format: ${t}`);
+  if (!e && !n)
+    throw new Error(`Invalid 'to' address format: ${a}`);
+  if (o !== e)
+    throw new Error(
+      `Address type mismatch: 'from' is ${o ? "Solana" : "EVM"} but 'to' is ${e ? "Solana" : "EVM"}`
+    );
+  return { fromIsSolana: o, fromIsEvm: r };
+}
+function A(t, a) {
+  const o = h(t);
+  if (a && !o)
+    throw new Error(`Network mismatch: Solana address provided but network is ${t}`);
+  if (!a && o)
+    throw new Error(`Network mismatch: EVM address provided but network is ${t}`);
+}
+function y(t, a, o) {
+  if (o) {
+    if (!t.solanaAccountObjects?.some((e) => e.address === a))
+      throw new Error(`User does not own Solana account: ${a}`);
+  } else {
+    const r = t.evmAccountObjects?.some((n) => n.address === a), e = t.evmSmartAccountObjects?.some((n) => n.address === a);
+    if (!r && !e)
+      throw new Error(`User does not own EVM account: ${a}`);
   }
 }
 export {
-  n as CUSTOM_AUTH_REFRESH_BUFFER_MS,
-  l as CustomAuthManager
+  C as sendUsdc
 };

package/dist/esm/index.web53.js

@@ -1,90 +1,22 @@
-import { verifyOAuth as i } from "./index.web9.js";
-import { getPlatformOAuth as h } from "./index.web4.js";
-import "@coinbase/cdp-api-client";
-import "viem";
-class A {
-  oauthFlowState = null;
-  oauthStateChangeCallbacks = [];
-  /**
-   * Adds a callback to be called when the OAuth state changes.
-   *
-   * @param callback - The function to call when the OAuth state changes.
-   */
-  async addOAuthStateChangeCallback(t) {
-    this.oauthStateChangeCallbacks.push(t), t(this.oauthFlowState);
-  }
-  /**
-   * Sets the OAuth flow state.
-   *
-   * @param oauthFlowState - The OAuth flow state.
-   */
-  async setOAuthFlowState(t) {
-    this.oauthFlowState = t, this.oauthStateChangeCallbacks.forEach((a) => a(this.oauthFlowState));
-  }
-  /**
-   * Clears the OAuth flow state.
-   */
-  async clearOAuthFlowState() {
-    this.oauthFlowState = null, this.oauthStateChangeCallbacks.forEach((t) => t(null));
-  }
-  /**
-   * Gets the OAuth flow state.
-   *
-   * @returns The OAuth flow state.
-   */
-  async getOAuthFlowState() {
-    return this.oauthFlowState;
-  }
-  /**
-   * Handles the OAuth code.
-   *
-   * @param url - The URL to handle.
-   * @returns A promise that resolves when the OAuth code is handled.
-   * @throws An error if the URL is required and not provided.
-   */
-  async handleOAuthCode(t) {
-    try {
-      const a = await h().getOAuthParams(t);
-      if (await h().cleanupOAuthParams(), !a)
-        return;
-      const { providerType: e, code: r, flowId: o, error: s, errorDescription: u } = a;
-      if (s || u) {
-        await this.setOAuthFlowState({
-          providerType: e,
-          status: "error",
-          errorDescription: s ?? u,
-          code: r,
-          flowId: o,
-          error: s
-        });
-        return;
-      }
-      if (!r || !e || !o)
-        return;
-      await this.setOAuthFlowState({
-        providerType: e,
-        status: "pending",
-        code: r,
-        flowId: o
-      }), await i({
-        code: r,
-        providerType: e,
-        flowId: o
-      }), await this.setOAuthFlowState({
-        providerType: e,
-        status: "success",
-        code: r,
-        flowId: o
-      });
-    } catch (a) {
-      const e = a instanceof Error ? a.message : "Unknown error";
-      await h().cleanupOAuthParams(), await this.setOAuthFlowState({
-        status: "error",
-        errorDescription: e
-      });
-    }
-  }
-}
+import { getMfaConfig as t } from "@coinbase/cdp-api-client";
+import { Analytics as n } from "./index.web2.js";
+import "./index.web3.js";
+import { getConfig as e } from "./index.web74.js";
+const s = async () => (n.sendActionCallEvent({ name: "get_mfa_config" }), e().useMock ? {
+  projectId: e().projectId,
+  enabled: !1,
+  totpConfig: {
+    enabled: !1
+  },
+  smsConfig: {
+    enabled: !1
+  },
+  verificationWindowSeconds: 300,
+  promptEnrollmentOnLogin: !1,
+  requireVerificationOnLogin: !1,
+  createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+  updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+} : await t(e().projectId));
 export {
-  A as OAuthManager
+  s as getMfaConfig
 };

package/dist/esm/index.web54.js

@@ -1,26 +1,33 @@
-import "@coinbase/cdp-api-client";
-const e = (t) => ({
-  userId: t.userId,
-  // Deprecated fields - keep for backward compatibility
-  evmAccounts: t.evmAccounts?.map((c) => c) ?? [],
-  evmSmartAccounts: t.evmSmartAccounts?.map((c) => c) ?? [],
-  solanaAccounts: t.solanaAccounts?.map((c) => c) ?? [],
-  // New account object fields
-  evmAccountObjects: t.evmAccountObjects,
-  evmSmartAccountObjects: t.evmSmartAccountObjects,
-  solanaAccountObjects: t.solanaAccountObjects,
-  authenticationMethods: t.authenticationMethods.reduce((c, a) => (c[a.type] = a, c), {}),
-  mfaMethods: t.mfaMethods,
-  lastAuthenticatedAt: t.lastAuthenticatedAt
-}), s = (t, c, a) => {
-  const o = new Date(c).getTime();
-  return {
-    accessToken: t,
-    expiresAt: o,
-    user: e(a)
-  };
+import { recordMfaEnrollmentPrompted as s } from "@coinbase/cdp-api-client";
+import { Analytics as l } from "./index.web2.js";
+import "./index.web3.js";
+import { withAuth as d } from "./index.web76.js";
+import { validateUserAuthState as p } from "./index.web80.js";
+import { getConfig as o, getCoreAuthManager as i } from "./index.web74.js";
+const M = async (n) => {
+  if (l.sendActionCallEvent({ name: "record_mfa_enrollment_prompted" }), o().useMock)
+    return {
+      enrollmentPromptedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  const t = i(), { user: e, authState: m } = p(
+    t.getUser(),
+    t.getAuthState()
+  ), r = await d({}, t, async ({ user: a }) => s(
+    o().projectId,
+    a.userId,
+    n?.idempotencyKey
+  ));
+  return await t.setAuthState({
+    ...m,
+    user: {
+      ...e,
+      mfaMethods: {
+        enrollmentPromptedAt: r.enrollmentPromptedAt,
+        ...e.mfaMethods
+      }
+    }
+  }), r;
 };
 export {
-  s as toAuthState,
-  e as toAuthStateUser
+  M as recordMfaEnrollmentPrompted
 };

package/dist/esm/index.web55.js

@@ -1,20 +1,67 @@
-import "@coinbase/cdp-api-client";
-import "viem";
-const u = async (c) => await c.isSignedIn();
-async function A(c, a, r) {
-  if (!await u(a))
-    throw new Error("User not signed in");
-  const t = a.getUser();
-  if ("evmAccount" in c && !(t.evmAccounts?.find((n) => n === c.evmAccount) || t.evmAccountObjects?.find((n) => n.address === c.evmAccount)))
-    throw new Error("EVM account not found");
-  if ("evmSmartAccount" in c && !(t.evmSmartAccounts?.find((n) => n === c.evmSmartAccount) || t.evmSmartAccountObjects?.find((n) => n.address === c.evmSmartAccount)))
-    throw new Error("EVM Smart Account not found");
-  if ("solanaAccount" in c && !(t.solanaAccounts?.find((n) => n === c.solanaAccount) || t.solanaAccountObjects?.find((n) => n.address === c.solanaAccount)))
-    throw new Error("Solana account not found");
-  const e = await a.getWalletSecretId();
-  return r({ ...c, user: t, walletSecretId: e });
+import { initiateMfaEnrollment2 as a } from "@coinbase/cdp-api-client";
+import { Analytics as u } from "./index.web2.js";
+import "./index.web3.js";
+import { withAuth as c } from "./index.web76.js";
+import { validateUserAuthState as i } from "./index.web80.js";
+import { getConfig as o, getCoreAuthManager as p } from "./index.web74.js";
+import { validatePhoneNumber as h } from "./index.web68.js";
+async function l(t, e) {
+  const r = await a(
+    o().projectId,
+    t.userId,
+    "totp",
+    { type: "totp" },
+    e
+  );
+  return {
+    method: "totp",
+    authUrl: r.authUrl,
+    secret: r.secret
+  };
 }
+async function f(t, e, r) {
+  return {
+    method: "sms",
+    success: (await a(
+      o().projectId,
+      t.userId,
+      "sms",
+      { type: "sms", phoneNumber: e },
+      r
+    )).success
+  };
+}
+function d() {
+  return {
+    method: "totp",
+    authUrl: "otpauth://totp/MockApp:mock@example.com?secret=MOCKTOTP&issuer=MockApp",
+    secret: "MOCKTOTP"
+  };
+}
+function M() {
+  return {
+    method: "sms",
+    success: !0
+  };
+}
+const C = async (t) => {
+  if (u.sendActionCallEvent({ name: "initiate_mfa_enrollment" }), t.mfaMethod === "sms" && h(t.phoneNumber), o().useMock)
+    return t.mfaMethod === "totp" ? d() : M();
+  const e = p(), { user: r, authState: n } = i(
+    e.getUser(),
+    e.getAuthState()
+  ), m = await c({}, e, async ({ user: s }) => t.mfaMethod === "totp" ? l(s, t.idempotencyKey) : f(s, t.phoneNumber, t.idempotencyKey));
+  return await e.setAuthState({
+    ...n,
+    user: {
+      ...r,
+      mfaMethods: {
+        enrollmentPromptedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        ...r.mfaMethods
+      }
+    }
+  }), m;
+};
 export {
-  u as isSignedIn,
-  A as withAuth
+  C as initiateMfaEnrollment
 };