@coinbase/cdp-core 0.0.19 → 0.0.21

package/README.md

@@ -48,6 +48,24 @@ const config: Config = {
 await initialize(config);
 ```
 
+#### Smart Account Configuration
+
+You can configure the SDK to automatically create Smart Accounts for new users by setting `createAccountOnLogin` to `"evm-smart"`:
+
+```ts
+const config: Config = {
+  projectId: "your-project-id",
+  createAccountOnLogin: "evm-smart", // Creates Smart Accounts instead of EOAs
+}
+
+await initialize(config);
+```
+
+When `createAccountOnLogin` is set to `"evm-smart"`, the SDK will:
+1. Create an EOA (Externally Owned Account) first
+2. Use that EOA as the owner to create a Smart Account
+3. Both accounts will be available on the user object
+
 ### Sign In a User
 
 You're now ready to start calling the APIs provided by the package!
@@ -84,7 +102,8 @@ if (signedIn) {
   // Get the user's information
   const user = await getCurrentUser();
   console.log("User ID:", user.userId);
-  console.log("EVM Accounts:", user.evmAccounts);
+  console.log("EVM Accounts (EOAs):", user.evmAccounts);
+  console.log("EVM Smart Accounts:", user.evmSmartAccounts);
 
   // Find the user's email address (if they logged in with email/otp)
   const email = user.authenticationMethods.email?.email;
@@ -93,7 +112,15 @@ if (signedIn) {
 ```
 
 ### Send a Transaction
-We support signing and sending a Blockchain transaction in a single call on Base or Base Sepolia:
+We support signing and sending a Blockchain transaction in a single call on the following networks:
+- Base
+- Base Sepolia
+- Ethereum
+- Ethereum Sepolia
+- Avalanche
+- Arbitrum
+- Optimism
+- Polygon
 
 ```typescript
 import { sendEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
@@ -118,13 +145,13 @@ const result = await sendEvmTransaction({
 console.log("Transaction Hash:", result.transactionHash);
 ```
 
-For networks other than Base or Base Sepolia, your end user must sign the transaction, and then
+For networks other than those supported by the CDP APIs, your end user must sign the transaction, and then
 you must broadcast the transaction yourself. This example uses the public client from `viem` to broadcast the transaction. 
 
 ```typescript
 import { signEvmTransaction, getCurrentUser } from "@coinbase/cdp-core";
 import { http, createPublicClient } from "viem";
-import { sepolia } from "viem/chains";
+import { tron } from "viem/chains";
 
 const user = await getCurrentUser();
 const evmAccount = user.evmAccounts[0];
@@ -139,14 +166,14 @@ const { signedTransaction } = await signEvmTransaction({
     gas: 21000n,
     maxFeePerGas: 30000000000n,
     maxPriorityFeePerGas: 1000000000n,
-    chainId: 11155111, // Sepolia
+    chainId: 728126428, // Tron
     type: "eip1559",
   }
 });
 
 // Broadcast signed transaction to non-Base chain
 const client = createPublicClient({
-  chain: sepolia,
+  chain: tron,
   transport: http()
 });
 
@@ -155,6 +182,61 @@ const hash = await client.sendRawTransaction({
 });
 ```
 
+### Smart Account Operations
+
+Smart Accounts provide advanced account abstraction features, including user operations and paymaster support.
+
+#### Send User Operations
+
+Send user operations from a Smart Account:
+
+```typescript
+import { sendUserOperation, getCurrentUser } from "@coinbase/cdp-core";
+
+const user = await getCurrentUser();
+const smartAccount = user.evmSmartAccounts[0];
+
+const result = await sendUserOperation({
+  evmSmartAccount: smartAccount,
+  network: "base-sepolia",
+  calls: [
+    {
+      to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      value: 1000000000000000000n, // 1 ETH in wei
+      data: "0x", // Optional contract interaction data
+    }
+  ],
+  // Optional paymaster for gas sponsorship. Get your free Base paymaster URL [from the CDP Portal](https://portal.cdp.coinbase.com/products/node).
+  paymasterUrl: "https://paymaster.example.com",
+});
+
+console.log("User Operation Hash:", result.userOperationHash);
+```
+
+#### Get User Operation Status
+
+After sending a user operation, you can get its status and retrieve the result:
+
+```typescript
+import { getUserOperation } from "@coinbase/cdp-core";
+
+// Get the status of a user operation
+const userOperationResult = await getUserOperation({
+  userOperationHash: result.userOperationHash,
+  evmSmartAccount: smartAccount,
+  network: "base-sepolia"
+});
+
+console.log("Status:", userOperationResult.status); // "pending", "complete", or "failed"
+
+if (userOperationResult.status === "complete") {
+  console.log("Transaction Hash:", userOperationResult.transactionHash);
+  console.log("Block Number:", userOperationResult.receipts?.[0]?.blockNumber);
+} else if (userOperationResult.status === "failed") {
+  console.log("Failure reason:", userOperationResult.receipts?.[0]?.revert?.message);
+}
+```
+
 ### Sign Messages and Typed Data
 
 End users can sign EVM messages, hashes, and typed data to generate signatures for various onchain applications.

package/dist/esm/index.js

@@ -1,34 +1,36 @@
-import { exportEvmAccount as n, getAccessToken as m, getCurrentUser as s, initialize as E, isSignedIn as a, onAuthStateChange as p, sendEvmTransaction as c, signEvmHash as g, signEvmMessage as d, signEvmTransaction as v, signEvmTypedData as T, signInWithEmail as A, signInWithSms as f, signOut as S, verifyEmailOTP as h, verifySmsOTP as u } from "./index2.js";
-import { APIError as y, ErrorType as P, HttpErrorType as l, SendEvmTransactionWithEndUserAccountBodyNetwork as D } from "@coinbase/cdp-api-client";
+import { exportEvmAccount as i, getAccessToken as s, getCurrentUser as m, getUserOperation as a, initialize as E, isSignedIn as p, onAuthStateChange as g, sendEvmTransaction as c, sendUserOperation as d, signEvmHash as v, signEvmMessage as T, signEvmTransaction as A, signEvmTypedData as f, signInWithEmail as O, signInWithSms as S, signOut as h, verifyEmailOTP as u, verifySmsOTP as x } from "./index2.js";
+import { APIError as P, ErrorType as l, HttpErrorType as D, SendEvmTransactionWithEndUserAccountBodyNetwork as I } from "@coinbase/cdp-api-client";
 import "viem";
-import { createCDPEmbeddedWallet as O } from "./index3.js";
-import { EIP1193ProviderError as R, STANDARD_ERROR_CODES as W } from "./index4.js";
+import { createCDPEmbeddedWallet as R } from "./index3.js";
+import { EIP1193ProviderError as W, STANDARD_ERROR_CODES as k } from "./index4.js";
 import "ox";
 import "zustand";
-import { toViemAccount as H } from "./index5.js";
+import { toViemAccount as N } from "./index5.js";
 export {
-  y as APIError,
-  R as EIP1193ProviderError,
-  P as ErrorType,
-  l as HttpErrorType,
-  W as STANDARD_ERROR_CODES,
-  D as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  O as createCDPEmbeddedWallet,
-  n as exportEvmAccount,
-  m as getAccessToken,
-  s as getCurrentUser,
+  P as APIError,
+  W as EIP1193ProviderError,
+  l as ErrorType,
+  D as HttpErrorType,
+  k as STANDARD_ERROR_CODES,
+  I as SendEvmTransactionWithEndUserAccountBodyNetwork,
+  R as createCDPEmbeddedWallet,
+  i as exportEvmAccount,
+  s as getAccessToken,
+  m as getCurrentUser,
+  a as getUserOperation,
   E as initialize,
-  a as isSignedIn,
-  p as onAuthStateChange,
+  p as isSignedIn,
+  g as onAuthStateChange,
   c as sendEvmTransaction,
-  g as signEvmHash,
-  d as signEvmMessage,
-  v as signEvmTransaction,
-  T as signEvmTypedData,
-  A as signInWithEmail,
-  f as signInWithSms,
-  S as signOut,
-  H as toViemAccount,
-  h as verifyEmailOTP,
-  u as verifySmsOTP
+  d as sendUserOperation,
+  v as signEvmHash,
+  T as signEvmMessage,
+  A as signEvmTransaction,
+  f as signEvmTypedData,
+  O as signInWithEmail,
+  S as signInWithSms,
+  h as signOut,
+  N as toViemAccount,
+  u as verifyEmailOTP,
+  x as verifySmsOTP
 };

package/dist/esm/index103.js

@@ -1,4 +1,4 @@
-import n from "./index86.js";
+import n from "./index84.js";
 function r(t) {
   return n(t) && typeof t.kty == "string";
 }

package/dist/esm/index104.js

@@ -1,4 +1,4 @@
-import { JOSENotSupported as s } from "./index73.js";
+import { JOSENotSupported as s } from "./index71.js";
 function n(e) {
   let a, r;
   switch (e.kty) {

package/dist/esm/index13.js

@@ -1,12 +1,18 @@
-import { SendEvmTransactionWithEndUserAccountBodyNetwork as i } from "@coinbase/cdp-api-client";
+import { SendEvmTransactionWithEndUserAccountBodyNetwork as a } from "@coinbase/cdp-api-client";
 const n = (e) => !e || typeof e != "object" ? e : Array.isArray(e) ? e.map(n) : Object.keys(e).sort().reduce(
   (r, t) => (r[t] = n(e[t]), r),
   {}
-), o = (e) => Object.values(i).includes(
+), o = (e) => Object.values(a).includes(
   e
 ), s = {
   "base-sepolia": 84532,
-  base: 8453
+  base: 8453,
+  ethereum: 1,
+  "ethereum-sepolia": 11155111,
+  avalanche: 43114,
+  polygon: 137,
+  optimism: 10,
+  arbitrum: 42161
 }, c = Object.fromEntries(
   Object.entries(s).map(([e, r]) => [r, e])
 ), p = (e) => Object.values(s).includes(e);

package/dist/esm/index17.js

@@ -1,6 +1,6 @@
-import { CompactSign as i } from "./index72.js";
-import { JWTInvalid as r } from "./index73.js";
-import { JWTClaimsBuilder as n } from "./index74.js";
+import { CompactSign as i } from "./index70.js";
+import { JWTInvalid as r } from "./index71.js";
+import { JWTClaimsBuilder as n } from "./index72.js";
 class d {
   #s;
   #t;

package/dist/esm/index2.js

@@ -1,89 +1,89 @@
-import { configureCdpApiClient as I, setAuthManager as l, initiateAuthentication as v, createEndUserEvmAccount as A, verifyEmailAuthentication as E, verifySmsAuthentication as k, signEvmHashWithEndUserAccount as S, signEvmTransactionWithEndUserAccount as M, sendEvmTransactionWithEndUserAccount as T, signEvmMessageWithEndUserAccount as U, signEvmTypedDataWithEndUserAccount as C, exportEndUserEvmAccount as j } from "@coinbase/cdp-api-client";
-import { AuthManager as P } from "./index6.js";
-import { toAuthState as d } from "./index7.js";
+import { configureCdpApiClient as A, setAuthManager as v, initiateAuthentication as S, createEndUserEvmAccount as E, createEndUserEvmSmartAccount as g, verifyEmailAuthentication as k, verifySmsAuthentication as U, signEvmHashWithEndUserAccount as M, signEvmTransactionWithEndUserAccount as T, sendEvmTransactionWithEndUserAccount as j, signEvmMessageWithEndUserAccount as O, signEvmTypedDataWithEndUserAccount as P, sendUserOperationWithEndUserAccount as C, getUserOperationWithEndUserAccount as x, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
+import { AuthManager as W } from "./index6.js";
+import { toAuthState as m } from "./index7.js";
 import { withAuth as o } from "./index8.js";
-import { createExportKeyPair as x } from "./index9.js";
-import { decryptWithPrivateKey as b } from "./index10.js";
-import { MockAuthManager as K } from "./index11.js";
-import { mockUser as g } from "./index12.js";
-import { isChainSupportedForCDPSends as W } from "./index13.js";
-import { getConfig as n, setCoreAuthManager as m, getCoreAuthManager as s, setConfig as D } from "./index14.js";
+import { createExportKeyPair as b } from "./index9.js";
+import { decryptWithPrivateKey as K } from "./index10.js";
+import { MockAuthManager as D } from "./index11.js";
+import { mockUser as p } from "./index12.js";
+import { isChainSupportedForCDPSends as z } from "./index13.js";
+import { getConfig as t, setCoreAuthManager as h, getCoreAuthManager as s, setConfig as N } from "./index14.js";
 import "viem";
-import { serializeTransaction as p } from "./index15.js";
-const Q = async (e) => {
+import { serializeTransaction as w } from "./index15.js";
+const _ = async (e) => {
   if (!e.projectId)
     throw new Error("Project ID is required");
   let r;
   try {
-    r = n().projectId !== e.projectId;
+    r = t().projectId !== e.projectId;
   } catch {
     r = !0;
   }
-  if (D(e), n().useMock) {
-    m(new K(n().projectId));
+  if (N(e), t().useMock) {
+    h(new D(t().projectId));
     return;
   }
-  if (I({
-    debugging: n().debugging,
-    basePath: n().basePath
+  if (A({
+    debugging: t().debugging,
+    basePath: t().basePath
   }), r) {
-    const t = new P(n().projectId);
-    m(t), l(t);
+    const n = new W(t().projectId);
+    h(n), v(n);
   }
   await s().ensureInitialized();
-}, R = async (e) => h({
+}, ee = async (e) => y({
   email: e.email,
   type: "email"
-}), X = async (e) => h({
+}), te = async (e) => y({
   phoneNumber: e.phoneNumber,
   type: "sms"
-}), Y = async (e) => w(
+}), re = async (e) => l(
   e,
   "Mock email OTP verified",
-  (r, t) => E(r, t)
-), Z = async (e) => w(
+  (r, n) => k(r, n)
+), ne = async (e) => l(
   e,
   "Mock SMS OTP verified",
-  (r, t) => k(r, t)
-), _ = async () => s().getUser(), ee = async () => s().isSignedIn(), te = async () => {
-  if (n().useMock) {
+  (r, n) => U(r, n)
+), se = async () => s().getUser(), ae = async () => s().isSignedIn(), ce = async () => {
+  if (t().useMock) {
     await s().signOut();
     return;
   }
   if (!await s().isSignedIn())
     throw new Error("User not signed in");
   await s().signOut();
-}, ne = async () => s().getToken(), re = (e) => {
+}, ie = async () => s().getToken(), oe = (e) => {
   s().addAuthStateChangeCallback(e);
-}, se = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
-  signature: (await S(n().projectId, r.userId, {
+}, ue = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  signature: (await M(t().projectId, r.userId, {
     hash: e.hash,
     address: e.evmAccount,
-    walletSecretId: t
+    walletSecretId: n
   })).signature
-})), ae = async (e) => n().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => {
-  const i = p(e.transaction);
+})), de = async (e) => t().useMock ? { signedTransaction: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => {
+  const i = w(e.transaction);
   return {
-    signedTransaction: (await M(
-      n().projectId,
+    signedTransaction: (await T(
+      t().projectId,
       r.userId,
       {
         transaction: i,
         address: e.evmAccount,
-        walletSecretId: t
+        walletSecretId: n
       }
     )).signedTransaction
   };
-}), ie = async (e) => {
-  if (!W(e.network))
+}), me = async (e) => {
+  if (!z(e.network))
     throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
-  if (n().useMock)
+  if (t().useMock)
     return { transactionHash: "0x0" };
-  const r = p(e.transaction);
-  return o(e, s(), async ({ user: t, walletSecretId: i }) => ({
-    transactionHash: (await T(
-      n().projectId,
-      t.userId,
+  const r = w(e.transaction);
+  return o(e, s(), async ({ user: n, walletSecretId: i }) => ({
+    transactionHash: (await j(
+      t().projectId,
+      n.userId,
       {
         transaction: r,
         address: e.evmAccount,
@@ -92,99 +92,166 @@ const Q = async (e) => {
       }
     )).transactionHash
   }));
-}, ce = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
-  signature: (await U(n().projectId, r.userId, {
+}, ge = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  signature: (await O(t().projectId, r.userId, {
     message: e.message,
     address: e.evmAccount,
-    walletSecretId: t
+    walletSecretId: n
   })).signature
-})), oe = async (e) => n().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: t }) => ({
-  signature: (await C(n().projectId, r.userId, {
+})), pe = async (e) => t().useMock ? { signature: "0x0" } : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  signature: (await P(t().projectId, r.userId, {
     typedData: e.typedData,
     address: e.evmAccount,
-    walletSecretId: t
+    walletSecretId: n
   })).signature
-})), ue = async (e) => {
-  if (n().useMock)
+})), he = async (e) => t().useMock ? {
+  userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
+} : o(e, s(), async ({ user: r, walletSecretId: n }) => ({
+  userOperationHash: (await C(
+    t().projectId,
+    r.userId,
+    e.evmSmartAccount,
+    {
+      network: e.network,
+      calls: e.calls.map((a) => ({
+        to: a.to,
+        value: String(a.value ?? 0n),
+        data: a.data ?? "0x"
+      })),
+      walletSecretId: n,
+      useCdpPaymaster: e.useCdpPaymaster ?? !1,
+      paymasterUrl: e.paymasterUrl
+    }
+  )).userOpHash
+})), we = async (e) => t().useMock ? {
+  userOpHash: e.userOperationHash,
+  network: e.network,
+  calls: [
+    {
+      to: "0x1234567890123456789012345678901234567890",
+      value: "0",
+      data: "0x"
+    }
+  ],
+  status: "complete",
+  transactionHash: "0x9876543210987654321098765432109876543210987654321098765432109876",
+  receipts: []
+} : o(e, s(), async ({ user: r }) => await x(
+  t().projectId,
+  r.userId,
+  e.evmSmartAccount,
+  e.userOperationHash
+)), ye = async (e) => {
+  if (t().useMock)
     return {
       privateKey: "mock-private-key"
     };
-  const r = await x();
-  return o(e, s(), async ({ user: t, walletSecretId: i }) => {
-    const a = await j(n().projectId, t.userId, {
+  const r = await b();
+  return o(e, s(), async ({ user: n, walletSecretId: i }) => {
+    const a = await H(t().projectId, n.userId, {
       address: e.evmAccount,
       walletSecretId: i,
       exportEncryptionKey: r.publicKeyBase64
     });
     return {
-      privateKey: await b(
+      privateKey: await K(
         r.privateKey,
         a.encryptedPrivateKey
       )
     };
   });
-}, h = async (e) => {
-  if (n().useMock)
+}, y = async (e) => {
+  if (t().useMock)
     return {
       message: "Mock sign in initiated",
       flowId: "mock-flow-id"
     };
   if (await s().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const t = await v(n().projectId, e);
+  const n = await S(t().projectId, e);
   return {
-    flowId: t.flowId,
-    message: t.message
+    flowId: n.flowId,
+    message: n.message
   };
-}, w = async (e, r, t) => {
-  if (n().useMock)
+}, l = async (e, r, n) => {
+  if (t().useMock)
     return await s().setAuthState({
       accessToken: "mock-access-token",
       expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
-      user: g
+      user: p
     }), {
       message: r,
-      user: g,
+      user: p,
       isNewUser: !1
     };
   if (await s().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const a = await t(n().projectId, {
+  const a = await n(t().projectId, {
     flowId: e.flowId,
     otp: e.otp
   });
-  let c = d(a.accessToken, a.validUntil, a.endUser);
+  let c = m(a.accessToken, a.validUntil, a.endUser);
   if (await s().setAuthState(c), !c.user.evmAccounts || c.user.evmAccounts.length === 0)
     try {
-      const u = await s().getWalletSecretId(), f = await A(n().projectId, c.user.userId, {
+      const u = await s().getWalletSecretId();
+      let d = await E(t().projectId, c.user.userId, {
         walletSecretId: u
       });
-      c = d(a.accessToken, a.validUntil, f), await s().setAuthState(c);
+      if (t().createAccountOnLogin === "evm-smart") {
+        const [I] = d.evmAccounts;
+        d = await g(
+          t().projectId,
+          c.user.userId,
+          {
+            owner: I,
+            enableSpendPermissions: !1
+            // Defaulting to false until the feature is ready.
+          }
+        );
+      }
+      c = m(a.accessToken, a.validUntil, d), await s().setAuthState(c);
     } catch (u) {
       throw new Error(`Failed to create EVM account: ${u}`);
     }
-  const y = await s().getUser();
+  if (t().createAccountOnLogin === "evm-smart" && (!c.user.evmSmartAccounts || c.user.evmSmartAccounts.length === 0))
+    try {
+      const [u] = c.user.evmAccounts, d = await g(
+        t().projectId,
+        c.user.userId,
+        {
+          owner: u,
+          enableSpendPermissions: !1
+          // Defaulting to false until the feature is ready.
+        }
+      );
+      c = m(a.accessToken, a.validUntil, d), await s().setAuthState(c);
+    } catch (u) {
+      throw new Error(`Failed to create EVM Smart Account: ${u}`);
+    }
+  const f = await s().getUser();
   return {
     message: a.message,
-    user: y,
+    user: f,
     isNewUser: a.isNewEndUser
   };
 };
 export {
-  ue as exportEvmAccount,
-  ne as getAccessToken,
-  _ as getCurrentUser,
-  Q as initialize,
-  ee as isSignedIn,
-  re as onAuthStateChange,
-  ie as sendEvmTransaction,
-  se as signEvmHash,
-  ce as signEvmMessage,
-  ae as signEvmTransaction,
-  oe as signEvmTypedData,
-  R as signInWithEmail,
-  X as signInWithSms,
-  te as signOut,
-  Y as verifyEmailOTP,
-  Z as verifySmsOTP
+  ye as exportEvmAccount,
+  ie as getAccessToken,
+  se as getCurrentUser,
+  we as getUserOperation,
+  _ as initialize,
+  ae as isSignedIn,
+  oe as onAuthStateChange,
+  me as sendEvmTransaction,
+  he as sendUserOperation,
+  ue as signEvmHash,
+  ge as signEvmMessage,
+  de as signEvmTransaction,
+  pe as signEvmTypedData,
+  ee as signInWithEmail,
+  te as signInWithSms,
+  ce as signOut,
+  re as verifyEmailOTP,
+  ne as verifySmsOTP
 };

package/dist/esm/index24.js

@@ -1,4 +1,4 @@
-import { chainConfig as a } from "./index81.js";
+import { chainConfig as a } from "./index85.js";
 import { defineChain as t } from "./index25.js";
 const e = 11155111, r = /* @__PURE__ */ t({
   ...a,

package/dist/esm/index47.js

@@ -1,4 +1,4 @@
-import { version as o } from "./index70.js";
+import { version as o } from "./index73.js";
 let r = {
   getDocsUrl: ({ docsBaseUrl: s, docsPath: t = "", docsSlug: e }) => t ? `${s ?? "https://viem.sh"}${t}${e ? `#${e}` : ""}` : void 0,
   version: `viem@${o}`

package/dist/esm/index48.js

@@ -1,4 +1,4 @@
-import { NegativeOffsetError as o, PositionOutOfBoundsError as e, RecursiveReadLimitExceededError as n } from "./index71.js";
+import { NegativeOffsetError as o, PositionOutOfBoundsError as e, RecursiveReadLimitExceededError as n } from "./index74.js";
 const h = {
   bytes: new Uint8Array(),
   dataView: new DataView(new ArrayBuffer(0)),

package/dist/esm/index7.js

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