@zerodev/wallet-core 0.0.1-alpha.20 → 0.0.1-alpha.22

package/package.json

@@ -1,15 +1,69 @@
 {
   "name": "@zerodev/wallet-core",
-  "version": "0.0.1-alpha.20",
+  "version": "0.0.1-alpha.22",
   "description": "ZeroDev Wallet SDK built on Turnkey",
+  "sideEffects": false,
   "main": "./dist/_cjs/index.js",
   "module": "./dist/_esm/index.js",
   "types": "./dist/_types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/_types/index.d.ts",
-      "import": "./dist/_esm/index.js",
-      "require": "./dist/_cjs/index.js"
+      "react-native": {
+        "types": "./dist/_types/index.native.d.ts",
+        "default": "./dist/_esm/index.native.js"
+      },
+      "browser": {
+        "types": "./dist/_types/index.d.ts",
+        "default": "./dist/_esm/index.js"
+      },
+      "import": {
+        "types": "./dist/_types/index.d.ts",
+        "default": "./dist/_esm/index.js"
+      },
+      "require": {
+        "types": "./dist/_types/index.d.ts",
+        "default": "./dist/_cjs/index.js"
+      },
+      "default": {
+        "types": "./dist/_types/index.d.ts",
+        "default": "./dist/_esm/index.js"
+      }
+    },
+    "./react-native": {
+      "browser": "./dist/_esm/stubs/native-on-web.js",
+      "node": "./dist/_esm/stubs/native-on-web.js",
+      "import": {
+        "types": "./dist/_types/index.native.d.ts",
+        "default": "./dist/_esm/index.native.js"
+      },
+      "default": "./dist/_esm/index.native.js"
+    },
+    "./react-native/stampers/secure-store": {
+      "browser": "./dist/_esm/stubs/native-on-web.js",
+      "node": "./dist/_esm/stubs/native-on-web.js",
+      "import": {
+        "types": "./dist/_types/native/stampers/secureStore.d.ts",
+        "default": "./dist/_esm/native/stampers/secureStore.js"
+      },
+      "default": "./dist/_esm/native/stampers/secureStore.js"
+    },
+    "./react-native/stampers/passkey": {
+      "browser": "./dist/_esm/stubs/native-on-web.js",
+      "node": "./dist/_esm/stubs/native-on-web.js",
+      "import": {
+        "types": "./dist/_types/native/stampers/passkey.d.ts",
+        "default": "./dist/_esm/native/stampers/passkey.js"
+      },
+      "default": "./dist/_esm/native/stampers/passkey.js"
+    },
+    "./react-native/storage/async-storage": {
+      "browser": "./dist/_esm/stubs/native-on-web.js",
+      "node": "./dist/_esm/stubs/native-on-web.js",
+      "import": {
+        "types": "./dist/_types/native/storage/asyncStorage.d.ts",
+        "default": "./dist/_esm/native/storage/asyncStorage.js"
+      },
+      "default": "./dist/_esm/native/storage/asyncStorage.js"
     },
     "./viem": {
       "types": "./dist/_types/adapters/viem.d.ts",
@@ -20,11 +74,6 @@
       "types": "./dist/_types/actions/index.d.ts",
       "import": "./dist/_esm/actions/index.js",
       "require": "./dist/_cjs/actions/index.js"
-    },
-    "./stampers": {
-      "types": "./dist/_types/stampers/index.d.ts",
-      "import": "./dist/_esm/stampers/index.js",
-      "require": "./dist/_cjs/stampers/index.js"
     }
   },
   "files": [
@@ -59,12 +108,48 @@
     "json-canonicalize": "^2.0.0"
   },
   "peerDependencies": {
-    "viem": "^2.38.0"
+    "viem": "^2.38.0",
+    "@react-native-async-storage/async-storage": ">=2.0.0",
+    "@turnkey/api-key-stamper": ">=0.6.0",
+    "@turnkey/crypto": ">=2.8.0",
+    "@turnkey/react-native-passkey-stamper": ">=1.2.0",
+    "expo-secure-store": ">=14.0.0",
+    "react-native": ">=0.73.0",
+    "uuid": ">=11.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    },
+    "@turnkey/api-key-stamper": {
+      "optional": true
+    },
+    "@turnkey/crypto": {
+      "optional": true
+    },
+    "@turnkey/react-native-passkey-stamper": {
+      "optional": true
+    },
+    "expo-secure-store": {
+      "optional": true
+    },
+    "react-native": {
+      "optional": true
+    },
+    "uuid": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@hpke/core": "^1.9.0",
+    "@react-native-async-storage/async-storage": "2.2.0",
+    "@turnkey/api-key-stamper": "0.6.4",
+    "@turnkey/crypto": "2.8.13",
+    "@turnkey/react-native-passkey-stamper": "1.2.12",
     "@types/node": "^20.0.0",
-    "typescript": "5.9.3"
+    "expo-secure-store": "55.0.9",
+    "typescript": "5.9.3",
+    "uuid": "^13.0.0"
   },
   "scripts": {
     "build": "pnpm run clean && pnpm run build:cjs && pnpm run build:esm && pnpm run build:types",

package/src/core/{createZeroDevWallet.ts → createZeroDevWalletCore.ts}

@@ -16,10 +16,8 @@ import {
   DEFAULT_SESSION_EXPIRATION_IN_SECONDS,
   KMS_SERVER_URL,
 } from '../constants.js'
-import { createIndexedDbStamper } from '../stampers/indexedDbStamper.js'
+import { createNoopPasskeyStamper } from '../stampers/noopPasskeyStamper.js'
 import type { ApiKeyStamper, PasskeyStamper } from '../stampers/types.js'
-import { createWebauthnStamper } from '../stampers/webauthnStamper.js'
-import { createWebStorageAdapter } from '../storage/adapters.js'
 import {
   createStorageManager,
   type StorageAdapter,
@@ -28,13 +26,13 @@ import { SessionType, type ZeroDevWalletSession } from '../types/session.js'
 import { buildClientSignature } from '../utils/buildClientSignature.js'
 import { encryptOtpAttempt } from '../utils/encryptOtpAttempt.js'
 import { humanReadableDateTime, parseSession } from '../utils/utils.js'
-export interface ZeroDevWalletConfig {
+export interface ZeroDevWalletConfigCore {
   organizationId?: string
   proxyBaseUrl?: string
   projectId: string
-  sessionStorage?: StorageAdapter
-  rpId?: string
-  apiKeyStamper?: ApiKeyStamper
+  sessionStorage: StorageAdapter
+  rpId: string
+  apiKeyStamper: ApiKeyStamper
   passkeyStamper?: PasskeyStamper
   fetchOptions?: CreateTransportOptions['fetchOptions']
 }
@@ -118,24 +116,19 @@ export interface ZeroDevWalletSDK {
   toAccount: () => Promise<LocalAccount>
 }
 
-export async function createZeroDevWallet(
-  config: ZeroDevWalletConfig,
+export async function createZeroDevWalletCore(
+  config: ZeroDevWalletConfigCore,
 ): Promise<ZeroDevWalletSDK> {
   const {
     projectId,
     sessionStorage,
-    rpId = window.location.hostname,
+    rpId,
+    apiKeyStamper,
     organizationId = DEFAULT_ORGANIZATION_ID,
   } = config
+  const passkeyStamper = config.passkeyStamper ?? createNoopPasskeyStamper()
 
-  const sessionStorageManager = createStorageManager(
-    sessionStorage || createWebStorageAdapter(),
-  )
-
-  const apiKeyStamper = config.apiKeyStamper ?? (await createIndexedDbStamper())
-
-  const passkeyStamper =
-    config.passkeyStamper ?? (await createWebauthnStamper({ rpId }))
+  const sessionStorageManager = createStorageManager(sessionStorage)
 
   const client = createClient({
     apiKeyStamper,

package/src/index.native.ts

@@ -0,0 +1,103 @@
+import { isReactNative } from './utils/platform.js'
+
+if (!isReactNative()) {
+  // biome-ignore lint/suspicious/noConsole: Warning users if they try to use the web entry on React Native.
+  console.warn(
+    '@zerodev/wallet-core/react-native: the React Native entry was loaded outside a React Native runtime. If this is a non-RN context, import `@zerodev/wallet-core` (the bare specifier) instead.',
+  )
+}
+
+// Re-export shared API surface. Note: we intentionally do NOT re-export the
+// web stamper factories (createIndexedDbStamper, createWebauthnStamper,
+// createIframeStamper) here — they're web-only. The native adapter factories
+// live behind their own granular subpaths so consumers using alternative
+// adapters (Keychain, MMKV, custom) skip the unused peer-dep installs.
+export type {
+  ApiKeyAuthenticator,
+  AuthenticateWithEmailParameters,
+  AuthenticateWithEmailReturnType,
+  AuthenticateWithOAuthParameters,
+  AuthenticateWithOAuthReturnType,
+  EmailContact,
+  EmailCustomization,
+  GetAuthenticatorsParameters,
+  GetAuthenticatorsReturnType,
+  GetUserWalletParameters,
+  GetUserWalletReturnType,
+  GetWhoamiParameters,
+  GetWhoamiReturnType,
+  LoginWithOTPParameters,
+  LoginWithOTPReturnType,
+  OAuthAuthenticator,
+  OtpContact,
+  PasskeyAuthenticator,
+  RegisterWithOTPParameters,
+  RegisterWithOTPReturnType,
+  Sign7702AuthorizationParameters,
+  Sign7702AuthorizationReturnType,
+  SignMessageParameters,
+  SignMessageReturnType,
+  SignTransactionParameters,
+  SignTransactionReturnType,
+  SignTypedDataV4Parameters,
+  SignTypedDataV4ReturnType,
+  SignUserOperationParameters,
+  SignUserOperationReturnType,
+} from './actions/index.js'
+export {
+  authenticateWithEmail,
+  authenticateWithOAuth,
+  getAuthenticators,
+  getUserWallet,
+  getWhoami,
+  loginWithOTP,
+  registerWithOTP,
+  sign7702Authorization,
+  signMessage,
+  signTransaction,
+  signTypedDataV4,
+  signUserOperation,
+} from './actions/index.js'
+export type { ToViemAccountParams } from './adapters/viem.js'
+export { toViemAccount } from './adapters/viem.js'
+export type { ZeroDevWalletActions } from './client/decorators/client.js'
+export { zeroDevWalletActions } from './client/decorators/client.js'
+export type {
+  Client,
+  ClientConfig,
+  CreateTransportOptions,
+  Transport,
+} from './client/index.js'
+export {
+  createBaseClient,
+  createClient,
+  type ZeroDevWalletClient,
+  zeroDevWalletTransport,
+} from './client/index.js'
+export { KMS_SERVER_URL } from './constants.js'
+export type {
+  AuthParams,
+  ZeroDevWalletSDK,
+} from './core/createZeroDevWalletCore.js'
+// RN entry re-exports through a thin wrapper that auto-injects the
+// `Origin: https://${rpId}` header on Turnkey requests. `ZeroDevWalletConfig`
+// matches the strict `ZeroDevWalletConfigCore` shape, so RN consumers still
+// get compile-time enforcement of the four required adapter fields.
+export {
+  createZeroDevWallet,
+  type ZeroDevWalletConfig,
+} from './native/createZeroDevWallet.js'
+export type {
+  ApiKeyStamper,
+  Attestation,
+  IframeStamper,
+  PasskeyRegistrationOptions,
+  PasskeyRegistrationResult,
+  PasskeyStamper,
+} from './stampers/types.js'
+export type { StorageAdapter, StorageManager } from './storage/manager.js'
+export type { StamperType, ZeroDevWalletSession } from './types/session.js'
+export type { KeyFormat } from './utils/exportPrivateKey.js'
+export { exportPrivateKey } from './utils/exportPrivateKey.js'
+export { exportWallet } from './utils/exportWallet.js'
+export { normalizeTimestamp } from './utils/utils.js'

package/src/index.ts

@@ -1,3 +1,12 @@
+import { isReactNative } from './utils/platform.js'
+
+if (isReactNative()) {
+  // biome-ignore lint/suspicious/noConsole: Warning users if they try to use the web entry on React Native.
+  console.warn(
+    '@zerodev/wallet-core: the web entry was loaded in a React Native runtime. Check that your metro.config.js has `unstable_enablePackageExports: true` and `"react-native"` in `unstable_conditionNames`.',
+  )
+}
+
 export type {
   // Auth types
   ApiKeyAuthenticator,
@@ -73,17 +82,10 @@ export {
 export { KMS_SERVER_URL } from './constants.js'
 export type {
   AuthParams,
-  ZeroDevWalletConfig,
   ZeroDevWalletSDK,
-} from './core/createZeroDevWallet.js'
-// Core
-export { createZeroDevWallet } from './core/createZeroDevWallet.js'
+} from './core/createZeroDevWalletCore.js'
 // Stampers
-export {
-  createIframeStamper,
-  createIndexedDbStamper,
-  createWebauthnStamper,
-} from './stampers/index.js'
+export { createIframeStamper } from './stampers/iframeStamper.js'
 export type {
   ApiKeyStamper,
   Attestation,
@@ -101,3 +103,11 @@ export { exportPrivateKey } from './utils/exportPrivateKey.js'
 export { exportWallet } from './utils/exportWallet.js'
 // Utils
 export { normalizeTimestamp } from './utils/utils.js'
+// Core — bare specifier resolves web defaults (IndexedDB, WebAuthn, session
+// storage, hostname-derived rpId) before forwarding to the shared factory.
+// RN consumers go through `@zerodev/wallet-core/react-native`, which exposes
+// the strict `ZeroDevWalletConfig` (= core's required-fields shape) directly.
+export {
+  createZeroDevWallet,
+  type ZeroDevWalletConfig,
+} from './web/createZeroDevWallet.js'

package/src/native/createZeroDevWallet.ts

@@ -0,0 +1,26 @@
+import {
+  createZeroDevWalletCore,
+  type ZeroDevWalletConfigCore,
+  type ZeroDevWalletSDK,
+} from '../core/createZeroDevWalletCore.js'
+
+/**
+ * React Native config — mirrors `web/createZeroDevWallet.ts`'s wrapper
+ * pattern. RN consumers must supply all four adapter fields up front
+ * (no platform-native defaults exist for IndexedDB/WebAuthn). The only
+ * RN-specific defaulting is `fetchOptions`: when omitted, we set
+ * `Origin: https://${rpId}` so Turnkey's ACL accepts the request. Power
+ * users wanting a different Origin can pass `fetchOptions` explicitly.
+ */
+export type ZeroDevWalletConfig = ZeroDevWalletConfigCore
+
+export async function createZeroDevWallet(
+  config: ZeroDevWalletConfig,
+): Promise<ZeroDevWalletSDK> {
+  return createZeroDevWalletCore({
+    ...config,
+    fetchOptions: config.fetchOptions ?? {
+      headers: { Origin: `https://${config.rpId}` },
+    },
+  })
+}

package/src/native/stampers/passkey.ts

@@ -0,0 +1,39 @@
+import {
+  createPasskey,
+  PasskeyStamper as TurnkeyPasskeyStamper,
+} from '@turnkey/react-native-passkey-stamper'
+import { v4 as uuidv4 } from 'uuid'
+import type {
+  PasskeyRegistrationOptions,
+  PasskeyStamper,
+} from '../../stampers/types.js'
+
+export async function createReactNativePasskeyStamper({
+  rpId,
+}: {
+  rpId: string
+}): Promise<PasskeyStamper> {
+  const inner = new TurnkeyPasskeyStamper({ rpId })
+
+  return {
+    async stamp(payload: string) {
+      return await inner.stamp(payload)
+    },
+    async clear() {},
+    async register({ rp, userName }: PasskeyRegistrationOptions) {
+      const { attestation, challenge: encodedChallenge } = await createPasskey({
+        rp: {
+          id: rp.id,
+          name: rp.name ?? 'Turnkey',
+        },
+        user: {
+          id: uuidv4(),
+          name: userName,
+          displayName: userName,
+        },
+        authenticatorName: userName ?? 'End-User Passkey',
+      })
+      return { attestation, encodedChallenge }
+    },
+  }
+}

package/src/native/stampers/secureStore.ts

@@ -0,0 +1,139 @@
+import { ApiKeyStamper, SignatureFormat } from '@turnkey/api-key-stamper'
+import { generateP256KeyPair } from '@turnkey/crypto'
+import * as SecureStore from 'expo-secure-store'
+import type { ApiKeyStamper as ZDApiKeyStamper } from '../../stampers/types.js'
+
+const PUBLIC_KEY = 'zerodev.publicKey'
+const PRIVATE_KEY = 'zerodev.privateKey'
+
+class SecureStoreStamperInner {
+  private publicKeyHex: string | null = null
+
+  async init(): Promise<void> {
+    const publicKey = await SecureStore.getItemAsync(PUBLIC_KEY)
+    const privateKey = await SecureStore.getItemAsync(PRIVATE_KEY)
+
+    if (publicKey && privateKey) {
+      this.publicKeyHex = publicKey
+    } else {
+      await this.resetKeyPair()
+    }
+  }
+
+  async getPublicKey(): Promise<string | null> {
+    return this.publicKeyHex
+  }
+
+  async resetKeyPair(externalKeyPair?: {
+    publicKey: string
+    privateKey: string
+  }): Promise<void> {
+    await this.clear()
+
+    const pair = externalKeyPair ?? generateP256KeyPair()
+
+    await SecureStore.setItemAsync(PUBLIC_KEY, pair.publicKey)
+    await SecureStore.setItemAsync(PRIVATE_KEY, pair.privateKey)
+
+    this.publicKeyHex = pair.publicKey
+  }
+
+  private async getTurnkeyApiKeyStamper(): Promise<ApiKeyStamper> {
+    if (!this.publicKeyHex) {
+      throw new Error(
+        'Key not initialized. Call init() or resetKeyPair() first.',
+      )
+    }
+
+    const privateKey = await SecureStore.getItemAsync(PRIVATE_KEY)
+    if (!privateKey) {
+      throw new Error('No private key found in secure store.')
+    }
+
+    return new ApiKeyStamper({
+      apiPublicKey: this.publicKeyHex,
+      apiPrivateKey: privateKey,
+    })
+  }
+
+  async stamp(
+    payload: string,
+  ): Promise<{ stampHeaderName: string; stampHeaderValue: string }> {
+    const stamper = await this.getTurnkeyApiKeyStamper()
+    const { stampHeaderName, stampHeaderValue } = await stamper.stamp(payload)
+    return { stampHeaderName, stampHeaderValue }
+  }
+
+  async sign(payload: string): Promise<string> {
+    const stamper = await this.getTurnkeyApiKeyStamper()
+    return stamper.sign(payload, SignatureFormat.Der)
+  }
+
+  async clear(): Promise<void> {
+    await SecureStore.deleteItemAsync(PUBLIC_KEY)
+    await SecureStore.deleteItemAsync(PRIVATE_KEY)
+    this.publicKeyHex = null
+  }
+}
+
+async function warmApiKeyStamperForMetroDev(
+  inner: SecureStoreStamperInner,
+): Promise<void> {
+  // `__DEV__` is a global set by React Native's Metro; read it via globalThis
+  // so this file needs no ambient `.d.ts` (which would conflict with RN's own
+  // typings when both happen to be in scope, e.g. in the editor).
+  if (!(globalThis as { __DEV__?: boolean }).__DEV__) return
+
+  // In Expo dev, Turnkey's API key stamper loads its React Native signer with a
+  // dynamic import the first time `stamp()` runs. OTP verification is usually
+  // the first code path that stamps a payload, and if the app was backgrounded
+  // while the user copied the code, Metro can serve that lazy module after
+  // foregrounding and trigger a full JS reload. Warming the stamper during dev
+  // startup makes Metro load the signer while the app is foregrounded; production
+  // builds do not use Metro and skip this block via `__DEV__`.
+  try {
+    await inner.stamp('{"purpose":"metro-dev-warmup"}')
+  } catch (error) {
+    // biome-ignore lint/suspicious/noConsole: This only runs in dev mode
+    console.warn('Failed to warm API key stamper in dev:', error)
+  }
+}
+
+export async function createSecureStoreStamper(): Promise<ZDApiKeyStamper> {
+  const inner = new SecureStoreStamperInner()
+  await inner.init()
+  await warmApiKeyStamperForMetroDev(inner)
+
+  let pendingKeyPair: { publicKey: string; privateKey: string } | null = null
+
+  return {
+    async getPublicKey() {
+      return inner.getPublicKey()
+    },
+    async stamp(payload: string) {
+      return inner.stamp(payload)
+    },
+    async sign(payload: string) {
+      return inner.sign(payload)
+    },
+    async clear() {
+      await inner.clear()
+    },
+    async resetKeyPair() {
+      pendingKeyPair = null
+      await inner.resetKeyPair()
+    },
+    async prepareKeyRotation() {
+      const keyPair = generateP256KeyPair()
+      pendingKeyPair = keyPair
+      return keyPair.publicKey
+    },
+    async commitKeyRotation() {
+      if (!pendingKeyPair) {
+        throw new Error('No pending key rotation to commit')
+      }
+      await inner.resetKeyPair(pendingKeyPair)
+      pendingKeyPair = null
+    },
+  }
+}

package/src/native/storage/asyncStorage.ts

@@ -0,0 +1,18 @@
+import type { AsyncStorageStatic } from '@react-native-async-storage/async-storage'
+import * as AsyncStorageNS from '@react-native-async-storage/async-storage'
+import type { StorageAdapter } from '../../storage/manager.js'
+
+// CJS package whose `.d.ts` declares `export default AsyncStorage`. Our tsconfig
+// keeps `esModuleInterop: false` (and `verbatimModuleSyntax: true`), so a plain
+// `import AsyncStorage from '...'` types as the module namespace instead of
+// the default. Unwrap explicitly. At runtime Metro returns the default object
+// either way; this only affects the static type.
+const AsyncStorage: AsyncStorageStatic = (
+  AsyncStorageNS as unknown as { default: AsyncStorageStatic }
+).default
+
+export const asyncStorageAdapter: StorageAdapter = {
+  getItem: (key) => AsyncStorage.getItem(key),
+  setItem: (key, value) => AsyncStorage.setItem(key, value),
+  removeItem: (key) => AsyncStorage.removeItem(key),
+}

package/src/stampers/noopPasskeyStamper.ts

@@ -0,0 +1,21 @@
+import type { PasskeyStamper } from './types.js'
+
+const NOT_CONFIGURED_MESSAGE =
+  'passkeyStamper is not configured. Pass passkeyStamper to zeroDevWallet({ ... }) — use createReactNativePasskeyStamper({ rpId }) on React Native or createWebauthnStamper({ rpId }) on web.'
+
+/**
+ * Internal fallback used when a consumer doesn't supply a `passkeyStamper`.
+ * Methods throw on use, so passkey register/login fails with an actionable
+ * message — all other flows (apiKey signing, OAuth, OTP) are unaffected.
+ */
+export function createNoopPasskeyStamper(): PasskeyStamper {
+  return {
+    async stamp() {
+      throw new Error(NOT_CONFIGURED_MESSAGE)
+    },
+    async register() {
+      throw new Error(NOT_CONFIGURED_MESSAGE)
+    },
+    async clear() {},
+  }
+}

package/src/stubs/native-on-web.ts

@@ -0,0 +1,29 @@
+// Catch-all stub used by every `./react-native/*` subpath in this package
+// under the `browser` and `node` exports conditions. Both are needed for
+// Expo web: the client bundle resolves with `browser` active, while Expo
+// Router's SSR/RSC route render drops platform conditions (no `browser`)
+// and turns on `node` instead — so the web stub has to be gated on both or
+// the SSR pass falls through to the native impl. Imports must be safe on web
+// (some route files are bundled even when they aren't rendered) so we expose
+// the RN-only symbols as throw-on-use functions instead of throwing at
+// module-init time.
+//
+// Anyone who *uses* these on web gets a clear actionable error; anyone who
+// merely imports them (typically because their universal app bundles the
+// native variant too) is unaffected.
+
+const message =
+  '@zerodev/wallet-core react-native subpaths cannot be imported in a web environment. Use the bare specifier (`import { ... } from "@zerodev/wallet-core"`) instead.'
+
+function throwOnUse(): never {
+  throw new Error(message)
+}
+
+export const createSecureStoreStamper = throwOnUse
+export const createReactNativePasskeyStamper = throwOnUse
+export const asyncStorageAdapter = throwOnUse
+
+// For the broad `./react-native` entry: any consumer reaching it on web is
+// already off-pattern (they should use the bare specifier). Default export
+// covers `import X from '...'`.
+export default throwOnUse

package/src/utils/exportPrivateKey.ts

@@ -1,4 +1,4 @@
-import type { ZeroDevWalletSDK } from '../core/createZeroDevWallet.js'
+import type { ZeroDevWalletSDK } from '../core/createZeroDevWalletCore.js'
 import type { KeyFormat } from '../stampers/types.js'
 
 export type ExportPrivateKeyParameters = {