@coinbase/cdp-core 0.0.33 → 0.0.35

package/dist/web/index.web5.js

@@ -1,135 +1,156 @@
-import { configureCdpApiClient as A, setAuthManager as S, initiateAuthentication as k, createEndUserEvmAccount as E, createEndUserEvmSmartAccount as h, verifyEmailAuthentication as U, verifySmsAuthentication as M, signEvmHashWithEndUserAccount as T, signEvmTransactionWithEndUserAccount as P, sendEvmTransactionWithEndUserAccount as j, signEvmMessageWithEndUserAccount as C, signEvmTypedDataWithEndUserAccount as O, sendUserOperationWithEndUserAccount as x, getUserOperationWithEndUserAccount as H, exportEndUserEvmAccount as W } from "@coinbase/cdp-api-client";
+import { configureCdpApiClient as h, setAuthManager as I, initiateAuthentication as A, createEndUserSolanaAccount as v, createEndUserEvmAccount as k, createEndUserEvmSmartAccount as d, verifyEmailAuthentication as S, verifySmsAuthentication as E, signEvmHashWithEndUserAccount as U, signEvmTransactionWithEndUserAccount as T, signSolanaTransactionWithEndUserAccount as M, sendEvmTransactionWithEndUserAccount as j, sendSolanaTransactionWithEndUserAccount as P, signEvmMessageWithEndUserAccount as O, signEvmTypedDataWithEndUserAccount as C, sendUserOperationWithEndUserAccount as x, getUserOperationWithEndUserAccount as W, exportEndUserEvmAccount as H } from "@coinbase/cdp-api-client";
 import { AuthManager as b } from "./index.web6.js";
-import { toAuthState as m } from "./index.web12.js";
-import { withAuth as i } from "./index.web13.js";
+import { toAuthState as u } from "./index.web12.js";
+import { withAuth as o } from "./index.web13.js";
 import { MockAuthManager as K } from "./index.web14.js";
-import { mockUser as p } from "./index.web15.js";
-import { getPlatformServices as f, getPlatformCrypto as D } from "./index.web2.js";
+import { mockUser as g } from "./index.web15.js";
+import { getPlatformServices as l, getPlatformCrypto as D } from "./index.web2.js";
 import { isChainSupportedForCDPSends as _ } from "./index.web16.js";
-import { getConfig as t, setCoreAuthManager as w, getCoreAuthManager as n, setConfig as z } from "./index.web17.js";
+import { getConfig as n, setCoreAuthManager as m, getCoreAuthManager as a, setConfig as N } from "./index.web17.js";
 import "viem";
