@coinbase/cdp-core 0.0.25 → 0.0.27

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

@@ -0,0 +1,6 @@
+export * from './core.js';
+export * from './auth/authManager.js';
+export * from './types.js';
+export * from './provider.js';
+export * from './viem/toViemAccount.js';
+export * from './errors.js';

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

@@ -0,0 +1,6 @@
+export * from './core.js';
+export * from './auth/authManager.js';
+export * from './types.js';
+export * from './provider.js';
+export * from './viem/toViemAccount.js';
+export * from './errors.js';

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

@@ -0,0 +1,23 @@
+import { AuthState, IAuthManager } from '../auth/types.js';
+import { OnAuthStateChangeFn, User } from '../types.js';
+export declare class MockAuthManager implements IAuthManager {
+    private authState;
+    private authStateChangeCallback;
+    constructor(_projectId: string);
+    ensureInitialized(): Promise<void>;
+    getUser(): Promise<User | null>;
+    isSignedIn(): Promise<boolean>;
+    signOut(): Promise<void>;
+    addAuthStateChangeCallback(callback: OnAuthStateChangeFn): void;
+    getToken(): Promise<string | null>;
+    getWalletSecretId(): Promise<string>;
+    getXWalletAuth(_options: {
+        requestMethod: string;
+        requestHost: string;
+        requestPath: string;
+        requestData?: Record<string, unknown>;
+    }): Promise<string>;
+    setAuthState(authState: AuthState): Promise<void>;
+    clearAuthState(): Promise<void>;
+    private refreshToken;
+}

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

@@ -0,0 +1,4 @@
+import { User } from '../types.js';
+export declare const mockAddress: `0x${string}`;
+export declare const mockUser: User;
+export declare const getCurrentUser: () => Promise<User | null>;

package/dist/web-types/platform/native/crypto.d.ts

@@ -0,0 +1,2 @@
+import { PlatformCrypto } from '../types.js';
+export declare const nativeCrypto: PlatformCrypto;

package/dist/web-types/platform/native/storage.d.ts

@@ -0,0 +1,2 @@
+import { PlatformStorage } from '../types.js';
+export declare const nativeStorage: PlatformStorage;

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

@@ -0,0 +1,7 @@
+import { PlatformServices, PlatformCrypto, PlatformStorage } from './types.js';
+export declare function setPlatformServices(services: PlatformServices): void;
+export declare function getPlatformServices(): PlatformServices;
+export declare function getPlatformCrypto(): PlatformCrypto;
+export declare function getPlatformStorage(): PlatformStorage;
+export declare function isPlatformInitialized(): boolean;
+export declare function clearPlatformServices(): void;

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

@@ -0,0 +1,18 @@
+import { KeyPair } from '../shared/types.js';
+export interface PlatformCrypto {
+    createKeyPair(): Promise<KeyPair>;
+    createExportKeyPair(): Promise<KeyPair>;
+    hash(data: Uint8Array): Promise<string>;
+    generateRandomId(): string;
+    decryptWithPrivateKey(privateKey: CryptoKey, encryptedData: string): Promise<string>;
+}
+export interface PlatformStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface PlatformServices {
+    crypto: PlatformCrypto;
+    storage: PlatformStorage;
+}

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

@@ -0,0 +1,2 @@
+import { PlatformCrypto } from '../types.js';
+export declare const webCrypto: PlatformCrypto;

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

@@ -0,0 +1,2 @@
+import { PlatformStorage } from '../types.js';
+export declare const webStorage: PlatformStorage;

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

@@ -0,0 +1,3 @@
+export { createCDPEmbeddedWallet } from './eip1193/index.js';
+export { EIP1193ProviderError, type EIP1193ErrorCode, type RPCErrorCode, STANDARD_ERROR_CODES, } from './eip1193/errors.js';
+export * from './eip1193/types.js';

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

@@ -0,0 +1,2 @@
+export declare function encodeBase64(data: Uint8Array): string;
+export declare function decodeBase64(base64: string): Uint8Array;

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

