@crossmint/client-sdk-smart-wallet 0.1.2 → 0.1.3

package/src/SmartWalletSDK.test.ts

@@ -1,27 +1,26 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
 import { SmartWalletSDK } from "./SmartWalletSDK";
-import { SmartWalletSDKInitParams } from "./types/Config";
 
-jest.mock("./services/logging");
+vi.mock("./services/logging");
 
-Object.defineProperty(global, "window", {
-    value: {
-        location: {
-            origin: "http://localhost",
-        },
+// Mock global window object
+vi.stubGlobal("window", {
+    location: {
+        origin: "http://localhost",
     },
 });
 
 describe("SmartWalletSDK", () => {
     let sdk: SmartWalletSDK;
-    const mockInitParams: SmartWalletSDKInitParams = {
-        clientApiKey:
-            "sk_staging_A4vDwAp4t5az6fVQMpQK6qapBnAqgpxrrD35TaFQnyKgxehNbd959uZeaHjNCadWDXrgLRAK1CxeasZjtYEq4TbFkKMBBvbQ9oinAxQf8LbHsSYW2DMzT8fBko3YGLq9t7ZiXZjmgkTioxGVUUjyLtWLeBKwNUDLgpshWjaoR7pKRnSE9SqhwjQbiK62VKiBTdA3KvHsyG9k8mLMcKrDyfXp",
-    };
 
     beforeEach(() => {
         // Reset mocks before each test
-        jest.clearAllMocks();
-        sdk = SmartWalletSDK.init(mockInitParams);
+        vi.clearAllMocks();
+        sdk = SmartWalletSDK.init({
+            clientApiKey:
+                "sk_staging_A4vDwAp4t5az6fVQMpQK6qapBnAqgpxrrD35TaFQnyKgxehNbd959uZeaHjNCadWDXrgLRAK1CxeasZjtYEq4TbFkKMBBvbQ9oinAxQf8LbHsSYW2DMzT8fBko3YGLq9t7ZiXZjmgkTioxGVUUjyLtWLeBKwNUDLgpshWjaoR7pKRnSE9SqhwjQbiK62VKiBTdA3KvHsyG9k8mLMcKrDyfXp",
+        });
     });
 
     describe("init", () => {

package/src/SmartWalletSDK.ts

@@ -3,24 +3,26 @@ import { stringify } from "viem";
 import { validateAPIKey } from "@crossmint/common-sdk-base";
 
 import { CrossmintWalletService } from "./api/CrossmintWalletService";
-import { SmartWalletChain } from "./blockchain/chains";
+import type { SmartWalletChain } from "./blockchain/chains";
 import type { EVMSmartWallet } from "./blockchain/wallets";
+import { AccountConfigFacade } from "./blockchain/wallets/account/config";
+import { AccountCreator } from "./blockchain/wallets/account/creator";
+import { EOACreationStrategy } from "./blockchain/wallets/account/eoa";
+import { PasskeyCreationStrategy } from "./blockchain/wallets/account/passkey";
 import { ClientDecorator } from "./blockchain/wallets/clientDecorator";
 import { SmartWalletService } from "./blockchain/wallets/service";
-import { SmartWalletSDKError } from "./error";
+import { SmartWalletError } from "./error";
 import { ErrorProcessor } from "./error/processor";
 import { DatadogProvider } from "./services/logging/DatadogProvider";
-import type { SmartWalletSDKInitParams, UserParams, WalletParams } from "./types/Config";
+import type { SmartWalletSDKInitParams, UserParams, WalletParams } from "./types/params";
 import { isClient } from "./utils/environment";
-import { LoggerWrapper, logPerformance } from "./utils/log";
+import { logPerformance } from "./utils/log";
 
-export class SmartWalletSDK extends LoggerWrapper {
+export class SmartWalletSDK {
     private constructor(
         private readonly smartWalletService: SmartWalletService,
         private readonly errorProcessor: ErrorProcessor
-    ) {
-        super("SmartWalletSDK");
-    }
+    ) {}
 
     /**
      * Initializes the SDK with the **client side** API key obtained from the Crossmint console.
@@ -28,7 +30,7 @@ export class SmartWalletSDK extends LoggerWrapper {
      */
     static init({ clientApiKey }: SmartWalletSDKInitParams): SmartWalletSDK {
         if (!isClient()) {
-            throw new SmartWalletSDKError("Smart Wallet SDK should only be used client side.");
+            throw new SmartWalletError("Smart Wallet SDK should only be used client side.");
         }
 
         const validationResult = validateAPIKey(clientApiKey);
@@ -38,10 +40,19 @@ export class SmartWalletSDK extends LoggerWrapper {
 
         const crossmintService = new CrossmintWalletService(clientApiKey);
         const errorProcessor = new ErrorProcessor(new DatadogProvider());
-        return new SmartWalletSDK(
-            new SmartWalletService(crossmintService, new ClientDecorator(errorProcessor)),
-            errorProcessor
+        const accountCreator = new AccountCreator(
+            new EOACreationStrategy(),
+            new PasskeyCreationStrategy(crossmintService.getPasskeyServerUrl(), clientApiKey)
+        );
+
+        const smartWalletService = new SmartWalletService(
+            crossmintService,
+            new AccountConfigFacade(crossmintService),
+            accountCreator,
+            new ClientDecorator(errorProcessor)
         );
+
+        return new SmartWalletSDK(smartWalletService, errorProcessor);
     }
 
     /**
@@ -58,19 +69,15 @@ export class SmartWalletSDK extends LoggerWrapper {
         chain: SmartWalletChain,
         walletParams: WalletParams = { signer: { type: "PASSKEY" } }
     ): Promise<EVMSmartWallet> {
-        return logPerformance(
-            "GET_OR_CREATE_WALLET",
-            async () => {
-                try {
-                    return await this.smartWalletService.getOrCreate(user, chain, walletParams);
-                } catch (error: any) {
-                    throw this.errorProcessor.map(
-                        error,
-                        new SmartWalletSDKError(`Wallet creation failed: ${error.message}.`, stringify(error))
-                    );
-                }
-            },
-            { user, chain }
-        );
+        return logPerformance("GET_OR_CREATE_WALLET", async () => {
+            try {
+                return await this.smartWalletService.getOrCreate(user, chain, walletParams);
+            } catch (error: any) {
+                throw this.errorProcessor.map(
+                    error,
+                    new SmartWalletError(`Wallet creation failed: ${error.message}.`, stringify(error))
+                );
+            }
+        });
     }
 }

package/src/api/APIErrorService.ts

@@ -1,15 +1,18 @@
 import {
-    AdminAlreadyUsedError,
     CrossmintServiceError,
     JWTDecryptionError,
     JWTExpiredError,
     JWTIdentifierError,
     JWTInvalidError,
-    NonCustodialWalletsNotEnabledError,
     OutOfCreditsError,
-    SmartWalletSDKError,
+} from "@crossmint/client-sdk-base";
+
+import {
+    AdminAlreadyUsedError,
+    SmartWalletError,
+    SmartWalletsNotEnabledError,
     UserWalletAlreadyCreatedError,
-} from "@/error";
+} from "../error";
 
 export type CrossmintAPIErrorCodes =
     | "ERROR_JWT_INVALID"
@@ -22,7 +25,7 @@ export type CrossmintAPIErrorCodes =
 
 export class APIErrorService {
     constructor(
-        private errors: Partial<Record<CrossmintAPIErrorCodes, (apiResponse: any) => SmartWalletSDKError>> = {
+        private errors: Record<CrossmintAPIErrorCodes, (apiResponse: any) => SmartWalletError> = {
             ERROR_JWT_INVALID: () => new JWTInvalidError(),
             ERROR_JWT_DECRYPTION: () => new JWTDecryptionError(),
             ERROR_JWT_EXPIRED: ({ expiredAt }: { expiredAt: string }) => new JWTExpiredError(new Date(expiredAt)),
@@ -31,7 +34,7 @@ export class APIErrorService {
             ERROR_USER_WALLET_ALREADY_CREATED: ({ userId }: { userId: string }) =>
                 new UserWalletAlreadyCreatedError(userId),
             ERROR_ADMIN_SIGNER_ALREADY_USED: () => new AdminAlreadyUsedError(),
-            ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED: () => new NonCustodialWalletsNotEnabledError(),
+            ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED: () => new SmartWalletsNotEnabledError(),
         }
     ) {}
 
@@ -64,7 +67,7 @@ export class APIErrorService {
                 throw new CrossmintServiceError(body.message, response.status);
             }
         } catch (e) {
-            if (e instanceof SmartWalletSDKError) {
+            if (e instanceof SmartWalletError) {
                 throw e;
             }
             console.error("Error parsing response", e);

package/src/api/BaseCrossmintService.ts

@@ -1,11 +1,11 @@
+import { CrossmintServiceError } from "@crossmint/client-sdk-base";
 import { validateAPIKey } from "@crossmint/common-sdk-base";
 
-import { CrossmintServiceError } from "../error";
 import { CROSSMINT_DEV_URL, CROSSMINT_PROD_URL, CROSSMINT_STG_URL } from "../utils/constants";
-import { LoggerWrapper, logPerformance } from "../utils/log";
+import { logPerformance } from "../utils/log";
 import { APIErrorService } from "./APIErrorService";
 
-export abstract class BaseCrossmintService extends LoggerWrapper {
+export abstract class BaseCrossmintService {
     public crossmintAPIHeaders: Record<string, string>;
     protected crossmintBaseUrl: string;
     protected apiErrorService: APIErrorService;
@@ -16,7 +16,6 @@ export abstract class BaseCrossmintService extends LoggerWrapper {
     };
 
     constructor(apiKey: string) {
-        super("BaseCrossmintService");
         const result = validateAPIKey(apiKey);
         if (!result.isValid) {
             throw new Error("API key invalid");

package/src/api/CrossmintWalletService.test.ts

@@ -1,16 +1,16 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
 import { CROSSMINT_STG_URL } from "../utils/constants";
 import { CrossmintWalletService } from "./CrossmintWalletService";
 
-jest.mock("../services/logging", () => ({
-    logError: jest.fn(),
-    logInfo: jest.fn(),
+vi.mock("../services/logging", () => ({
+    logError: vi.fn(),
+    logInfo: vi.fn(),
 }));
 
-jest.mock("../utils/helpers", () => {
-    return {
-        isLocalhost: jest.fn().mockReturnValue(true),
-    };
-});
+vi.mock("../utils/helpers", () => ({
+    isLocalhost: vi.fn().mockReturnValue(true),
+}));
 
 describe("CrossmintService", () => {
     let crossmintService: CrossmintWalletService;
@@ -37,6 +37,6 @@ describe("CrossmintService", () => {
     });
 
     afterEach(() => {
-        jest.clearAllMocks();
+        vi.clearAllMocks();
     });
 });

package/src/api/CrossmintWalletService.ts

@@ -1,13 +1,20 @@
-import { SmartWalletChain } from "@/blockchain/chains";
-import { SignerData, StoreSmartWalletParams } from "@/types/API";
-import type { UserParams } from "@/types/Config";
-import { API_VERSION } from "@/utils/constants";
+import type { UserOperation } from "permissionless";
+import type { EntryPoint, GetEntryPointVersion } from "permissionless/types/entrypoint";
 
-import { BaseCrossmintService } from "./BaseCrossmintService";
+import { CrossmintServiceError } from "@crossmint/client-sdk-base";
+import { blockchainToChainId } from "@crossmint/common-sdk-base";
+
+import { BaseCrossmintService } from "../api/BaseCrossmintService";
+import type { SmartWalletChain } from "../blockchain/chains";
+import type { UserParams } from "../types/params";
+import { SmartWalletConfigSchema } from "../types/schema";
+import type { SmartWalletConfig, StoreSmartWalletParams } from "../types/service";
+import { bigintsToHex, parseBigintAPIResponse } from "../utils/api";
+import { API_VERSION } from "../utils/constants";
 
 export class CrossmintWalletService extends BaseCrossmintService {
-    async idempotentCreateSmartWallet(user: UserParams, input: StoreSmartWalletParams) {
-        return this.fetchCrossmintAPI(
+    async idempotentCreateSmartWallet(user: UserParams, input: StoreSmartWalletParams): Promise<void> {
+        await this.fetchCrossmintAPI(
             `${API_VERSION}/sdk/smart-wallet`,
             { method: "PUT", body: JSON.stringify(input) },
             "Error creating abstract wallet. Please contact support",
@@ -15,22 +22,38 @@ export class CrossmintWalletService extends BaseCrossmintService {
         );
     }
 
-    async getSmartWalletConfig(
+    async sponsorUserOperation<E extends EntryPoint>(
         user: UserParams,
+        userOp: UserOperation<GetEntryPointVersion<E>>,
+        entryPoint: E,
         chain: SmartWalletChain
-    ): Promise<{
-        kernelVersion: string;
-        entryPointVersion: string;
-        userId: string;
-        signers: { signerData: SignerData }[];
-        smartContractWalletAddress?: string;
-    }> {
-        return this.fetchCrossmintAPI(
+    ): Promise<{ sponsorUserOpParams: UserOperation<GetEntryPointVersion<E>> }> {
+        const chainId = blockchainToChainId(chain);
+        const result = await this.fetchCrossmintAPI(
+            `${API_VERSION}/sdk/paymaster`,
+            { method: "POST", body: JSON.stringify({ userOp: bigintsToHex(userOp), entryPoint, chainId }) },
+            "Error sponsoring user operation. Please contact support",
+            user.jwt
+        );
+        return parseBigintAPIResponse(result);
+    }
+
+    async getSmartWalletConfig(user: UserParams, chain: SmartWalletChain): Promise<SmartWalletConfig> {
+        const data: unknown = await this.fetchCrossmintAPI(
             `${API_VERSION}/sdk/smart-wallet/config?chain=${chain}`,
             { method: "GET" },
             "Error getting smart wallet version configuration. Please contact support",
             user.jwt
         );
+
+        const result = SmartWalletConfigSchema.safeParse(data);
+        if (result.success) {
+            return result.data;
+        }
+
+        throw new CrossmintServiceError(
+            `Invalid smart wallet config, please contact support. Details below:\n${result.error.toString()}`
+        );
     }
 
     async fetchNFTs(address: string, chain: SmartWalletChain) {

package/src/blockchain/chains.ts

@@ -1,11 +1,24 @@
-import { BUNDLER_RPC } from "@/utils/constants";
-import { Chain, base, baseSepolia, polygon, polygonAmoy } from "viem/chains";
+import {
+    Chain,
+    arbitrum,
+    arbitrumSepolia,
+    base,
+    baseSepolia,
+    optimism,
+    optimismSepolia,
+    polygon,
+    polygonAmoy,
+} from "viem/chains";
 
 import { BlockchainIncludingTestnet as Blockchain, ObjectValues, objectValues } from "@crossmint/common-sdk-base";
 
+import { BUNDLER_RPC } from "../utils/constants";
+
 export const SmartWalletTestnet = {
     BASE_SEPOLIA: Blockchain.BASE_SEPOLIA,
     POLYGON_AMOY: Blockchain.POLYGON_AMOY,
+    OPTIMISM_SEPOLIA: Blockchain.OPTIMISM_SEPOLIA,
+    ARBITRUM_SEPOLIA: Blockchain.ARBITRUM_SEPOLIA,
 } as const;
 export type SmartWalletTestnet = ObjectValues<typeof SmartWalletTestnet>;
 export const SMART_WALLET_TESTNETS = objectValues(SmartWalletTestnet);
@@ -13,6 +26,8 @@ export const SMART_WALLET_TESTNETS = objectValues(SmartWalletTestnet);
 export const SmartWalletMainnet = {
     BASE: Blockchain.BASE,
     POLYGON: Blockchain.POLYGON,
+    OPTIMISM: Blockchain.OPTIMISM,
+    ARBITRUM: Blockchain.ARBITRUM,
 } as const;
 export type SmartWalletMainnet = ObjectValues<typeof SmartWalletMainnet>;
 export const SMART_WALLET_MAINNETS = objectValues(SmartWalletMainnet);
@@ -29,6 +44,10 @@ export const zerodevProjects: Record<SmartWalletChain, string> = {
     "polygon-amoy": "3deef404-ca06-4a5d-9a58-907c99e7ef00",
     "base-sepolia": "5a127978-6473-4784-9dfb-f74395b220a6",
     base: "e8b3020f-4dde-4176-8a7d-be8102527a5c",
+    "optimism-sepolia": "f8dd488e-eaed-467d-a5de-0184c160f3b1",
+    optimism: "505950ab-ee07-4a9c-bd16-320ac71a9350",
+    arbitrum: "a965100f-fedf-4e6b-a207-20f5687fcc4f",
+    "arbitrum-sepolia": "76c860ca-af77-4fb1-8eac-07825952f6f4",
 };
 
 export const viemNetworks: Record<SmartWalletChain, Chain> = {
@@ -36,6 +55,10 @@ export const viemNetworks: Record<SmartWalletChain, Chain> = {
     "polygon-amoy": polygonAmoy,
     base: base,
     "base-sepolia": baseSepolia,
+    optimism: optimism,
+    "optimism-sepolia": optimismSepolia,
+    arbitrum: arbitrum,
+    "arbitrum-sepolia": arbitrumSepolia,
 };
 
 export const getBundlerRPC = (chain: SmartWalletChain) => {

package/src/blockchain/transfer.ts

@@ -1,7 +1,7 @@
 import { Abi, Account, Address, erc20Abi, erc721Abi } from "viem";
 
 import erc1155Abi from "../ABI/ERC1155.json";
-import type { ERC20TransferType, SFTTransferType, TransferType } from "../types/Tokens";
+import type { ERC20TransferType, SFTTransferType, TransferType } from "../types/token";
 
 type TransferInputParams = {
     from: Account;

package/src/blockchain/wallets/EVMSmartWallet.ts

@@ -1,12 +1,13 @@
-import { logError } from "@/services/logging";
 import { type HttpTransport, type PublicClient, isAddress, publicActions } from "viem";
 
+import { TransferError } from "@crossmint/client-sdk-base";
+
 import type { CrossmintWalletService } from "../../api/CrossmintWalletService";
-import { TransferError } from "../../error";
-import type { TransferType } from "../../types/Tokens";
+import { logError, logInfo } from "../../services/logging";
 import { SmartWalletClient } from "../../types/internal";
+import type { TransferType } from "../../types/token";
 import { SCW_SERVICE } from "../../utils/constants";
-import { LoggerWrapper, errorToJSON } from "../../utils/log";
+import { errorToJSON, logPerformance } from "../../utils/log";
 import { SmartWalletChain } from "../chains";
 import { transferParams } from "../transfer";
 
@@ -14,7 +15,7 @@ import { transferParams } from "../transfer";
  * Smart wallet interface for EVM chains enhanced with Crossmint capabilities.
  * Core functionality is exposed via [viem](https://viem.sh/) clients within the `client` property of the class.
  */
-export class EVMSmartWallet extends LoggerWrapper {
+export class EVMSmartWallet {
     public readonly chain: SmartWalletChain;
 
     /**
@@ -38,7 +39,6 @@ export class EVMSmartWallet extends LoggerWrapper {
         publicClient: PublicClient<HttpTransport>,
         chain: SmartWalletChain
     ) {
-        super("EVMSmartWallet", { chain, address: accountClient.account.address });
         this.chain = chain;
         this.client = {
             wallet: accountClient,
@@ -57,46 +57,53 @@ export class EVMSmartWallet extends LoggerWrapper {
      * @returns The transaction hash.
      */
     public async transferToken(toAddress: string, config: TransferType): Promise<string> {
-        return this.logPerformance("TRANSFER", async () => {
-            if (this.chain !== config.token.chain) {
-                throw new Error(
-                    `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`
-                );
-            }
-
-            if (!isAddress(toAddress)) {
-                throw new Error(`Invalid recipient address: '${toAddress}' is not a valid EVM address.`);
-            }
+        return logPerformance(
+            "TRANSFER",
+            async () => {
+                if (this.chain !== config.token.chain) {
+                    throw new Error(
+                        `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`
+                    );
+                }
 
-            if (!isAddress(config.token.contractAddress)) {
-                throw new Error(
-                    `Invalid contract address: '${config.token.contractAddress}' is not a valid EVM address.`
-                );
-            }
+                if (!isAddress(toAddress)) {
+                    throw new Error(`Invalid recipient address: '${toAddress}' is not a valid EVM address.`);
+                }
 
-            const tx = transferParams({
-                contract: config.token.contractAddress,
-                to: toAddress,
-                from: this.accountClient.account,
-                config,
-            });
+                if (!isAddress(config.token.contractAddress)) {
+                    throw new Error(
+                        `Invalid contract address: '${config.token.contractAddress}' is not a valid EVM address.`
+                    );
+                }
 
-            try {
-                const client = this.accountClient.extend(publicActions);
-                const { request } = await client.simulateContract(tx);
-                return await client.writeContract(request);
-            } catch (error) {
-                logError("[TRANSFER] - ERROR_TRANSFERRING_TOKEN", {
-                    service: SCW_SERVICE,
-                    error: errorToJSON(error),
-                    tokenId: tx.tokenId,
-                    contractAddress: config.token.contractAddress,
-                    chain: config.token.chain,
+                const tx = transferParams({
+                    contract: config.token.contractAddress,
+                    to: toAddress,
+                    from: this.accountClient.account,
+                    config,
                 });
-                const tokenIdString = tx.tokenId == null ? "" : `:${tx.tokenId}}`;
-                throw new TransferError(`Error transferring token ${config.token.contractAddress}${tokenIdString}`);
-            }
-        });
+
+                try {
+                    const client = this.accountClient.extend(publicActions);
+                    const { request } = await client.simulateContract(tx);
+                    const hash = await client.writeContract(request);
+                    logInfo(`[TRANSFER] - Transaction hash from transfer: ${hash}`);
+
+                    return hash;
+                } catch (error) {
+                    logError("[TRANSFER] - ERROR_TRANSFERRING_TOKEN", {
+                        service: SCW_SERVICE,
+                        error: errorToJSON(error),
+                        tokenId: tx.tokenId,
+                        contractAddress: config.token.contractAddress,
+                        chain: config.token.chain,
+                    });
+                    const tokenIdString = tx.tokenId == null ? "" : `:${tx.tokenId}}`;
+                    throw new TransferError(`Error transferring token ${config.token.contractAddress}${tokenIdString}`);
+                }
+            },
+            { toAddress, config }
+        );
     }
 
     /**

package/src/blockchain/wallets/account/config.ts

@@ -0,0 +1,60 @@
+import type { Address } from "viem";
+
+import type { CrossmintWalletService } from "../../../api/CrossmintWalletService";
+import type { SmartWalletChain } from "../../../blockchain/chains";
+import { SmartWalletError } from "../../../error";
+import type { SupportedEntryPointVersion, SupportedKernelVersion } from "../../../types/internal";
+import type { UserParams } from "../../../types/params";
+import type { SignerData } from "../../../types/service";
+import { EOASignerConfig, PasskeySignerConfig, type SignerConfig } from "./signer";
+
+export class AccountConfigFacade {
+    constructor(private readonly crossmintService: CrossmintWalletService) {}
+
+    public async get(
+        user: UserParams,
+        chain: SmartWalletChain
+    ): Promise<{
+        entryPointVersion: SupportedEntryPointVersion;
+        kernelVersion: SupportedKernelVersion;
+        userId: string;
+        existingSignerConfig?: SignerConfig;
+        smartContractWalletAddress?: Address;
+    }> {
+        const { entryPointVersion, kernelVersion, signers, smartContractWalletAddress, userId } =
+            await this.crossmintService.getSmartWalletConfig(user, chain);
+
+        if (
+            (entryPointVersion === "v0.7" && kernelVersion.startsWith("0.2")) ||
+            (entryPointVersion === "v0.6" && kernelVersion.startsWith("0.3"))
+        ) {
+            throw new SmartWalletError(
+                `Unsupported combination: entryPoint ${entryPointVersion} and kernel version ${kernelVersion}. Please contact support`
+            );
+        }
+
+        return {
+            entryPointVersion,
+            kernelVersion,
+            userId,
+            existingSignerConfig: this.getSigner(signers.map((x) => x.signerData)),
+            smartContractWalletAddress,
+        };
+    }
+
+    private getSigner(signers: SignerData[]): SignerConfig | undefined {
+        if (signers.length === 0) {
+            return undefined;
+        }
+
+        const data = signers[0];
+
+        if (data.type === "eoa") {
+            return new EOASignerConfig(data);
+        }
+
+        if (data.type === "passkeys") {
+            return new PasskeySignerConfig(data);
+        }
+    }
+}

package/src/blockchain/wallets/account/creator.ts

@@ -0,0 +1,36 @@
+import { AdminMismatchError, ConfigError } from "../../../error";
+import {
+    AccountAndSigner,
+    type WalletCreationParams,
+    isEOACreationParams,
+    isPasskeyCreationParams,
+} from "../../../types/internal";
+import { EOACreationStrategy } from "./eoa";
+import { PasskeyCreationStrategy } from "./passkey";
+
+export class AccountCreator {
+    constructor(
+        private readonly eoaStrategy: EOACreationStrategy,
+        private readonly passkeyStrategy: PasskeyCreationStrategy
+    ) {}
+
+    public get(params: WalletCreationParams): Promise<AccountAndSigner> {
+        if (isPasskeyCreationParams(params)) {
+            return this.passkeyStrategy.create(params);
+        }
+
+        if (isEOACreationParams(params)) {
+            return this.eoaStrategy.create(params);
+        }
+
+        if (params.existingSignerConfig == null) {
+            throw new ConfigError(`Unsupported wallet params:\n${params.walletParams}`);
+        }
+
+        const signerDisplay = params.existingSignerConfig.display();
+        throw new AdminMismatchError(
+            `Cannot create wallet with ${params.existingSignerConfig.type} signer for user ${params.user.id}', they already have a wallet with signer:\n'${signerDisplay}'`,
+            signerDisplay
+        );
+    }
+}

package/src/blockchain/wallets/account/eoa.ts

@@ -0,0 +1,50 @@
+import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
+import { createKernelAccount } from "@zerodev/sdk";
+
+import { AdminMismatchError } from "../../../error";
+import type { AccountAndSigner, EOACreationParams } from "../../../types/internal";
+import { equalsIgnoreCase } from "../../../utils/helpers";
+import { createOwnerSigner } from "../../../utils/signer";
+import { EOASignerConfig } from "./signer";
+import { AccountCreationStrategy } from "./strategy";
+
+export class EOACreationStrategy implements AccountCreationStrategy {
+    public async create({
+        chain,
+        publicClient,
+        entryPoint,
+        walletParams,
+        kernelVersion,
+        user,
+        existingSignerConfig,
+    }: EOACreationParams): Promise<AccountAndSigner> {
+        const eoa = await createOwnerSigner({
+            chain,
+            walletParams,
+        });
+
+        if (existingSignerConfig != null && !equalsIgnoreCase(eoa.address, existingSignerConfig.data.eoaAddress)) {
+            throw new AdminMismatchError(
+                `User '${user.id}' has an existing wallet with an eoa signer '${existingSignerConfig.data.eoaAddress}', this does not match input eoa signer '${eoa.address}'.`,
+                existingSignerConfig.display(),
+                { type: "eoa", eoaAddress: existingSignerConfig.data.eoaAddress }
+            );
+        }
+
+        const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
+            signer: eoa,
+            entryPoint: entryPoint.address,
+            kernelVersion,
+        });
+        const account = await createKernelAccount(publicClient, {
+            plugins: {
+                sudo: ecdsaValidator,
+            },
+            index: 0n,
+            entryPoint: entryPoint.address,
+            kernelVersion,
+        });
+
+        return { account, signerConfig: new EOASignerConfig({ eoaAddress: eoa.address, type: "eoa" }) };
+    }
+}