-import { serializeTransaction as y } from "./index.web18.js";
-const Y = async (e) => {
+import { serializeTransaction as w } from "./index.web18.js";
+const R = async (e) => {
   if (!e.projectId)
     throw new Error("Project ID is required");
   let r;
   try {
-    r = t().projectId !== e.projectId;
+    r = n().projectId !== e.projectId;
   } catch {
     r = !0;
   }
-  if (z(e), t().useMock) {
-    w(new K(t().projectId));
+  if (N(e), n().useMock) {
+    m(new K(n().projectId));
     return;
   }
-  let s;
+  let t;
   try {
-    const a = f();
-    s = a.secureStorage ? {
-      getRefreshToken: () => a.secureStorage.getItem("cdp_refresh_token"),
-      setRefreshToken: (c) => a.secureStorage.setItem("cdp_refresh_token", c),
-      removeRefreshToken: () => a.secureStorage.removeItem("cdp_refresh_token")
+    const s = l();
+    t = s.secureStorage ? {
+      getRefreshToken: () => s.secureStorage.getItem("cdp_refresh_token"),
+      setRefreshToken: (c) => s.secureStorage.setItem("cdp_refresh_token", c),
+      removeRefreshToken: () => s.secureStorage.removeItem("cdp_refresh_token")
     } : void 0;
   } catch {
-    s = void 0;
+    t = void 0;
   }
-  if (A({
-    debugging: t().debugging,
-    basePath: t().basePath,
-    refreshTokenStorage: s
+  if (h({
+    debugging: n().debugging,
+    basePath: n().basePath,
+    refreshTokenStorage: t
   }), r) {
-    const a = new b(t().projectId);
-    w(a), S(a);
+    const s = new b(n().projectId);
+    m(s), I(s);
   }
-  await n().ensureInitialized();
-}, Z = async (e) => l({
+  await a().ensureInitialized();
+}, ee = async (e) => p({
   email: e.email,
   type: "email"
-}), ee = async (e) => l({
+}), re = async (e) => p({
   phoneNumber: e.phoneNumber,
   type: "sms"
-}), te = async (e) => v(
+}), te = async (e) => y(
   e,
   "Mock email OTP verified",
-  (r, s) => U(r, s)
-), re = async (e) => v(
+  (r, t) => S(r, t)
+), ne = async (e) => y(
   e,
   "Mock SMS OTP verified",
-  (r, s) => M(r, s)
-), se = async () => n().getUser(), ne = async () => n().isSignedIn(), ae = async () => {
-  if (t().useMock) {
-    await n().signOut();
+  (r, t) => E(r, t)
+), se = async () => a().getUser(), ae = async () => a().isSignedIn(), ce = async () => {
+  if (n().useMock) {
+    await a().signOut();
     return;
   }
-  if (!await n().isSignedIn())
+  if (!await a().isSignedIn())
     throw new Error("User not signed in");
-  await n().signOut();
+  await a().signOut();
   try {
-    const r = f();
+    const r = l();
     if (r.secureStorage)
       try {
         await r.secureStorage.removeItem("cdp_refresh_token");
-      } catch (s) {
-        console.warn("Failed to clear stored refresh token:", s);
+      } catch (t) {
+        console.warn("Failed to clear stored refresh token:", t);
       }
   } catch {
   }
-}, ce = async () => n().getToken(), oe = (e) => {
-  n().addAuthStateChangeCallback(e);
-}, ie = async (e) => t().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: r, walletSecretId: s }) => ({
-  signature: (await T(t().projectId, r.userId, {
+}, oe = async () => a().getToken(), ie = (e) => {
+  a().addAuthStateChangeCallback(e);
+}, ue = async (e) => n().useMock ? { signature: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await U(n().projectId, r.userId, {
     hash: e.hash,
     address: e.evmAccount,
-    walletSecretId: s
+    walletSecretId: t
   })).signature
-})), ue = async (e) => t().useMock ? { signedTransaction: "0x0" } : i(e, n(), async ({ user: r, walletSecretId: s }) => {
-  const a = y(e.transaction);
+})), de = async (e) => n().useMock ? { signedTransaction: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => {
+  const s = w(e.transaction);
   return {
-    signedTransaction: (await P(
-      t().projectId,
+    signedTransaction: (await T(
+      n().projectId,
       r.userId,
       {
-        transaction: a,
+        transaction: s,
         address: e.evmAccount,
-        walletSecretId: s
+        walletSecretId: t
       }
     )).signedTransaction
   };
-}), de = async (e) => {
+}), ge = async (e) => n().useMock ? { signedTransaction: "mock-signed-transaction" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signedTransaction: (await M(
+    n().projectId,
+    r.userId,
+    {
+      transaction: e.transaction,
+      address: e.solanaAccount,
+      walletSecretId: t
+    }
+  )).signedTransaction
+})), me = async (e) => {
   if (!_(e.network))
     throw new Error(`Chain ${e.network} is not supported by the CDP Apis`);
-  if (t().useMock)
+  if (n().useMock)
     return { transactionHash: "0x0" };
-  const r = y(e.transaction);
-  return i(e, n(), async ({ user: s, walletSecretId: a }) => ({
+  const r = w(e.transaction);
+  return o(e, a(), async ({ user: t, walletSecretId: s }) => ({
     transactionHash: (await j(
-      t().projectId,
-      s.userId,
+      n().projectId,
+      t.userId,
       {
         transaction: r,
         address: e.evmAccount,
-        walletSecretId: a,
+        walletSecretId: s,
         network: e.network
       }
     )).transactionHash
   }));
-}, me = async (e) => t().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: r, walletSecretId: s }) => ({
-  signature: (await C(t().projectId, r.userId, {
+}, le = async (e) => n().useMock ? { transactionSignature: "mock-signature" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  transactionSignature: (await P(
+    n().projectId,
+    r.userId,
+    {
+      transaction: e.transaction,
+      address: e.solanaAccount,
+      walletSecretId: t,
+      network: e.network
+    }
+  )).transactionSignature
+})), we = async (e) => n().useMock ? { signature: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await O(n().projectId, r.userId, {
     message: e.message,
     address: e.evmAccount,
-    walletSecretId: s
+    walletSecretId: t
   })).signature
-})), ge = async (e) => t().useMock ? { signature: "0x0" } : i(e, n(), async ({ user: r, walletSecretId: s }) => ({
-  signature: (await O(t().projectId, r.userId, {
+})), pe = async (e) => n().useMock ? { signature: "0x0" } : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
+  signature: (await C(n().projectId, r.userId, {
     typedData: e.typedData,
     address: e.evmAccount,
-    walletSecretId: s
+    walletSecretId: t
   })).signature
-})), he = async (e) => t().useMock ? {
+})), ye = async (e) => n().useMock ? {
   userOperationHash: "0x1234567890123456789012345678901234567890123456789012345678901234"
-} : i(e, n(), async ({ user: r, walletSecretId: s }) => ({
+} : o(e, a(), async ({ user: r, walletSecretId: t }) => ({
   userOperationHash: (await x(
-    t().projectId,
+    n().projectId,
     r.userId,
     e.evmSmartAccount,
     {
@@ -139,12 +160,12 @@ const Y = async (e) => {
         value: String(c.value ?? 0n),
         data: c.data ?? "0x"
       })),
-      walletSecretId: s,
+      walletSecretId: t,
       useCdpPaymaster: e.useCdpPaymaster ?? !1,
       paymasterUrl: e.paymasterUrl
     }
   )).userOpHash
-})), pe = async (e) => t().useMock ? {
+})), fe = async (e) => n().useMock ? {
   userOpHash: e.userOperationHash,
   network: e.network,
   calls: [
@@ -157,122 +178,155 @@ const Y = async (e) => {
   status: "complete",
   transactionHash: "0x9876543210987654321098765432109876543210987654321098765432109876",
   receipts: []
-} : i(e, n(), async ({ user: r }) => await H(
-  t().projectId,
+} : o(e, a(), async ({ user: r }) => await W(
+  n().projectId,
   r.userId,
   e.evmSmartAccount,
   e.userOperationHash
-)), we = async (e) => {
-  if (t().useMock)
+)), he = async (e) => {
+  if (n().useMock)
     return {
       privateKey: "mock-private-key"
     };
-  const r = D(), s = await r.createExportKeyPair();
-  return i(e, n(), async ({ user: a, walletSecretId: c }) => {
-    const o = await W(t().projectId, a.userId, {
+  const r = D(), t = await r.createExportKeyPair();
+  return o(e, a(), async ({ user: s, walletSecretId: c }) => {
+    const i = await H(n().projectId, s.userId, {
       address: e.evmAccount,
       walletSecretId: c,
-      exportEncryptionKey: s.publicKeyBase64
+      exportEncryptionKey: t.publicKeyBase64
     });
     return {
       privateKey: await r.decryptWithPrivateKey(
-        s.privateKey,
-        o.encryptedPrivateKey
+        t.privateKey,
+        i.encryptedPrivateKey
       )
     };
   });
-}, l = async (e) => {
-  if (t().useMock)
+}, p = async (e) => {
+  if (n().useMock)
     return {
       message: "Mock sign in initiated",
       flowId: "mock-flow-id"
     };
-  if (await n().isSignedIn())
+  if (await a().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const s = await k(t().projectId, e);
+  const t = await A(n().projectId, e);
   return {
-    flowId: s.flowId,
-    message: s.message
+    flowId: t.flowId,
+    message: t.message
   };
-}, v = async (e, r, s) => {
-  if (t().useMock)
-    return await n().setAuthState({
+}, y = async (e, r, t) => {
+  if (n().useMock)
+    return await a().setAuthState({
       accessToken: "mock-access-token",
       expiresAt: Date.now() + 1e3 * 60 * 60 * 24,
-      user: p
+      user: g
     }), {
       message: r,
-      user: p,
+      user: g,
       isNewUser: !1
     };
-  if (await n().isSignedIn())
+  if (await a().isSignedIn())
     throw new Error("User is already authenticated. Please sign out first.");
-  const c = await s(t().projectId, {
+  const c = await t(n().projectId, {
     flowId: e.flowId,
     otp: e.otp
-  });
-  let o = m(c.accessToken, c.validUntil, c.endUser);
-  if (await n().setAuthState(o), !o.user.evmAccounts || o.user.evmAccounts.length === 0)
+  }), i = u(
+    c.accessToken,
+    c.validUntil,
+    c.endUser
+  );
+  return await a().setAuthState(i), n().createAccountOnLogin === "solana" ? F({ authResponse: c, authState: i }) : z({ authResponse: c, authState: i });
+}, z = async ({
+  authResponse: e,
+  authState: r
+}) => {
+  if (!r.user.evmAccounts || r.user.evmAccounts.length === 0)
     try {
-      const u = await n().getWalletSecretId();
-      let d = await E(t().projectId, o.user.userId, {
-        walletSecretId: u
+      const s = await a().getWalletSecretId();
+      let c = await k(n().projectId, r.user.userId, {
+        walletSecretId: s
       });
-      if (t().createAccountOnLogin === "evm-smart") {
-        const [I] = d.evmAccounts;
-        d = await h(
-          t().projectId,
-          o.user.userId,
+      if (n().createAccountOnLogin === "evm-smart") {
+        const [i] = c.evmAccounts;
+        c = await d(
+          n().projectId,
+          r.user.userId,
           {
-            owner: I,
+            owner: i,
             enableSpendPermissions: !1
             // Defaulting to false until the feature is ready.
           }
         );
       }
-      o = m(c.accessToken, c.validUntil, d), await n().setAuthState(o);
-    } catch (u) {
-      throw new Error(`Failed to create EVM account: ${u}`);
+      r = u(e.accessToken, e.validUntil, c), await a().setAuthState(r);
+    } catch (s) {
+      throw new Error(`Failed to create EVM account: ${s}`);
     }
-  if (t().createAccountOnLogin === "evm-smart" && (!o.user.evmSmartAccounts || o.user.evmSmartAccounts.length === 0))
+  if (n().createAccountOnLogin === "evm-smart" && (!r.user.evmSmartAccounts || r.user.evmSmartAccounts.length === 0))
     try {
-      const [u] = o.user.evmAccounts, d = await h(
-        t().projectId,
-        o.user.userId,
+      const [s] = r.user.evmAccounts, c = await d(
+        n().projectId,
+        r.user.userId,
         {
-          owner: u,
+          owner: s,
           enableSpendPermissions: !1
           // Defaulting to false until the feature is ready.
         }
       );
-      o = m(c.accessToken, c.validUntil, d), await n().setAuthState(o);
-    } catch (u) {
-      throw new Error(`Failed to create EVM Smart Account: ${u}`);
+      r = u(e.accessToken, e.validUntil, c), await a().setAuthState(r);
+    } catch (s) {
+      throw new Error(`Failed to create EVM Smart Account: ${s}`);
     }
-  const g = await n().getUser();
+  const t = await a().getUser();
   return {
-    message: c.message,
-    user: g,
-    isNewUser: c.isNewEndUser
+    message: e.message,
+    user: t,
+    isNewUser: e.isNewEndUser
+  };
+}, F = async ({
+  authResponse: e,
+  authState: r
+}) => {
+  if (!r.user.solanaAccounts || r.user.solanaAccounts.length === 0)
+    try {
+      const s = await a().getWalletSecretId(), c = await v(
+        n().projectId,
+        r.user.userId,
+        {
+          walletSecretId: s
+        }
+      );
+      r = u(e.accessToken, e.validUntil, c), await a().setAuthState(r);
+    } catch (s) {
+      throw new Error(`Failed to create Solana account: ${s}`);
+    }
+  const t = await a().getUser();
+  return {
+    message: e.message,
+    user: t,
+    isNewUser: e.isNewEndUser
   };
 };
 export {
-  we as exportEvmAccount,
-  ce as getAccessToken,
+  he as exportEvmAccount,
+  oe as getAccessToken,
   se as getCurrentUser,
-  pe as getUserOperation,
-  Y as initialize,
-  ne as isSignedIn,
-  oe as onAuthStateChange,
-  de as sendEvmTransaction,
-  he as sendUserOperation,
-  ie as signEvmHash,
-  me as signEvmMessage,
-  ue as signEvmTransaction,
-  ge as signEvmTypedData,
-  Z as signInWithEmail,
-  ee as signInWithSms,
-  ae as signOut,
+  fe as getUserOperation,
+  R as initialize,
+  ae as isSignedIn,
+  ie as onAuthStateChange,
+  me as sendEvmTransaction,
+  le as sendSolanaTransaction,
+  ye as sendUserOperation,
+  ue as signEvmHash,
+  we as signEvmMessage,
+  de as signEvmTransaction,
+  pe as signEvmTypedData,
+  ee as signInWithEmail,
+  re as signInWithSms,
+  ce as signOut,
+  ge as signSolanaTransaction,
   te as verifyEmailOTP,
-  re as verifySmsOTP
+  ne as verifySmsOTP
 };

package/dist/web-types/auth/withAuth.d.ts

@@ -1,4 +1,4 @@
-import { EvmAddress, User } from '../types.js';
+import { EvmAddress, SolanaAddress, User } from '../types.js';
 import { IAuthManager } from './types.js';
 export declare const isSignedIn: (authManager: IAuthManager) => Promise<boolean>;
 type AuthenticatedFunction<T, R> = (params: T & {
@@ -9,5 +9,7 @@ export declare function withAuth<T, R>(options: T & ({
     evmAccount: EvmAddress;
 } | {
     evmSmartAccount: EvmAddress;
+} | {
+    solanaAccount: SolanaAddress;
 }), authManager: IAuthManager, fn: AuthenticatedFunction<T, R>): Promise<R>;
 export {};

package/dist/web-types/core.d.ts

@@ -1,4 +1,4 @@
-import { Config, User, SignInWithEmailOptions, SignInWithEmailResult, SignInWithSmsOptions, SignInWithSmsResult, VerifySmsOTPOptions, VerifySmsOTPResult, SignEvmHashOptions, SignEvmHashResult, VerifyEmailOTPOptions, VerifyEmailOTPResult, OnAuthStateChangeFn, SendEvmTransactionResult, SignEvmTransactionOptions, SignEvmTransactionResult, SignEvmTypedDataOptions, SignEvmTypedDataResult, SignEvmMessageOptions, ExportEvmAccountResult, SendEvmTransactionOptions, ExportEvmAccountOptions, SendUserOperationOptions, SendUserOperationResult, GetUserOperationOptions, GetUserOperationResult } from './types.js';
+import { Config, User, SignInWithEmailOptions, SignInWithEmailResult, SignInWithSmsOptions, SignInWithSmsResult, VerifySmsOTPOptions, VerifySmsOTPResult, SignEvmHashOptions, SignEvmHashResult, VerifyEmailOTPOptions, VerifyEmailOTPResult, OnAuthStateChangeFn, SendEvmTransactionResult, SignEvmTransactionOptions, SignEvmTransactionResult, SignSolanaTransactionOptions, SignSolanaTransactionResult, SignEvmTypedDataOptions, SignEvmTypedDataResult, SignEvmMessageOptions, ExportEvmAccountResult, SendEvmTransactionOptions, SendSolanaTransactionOptions, SendSolanaTransactionResult, ExportEvmAccountOptions, SendUserOperationOptions, SendUserOperationResult, GetUserOperationOptions, GetUserOperationResult } from './types.js';
 export declare const initialize: (cfg: Config) => Promise<void>;
 export declare const signInWithEmail: (options: SignInWithEmailOptions) => Promise<SignInWithEmailResult>;
 export declare const signInWithSms: (options: SignInWithSmsOptions) => Promise<SignInWithSmsResult>;
@@ -11,7 +11,9 @@ export declare const getAccessToken: () => Promise<string | null>;
 export declare const onAuthStateChange: (callback: OnAuthStateChangeFn) => void;
 export declare const signEvmHash: (options: SignEvmHashOptions) => Promise<SignEvmHashResult>;
 export declare const signEvmTransaction: (options: SignEvmTransactionOptions) => Promise<SignEvmTransactionResult>;
+export declare const signSolanaTransaction: (options: SignSolanaTransactionOptions) => Promise<SignSolanaTransactionResult>;
 export declare const sendEvmTransaction: (options: SendEvmTransactionOptions) => Promise<SendEvmTransactionResult>;
+export declare const sendSolanaTransaction: (options: SendSolanaTransactionOptions) => Promise<SendSolanaTransactionResult>;
 export declare const signEvmMessage: (options: SignEvmMessageOptions) => Promise<SignEvmHashResult>;
 export declare const signEvmTypedData: (options: SignEvmTypedDataOptions) => Promise<SignEvmTypedDataResult>;
 export declare const sendUserOperation: (options: SendUserOperationOptions) => Promise<SendUserOperationResult>;

package/dist/web-types/types.d.ts

@@ -1,15 +1,16 @@
-import { SendEvmTransactionWithEndUserAccountBodyNetwork, APIError, APIErrorType, ErrorType, HttpErrorType, EvmUserOperation } from '@coinbase/cdp-api-client';
+import { SendEvmTransactionWithEndUserAccountBodyNetwork, SendSolanaTransactionWithEndUserAccountBodyNetwork, APIError, APIErrorType, ErrorType, HttpErrorType, EvmUserOperation } from '@coinbase/cdp-api-client';
 import { TransactionSerializableEIP1559 } from 'viem';
-export { APIError, type APIErrorType, ErrorType, HttpErrorType, SendEvmTransactionWithEndUserAccountBodyNetwork, };
+export { APIError, type APIErrorType, ErrorType, HttpErrorType, SendEvmTransactionWithEndUserAccountBodyNetwork, SendSolanaTransactionWithEndUserAccountBodyNetwork, };
 export type Config = {
     projectId: string;
     useMock?: boolean;
     debugging?: boolean;
     basePath?: string;
-    createAccountOnLogin?: "evm-eoa" | "evm-smart";
+    createAccountOnLogin?: "evm-eoa" | "evm-smart" | "solana";
 };
 export type Hex = `0x${string}`;
 export type EvmAddress = `0x${string}`;
+export type SolanaAddress = string;
 export type AuthenticationMethods = {
     email?: EmailAuthentication;
     sms?: SmsAuthentication;
@@ -19,6 +20,7 @@ export type User = {
     authenticationMethods: AuthenticationMethods;
     evmAccounts?: EvmAddress[];
     evmSmartAccounts?: EvmAddress[];
+    solanaAccounts?: SolanaAddress[];
 };
 export type EmailAuthentication = {
     type: "email";
@@ -76,6 +78,13 @@ export type SignEvmTransactionOptions = {
 export type SignEvmTransactionResult = {
     signedTransaction: Hex;
 };
+export type SignSolanaTransactionOptions = {
+    solanaAccount: SolanaAddress;
+    transaction: string;
+};
+export type SignSolanaTransactionResult = {
+    signedTransaction: string;
+};
 export type SendEvmTransactionOptions = {
     evmAccount: EvmAddress;
     network: SendEvmTransactionWithEndUserAccountBodyNetwork;
@@ -84,6 +93,14 @@ export type SendEvmTransactionOptions = {
 export type SendEvmTransactionResult = {
     transactionHash: Hex;
 };
+export type SendSolanaTransactionOptions = {
+    solanaAccount: SolanaAddress;
+    network: SendSolanaTransactionWithEndUserAccountBodyNetwork;
+    transaction: string;
+};
+export type SendSolanaTransactionResult = {
+    transactionSignature: string;
+};
 export type SignEvmMessageOptions = {
     evmAccount: EvmAddress;
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-core",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "files": [
     "dist/**",
@@ -25,7 +25,7 @@
     "ox": "0.8.1",
     "viem": "^2.33.0",
     "zustand": "^5.0.6",
-    "@coinbase/cdp-api-client": "^0.0.33"
+    "@coinbase/cdp-api-client": "^0.0.35"
   },
   "peerDependencies": {
     "@react-native-async-storage/async-storage": "^2.0.0",