@@ -0,0 +1,2 @@
+export declare function encodeText(text: string): Uint8Array;
+export declare function decodeText(bytes: Uint8Array): string;

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

@@ -0,0 +1,5 @@
+import { CryptoKey, KeyObject, JWK } from 'jose';
+export type KeyPair = {
+    privateKey: CryptoKey | KeyObject | JWK | Uint8Array;
+    publicKeyBase64: string;
+};

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

@@ -0,0 +1,32 @@
+import { EvmUserOperationNetwork, SendEvmTransactionWithEndUserAccountBodyNetwork } from '@coinbase/cdp-api-client';
+export declare const sortKeys: (obj: any) => any;
+export declare const isChainSupportedForCDPSends: (chainName: SendEvmTransactionWithEndUserAccountBodyNetwork) => boolean;
+declare const sendTransactionNameToChainIdMapping: {
+    "base-sepolia": 84532;
+    base: 8453;
+    ethereum: 1;
+    "ethereum-sepolia": 11155111;
+    avalanche: 43114;
+    polygon: 137;
+    optimism: 10;
+    arbitrum: 42161;
+};
+type SendTransactionSupportedChainId = (typeof sendTransactionNameToChainIdMapping)[keyof typeof sendTransactionNameToChainIdMapping];
+export declare const sendTransactionChainIdToNameMapping: Record<SendTransactionSupportedChainId, SendEvmTransactionWithEndUserAccountBodyNetwork>;
+export declare const isChainIdSupportedForCDPSends: (chainId: number) => boolean;
+export declare const userOperationNameToChainIdMapping: {
+    "base-sepolia": 84532;
+    base: 8453;
+    ethereum: 1;
+    "ethereum-sepolia": 11155111;
+    avalanche: 43114;
+    polygon: 137;
+    optimism: 10;
+    arbitrum: 42161;
+    zora: 7777777;
+    bnb: 56;
+};
+type SendUserOperationSupportedChainId = (typeof userOperationNameToChainIdMapping)[keyof typeof userOperationNameToChainIdMapping];
+export declare const userOperationChainIdToNameMapping: Record<SendUserOperationSupportedChainId, EvmUserOperationNetwork>;
+export declare const isChainIdSupportedForCDPUserOps: (chainId: number) => boolean;
+export {};

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

@@ -0,0 +1,7 @@
+import { IAuthManager } from './auth/types.js';
+import { Config } from './types.js';
+export declare const setConfig: (cfg: Config) => void;
+export declare const getConfig: () => Config;
+export declare const setCoreAuthManager: (manager: IAuthManager) => void;
+export declare const getCoreAuthManager: () => IAuthManager;
+export declare const resetState: () => void;

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

