@coinbase/cdp-core 0.0.15 → 0.0.17

package/dist/esm/index.js

@@ -1,23 +1,31 @@
-import { exportEvmAccount as t, getCurrentUser as i, initialize as n, isSignedIn as o, onAuthStateChange as a, sendEvmTransaction as m, signEvmHash as s, signEvmMessage as E, signEvmTransaction as g, signEvmTypedData as v, signInWithEmail as c, signOut as d, verifyEmailOTP as p } from "./index2.js";
-import { createCDPEmbeddedWallet as l } from "./index3.js";
-import { EIP1193ProviderError as x, STANDARD_ERROR_CODES as A } from "./index4.js";
-import { toViemAccount as T } from "./index5.js";
+import { exportEvmAccount as n, getCurrentUser as m, initialize as E, isSignedIn as a, onAuthStateChange as s, sendEvmTransaction as p, signEvmHash as c, signEvmMessage as d, signEvmTransaction as g, signEvmTypedData as v, signInWithEmail as T, signOut as A, verifyEmailOTP as f } from "./index2.js";
+import { APIError as x, ErrorType as h, HttpErrorType as l, SendEvmTransactionWithEndUserAccountBodyNetwork as y } from "@coinbase/cdp-api-client";
+import "viem";
+import { createCDPEmbeddedWallet as P } from "./index3.js";
+import { EIP1193ProviderError as C, STANDARD_ERROR_CODES as I } from "./index4.js";
+import "ox";
+import "zustand";
+import { toViemAccount as R } from "./index5.js";
 export {
-  x as EIP1193ProviderError,
-  A as STANDARD_ERROR_CODES,
-  l as createCDPEmbeddedWallet,
-  t as exportEvmAccount,
-  i as getCurrentUser,
-  n as initialize,
-  o as isSignedIn,
-  a as onAuthStateChange,
-  m as sendEvmTransaction,
-  s as signEvmHash,
-  E as signEvmMessage,
+  x as APIError,
+  C as EIP1193ProviderError,
+  h as ErrorType,
+  l as HttpErrorType,
+  I as STANDARD_ERROR_CODES,
+  y as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  P as createCDPEmbeddedWallet,
+  n as exportEvmAccount,
+  m as getCurrentUser,
+  E as initialize,
+  a as isSignedIn,
+  s as onAuthStateChange,
+  p as sendEvmTransaction,
+  c as signEvmHash,
+  d as signEvmMessage,
   g as signEvmTransaction,
   v as signEvmTypedData,
-  c as signInWithEmail,
-  d as signOut,
-  T as toViemAccount,
-  p as verifyEmailOTP
+  T as signInWithEmail,
+  A as signOut,
+  R as toViemAccount,
+  f as verifyEmailOTP
 };

package/dist/esm/index11.js

@@ -1,5 +1,7 @@
+import "@coinbase/cdp-api-client";
+import "viem";
 import { mockUser as e } from "./index12.js";
