@coinbase/cdp-core 0.0.124 → 0.0.126

package/dist/web/index.web83.js

@@ -1,12 +1,21 @@
-import { initiateMfaEnrollment2 as a } from "@coinbase/cdp-api-client";
-import { Analytics as c } from "./index.web2.js";
+import { initiateMfaEnrollment2 as i } from "@coinbase/cdp-api-client";
+import { Analytics as u } from "./index.web2.js";
 import "./index.web3.js";
-import { withAuth as u } from "./index.web109.js";
-import { validateUserAuthState as i } from "./index.web115.js";
-import { getConfig as o, getCoreAuthManager as p } from "./index.web81.js";
-import { validatePhoneNumber as h } from "./index.web100.js";
-async function l(t, e) {
-  const r = await a(
+import { withAuth as p } from "./index.web109.js";
+import { getConfig as o, getCoreAuthManager as h } from "./index.web81.js";
+import "viem";
+import { withMfa as l } from "./index.web93.js";
+import { validateUserAuthState as f } from "./index.web116.js";
+import "jose";
+import "./index.web110.js";
+import "./index.web111.js";
+import "@solana/web3.js";
+import "bs58";
+import "./index.web104.js";
+import "./index.web113.js";
+import { validatePhoneNumber as d } from "./index.web100.js";
+async function M(t, e) {
+  const r = await i(
     t.userId,
     "totp",
     { type: "totp" },
@@ -19,10 +28,10 @@ async function l(t, e) {
     secret: r.secret
   };
 }
-async function f(t, e, r) {
+async function A(t, e, r) {
   return {
     method: "sms",
-    success: (await a(
+    success: (await i(
       t.userId,
       "sms",
       { type: "sms", phoneNumber: e },
@@ -31,37 +40,39 @@ async function f(t, e, r) {
     )).success
   };
 }
-function d() {
+function g() {
   return {
     method: "totp",
     authUrl: "otpauth://totp/MockApp:mock@example.com?secret=MOCKTOTP&issuer=MockApp",
     secret: "MOCKTOTP"
   };
 }
-function M() {
+function y() {
   return {
     method: "sms",
     success: !0
   };
 }
-const T = async (t) => {
-  if (c.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(
+const x = async (t) => {
+  if (u.sendActionCallEvent({ name: "initiate_mfa_enrollment" }), t.mfaMethod === "sms" && d(t.phoneNumber), o().useMock)
+    return t.mfaMethod === "totp" ? g() : y();
+  const e = h(), { user: r, authState: s } = f(
     e.getUser(),
     e.getAuthState()
-  ), m = await u({}, e, async ({ user: s }) => t.mfaMethod === "totp" ? l(s, t.idempotencyKey) : f(s, t.phoneNumber, t.idempotencyKey));
+  ), c = await l(
+    () => p({}, e, async ({ user: a }) => t.mfaMethod === "totp" ? M(a, t.idempotencyKey) : A(a, t.phoneNumber, t.idempotencyKey))
+  ), m = e.getAuthState() ?? s, n = m.user ?? r;
   return await e.setAuthState({
-    ...n,
+    ...m,
     user: {
-      ...r,
+      ...n,
       mfaMethods: {
         enrollmentPromptedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        ...r.mfaMethods
+        ...n.mfaMethods
       }
     }
-  }), m;
+  }), c;
 };
 export {
-  T as initiateMfaEnrollment
+  x as initiateMfaEnrollment
 };

package/dist/web/index.web84.js

@@ -1,27 +1,38 @@
-import { submitMfaEnrollment as u } from "@coinbase/cdp-api-client";
-import { Analytics as i } from "./index.web2.js";
+import { submitMfaEnrollment as s } from "@coinbase/cdp-api-client";
+import { Analytics as u } from "./index.web2.js";
 import "./index.web3.js";
-import { toAuthStateUser as f } from "./index.web114.js";
-import { withAuth as c } from "./index.web109.js";
-import { mockUser as l } from "./index.web119.js";
-import { validateUserAuthState as h } from "./index.web115.js";
-import { getConfig as o, getCoreAuthManager as p } from "./index.web81.js";
-const E = async (e) => {
-  if (i.sendActionCallEvent({ name: "submit_mfa_enrollment" }), o().useMock)
+import { toAuthStateUser as p } from "./index.web115.js";
+import { withAuth as f } from "./index.web109.js";
+import { getConfig as o, getCoreAuthManager as c } from "./index.web81.js";
+import "viem";
+import { withMfa as l } from "./index.web93.js";
+import { validateUserAuthState as h } from "./index.web116.js";
+import "jose";
+import "./index.web110.js";
+import { mockUser as A } from "./index.web119.js";
+import "./index.web111.js";
+import "@solana/web3.js";
+import "bs58";
+import "./index.web104.js";
+import "./index.web113.js";
+const K = async (e) => {
+  if (u.sendActionCallEvent({ name: "submit_mfa_enrollment" }), o().useMock)
     return {
-      user: l
+      user: A
     };
-  const t = p(), { authState: a } = h(t.getUser(), t.getAuthState()), m = await c({}, t, async ({ user: s }) => u(
-    s.userId,
-    e.mfaMethod,
-    {
-      mfaCode: e.mfaCode
-    },
-    { projectID: o().projectId },
-    e.idempotencyKey
-  )), r = f(m.endUser), n = t.getAuthState() ?? a;
-  return await t.setAuthState({ ...n, user: r }), { user: r };
+  const t = c(), { authState: m } = h(t.getUser(), t.getAuthState()), a = await l(
+    () => f({}, t, async ({ user: n }) => s(
+      n.userId,
+      e.mfaMethod,
+      {
+        mfaCode: e.mfaCode
+      },
+      { projectID: o().projectId },
+      e.idempotencyKey
+    ))
+  ), r = p(a.endUser), i = t.getAuthState() ?? m;
+  return await t.setAuthState({ ...i, user: r }), { user: r };
 };
 export {
-  E as submitMfaEnrollment
+  K as submitMfaEnrollment
 };

package/dist/web/index.web85.js

@@ -1,19 +1,21 @@
 import { initiateMfaVerification as a } from "@coinbase/cdp-api-client";
 import { Analytics as r } from "./index.web2.js";
 import "./index.web3.js";
-import { withAuth as o } from "./index.web109.js";
-import { getConfig as t, getCoreAuthManager as n } from "./index.web81.js";
-const u = async (i) => {
-  if (r.sendActionCallEvent({ name: "initiate_mfa_verification" }), !t().useMock)
-    return o({}, n(), async ({ user: e }) => {
-      await a(
-        e.userId,
-        i.mfaMethod,
-        { projectID: t().projectId },
-        i.idempotencyKey
-      );
-    });
+import { withAuth as n } from "./index.web109.js";
+import { getPendingMfaChallengeId as o } from "./index.web4.js";
+import { getConfig as i, getCoreAuthManager as f } from "./index.web81.js";
+const h = async (e) => {
+  if (r.sendActionCallEvent({ name: "initiate_mfa_verification" }), !i().useMock)
+    return n({}, f(), async ({ user: t }) => await a(
+      t.userId,
+      e.mfaMethod,
+      { projectID: i().projectId },
+      {
+        idempotencyKey: e.idempotencyKey,
+        mfaChallengeId: e.challengeId ?? o()
+      }
+    ));
 };
 export {
-  u as initiateMfaVerification
+  h as initiateMfaVerification
 };

package/dist/web/index.web86.js

@@ -1,37 +1,43 @@
-import { submitMfaVerification as m } from "@coinbase/cdp-api-client";
-import { Analytics as n } from "./index.web2.js";
+import { submitMfaVerification as c, APIError as s, ErrorType as d } from "@coinbase/cdp-api-client";
+import { Analytics as u } from "./index.web2.js";
 import "./index.web3.js";
-import { withAuth as s } from "./index.web109.js";
-import { resolvePendingMfaVerification as i } from "./index.web4.js";
-import { getConfig as r, getCoreAuthManager as o } from "./index.web81.js";
-const p = async (t) => {
-  if (n.sendActionCallEvent({ name: "submit_mfa_verification" }), r().useMock) {
+import { withAuth as h } from "./index.web109.js";
+import { resolvePendingMfaVerification as i, getPendingMfaChallengeId as g, rejectPendingMfaVerification as l } from "./index.web4.js";
+import { isRequestScope as o } from "./index.web93.js";
+import { getConfig as f, getCoreAuthManager as n } from "./index.web81.js";
+const S = async (e) => {
+  if (u.sendActionCallEvent({ name: "submit_mfa_verification" }), f().useMock) {
     i();
     return;
   }
-  await s(t, o(), async ({ user: f }) => {
-    await m(
-      f.userId,
-      t.mfaMethod,
-      {
-        mfaCode: t.mfaCode
-      },
-      { projectID: r().projectId },
-      t.idempotencyKey
-    );
-    const a = o(), e = a.getAuthState();
-    e && await a.setAuthState({
-      ...e,
+  await h(e, n(), async ({ user: m }) => {
+    try {
+      await c(
+        m.userId,
+        e.mfaMethod,
+        { mfaCode: e.mfaCode },
+        { projectID: f().projectId },
+        {
+          idempotencyKey: e.idempotencyKey,
+          mfaChallengeId: e.challengeId ?? g()
+        }
+      );
+    } catch (a) {
+      throw o() && a instanceof s && a.errorType === d.mfa_invalid_code && l(a), a;
+    }
+    const r = n(), t = r.getAuthState();
+    t && await r.setAuthState({
+      ...t,
       user: {
-        ...e.user,
+        ...t.user,
         mfaMethods: {
-          ...e.user.mfaMethods,
+          ...t.user.mfaMethods,
           lastVerificationCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
         }
       }
-    }), await a.getToken({ forceRefresh: !0 }), i();
+    }), o() || await r.getToken({ forceRefresh: !0 }), i();
   });
 };
 export {
-  p as submitMfaVerification
+  S as submitMfaVerification
 };

package/dist/web/index.web88.js

@@ -1,58 +1,77 @@
-import { initiateMfaEnrollment2 as y, submitMfaEnrollment as d } from "@coinbase/cdp-api-client";
-import { Analytics as f } from "./index.web2.js";
+import { initiateMfaEnrollment2 as h, submitMfaEnrollment as y } from "@coinbase/cdp-api-client";
+import { Analytics as S } from "./index.web2.js";
 import "./index.web3.js";
-import { toAuthStateUser as h } from "./index.web114.js";
-import { withAuth as S } from "./index.web109.js";
-import { MfaError as i, InternalError as A } from "./index.web99.js";
-import { mockUser as w } from "./index.web119.js";
-import { validateUserAuthState as E } from "./index.web115.js";
-import { isPasskeySupported as k, deserializeCreationOptions as M, mapCeremonyError as P, PASSKEY_PROMPT_DISMISSED as g, serializeAttestationResponse as I } from "./index.web107.js";
-import { getConfig as a, getCoreAuthManager as C } from "./index.web81.js";
-const z = async (t = {}) => {
-  if (f.sendActionCallEvent({ name: "enroll_passkey" }), a().useMock)
-    return { user: w };
-  if (!await k())
-    throw new i(
+import { toAuthStateUser as A } from "./index.web115.js";
+import { withAuth as s } from "./index.web109.js";
+import { MfaError as m, InternalError as w } from "./index.web99.js";
+import { getConfig as a, getCoreAuthManager as E } from "./index.web81.js";
+import "viem";
+import { withMfa as p } from "./index.web93.js";
+import { validateUserAuthState as k } from "./index.web116.js";
+import "jose";
+import "./index.web110.js";
+import { mockUser as M } from "./index.web119.js";
+import "./index.web111.js";
+import "@solana/web3.js";
+import "bs58";
+import "./index.web104.js";
+import { isPasskeySupported as P, deserializeCreationOptions as g, mapCeremonyError as I, PASSKEY_PROMPT_DISMISSED as C, serializeAttestationResponse as O } from "./index.web107.js";
+import "./index.web113.js";
+const J = async (r = {}) => {
+  if (S.sendActionCallEvent({ name: "enroll_passkey" }), a().useMock)
+    return { user: M };
+  if (!await P())
+    throw new m(
       "PASSKEY_NOT_SUPPORTED",
       "Passkeys are not supported in the current environment."
     );
-  const e = C(), { authState: m } = E(e.getUser(), e.getAuthState()), p = await S({}, e, async ({ user: n }) => {
-    const s = await y(
-      n.userId,
-      "passkey",
-      { type: "passkey" },
-      { projectID: a().projectId },
-      t.idempotencyKey
+  const t = E(), { authState: c } = k(t.getUser(), t.getAuthState()), n = await p(
+    () => s(
+      {},
+      t,
+      ({ user: e }) => h(
+        e.userId,
+        "passkey",
+        { type: "passkey" },
+        { projectID: a().projectId },
+        r.idempotencyKey
+      )
+    )
+  );
+  if (!n?.creationOptions)
+    throw new w(
+      "Passkey enrollment did not return credential creation options. The server may have started a different MFA method."
     );
-    if (!s?.creationOptions)
-      throw new A(
-        "Passkey enrollment did not return credential creation options. The server may have started a different MFA method."
-      );
-    const l = M(s.creationOptions);
-    let r;
-    try {
-      r = await navigator.credentials.create({
-        publicKey: l
-      });
-    } catch (u) {
-      throw P(u);
-    }
-    if (!r)
-      throw new i("CANCELLED", g);
-    return d(
-      n.userId,
-      "passkey",
-      {
-        type: "passkey",
-        credential: I(r),
-        ...t.name ? { name: t.name } : {}
-      },
-      { projectID: a().projectId },
-      t.idempotencyKey
-    );
-  }), o = h(p.endUser), c = e.getAuthState() ?? m;
-  return await e.setAuthState({ ...c, user: o }), { user: o };
+  const l = g(n.creationOptions);
+  let o;
+  try {
+    o = await navigator.credentials.create({
+      publicKey: l
+    });
+  } catch (e) {
+    throw I(e);
+  }
+  if (!o)
+    throw new m("CANCELLED", C);
+  const u = O(o), f = await p(
+    () => s(
+      {},
+      t,
+      ({ user: e }) => y(
+        e.userId,
+        "passkey",
+        {
+          type: "passkey",
+          credential: u,
+          ...r.name ? { name: r.name } : {}
+        },
+        { projectID: a().projectId },
+        r.idempotencyKey
+      )
+    )
+  ), i = A(f.endUser), d = t.getAuthState() ?? c;
+  return await t.setAuthState({ ...d, user: i }), { user: i };
 };
 export {
-  z as enrollPasskey
+  J as enrollPasskey
 };

package/dist/web/index.web89.js

@@ -1,66 +1,81 @@
-import { initiateMfaVerification as u, submitMfaVerification as d } from "@coinbase/cdp-api-client";
-import { Analytics as y } from "./index.web2.js";
+import { initiateMfaVerification as u, submitMfaVerification as g, APIError as w, ErrorType as I } from "@coinbase/cdp-api-client";
+import { Analytics as S } from "./index.web2.js";
 import "./index.web3.js";
-import { withAuth as h } from "./index.web109.js";
-import { MfaError as n, InternalError as w } from "./index.web99.js";
-import { resolvePendingMfaVerification as p } from "./index.web4.js";
-import { isPasskeySupported as l, deserializeRequestOptions as S, mapCeremonyError as A, PASSKEY_PROMPT_DISMISSED as M, serializeAssertionResponse as g } from "./index.web107.js";
-import { getConfig as i, getCoreAuthManager as c } from "./index.web81.js";
-const R = async (a = {}) => {
-  if (y.sendActionCallEvent({ name: "verify_passkey" }), i().useMock) {
+import { withAuth as A } from "./index.web109.js";
+import { MfaError as o, InternalError as f } from "./index.web99.js";
+import { resolvePendingMfaVerification as p, getPendingMfaChallengeId as d, rejectPendingMfaVerification as M } from "./index.web4.js";
+import { isRequestScope as m } from "./index.web93.js";
+import { isPasskeySupported as P, deserializeRequestOptions as E, mapCeremonyError as C, PASSKEY_PROMPT_DISMISSED as k, serializeAssertionResponse as v } from "./index.web107.js";
+import { getConfig as n, getCoreAuthManager as y } from "./index.web81.js";
+const b = async (t = {}) => {
+  if (S.sendActionCallEvent({ name: "verify_passkey" }), n().useMock) {
     p();
     return;
   }
-  if (!await l())
-    throw new n(
+  if (!await P())
+    throw new o(
       "PASSKEY_NOT_SUPPORTED",
       "Passkeys are not supported in the current environment."
     );
-  await h({}, c(), async ({ user: o }) => {
-    const s = await u(
-      o.userId,
+  return A({}, y(), async ({ user: s }) => {
+    const c = await u(
+      s.userId,
       "passkey",
-      { projectID: i().projectId },
-      a.idempotencyKey
+      { projectID: n().projectId },
+      {
+        idempotencyKey: t.idempotencyKey,
+        mfaChallengeId: t.challengeId ?? d()
+      }
     );
-    if (!s?.requestOptions)
-      throw new w(
+    if (!c?.requestOptions)
+      throw new f(
         "Passkey verification did not return credential request options. The server may have started a different MFA method."
       );
-    const f = S(s.requestOptions);
-    let t;
+    const l = E(c.requestOptions);
     try {
-      t = await navigator.credentials.get({
-        publicKey: f
-      });
-    } catch (m) {
-      throw A(m);
+      let e;
+      try {
+        e = await navigator.credentials.get({
+          publicKey: l
+        });
+      } catch (a) {
+        throw C(a);
+      }
+      if (!e)
+        throw new o("CANCELLED", k);
+      await g(
+        s.userId,
+        "passkey",
+        {
+          type: "passkey",
+          credential: v(e)
+        },
+        { projectID: n().projectId },
+        {
+          idempotencyKey: t.idempotencyKey,
+          mfaChallengeId: t.challengeId ?? d()
+        }
+      );
+    } catch (e) {
+      if (m()) {
+        const a = e instanceof w && e.errorType === I.mfa_invalid_code, h = e instanceof o || e instanceof f;
+        (a || h) && M(e);
+      }
+      throw e;
     }
-    if (!t)
-      throw new n("CANCELLED", M);
-    await d(
-      o.userId,
-      "passkey",
-      {
-        type: "passkey",
-        credential: g(t)
-      },
-      { projectID: i().projectId },
-      a.idempotencyKey
-    );
-    const r = c(), e = r.getAuthState();
-    e && await r.setAuthState({
-      ...e,
+    const i = y(), r = i.getAuthState();
+    r && await i.setAuthState({
+      ...r,
       user: {
-        ...e.user,
+        ...r.user,
         mfaMethods: {
-          ...e.user.mfaMethods,
+          ...r.user.mfaMethods,
           lastVerificationCompletedAt: (/* @__PURE__ */ new Date()).toISOString()
         }
       }
-    }), await r.getToken({ forceRefresh: !0 }), p();
+    }), m() || await i.getToken({ forceRefresh: !0 }), p();
   });
 };
 export {
-  R as verifyPasskey
+  b as verifyPasskey
 };

package/dist/web/index.web9.js

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

package/dist/web/index.web93.js

@@ -1,51 +1,59 @@
-import { APIError as u, ErrorType as l } from "@coinbase/cdp-api-client";
-import { MfaError as M } from "./index.web99.js";
-import { getCoreAuthManager as a, getMfaConfigState as m } from "./index.web81.js";
-import { hasRegisteredMfaListeners as i, triggerMfaVerification as o } from "./index.web4.js";
-import { isEnrolledInMfa as w, getEnrolledMfaMethods as E } from "./index.web92.js";
-const g = 300, n = () => {
-  const e = a().getUser();
-  return e ? E(e) : [];
-}, s = () => {
-  throw new M(
+import { APIError as E, ErrorType as w, MfaVerificationScope as m } from "@coinbase/cdp-api-client";
+import { MfaError as d } from "./index.web99.js";
+import { getCoreAuthManager as u, getMfaConfigState as l } from "./index.web81.js";
+import { hasRegisteredMfaListeners as o, triggerMfaVerification as n } from "./index.web4.js";
+import { isEnrolledInMfa as g, getEnrolledMfaMethods as p } from "./index.web92.js";
+const S = 300, a = () => {
+  const e = u().getUser();
+  return e ? p(e) : [];
+}, f = () => l()?.verificationScope === m.MfaVerificationScopeRequest, s = () => {
+  throw new d(
     "LISTENER_REQUIRED",
     "MFA verification is required but no listener is registered."
   );
 };
-async function T(e) {
-  if (f()) {
-    i() || s();
-    const r = n();
-    await o(r);
+async function y(e) {
+  if (h() && !f()) {
+    o() || s();
+    const r = a();
+    await n(r);
   }
   try {
     return await e();
   } catch (r) {
-    if (r instanceof u && r.errorType === l.mfa_required) {
-      i() || s();
-      const t = n();
-      return await o(t), await e();
+    if (r instanceof E && r.errorType === w.mfa_required) {
+      const t = r.headers?.["x-mfa-challenge-id"], i = Array.isArray(t) ? t[0] : t;
+      o() || s();
+      const c = a();
+      return await n(c, void 0, i ? { challengeId: i } : void 0), await e();
     }
     throw r;
   }
 }
-function f() {
-  const e = a().getUser();
-  if (!e || !w(e)) return !1;
+function h() {
+  const e = u().getUser();
+  if (!e || !g(e)) return !1;
+  if (f()) return !0;
   const t = e?.mfaMethods?.lastVerificationCompletedAt;
   if (!t) return !0;
-  const c = new Date(t).getTime(), d = (m()?.verificationWindowSeconds ?? g) * 1e3;
-  return Date.now() > c + d;
+  const i = new Date(t).getTime(), M = (l()?.verificationWindowSeconds ?? S) * 1e3;
+  return Date.now() > i + M;
 }
-async function D() {
-  if (!f())
+async function V() {
+  if (f())
+    throw new d(
+      "REQUEST_SCOPE_UNSUPPORTED",
+      "MFA cannot be verified ahead of an operation when the project's verificationScope is 'request', because the challenge is issued by the operation itself."
+    );
+  if (!h())
     return;
-  i() || s();
-  const e = n();
-  await o(e);
+  o() || s();
+  const e = a();
+  await n(e);
 }
 export {
-  D as ensureMfaVerified,
-  f as isMfaRequired,
-  T as withMfa
+  V as ensureMfaVerified,
+  h as isMfaRequired,
+  f as isRequestScope,
+  y as withMfa
 };