@@ -0,0 +1,146 @@
+import { SendEvmTransactionWithEndUserAccountBodyNetwork, APIError, APIErrorType, ErrorType, HttpErrorType, EvmUserOperation } from '@coinbase/cdp-api-client';
+import { TransactionSerializableEIP1559 } from 'viem';
+export { APIError, type APIErrorType, ErrorType, HttpErrorType, SendEvmTransactionWithEndUserAccountBodyNetwork, };
+export type Config = {
+    projectId: string;
+    useMock?: boolean;
+    debugging?: boolean;
+    basePath?: string;
+    createAccountOnLogin?: "evm-eoa" | "evm-smart";
+};
+export type Hex = `0x${string}`;
+export type EvmAddress = `0x${string}`;
+export type AuthenticationMethods = {
+    email?: EmailAuthentication;
+    sms?: SmsAuthentication;
+};
+export type User = {
+    userId: string;
+    authenticationMethods: AuthenticationMethods;
+    evmAccounts?: EvmAddress[];
+    evmSmartAccounts?: EvmAddress[];
+};
+export type EmailAuthentication = {
+    type: "email";
+    email: string;
+};
+export type SmsAuthentication = {
+    type: "sms";
+    phoneNumber: string;
+};
+export type SignInWithEmailOptions = {
+    email: string;
+};
+export type SignInWithEmailResult = {
+    message: string;
+    flowId: string;
+};
+export type SignInWithSmsOptions = {
+    phoneNumber: string;
+};
+export type SignInWithSmsResult = {
+    message: string;
+    flowId: string;
+};
+export type VerifyEmailOTPOptions = {
+    flowId: string;
+    otp: string;
+};
+export type VerifyEmailOTPResult = {
+    user: User;
+    message: string;
+    isNewUser: boolean;
+};
+export type VerifySmsOTPOptions = {
+    flowId: string;
+    otp: string;
+};
+export type VerifySmsOTPResult = {
+    user: User;
+    message: string;
+    isNewUser: boolean;
+};
+export type OnAuthStateChangeFn = (user: User | null) => void;
+export type SignEvmHashOptions = {
+    evmAccount: EvmAddress;
+    hash: Hex;
+};
+export type SignEvmHashResult = {
+    signature: Hex;
+};
+export type AllowedEvmTransactionType = TransactionSerializableEIP1559;
+export type SignEvmTransactionOptions = {
+    evmAccount: EvmAddress;
+    transaction: AllowedEvmTransactionType;
+};
+export type SignEvmTransactionResult = {
+    signedTransaction: Hex;
+};
+export type SendEvmTransactionOptions = {
+    evmAccount: EvmAddress;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+    transaction: AllowedEvmTransactionType;
+};
+export type SendEvmTransactionResult = {
+    transactionHash: Hex;
+};
+export type SignEvmMessageOptions = {
+    evmAccount: EvmAddress;
+    message: string;
+};
+export type SignEvmMessageResult = {
+    signature: Hex;
+};
+export interface EIP712Domain {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    salt?: Hex;
+    verifyingContract?: EvmAddress;
+}
+export interface EIP712Types {
+    [key: string]: unknown;
+}
+export type EIP712Message = {
+    [key: string]: unknown;
+};
+export interface EIP712TypedData {
+    domain: EIP712Domain;
+    types: EIP712Types;
+    primaryType: string;
+    message: EIP712Message;
+}
+export type SignEvmTypedDataOptions = {
+    evmAccount: EvmAddress;
+    typedData: EIP712TypedData;
+};
+export type EvmCall = {
+    to: EvmAddress;
+    value?: bigint;
+    data?: Hex;
+};
+export type SendUserOperationOptions = {
+    evmSmartAccount: EvmAddress;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+    calls: EvmCall[];
+    useCdpPaymaster?: boolean;
+    paymasterUrl?: string;
+};
+export type SendUserOperationResult = {
+    userOperationHash: Hex;
+};
+export type GetUserOperationOptions = {
+    userOperationHash: Hex;
+    evmSmartAccount: EvmAddress;
+    network: SendEvmTransactionWithEndUserAccountBodyNetwork;
+};
+export type GetUserOperationResult = EvmUserOperation;
+export type SignEvmTypedDataResult = {
+    signature: Hex;
+};
+export type ExportEvmAccountOptions = {
+    evmAccount: EvmAddress;
+};
+export type ExportEvmAccountResult = {
+    privateKey: string;
+};

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

@@ -0,0 +1,17 @@
+import { EvmAddress, Hex, EIP712TypedData } from '../types.js';
+export interface SignAndWrapTypedDataForSmartAccountOptions {
+    smartAccount: EvmAddress;
+    ownerAddress: EvmAddress;
+    typedData: EIP712TypedData;
+}
+export interface SignAndWrapTypedDataForSmartAccountResult {
+    signature: Hex;
+}
+export declare function signAndWrapTypedDataForSmartAccount(options: SignAndWrapTypedDataForSmartAccountOptions): Promise<SignAndWrapTypedDataForSmartAccountResult>;
+export declare function createReplaySafeTypedData({ typedData, smartAccountAddress, }: {
+    typedData: EIP712TypedData;
+    smartAccountAddress: Hex;
+}): EIP712TypedData;
+export declare function createSmartAccountSignatureWrapper({ signatureHex }: {
+    signatureHex: Hex;
+}): Hex;

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

