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

package/src/blockchain/wallets/{passkey.ts → account/passkey.ts}

@@ -1,7 +1,3 @@
-import type { CrossmintWalletService } from "@/api/CrossmintWalletService";
-import { type PasskeySignerData, displayPasskey } from "@/types/API";
-import type { PasskeySigner, UserParams, WalletParams } from "@/types/Config";
-import type { AccountAndSigner, PasskeyValidatorSerializedData, WalletCreationParams } from "@/types/internal";
 import { PasskeyValidatorContractVersion, WebAuthnMode, toPasskeyValidator } from "@zerodev/passkey-validator";
 import { type KernelSmartAccount, type KernelValidator, createKernelAccount } from "@zerodev/sdk";
 import { type WebAuthnKey, toWebAuthnKey } from "@zerodev/webauthn-key";
@@ -13,40 +9,44 @@ import {
     PasskeyMismatchError,
     PasskeyPromptError,
     PasskeyRegistrationError,
-} from "../../error";
-
-export interface PasskeyWalletParams extends WalletCreationParams {
-    walletParams: WalletParams & { signer: PasskeySigner };
-}
-
-export function isPasskeyParams(params: WalletCreationParams): params is PasskeyWalletParams {
-    return (params.walletParams.signer as PasskeySigner).type === "PASSKEY";
-}
+} from "../../../error";
+import type { AccountAndSigner, PasskeyCreationParams } from "../../../types/internal";
+import type { UserParams } from "../../../types/params";
+import type { PasskeySignerData, PasskeyValidatorSerializedData } from "../../../types/service";
+import { PasskeySignerConfig } from "./signer";
+import { AccountCreationStrategy } from "./strategy";
 
 type PasskeyValidator = KernelValidator<EntryPoint, "WebAuthnValidator"> & {
     getSerializedData: () => string;
 };