-class h {
+class r {
   authState = null;
   authStateChangeCallback = null;
   /**
@@ -115,5 +117,5 @@ class h {
   }
 }
 export {
-  h as MockAuthManager
+  r as MockAuthManager
 };

package/dist/esm/index12.js

@@ -1,6 +1,8 @@
-const e = "0x0000000000000000000000000000000000000000", t = {
+import "@coinbase/cdp-api-client";
+import "viem";
+const t = "0x0000000000000000000000000000000000000000", s = {
   userId: "mock-user-id",
-  evmAccounts: [e],
+  evmAccounts: [t],
   authenticationMethods: {
     email: {
       type: "email",
@@ -9,6 +11,6 @@ const e = "0x0000000000000000000000000000000000000000", t = {
   }
 };
 export {
-  e as mockAddress,
-  t as mockUser
+  t as mockAddress,
+  s as mockUser
 };

package/dist/esm/index14.js

@@ -1,20 +1,22 @@
-let n = null, e = null;
-const r = (t) => {
+import "@coinbase/cdp-api-client";
+import "viem";
+let n = null, r = null;
+const i = (t) => {
   n = t;
-}, o = () => {
+}, a = () => {
   if (!n)
     throw new Error("SDK not initialized");
   return n;
-}, i = (t) => {
-  e = t;
-}, a = () => {
-  if (!e)
+}, g = (t) => {
+  r = t;
+}, l = () => {
+  if (!r)
     throw new Error("SDK not initialized");
-  return e;
+  return r;
 };
 export {
-  o as getConfig,
-  a as getCoreAuthManager,
-  r as setConfig,
-  i as setCoreAuthManager
+  a as getConfig,
+  l as getCoreAuthManager,
+  i as setConfig,
+  g as setCoreAuthManager
 };

package/dist/esm/index19.js

@@ -1,8 +1,10 @@
 import { Hex as y } from "ox";
 import { createWalletClient as I } from "viem";
 import { signEvmTypedData as E, signEvmHash as S, getCurrentUser as f, signOut as P, sendEvmTransaction as R, signEvmTransaction as T, signEvmMessage as A } from "./index2.js";
+import "@coinbase/cdp-api-client";
 import "./index3.js";
 import { validateUserOwnsAddress as m, EIP1193ProviderError as l, STANDARD_ERROR_CODES as s, RPCRequestError as o, validateUserHasEvmAccount as x, validateUserConnected as C } from "./index4.js";
+import "zustand";
 import { isChainIdSupportedForCDPSends as D, chainIdToNameMapping as b } from "./index13.js";
 function g(e) {
   return {
@@ -16,16 +18,16 @@ function g(e) {
     type: "eip1559"
   };
 }
-async function U() {
+async function M() {
   return (await f())?.evmAccounts || [];
 }
-async function H(e, n) {
+async function _(e, n) {
   const a = await C();
   return e.emit("connect", {
     chainId: y.fromNumber(n.getState().chainId)
   }), a.evmAccounts || [];
 }
-async function M(e) {
+async function k(e) {
   const [n, a] = e;
   await m(a);
   const t = Buffer.from(n.slice(2), "hex").toString();
@@ -41,7 +43,7 @@ async function M(e) {
     );
   }
 }
-async function _(e) {
+async function z(e) {
   const [n, a] = e;
   await m(n);
   try {
@@ -56,7 +58,7 @@ async function _(e) {
     );
   }
 }
-async function k(e, n, a) {
+async function J(e, n, a) {
   const [t] = e;
   if (!t || typeof t != "object")
     throw new o(
@@ -114,7 +116,7 @@ async function k(e, n, a) {
       );
     }
 }
-async function z(e) {
+async function V(e) {
   const [n, a] = e;
   await m(a);
   try {
@@ -129,25 +131,25 @@ async function z(e) {
     );
   }
 }
-async function J(e) {
+async function W(e) {
   return `0x${e.getState().chainId.toString(16)}`;
 }
-async function V() {
+async function $() {
   await f() && await P();
 }
-function W(e, n) {
+function K(e, n) {
   const a = Number.parseInt(e[0].chainId, 16);
   n.getState().setChainId(a);
 }
 export {
-  U as handleAccounts,
-  J as handleChainId,
-  V as handleDisconnect,
-  z as handleEthSign,
-  M as handlePersonalSign,
-  H as handleRequestAccounts,
-  k as handleSendTransaction,
-  _ as handleSignTypedData,
-  W as handleSwitchEthereumChain,
+  M as handleAccounts,
+  W as handleChainId,
+  $ as handleDisconnect,
+  V as handleEthSign,
+  k as handlePersonalSign,
+  _ as handleRequestAccounts,
+  J as handleSendTransaction,
+  z as handleSignTypedData,
+  K as handleSwitchEthereumChain,
   g as shimProviderTxRequest
 };

package/dist/esm/index2.js

@@ -1,15 +1,16 @@
-import { configureCdpApiClient as p, setAuthManager as w, initiateAuthentication as h, verifyEmailAuthentication as y, createEndUserEvmAccount as f, signEvmHashWithEndUserAccount as I, signEvmTransactionWithEndUserAccount as l, sendEvmTransactionWithEndUserAccount as v, signEvmMessageWithEndUserAccount as A, signEvmTypedDataWithEndUserAccount as E, exportEndUserEvmAccount as k } from "@coinbase/cdp-api-client";
-import { AuthManager as M } from "./index6.js";
+import { configureCdpApiClient as w, setAuthManager as h, initiateAuthentication as y, verifyEmailAuthentication as f, createEndUserEvmAccount as I, signEvmHashWithEndUserAccount as l, signEvmTransactionWithEndUserAccount as A, sendEvmTransactionWithEndUserAccount as v, signEvmMessageWithEndUserAccount as E, signEvmTypedDataWithEndUserAccount as k, exportEndUserEvmAccount as M } from "@coinbase/cdp-api-client";
+import { AuthManager as S } from "./index6.js";
 import { toAuthState as u } from "./index7.js";
 import { withAuth as i } from "./index8.js";
-import { createExportKeyPair as S } from "./index9.js";
-import { decryptWithPrivateKey as U } from "./index10.js";
-import { MockAuthManager as C } from "./index11.js";
+import { createExportKeyPair as U } from "./index9.js";
+import { decryptWithPrivateKey as C } from "./index10.js";
+import { MockAuthManager as T } from "./index11.js";
 import { mockUser as d } from "./index12.js";
-import { isChainSupportedForCDPSends as T } from "./index13.js";
-import { getConfig as r, setCoreAuthManager as g, getCoreAuthManager as n, setConfig as j } from "./index14.js";
+import { isChainSupportedForCDPSends as j } from "./index13.js";
+import { getConfig as r, setCoreAuthManager as g, getCoreAuthManager as n, setConfig as P } from "./index14.js";
+import "viem";
 import { serializeTransaction as m } from "./index15.js";
-const $ = async (e) => {
+const B = async (e) => {
   if (!e.projectId)
     throw new Error("Project ID is required");
   let s;
@@ -18,19 +19,19 @@ const $ = async (e) => {
   } catch {
     s = !0;
   }
-  if (j(e), r().useMock) {
-    g(new C(r().projectId));
+  if (P(e), r().useMock) {
+    g(new T(r().projectId));
     return;
   }
-  if (p({
+  if (w({
     debugging: r().debugging,
     basePath: r().basePath
   }), s) {
-    const t = new M(r().projectId);
-    g(t), w(t);
+    const t = new S(r().projectId);
+    g(t), h(t);
   }
   await n().ensureInitialized();
-}, q = async (e) => {
+}, V = async (e) => {
   if (r().useMock)
     return {
       message: "Mock sign in initiated",
@@ -38,7 +39,7 @@ const $ = async (e) => {
     };
   if (await n().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const t = await h(r().projectId, {
+  const t = await y(r().projectId, {
     email: e.email,
     type: "email"
   });
@@ -46,7 +47,7 @@ const $ = async (e) => {
     flowId: t.flowId,
     message: t.message
   };
-}, B = async (e) => {
+}, G = async (e) => {
   if (r().useMock)
     return await n().setAuthState({
       accessToken: "mock-access-token",
@@ -59,28 +60,27 @@ const $ = async (e) => {
     };
   if (await n().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const t = await y(r().projectId, {
+  const t = await f(r().projectId, {
     flowId: e.flowId,
     otp: e.otp
   });
   let a = u(t.accessToken, t.validUntil, t.endUser);
-  if (!a.user.evmAccounts || a.user.evmAccounts.length === 0)
+  if (await n().setAuthState(a), !a.user.evmAccounts || a.user.evmAccounts.length === 0)
     try {
-      const o = await f(r().projectId, a.user.userId, {
-        walletSecretId: await n().getWalletSecretId(a)
+      const o = await n().getWalletSecretId(), p = await I(r().projectId, a.user.userId, {
+        walletSecretId: o
       });
-      a = u(t.accessToken, t.validUntil, o);
+      a = u(t.accessToken, t.validUntil, p), await n().setAuthState(a);
     } catch (o) {
       throw new Error(`Failed to create EVM account: ${o}`);
     }
-  await n().setAuthState(a);
   const c = await n().getUser();
   return {
     message: t.message,
     user: c,
     isNewUser: t.isNewEndUser
   };
-}, V = async () => n().getUser(), G = async () => n().isSignedIn(), J = async () => {
+}, J = async () => n().getUser(), L = async () => n().isSignedIn(), Q = async () => {
   if (r().useMock) {
     await n().signOut();
     return;
@@ -88,18 +88,18 @@ const $ = async (e) => {
   if (!await n().isSignedIn())
     throw new Error("User not signed in");
   await n().signOut();
-}, L = (e) => {
+}, R = (e) => {
   n().addAuthStateChangeCallback(e);
-}, Q = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
-  signature: (await I(r().projectId, s.userId, {
+}, X = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
+  signature: (await l(r().projectId, s.userId, {
     hash: e.hash,
     address: e.evmAccount,
     walletSecretId: t
   })).signature
-})), R = async (e) => r().useMock ? { signedTransaction: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => {
+})), Y = async (e) => r().useMock ? { signedTransaction: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => {
   const a = m(e.transaction);
   return {
-    signedTransaction: (await l(
+    signedTransaction: (await A(
       r().projectId,
       s.userId,
       {
@@ -109,8 +109,8 @@ const $ = async (e) => {
       }
     )).signedTransaction
   };
-}), X = async (e) => {
-  if (!T(e.network))
+}), Z = async (e) => {
+  if (!j(e.network))
     throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
   if (r().useMock)
     return { transactionHash: "0x0" };
@@ -127,32 +127,32 @@ const $ = async (e) => {
       }
     )).transactionHash
   }));
-}, Y = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
-  signature: (await A(r().projectId, s.userId, {
+}, _ = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
+  signature: (await E(r().projectId, s.userId, {
     message: e.message,
     address: e.evmAccount,
     walletSecretId: t
   })).signature
-})), Z = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
-  signature: (await E(r().projectId, s.userId, {
+})), ee = async (e) => r().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: s, walletSecretId: t }) => ({
+  signature: (await k(r().projectId, s.userId, {
     typedData: e.typedData,
     address: e.evmAccount,
     walletSecretId: t
   })).signature
-})), _ = async (e) => {
+})), te = async (e) => {
   if (r().useMock)
     return {
       privateKey: "mock-private-key"
     };
-  const s = await S();
+  const s = await U();
   return i(e, n(), async ({ user: t, walletSecretId: a }) => {
-    const c = await k(r().projectId, t.userId, {
+    const c = await M(r().projectId, t.userId, {
       address: e.evmAccount,
       walletSecretId: a,
       exportEncryptionKey: s.publicKeyBase64
     });
     return {
-      privateKey: await U(
+      privateKey: await C(
         s.privateKey,
         c.encryptedPrivateKey
       )
@@ -160,17 +160,17 @@ const $ = async (e) => {
   });
 };
 export {
-  _ as exportEvmAccount,
-  V as getCurrentUser,
-  $ as initialize,
-  G as isSignedIn,
-  L as onAuthStateChange,
-  X as sendEvmTransaction,
-  Q as signEvmHash,
-  Y as signEvmMessage,
-  R as signEvmTransaction,
-  Z as signEvmTypedData,
-  q as signInWithEmail,
-  J as signOut,
-  B as verifyEmailOTP
+  te as exportEvmAccount,
+  J as getCurrentUser,
+  B as initialize,
+  L as isSignedIn,
+  R as onAuthStateChange,
+  Z as sendEvmTransaction,
+  X as signEvmHash,
+  _ as signEvmMessage,
+  Y as signEvmTransaction,
+  ee as signEvmTypedData,
+  V as signInWithEmail,
+  Q as signOut,
+  G as verifyEmailOTP
 };

package/dist/esm/index3.js

@@ -4,24 +4,25 @@ import { create as l } from "zustand";
 import { subscribeWithSelector as f, persist as g } from "./index17.js";
 import { validateRequest as w, EIP1193ProviderError as I, STANDARD_ERROR_CODES as S } from "./index4.js";
 import { EventEmitter as b } from "./index18.js";
+import "@coinbase/cdp-api-client";
 import { handleChainId as A, handleSignTypedData as C, handleEthSign as _, handleSwitchEthereumChain as v, handleDisconnect as D, handleSendTransaction as E, handlePersonalSign as P, handleRequestAccounts as R, handleAccounts as y } from "./index19.js";
 import { onAuthStateChange as T } from "./index2.js";
 import { baseSepolia as d } from "./index20.js";
 function q(r, e, a) {
   e.subscribe(
-    (n) => n.chainId,
-    (n, t) => {
-      n !== t && r.emit("chainChanged", n);
+    (t) => t.chainId,
+    (t, n) => {
+      t !== n && r.emit("chainChanged", t);
     }
   ), e.subscribe(
-    (n) => n.user,
-    (n, t) => {
-      if (!(n?.userId === t?.userId && n?.evmAccounts?.length === t?.evmAccounts?.length)) {
-        if (!n && t) {
+    (t) => t.user,
+    (t, n) => {
+      if (!(t?.userId === n?.userId && t?.evmAccounts?.length === n?.evmAccounts?.length)) {
+        if (!t && n) {
           r.emit("disconnect", new h.DisconnectedError());
           return;
         }
-        if (n && n.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
+        if (t && t.evmAccounts?.length && (!n || n.evmAccounts?.length === 0)) {
           const m = e.getState().chainId;
           r.emit("connect", { chainId: m });
           return;
@@ -31,33 +32,33 @@ function q(r, e, a) {
   );
   const { chainId: i, setChainId: o } = e.getState(), c = i || a.chains[0].id;
   return i || o(c), h.from({
-    request: async (n) => {
-      w(n, a);
-      const t = n;
-      switch (t.method) {
+    request: async (t) => {
+      w(t, a);
+      const n = t;
+      switch (n.method) {
         case "eth_accounts":
           return y();
         case "eth_requestAccounts":
           return R(r, e);
         case "personal_sign":
-          return P(t.params);
+          return P(n.params);
         case "eth_sendTransaction":
-          return E(t.params, e, a.transports);
+          return E(n.params, e, a.transports);
         case "wallet_disconnect":
           return D();
         case "wallet_switchEthereumChain":
-          return v(t.params, e);
+          return v(n.params, e);
         case "eth_sign":
-          return _(t.params);
+          return _(n.params);
         case "eth_signTypedData_v4":
-          return C(t.params);
+          return C(n.params);
         case "eth_chainId":
           return A(e);
         // Catch-all for any unknown method
         default:
           throw new I(
             S.provider.unsupportedMethod,
-            `Method ${t.method} not supported`
+            `Method ${n.method} not supported`
           );
       }
     },
@@ -72,7 +73,7 @@ const u = {
     [d.id]: p()
   }
 };
-function z(r) {
+function B(r) {
   if (r?.chains.length === 0)
     throw new Error("At least one chain must be configured");
   const e = r?.chains ?? u.chains, a = r?.transports ?? u.transports;
@@ -83,10 +84,10 @@ function z(r) {
       g(
         (s) => ({
           chainId: e[0].id,
-          setChainId: (n) => s({ chainId: n }),
+          setChainId: (t) => s({ chainId: t }),
           chains: e,
           user: null,
-          setUser: (n) => s({ user: n })
+          setUser: (t) => s({ user: t })
         }),
         {
           name: "cdp-provider-store"
@@ -105,5 +106,5 @@ function z(r) {
   };
 }
 export {
-  z as createCDPEmbeddedWallet
+  B as createCDPEmbeddedWallet
 };

package/dist/esm/index4.js

@@ -1,6 +1,9 @@
+import "ox";
+import "viem";
+import "zustand";
+import "@coinbase/cdp-api-client";
 import { getCurrentUser as u } from "./index2.js";
 import "./index3.js";
-import "viem";
 const n = {
   rpc: {
     invalidInput: -32e3,
@@ -54,7 +57,7 @@ class a extends Error {
     super(r), this.code = t;
   }
 }
-const h = /* @__PURE__ */ new Set([
+const p = /* @__PURE__ */ new Set([
   "eth_accounts",
   "eth_requestAccounts",
   "personal_sign",
@@ -65,7 +68,7 @@ const h = /* @__PURE__ */ new Set([
   "wallet_disconnect",
   "wallet_switchEthereumChain"
 ]);
-function l(e, { chains: t }) {
+function E(e, { chains: t }) {
   const { method: r, params: s } = e;
   if (typeof r != "string" || r.length === 0)
     throw new a(
@@ -83,7 +86,7 @@ function l(e, { chains: t }) {
       n.rpc.invalidParams,
       "'params' must be an array if provided."
     );
-  if (!h.has(r))
+  if (!p.has(r))
     throw new o(
       n.provider.unsupportedMethod,
       `Method ${e.method} not supported`
@@ -98,7 +101,7 @@ async function d() {
     );
   return e;
 }
-async function w(e) {
+async function _(e) {
   const t = await d();
   if (!t.evmAccounts?.includes(e))
     throw new o(
@@ -107,7 +110,7 @@ async function w(e) {
     );
   return t;
 }
-async function f() {
+async function R() {
   const e = await d();
   if (!e.evmAccounts?.[0])
     throw new o(
@@ -120,8 +123,8 @@ export {
   o as EIP1193ProviderError,
   a as RPCRequestError,
   n as STANDARD_ERROR_CODES,
-  l as validateRequest,
+  E as validateRequest,
   d as validateUserConnected,
-  f as validateUserHasEvmAccount,
-  w as validateUserOwnsAddress
+  R as validateUserHasEvmAccount,
+  _ as validateUserOwnsAddress
 };

package/dist/esm/index5.js

@@ -1,16 +1,17 @@
 import { getTypesForEIP712Domain as a } from "viem";
 import { getCurrentUser as s, signEvmHash as i, signEvmTypedData as c, signEvmTransaction as u, signEvmMessage as m } from "./index2.js";
+import "@coinbase/cdp-api-client";
 import { toAccount as g } from "./index16.js";
-async function w(n) {
-  const r = await s();
-  if (!r || !r.evmAccounts || r.evmAccounts.length === 0)
+async function w(r) {
+  const n = await s();
+  if (!n || !n.evmAccounts || n.evmAccounts.length === 0)
     throw new Error(
       "No accounts found - user must be authenticated and have at least one EVM account"
     );
-  if (!r.evmAccounts.includes(n))
-    throw new Error(`Cannot sign for address ${n} - not authorized for this account`);
+  if (!n.evmAccounts.includes(r))
+    throw new Error(`Cannot sign for address ${r} - not authorized for this account`);
   return g({
-    address: n,
+    address: r,
     /**
      * Signs a message using CDP's message signing functionality.
      * Supports string messages, hex strings, and byte arrays.
@@ -28,7 +29,7 @@ async function w(n) {
       else
         throw new Error("Unsupported message format");
       return (await m({
-        evmAccount: n,
+        evmAccount: r,
         message: t
       })).signature;
     },
@@ -49,7 +50,7 @@ async function w(n) {
         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 u({
-        evmAccount: n,
+        evmAccount: r,
         transaction: t
       })).signedTransaction;
     },
@@ -73,7 +74,7 @@ async function w(n) {
         message: e.message
       };
       return (await c({
-        evmAccount: n,
+        evmAccount: r,
         typedData: t
       })).signature;
     },
@@ -85,7 +86,7 @@ async function w(n) {
      */
     async sign(e) {
       return (await i({
-        evmAccount: n,
+        evmAccount: r,
         hash: e.hash
       })).signature;
     }

package/dist/esm/index6.js

@@ -1,12 +1,13 @@
-import { logOutEndUser as c, refreshAccessToken as o, registerTemporaryWalletSecret as u } from "@coinbase/cdp-api-client";
-import { SignJWT as S } from "./index21.js";
-import { toAuthState as w } from "./index7.js";
-import { createKeyPair as f } from "./index22.js";
-import { generateRandomId as n } from "./index23.js";
-import { hash as d } from "./index24.js";
-import { sortKeys as y } from "./index13.js";
-const h = 60 * 1e3;
-class E {
+import { logOutEndUser as h, refreshAccessToken as l, registerTemporaryWalletSecret as c } from "@coinbase/cdp-api-client";
+import { SignJWT as o } from "./index21.js";
+import "viem";
+import { toAuthState as u } from "./index7.js";
+import { createKeyPair as S } from "./index22.js";
+import { generateRandomId as i } from "./index23.js";
+import { hash as w } from "./index24.js";
+import { sortKeys as f } from "./index13.js";
+const n = 60 * 1e3;
+class C {
   projectId;
   authState = null;
   walletSecret = null;
@@ -42,7 +43,7 @@ class E {
    */
   async signOut() {
     try {
-      await c(this.projectId);
+      await h(this.projectId);
     } catch {
     } finally {
       await this.clearAuthState();
@@ -68,12 +69,12 @@ class E {
   /**
    * Gets the currently registered wallet secret ID. Rejects if the user is not signed in.
    *
-   * @param authState - The auth state to use. If not provided, the current auth state will be used.
-   *
    * @returns The wallet secret ID.
    */
-  async getWalletSecretId(t) {
-    return this.shouldRefreshWalletSecret() && await this.refreshWalletSecret(t), this.walletSecret.walletSecretId;
+  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.
@@ -86,15 +87,17 @@ class E {
    * @returns The X-Wallet-Auth header.
    */
   async getXWalletAuth(t) {
+    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 e = `${t.requestMethod} ${t.requestHost}${t.requestPath}`, a = Math.floor(Date.now() / 1e3), r = {
       uris: [e]
     };
     if (t.requestData && Object.keys(t.requestData).length > 0) {
-      const s = y(t.requestData);
-      r.reqHash = await d(new TextEncoder().encode(JSON.stringify(s)));
+      const s = f(t.requestData);
+      r.reqHash = await w(new TextEncoder().encode(JSON.stringify(s)));
     }
-    return await new S(r).setProtectedHeader({ alg: "ES256", typ: "JWT" }).setIssuedAt(a).setNotBefore(a).setJti(await n()).sign(this.walletSecret.keyPair.privateKey);
+    return await new o(r).setProtectedHeader({ alg: "ES256", typ: "JWT" }).setIssuedAt(a).setNotBefore(a).setJti(await i()).sign(this.walletSecret.keyPair.privateKey);
   }
   /**
    * Sets the authentication state.
@@ -137,7 +140,7 @@ class E {
    * @returns True if the token should be refreshed, false otherwise.
    */
   shouldRefreshToken() {
-    return !(this.authState && this.authState.expiresAt > Date.now() + h);
+    return !(this.authState && this.authState.expiresAt > Date.now() + n);
   }
   /**
    * Refreshes the access token and transitions the auth state accordingly.
@@ -147,16 +150,16 @@ class E {
    */
   async refreshAccessToken() {
     try {
-      const t = await o(this.projectId, {
+      const t = await l(this.projectId, {
         grantType: "refresh_token"
-      }), e = w(
+      }), e = u(
         t.accessToken,
         t.validUntil,
         t.endUser
       );
       await this.setAuthState(e);
     } catch {
-      await this.clearAuthState();
+      await this.signOut();
     }
   }
   /**
@@ -165,30 +168,27 @@ class E {
    * @returns True if the wallet secret should be refreshed, false otherwise.
    */
   shouldRefreshWalletSecret() {
-    return !(this.walletSecret && this.walletSecret.expiresAt > Date.now() + h);
+    return !(this.walletSecret && this.walletSecret.expiresAt > Date.now() + n);
   }
   /**
-   * Refreshes the wallet secret.
+   * Refreshes the wallet secret. Assumes the user is signed in.
    *
-   * @param authState - The auth state to use. If not provided, the current auth state will be used.
    * @returns The wallet secret.
    */
-  async refreshWalletSecret(t) {
-    if (!t && !await this.isSignedIn())
-      throw new Error("Cannot refresh wallet secret if the auth state is not present or expired");
-    const e = t ?? this.authState, a = this.walletSecret?.walletSecretId ?? await n(), r = this.walletSecret?.keyPair ?? await f(), s = e.expiresAt, l = new Date(s).toISOString();
-    this.walletSecret = { walletSecretId: a, keyPair: r, expiresAt: s };
+  async refreshWalletSecret() {
+    const t = this.walletSecret?.walletSecretId ?? await i(), e = this.walletSecret?.keyPair ?? await S(), a = this.authState.expiresAt, r = new Date(a).toISOString();
+    this.walletSecret = { walletSecretId: t, keyPair: e, expiresAt: a };
     try {
-      await u(this.projectId, e.user.userId, {
-        walletSecretId: a,
-        publicKey: r.publicKeyBase64,
-        validUntil: l
+      await c(this.projectId, this.authState.user.userId, {
+        walletSecretId: t,
+        publicKey: e.publicKeyBase64,
+        validUntil: r
       });
-    } catch (i) {
-      throw this.walletSecret = null, i;
+    } catch (s) {
+      throw this.walletSecret = null, s;
     }
   }
 }
 export {
-  E as AuthManager
+  C as AuthManager
 };

package/dist/esm/index7.js

@@ -1,12 +1,13 @@
-const c = (u, n, e) => {
-  const o = new Date(n).getTime(), r = {
+import "@coinbase/cdp-api-client";
+const c = (s, u, e) => {
+  const n = new Date(u).getTime(), r = {
     userId: e.userId,
     evmAccounts: e.evmAccounts?.map((t) => t) ?? [],
-    authenticationMethods: e.authenticationMethods.reduce((t, s) => (t[s.type] = s, t), {})
+    authenticationMethods: e.authenticationMethods.reduce((t, o) => (t[o.type] = o, t), {})
   };
   return {
-    accessToken: u,
-    expiresAt: o,
+    accessToken: s,
+    expiresAt: n,
     user: r
   };
 };

package/dist/esm/index8.js

@@ -1,14 +1,16 @@
-const o = async (t) => await t.isSignedIn();
-async function s(t, n, r) {
-  if (!await o(n))
+import "@coinbase/cdp-api-client";
+import "viem";
+const c = async (t) => await t.isSignedIn();
+async function a(t, n, r) {
+  if (!await c(n))
     throw new Error("User not signed in");
   const e = await n.getUser();
-  if (!e.evmAccounts?.find((i) => i === t.evmAccount))
+  if (!e.evmAccounts?.find((o) => o === t.evmAccount))
     throw new Error("EVM account not found");
-  const c = await n.getWalletSecretId();
-  return r({ ...t, user: e, walletSecretId: c });
+  const i = await n.getWalletSecretId();
+  return r({ ...t, user: e, walletSecretId: i });
 }
 export {
-  o as isSignedIn,
-  s as withAuth
+  c as isSignedIn,
+  a as withAuth
 };

package/dist/types/index.d.ts

@@ -1,6 +1,10 @@
 import { Address } from 'viem';
+import { APIError } from '@coinbase/cdp-api-client';
+import { APIErrorType } from '@coinbase/cdp-api-client';
 import { Chain } from 'viem/chains';
 import { Chain as Chain_2 } from 'viem';
+import { ErrorType } from '@coinbase/cdp-api-client';
+import { HttpErrorType } from '@coinbase/cdp-api-client';
 import { LocalAccount } from 'viem';
 import { Mutate } from 'zustand';
 import { Provider } from 'ox';
@@ -16,6 +20,10 @@ export declare type AccountsRequest = {
 
 export declare type AllowedEvmTransactionType = TransactionSerializableEIP1559;
 
+export { APIError }
+
+export { APIErrorType }
+
 export declare type AuthenticationMethod = EmailAuthentication;
 
 export declare type AuthenticationMethods = {
@@ -84,6 +92,8 @@ export declare type EmailAuthentication = {
     email: string;
 };
 
+export { ErrorType }
+
 export declare type EthSignRequest = {
     method: "eth_sign";
     params: [Hex, EvmAddress];
@@ -109,6 +119,8 @@ export declare const getCurrentUser: () => Promise<User | null>;
 
 export declare type Hex = `0x${string}`;
 
+export { HttpErrorType }
+
 export declare const initialize: (cfg: Config) => Promise<void>;
 
 export declare const isSignedIn: () => Promise<boolean>;
@@ -156,6 +168,8 @@ export declare type SendEvmTransactionResult = {
     transactionHash: Hex;
 };
 
+export { SendEvmTransactionWithEndUserAccountBodyNetwork }
+
 export declare type SendTransactionRequest = {
     method: "eth_sendTransaction";
     params: SendTransactionRequestParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-core",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "files": [
     "dist/**",
@@ -17,7 +17,7 @@
     "ox": "0.8.1",
     "viem": "^2.33.0",
     "zustand": "^5.0.6",
-    "@coinbase/cdp-api-client": "^0.0.15"
+    "@coinbase/cdp-api-client": "^0.0.17"
   },
   "devDependencies": {
     "@size-limit/preset-big-lib": "^11.2.0",