@@ -0,0 +1,2 @@
+import { Address, LocalAccount } from 'viem';
+export declare function toViemAccount(address: Address): Promise<LocalAccount>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-core",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "type": "module",
   "files": [
     "dist/**",
@@ -8,8 +8,16 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
-      "default": "./dist/esm/index.js"
+      "react-native": {
+        "types": "./dist/types/index.native.d.ts",
+        "default": "./dist/esm/index.native.js"
+      },
+      "browser": {
+        "types": "./dist/types/index.web.d.ts",
+        "default": "./dist/esm/index.web.js"
+      },
+      "types": "./dist/types/index.web.d.ts",
+      "default": "./dist/esm/index.web.js"
     }
   },
   "dependencies": {
@@ -17,7 +25,15 @@
     "ox": "0.8.1",
     "viem": "^2.33.0",
     "zustand": "^5.0.6",
-    "@coinbase/cdp-api-client": "^0.0.25"
+    "@coinbase/cdp-api-client": "^0.0.27"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": "^2.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@size-limit/preset-big-lib": "^11.2.0",
@@ -28,43 +44,45 @@
   "size-limit": [
     {
       "name": "full-package",
-      "path": "./dist/esm/index.js",
+      "path": "./dist/esm/index.web.js",
       "running": false,
       "import": "*",
       "limit": "60 KB"
     },
     {
       "name": "auth-only",
-      "path": "./dist/esm/index.js",
+      "path": "./dist/esm/index.web.js",
       "running": false,
       "import": "{ signInWithEmail, verifyEmailOTP, getCurrentUser, isSignedIn, signOut }",
       "limit": "30 KB"
     },
     {
       "name": "evm-only",
-      "path": "./dist/esm/index.js",
+      "path": "./dist/esm/index.web.js",
       "running": false,
       "import": "{ signEvmHash, signEvmTransaction, sendEvmTransaction, signEvmMessage, signEvmTypedData }",
       "limit": "30 KB"
     },
     {
       "name": "export",
-      "path": "./dist/esm/index.js",
+      "path": "./dist/esm/index.web.js",
       "running": false,
       "import": "{ exportEvmAccount }",
       "limit": "30 KB"
     },
     {
       "name": "provider-only",
-      "path": "./dist/esm/index.js",
+      "path": "./dist/esm/index.web.js",
       "running": false,
       "import": "{ createCDPEmbeddedWallet }",
       "limit": "55 KB"
     }
   ],
   "scripts": {
-    "build": "pnpm run clean && pnpm run check:types && vite build --config ../../vite.config.base.ts",
-    "build:watch": "vite build --config ../../vite.config.base.ts --watch",
+    "build": "pnpm run clean && pnpm run check:types && pnpm run build:web && pnpm run build:native && pnpm run build:consolidate",
+    "build:web": "vite build --config ./vite.config.web.ts",
+    "build:native": "vite build --config ./vite.config.native.ts",
+    "build:consolidate": "mkdir -p dist/esm dist/types && cp -r dist/web/* dist/esm/ && cp -r dist/native/* dist/esm/ && cp -r dist/web-types/* dist/types/ && cp -r dist/native-types/* dist/types/",
     "check:types": "tsc --noEmit",
     "clean": "rm -rf dist",
     "clean:all": "pnpm clean && rm -rf node_modules",

package/dist/esm/index.js

@@ -1,38 +0,0 @@
-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 f, signEvmTypedData as u, signInWithEmail as A, signInWithSms as l, signOut as x, verifyEmailOTP as O, verifySmsOTP as S } from "./index2.js";
-import { APIError as y, ErrorType as P, HttpErrorType as D, SendEvmTransactionWithEndUserAccountBodyNetwork as I } from "@coinbase/cdp-api-client";
-import "viem";
-import { createCDPEmbeddedWallet as C } from "./index3.js";
-import { EIP1193ProviderError as W, STANDARD_ERROR_CODES as k } from "./index4.js";
-import "ox";
-import "zustand";
-import { toViemAccount as M } from "./index5.js";
-import { ModuleResolutionError as _ } from "./index6.js";
-export {
-  y as APIError,
-  W as EIP1193ProviderError,
-  P as ErrorType,
-  D as HttpErrorType,
-  _ as ModuleResolutionError,
-  k as STANDARD_ERROR_CODES,
-  I as SendEvmTransactionWithEndUserAccountBodyNetwork,
-  C as createCDPEmbeddedWallet,
-  i as exportEvmAccount,
-  s as getAccessToken,
-  m as getCurrentUser,
-  a as getUserOperation,
-  E as initialize,
-  p as isSignedIn,
-  g as onAuthStateChange,
-  c as sendEvmTransaction,
-  d as sendUserOperation,
-  v as signEvmHash,
-  T as signEvmMessage,
-  f as signEvmTransaction,
-  u as signEvmTypedData,
-  A as signInWithEmail,
-  l as signInWithSms,
-  x as signOut,
-  M as toViemAccount,
-  O as verifyEmailOTP,
-  S as verifySmsOTP
-};

package/dist/esm/index10.js

@@ -1,23 +0,0 @@
-async function a() {
-  const e = await window.crypto.subtle.generateKey(
-    {
-      name: "RSA-OAEP",
-      modulusLength: 4096,
-      publicExponent: new Uint8Array([1, 0, 1]),
-      // 65537
-      hash: { name: "SHA-256" }
-    },
-    !0,
-    // Allow key export for compatibility with Node version
-    ["encrypt", "decrypt"]
-  ), r = await window.crypto.subtle.exportKey("spki", e.publicKey), t = btoa(
-    Array.from(new Uint8Array(r)).map((n) => String.fromCharCode(n)).join("")
-  );
-  return {
-    privateKey: e.privateKey,
-    publicKeyBase64: t
-  };
-}
-export {
-  a as createExportKeyPair
-};

package/dist/esm/index11.js

@@ -1,17 +0,0 @@
-async function a(e, n) {
-  try {
-    const r = new Uint8Array(Array.from(atob(n), (t) => t.charCodeAt(0))), o = await window.crypto.subtle.decrypt(
-      {
-        name: "RSA-OAEP"
-      },
-      e,
-      r
-    );
-    return Array.from(new Uint8Array(o)).map((t) => t.toString(16).padStart(2, "0")).join("");
-  } catch (r) {
-    throw new Error(`Decryption failed: ${String(r)}`);
-  }
-}
-export {
-  a as decryptWithPrivateKey
-};

package/dist/esm/index23.js

@@ -1,19 +0,0 @@
-async function n() {
-  const e = await window.crypto.subtle.generateKey(
-    {
-      name: "ECDSA",
-      namedCurve: "P-256"
-      // secp256r1
-    },
-    !1,
-    // Do not allow key export.
-    ["sign", "verify"]
-    // Key usages
-  ), r = await window.crypto.subtle.exportKey("spki", e.publicKey), t = new Uint8Array(r), a = btoa(
-    Array.from(t).map((i) => String.fromCharCode(i)).join("")
-  );
-  return { privateKey: e.privateKey, publicKeyBase64: a };
-}
-export {
-  n as createKeyPair
-};

package/dist/esm/index24.js

@@ -1,7 +0,0 @@
-async function t() {
-  const r = new Uint8Array(16);
-  return window.crypto.getRandomValues(r), Array.from(r, (n) => n.toString(16).padStart(2, "0")).join("");
-}
-export {
-  t as generateRandomId
-};

package/dist/esm/index25.js

@@ -1,7 +0,0 @@
-const h = async (t) => {
-  const a = await window.crypto.subtle.digest("SHA-256", t), r = new Uint8Array(a);
-  return Array.from(r).map((s) => s.toString(16).padStart(2, "0")).join("");
-};
-export {
-  h as hash
-};

package/dist/esm/index3.js

@@ -1,116 +0,0 @@
-import { Provider as d } from "ox";
-import { http as p } from "viem";
-import { create as m } from "zustand";
-import { subscribeWithSelector as f, persist as g } from "./index18.js";
-import { validateRequest as w, EIP1193ProviderError as C, STANDARD_ERROR_CODES as S } from "./index4.js";
-import { EventEmitter as b } from "./index19.js";
-import "@coinbase/cdp-api-client";
-import { handleGetCapabilities as I, handleGetCallsStatus as _, handleSendCalls as A, handleChainId as v, handleSignTypedData as D, handleEthSign as E, handleSwitchEthereumChain as P, handleDisconnect as R, handleSendTransaction as y, handlePersonalSign as T, handleRequestAccounts as q, handleAccounts as G } from "./index20.js";
-import { onAuthStateChange as L } from "./index2.js";
-import { baseSepolia as h } from "./index21.js";
-function M(a, n, r) {
-  n.subscribe(
-    (e) => e.chainId,
-    (e, t) => {
-      e !== t && a.emit("chainChanged", e);
-    }
-  ), n.subscribe(
-    (e) => e.user,
-    (e, t) => {
-      if (!(e?.userId === t?.userId && e?.evmAccounts?.length === t?.evmAccounts?.length)) {
-        if (!e && t) {
-          a.emit("disconnect", new d.DisconnectedError());
-          return;
-        }
-        if (e && e.evmAccounts?.length && (!t || t.evmAccounts?.length === 0)) {
-          const u = n.getState().chainId;
-          a.emit("connect", { chainId: u });
-          return;
-        }
-      }
-    }
-  );
-  const { chainId: o, setChainId: s } = n.getState(), c = o || r.chains[0].id;
-  return o || s(c), d.from({
-    request: async (e) => {
-      w(e, r);
-      const t = e;
-      switch (t.method) {
-        case "eth_accounts":
-          return G();
-        case "eth_requestAccounts":
-          return q(a, n);
-        case "personal_sign":
-          return T(t.params);
-        case "eth_sendTransaction":
-          return y(t.params, n, r.transports);
-        case "wallet_disconnect":
-          return R();
-        case "wallet_switchEthereumChain":
-          return P(t.params, n);
-        case "eth_sign":
-          return E(t.params);
-        case "eth_signTypedData_v4":
-          return D(t.params);
-        case "eth_chainId":
-          return v(n);
-        case "wallet_sendCalls":
-          return A(t.params, n);
-        case "wallet_getCallsStatus":
-          return _(t.params, n);
-        case "wallet_getCapabilities":
-          return I();
-        // Catch-all for any unknown method
-        default:
-          throw new C(
-            S.provider.unsupportedMethod,
-            `Method ${t.method} not supported`
-          );
-      }
-    },
-    // Event emitter methods - only the ones required by the interface
-    on: a.on.bind(a),
-    removeListener: a.removeListener.bind(a)
-  });
-}
-const l = {
-  chains: [h],
-  transports: {
-    [h.id]: p()
-  }
-};
-function H(a) {
-  if (a?.chains.length === 0)
-    throw new Error("At least one chain must be configured");
-  const n = a?.chains ?? l.chains, r = a?.transports ?? l.transports;
-  if (n.length === 0)
-    throw new Error("No chains found in configuration");
-  const o = new b(), s = m()(
-    f(
-      g(
-        (i) => ({
-          chainId: n[0].id,
-          setChainId: (e) => i({ chainId: e }),
-          chains: n,
-          user: null,
-          setUser: (e) => i({ user: e })
-        }),
-        {
-          name: "cdp-provider-store"
-          // localStorage key
-        }
-      )
-    )
-  );
-  return s.persist.rehydrate(), L((i) => {
-    s.getState().setUser(i);
-  }), {
-    provider: M(o, s, {
-      chains: n,
-      transports: r
-    })
-  };
-}
-export {
-  H as createCDPEmbeddedWallet
-};

package/dist/esm/index31.js

@@ -1,9 +0,0 @@
-import { keccak_256 as o } from "./index51.js";
-import { isHex as r } from "./index35.js";
-import { toBytes as c } from "./index30.js";
-function k(t, e) {
-  return o(r(t, { strict: !1 }) ? c(t) : t);
-}
-export {
-  k as keccak256
-};