-export class PasskeyAccountService {
-    constructor(private readonly crossmintService: CrossmintWalletService) {}
-
-    public async get(
-        { user, publicClient, walletParams, entryPoint, kernelVersion }: PasskeyWalletParams,
-        existingSignerConfig?: PasskeySignerData
-    ): Promise<AccountAndSigner> {
+export class PasskeyCreationStrategy implements AccountCreationStrategy {
+    constructor(private readonly passkeyServerUrl: string, private readonly apiKey: string) {}
+
+    public async create({
+        user,
+        publicClient,
+        walletParams,
+        entryPoint,
+        kernelVersion,
+        existingSignerConfig,
+    }: PasskeyCreationParams): Promise<AccountAndSigner> {
         const inputPasskeyName = walletParams.signer.passkeyName ?? user.id;
-        if (existingSignerConfig != null && existingSignerConfig.passkeyName !== inputPasskeyName) {
+        if (existingSignerConfig != null && existingSignerConfig.data.passkeyName !== inputPasskeyName) {
             throw new PasskeyMismatchError(
-                `User '${user.id}' has an existing wallet created with a passkey named '${existingSignerConfig.passkeyName}', this does match input passkey name '${inputPasskeyName}'.`,
-                displayPasskey(existingSignerConfig)
+                `User '${user.id}' has an existing wallet created with a passkey named '${existingSignerConfig.data.passkeyName}', this does match input passkey name '${inputPasskeyName}'.`,
+                existingSignerConfig.display()
             );
         }
 
         try {
-            const passkey = await this.getPasskey(user, inputPasskeyName, existingSignerConfig);
+            const passkey = await this.getPasskey(user, inputPasskeyName, existingSignerConfig?.data);
 
             const latestValidatorVersion = PasskeyValidatorContractVersion.V0_0_2;
             const validatorContractVersion =
-                existingSignerConfig == null ? latestValidatorVersion : existingSignerConfig.validatorContractVersion;
+                existingSignerConfig == null
+                    ? latestValidatorVersion
+                    : existingSignerConfig.data.validatorContractVersion;
+
             const validator = await toPasskeyValidator(publicClient, {
                 webAuthnKey: passkey,
                 entryPoint: entryPoint.address,
@@ -61,7 +61,7 @@ export class PasskeyAccountService {
             });
 
             return {
-                signerData: this.getSignerData(validator, validatorContractVersion, inputPasskeyName),
+                signerConfig: this.getSignerConfig(validator, validatorContractVersion, inputPasskeyName),
                 account: this.decorate(kernelAccount, inputPasskeyName),
             };
         } catch (error) {
@@ -85,29 +85,29 @@ export class PasskeyAccountService {
 
         return toWebAuthnKey({
             passkeyName,
-            passkeyServerUrl: this.crossmintService.getPasskeyServerUrl(),
+            passkeyServerUrl: this.passkeyServerUrl,
             mode: WebAuthnMode.Register,
             passkeyServerHeaders: this.createPasskeysServerHeaders(user),
         });
     }
 
-    private getSignerData(
+    private getSignerConfig(
         validator: PasskeyValidator,
         validatorContractVersion: PasskeyValidatorContractVersion,
         passkeyName: string
-    ): PasskeySignerData {
-        return {
+    ): PasskeySignerConfig {
+        return new PasskeySignerConfig({
             ...deserializePasskeyValidatorData(validator.getSerializedData()),
             passkeyName,
             validatorContractVersion,
             domain: window.location.hostname,
             type: "passkeys",
-        };
+        });
     }
 
     private createPasskeysServerHeaders(user: UserParams) {
         return {
-            "x-api-key": this.crossmintService.crossmintAPIHeaders["x-api-key"],
+            "x-api-key": this.apiKey,
             Authorization: `Bearer ${user.jwt}`,
         };
     }

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

@@ -0,0 +1,44 @@
+import type {
+    EOASignerData,
+    PasskeyDisplay,
+    PasskeySignerData,
+    SignerData,
+    SignerDisplay,
+} from "../../../types/service";
+
+export interface SignerConfig {
+    readonly type: "passkeys" | "eoa";
+    display(): SignerDisplay;
+    readonly data: SignerData;
+}
+
+export class PasskeySignerConfig implements SignerConfig {
+    public readonly data: PasskeySignerData;
+    public readonly type = "passkeys";
+
+    constructor(data: PasskeySignerData) {
+        this.data = data;
+    }
+
+    public display(): PasskeyDisplay {
+        return {
+            pubKeyX: this.data.pubKeyX,
+            pubKeyY: this.data.pubKeyY,
+            passkeyName: this.data.passkeyName,
+            type: this.type,
+        };
+    }
+}
+
+export class EOASignerConfig implements SignerConfig {
+    public readonly data: EOASignerData;
+    public readonly type = "eoa";
+
+    constructor(data: EOASignerData) {
+        this.data = data;
+    }
+
+    public display() {
+        return this.data;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { AccountAndSigner, WalletCreationParams } from "../../../types/internal";
+
+export interface AccountCreationStrategy {
+    create(params: WalletCreationParams): Promise<AccountAndSigner>;
+}

package/src/blockchain/wallets/clientDecorator.ts

@@ -1,12 +1,12 @@
-import { SmartWalletSDKError } from "@/error";
-import { ErrorProcessor } from "@/error/processor";
-import { logInfo } from "@/services/logging";
-import { usesGelatoBundler } from "@/utils/blockchain";
-import { logPerformance } from "@/utils/log";
 import type { SmartAccountClient } from "permissionless";
 import type { EntryPoint } from "permissionless/types/entrypoint";
 import { stringify } from "viem";
 
+import { SmartWalletError } from "../../error";
+import { ErrorProcessor } from "../../error/processor";
+import { logInfo } from "../../services/logging";
+import { usesGelatoBundler } from "../../utils/blockchain";
+import { logPerformance } from "../../utils/log";
 import { SmartWalletChain } from "../chains";
 
 const transactionMethods = [
@@ -83,7 +83,7 @@ export class ClientDecorator {
             const description = isTxnMethod(prop) ? "signing" : "sending transaction";
             throw this.errorProcessor.map(
                 error,
-                new SmartWalletSDKError(`Error ${description}: ${error.message}`, stringify(error))
+                new SmartWalletError(`Error ${description}: ${error.message}`, stringify(error))
             );
         }
     }

package/src/blockchain/wallets/paymaster.ts

@@ -1,39 +1,36 @@
-import { PAYMASTER_RPC } from "@/utils/constants";
-import { createZeroDevPaymasterClient } from "@zerodev/sdk";
+import { CrossmintWalletService } from "@/api/CrossmintWalletService";
 import { Middleware } from "permissionless/actions/smartAccount";
 import { EntryPoint } from "permissionless/types/entrypoint";
-import { http } from "viem";
 
+import { UserParams } from "../../types/params";
 import { usesGelatoBundler } from "../../utils/blockchain";
-import { SmartWalletChain, viemNetworks, zerodevProjects } from "../chains";
+import { SmartWalletChain } from "../chains";
 
 export function usePaymaster(chain: SmartWalletChain) {
     return !usesGelatoBundler(chain);
 }
 
-const getPaymasterRPC = (chain: SmartWalletChain) => {
-    return PAYMASTER_RPC + zerodevProjects[chain];
-};
-
 export function paymasterMiddleware({
     entryPoint,
     chain,
+    walletService,
+    user,
 }: {
     entryPoint: EntryPoint;
     chain: SmartWalletChain;
+    walletService: CrossmintWalletService;
+    user: UserParams;
 }): Middleware<EntryPoint> {
     return {
         middleware: {
             sponsorUserOperation: async ({ userOperation }) => {
-                const paymasterClient = createZeroDevPaymasterClient({
-                    chain: viemNetworks[chain],
-                    transport: http(getPaymasterRPC(chain)),
-                    entryPoint,
-                });
-                return paymasterClient.sponsorUserOperation({
+                const { sponsorUserOpParams } = await walletService.sponsorUserOperation(
+                    user,
                     userOperation,
                     entryPoint,
-                });
+                    chain
+                );
+                return sponsorUserOpParams;
             },
         },
     };

package/src/blockchain/wallets/service.ts

@@ -1,45 +1,28 @@
-import { type SignerData, displayPasskey } from "@/types/API";
-import { equalsIgnoreCase } from "@/utils/helpers";
-import { type KernelSmartAccount, createKernelAccountClient } from "@zerodev/sdk";
+import { createKernelAccountClient } from "@zerodev/sdk";
 import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07 } from "permissionless";
-import type { EntryPoint } from "permissionless/types/entrypoint";
-import { Address, type HttpTransport, createPublicClient, getAddress, http } from "viem";
+import { createPublicClient, http } from "viem";
 
 import { blockchainToChainId } from "@crossmint/common-sdk-base";
 
 import type { CrossmintWalletService } from "../../api/CrossmintWalletService";
-import {
-    AdminMismatchError,
-    CrossmintServiceError,
-    SmartWalletSDKError,
-    UserWalletAlreadyCreatedError,
-} from "../../error";
-import type { EntryPointDetails, UserParams, WalletParams } from "../../types/Config";
-import {
-    SUPPORTED_ENTRYPOINT_VERSIONS,
-    SUPPORTED_KERNEL_VERSIONS,
-    SmartWalletClient,
-    type SupportedKernelVersion,
-    type WalletCreationParams,
-    isSupportedEntryPointVersion,
-    isSupportedKernelVersion,
-} from "../../types/internal";
+import { UserWalletAlreadyCreatedError } from "../../error";
+import type { SmartWalletClient } from "../../types/internal";
+import type { UserParams, WalletParams } from "../../types/params";
 import { CURRENT_VERSION, ZERO_DEV_TYPE } from "../../utils/constants";
-import { SmartWalletChain, getBundlerRPC, viemNetworks } from "../chains";
+import { equalsIgnoreCase } from "../../utils/helpers";
+import { type SmartWalletChain, getBundlerRPC, viemNetworks } from "../chains";
 import { EVMSmartWallet } from "./EVMSmartWallet";
-import { ClientDecorator } from "./clientDecorator";
-import { EOAAccountService, type EOAWalletParams } from "./eoa";
-import { PasskeyAccountService, isPasskeyParams } from "./passkey";
+import type { AccountConfigFacade } from "./account/config";
+import type { AccountCreator } from "./account/creator";
+import type { ClientDecorator } from "./clientDecorator";
 import { paymasterMiddleware, usePaymaster } from "./paymaster";
 
 export class SmartWalletService {
     constructor(
-        private readonly crossmintWalletService: CrossmintWalletService,
-        private readonly clientDecorator: ClientDecorator,
-        private readonly accountFactory = new AccountFactory(
-            new EOAAccountService(),
-            new PasskeyAccountService(crossmintWalletService)
-        )
+        private readonly crossmintService: CrossmintWalletService,
+        private readonly accountConfigFacade: AccountConfigFacade,
+        private readonly accountCreator: AccountCreator,
+        private readonly clientDecorator: ClientDecorator
     ) {}
 
     public async getOrCreate(
@@ -47,35 +30,36 @@ export class SmartWalletService {
         chain: SmartWalletChain,
         walletParams: WalletParams
     ): Promise<EVMSmartWallet> {
-        const { entryPoint, kernelVersion, existingSignerConfig, smartContractWalletAddress, userId } =
-            await this.fetchConfig(user, chain);
+        const { entryPointVersion, kernelVersion, existingSignerConfig, smartContractWalletAddress, userId } =
+            await this.accountConfigFacade.get(user, chain);
         const publicClient = createPublicClient({ transport: http(getBundlerRPC(chain)) });
 
-        const { account, signerData } = await this.accountFactory.get(
-            {
-                chain,
-                walletParams,
-                publicClient,
-                user: { ...user, id: userId },
-                entryPoint,
-                kernelVersion,
+        const { account, signerConfig } = await this.accountCreator.get({
+            chain,
+            walletParams,
+            publicClient,
+            user: { ...user, id: userId },
+            entryPoint: {
+                version: entryPointVersion,
+                address: entryPointVersion === "v0.6" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,
             },
-            existingSignerConfig
-        );
+            kernelVersion,
+            existingSignerConfig,
+        });
 
         if (smartContractWalletAddress != null && !equalsIgnoreCase(smartContractWalletAddress, account.address)) {
             throw new UserWalletAlreadyCreatedError(userId);
         }
 
         if (existingSignerConfig == null) {
-            await this.crossmintWalletService.idempotentCreateSmartWallet(user, {
+            await this.crossmintService.idempotentCreateSmartWallet(user, {
                 type: ZERO_DEV_TYPE,
                 smartContractWalletAddress: account.address,
-                signerData: signerData,
+                signerData: signerConfig.data,
                 version: CURRENT_VERSION,
                 baseLayer: "evm",
                 chainId: blockchainToChainId(chain),
-                entryPointVersion: entryPoint.version,
+                entryPointVersion,
                 kernelVersion,
             });
         }
@@ -85,7 +69,13 @@ export class SmartWalletService {
             chain: viemNetworks[chain],
             entryPoint: account.entryPoint,
             bundlerTransport: http(getBundlerRPC(chain)),
-            ...(usePaymaster(chain) && paymasterMiddleware({ entryPoint: account.entryPoint, chain })),
+            ...(usePaymaster(chain) &&
+                paymasterMiddleware({
+                    entryPoint: account.entryPoint,
+                    chain,
+                    walletService: this.crossmintService,
+                    user,
+                })),
         });
 
         const smartAccountClient = this.clientDecorator.decorate({
@@ -93,101 +83,6 @@ export class SmartWalletService {
             smartAccountClient: kernelAccountClient,
         });
 
-        return new EVMSmartWallet(this.crossmintWalletService, smartAccountClient, publicClient, chain);
-    }
-
-    private async fetchConfig(
-        user: UserParams,
-        chain: SmartWalletChain
-    ): Promise<{
-        entryPoint: EntryPointDetails;
-        kernelVersion: SupportedKernelVersion;
-        userId: string;
-        existingSignerConfig?: SignerData;
-        smartContractWalletAddress?: Address;
-    }> {
-        const { entryPointVersion, kernelVersion, signers, smartContractWalletAddress, userId } =
-            await this.crossmintWalletService.getSmartWalletConfig(user, chain);
-
-        if (!isSupportedKernelVersion(kernelVersion)) {
-            throw new SmartWalletSDKError(
-                `Unsupported kernel version. Supported versions: ${SUPPORTED_KERNEL_VERSIONS.join(
-                    ", "
-                )}. Version used: ${kernelVersion}, Please contact support`
-            );
-        }
-
-        if (!isSupportedEntryPointVersion(entryPointVersion)) {
-            throw new SmartWalletSDKError(
-                `Unsupported entry point version. Supported versions: ${SUPPORTED_ENTRYPOINT_VERSIONS.join(
-                    ", "
-                )}. Version used: ${entryPointVersion}. Please contact support`
-            );
-        }
-
-        if (
-            (entryPointVersion === "v0.7" && kernelVersion.startsWith("0.2")) ||
-            (entryPointVersion === "v0.6" && kernelVersion.startsWith("0.3"))
-        ) {
-            throw new SmartWalletSDKError(
-                `Unsupported combination: entryPoint ${entryPointVersion} and kernel version ${kernelVersion}. Please contact support`
-            );
-        }
-
-        return {
-            entryPoint: {
-                version: entryPointVersion,
-                address: entryPointVersion === "v0.6" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,
-            },
-            kernelVersion,
-            userId,
-            existingSignerConfig: this.getSigner(signers),
-            smartContractWalletAddress:
-                smartContractWalletAddress != null ? getAddress(smartContractWalletAddress) : undefined,
-        };
-    }
-
-    private getSigner(signers: any[]): SignerData | undefined {
-        if (signers.length === 0) {
-            return undefined;
-        }
-
-        if (signers.length > 1) {
-            throw new CrossmintServiceError("Invalid wallet signer configuration. Please contact support");
-        }
-
-        return signers[0].signerData;
-    }
-}
-
-class AccountFactory {
-    constructor(private readonly eoa: EOAAccountService, private readonly passkey: PasskeyAccountService) {}
-
-    public get(
-        params: WalletCreationParams,
-        existingSignerConfig?: SignerData
-    ): Promise<{
-        signerData: SignerData;
-        account: KernelSmartAccount<EntryPoint, HttpTransport>;
-    }> {
-        if (isPasskeyParams(params)) {
-            if (existingSignerConfig != null && existingSignerConfig?.type !== "passkeys") {
-                throw new AdminMismatchError(
-                    `Cannot create wallet with passkey signer for user '${params.user.id}', they have an existing wallet with eoa signer '${existingSignerConfig.eoaAddress}.'`,
-                    existingSignerConfig
-                );
-            }
-
-            return this.passkey.get(params, existingSignerConfig);
-        }
-
-        if (existingSignerConfig != null && existingSignerConfig?.type !== "eoa") {
-            throw new AdminMismatchError(
-                `Cannot create wallet with eoa signer for user '${params.user.id}', they already have a wallet with a passkey named '${existingSignerConfig.passkeyName}' as it's signer.`,
-                displayPasskey(existingSignerConfig)
-            );
-        }
-
-        return this.eoa.get(params as EOAWalletParams, existingSignerConfig);
+        return new EVMSmartWallet(this.crossmintService, smartAccountClient, publicClient, chain);
     }
 }