@crossmint/client-sdk-smart-wallet 0.1.25 → 0.1.26

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

@@ -1,103 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import { mock } from "vitest-mock-extended";
-
-import type { CrossmintWalletService } from "../../../api/CrossmintWalletService";
-import type { SmartWalletConfig } from "../../../types/service";
-import { mockConfig } from "../../../utils/test";
-import { SmartWalletChain } from "../../chains";
-import type { AccountConfigCache } from "./cache";
-import { AccountConfigService } from "./config";
-import { PasskeySignerConfig } from "./signer";
-
-describe("AccountConfigService", () => {
-    let service: AccountConfigService;
-    const mockCrossmintService = mock<CrossmintWalletService>();
-    const mockCache = mock<AccountConfigCache>();
-
-    const mockUser = { jwt: "test_jwt" };
-    const mockChain = SmartWalletChain.POLYGON_AMOY;
-
-    beforeEach(() => {
-        service = new AccountConfigService(mockCrossmintService, mockCache);
-    });
-
-    describe("get", () => {
-        it("should return config from cache if available", async () => {
-            mockCache.get.mockReturnValue(mockConfig);
-            const result = await service.get(mockUser, mockChain);
-
-            expect(result).toEqual({
-                config: {
-                    entryPointVersion: mockConfig.entryPointVersion,
-                    kernelVersion: mockConfig.kernelVersion,
-                    userWithId: { ...mockUser, id: mockConfig.userId },
-                    existing: {
-                        signerConfig: expect.any(PasskeySignerConfig),
-                        address: mockConfig.smartContractWalletAddress,
-                    },
-                },
-                cached: true,
-            });
-            expect(mockCache.get).toHaveBeenCalledWith(mockUser);
-            expect(mockCrossmintService.getSmartWalletConfig).not.toHaveBeenCalled();
-        });
-
-        it("should fetch config from service if not in cache", async () => {
-            mockCache.get.mockReturnValue(null);
-            mockCrossmintService.getSmartWalletConfig.mockResolvedValue(mockConfig);
-
-            const result = await service.get(mockUser, mockChain);
-
-            expect(result).toEqual({
-                config: {
-                    entryPointVersion: mockConfig.entryPointVersion,
-                    kernelVersion: mockConfig.kernelVersion,
-                    userWithId: { ...mockUser, id: mockConfig.userId },
-                    existing: {
-                        signerConfig: expect.any(PasskeySignerConfig),
-                        address: mockConfig.smartContractWalletAddress,
-                    },
-                },
-                cached: false,
-            });
-
-            expect(mockCache.get).toHaveBeenCalledWith(mockUser);
-            expect(mockCrossmintService.getSmartWalletConfig).toHaveBeenCalledWith(mockUser, mockChain);
-        });
-
-        it("should throw error for unsupported entryPoint and kernel version combination", async () => {
-            const unsupportedConfig: SmartWalletConfig = {
-                ...mockConfig,
-                entryPointVersion: "v0.7" as const,
-                kernelVersion: "0.2.4" as const,
-            };
-            mockCache.get.mockReturnValue(unsupportedConfig);
-
-            await expect(service.get(mockUser, mockChain)).rejects.toThrow(
-                "Unsupported combination: entryPoint v0.7 and kernel version 0.2.4. Please contact support"
-            );
-        });
-
-        describe("incomplete configurations", () => {
-            const testCases = [
-                {
-                    name: "only signer is present",
-                    config: { ...mockConfig, smartContractWalletAddress: undefined },
-                },
-                {
-                    name: "only address is present",
-                    config: { ...mockConfig, signers: [] },
-                },
-            ];
-
-            testCases.forEach(({ name, config }) => {
-                it(`should throw error when ${name}`, async () => {
-                    mockCache.get.mockReturnValue(config);
-                    await expect(service.get(mockUser, mockChain)).rejects.toThrow(
-                        "Either both signer and address must be present, or both must be null"
-                    );
-                });
-            });
-        });
-    });
-});

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

@@ -1,116 +0,0 @@
-import type { CrossmintWalletService } from "../../../api/CrossmintWalletService";
-import type { SmartWalletChain } from "../../../blockchain/chains";
-import { SmartWalletError } from "../../../error";
-import type {
-    PreExistingWalletProperties,
-    SupportedEntryPointVersion,
-    SupportedKernelVersion,
-} from "../../../types/internal";
-import type { UserParams } from "../../../types/params";
-import type { SignerData, SmartWalletConfig } from "../../../types/service";
-import type { AccountConfigCache } from "./cache";
-import { EOASignerConfig, PasskeySignerConfig, type SignerConfig } from "./signer";
-
-interface AccountConfig {
-    entryPointVersion: SupportedEntryPointVersion;
-    kernelVersion: SupportedKernelVersion;
-    userWithId: UserParams & { id: string };
-    existing?: PreExistingWalletProperties;
-}
-export class AccountConfigService {
-    constructor(
-        private readonly crossmintService: CrossmintWalletService,
-        private readonly configCache: AccountConfigCache
-    ) {}
-
-    public async get(
-        user: UserParams,
-        chain: SmartWalletChain
-    ): Promise<{
-        config: AccountConfig;
-        cached: boolean;
-    }> {
-        const cached = this.configCache.get(user);
-        if (cached != null) {
-            return {
-                config: this.validateAndFormat(user, cached),
-                cached: true,
-            };
-        }
-
-        const config = await this.crossmintService.getSmartWalletConfig(user, chain);
-        return { config: this.validateAndFormat(user, config), cached: false };
-    }
-
-    public cache({
-        entryPointVersion,
-        kernelVersion,
-        user,
-        existing,
-    }: {
-        entryPointVersion: SupportedEntryPointVersion;
-        kernelVersion: SupportedKernelVersion;
-        user: UserParams & { id: string };
-        existing: PreExistingWalletProperties;
-    }) {
-        this.configCache.clear();
-        this.configCache.set(user, {
-            entryPointVersion,
-            kernelVersion,
-            userId: user.id,
-            signers: [{ signerData: existing.signerConfig.data }],
-            smartContractWalletAddress: existing.address,
-        });
-    }
-
-    private validateAndFormat(
-        user: UserParams,
-        { entryPointVersion, kernelVersion, signers, smartContractWalletAddress, userId }: SmartWalletConfig
-    ): AccountConfig {
-        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`
-            );
-        }
-
-        const signerData = signers.map((x) => x.signerData);
-        const signer = this.getSigner(signerData);
-
-        if (
-            (smartContractWalletAddress != null && signer == null) ||
-            (signer != null && smartContractWalletAddress == null)
-        ) {
-            throw new SmartWalletError("Either both signer and address must be present, or both must be null");
-        }
-
-        if (signer == null || smartContractWalletAddress == null) {
-            return { entryPointVersion, kernelVersion, userWithId: { ...user, id: userId } };
-        }
-
-        return {
-            entryPointVersion,
-            kernelVersion,
-            userWithId: { ...user, id: userId },
-            existing: { signerConfig: signer, address: 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

@@ -1,40 +0,0 @@
-import { AdminMismatchError, ConfigError } from "../../../error";
-import {
-    type AccountAndSigner,
-    type WalletCreationContext,
-    isEOACreationContext,
-    isPasskeyCreationContext,
-    isPasskeyWalletParams,
-} from "../../../types/internal";
-import type { EOACreationStrategy } from "./eoa";
-import type { PasskeyCreationStrategy } from "./passkey";
-
-export class AccountCreator {
-    constructor(
-        private readonly eoaStrategy: EOACreationStrategy,
-        private readonly passkeyStrategy: PasskeyCreationStrategy
-    ) {}
-
-    public get(context: WalletCreationContext): Promise<AccountAndSigner> {
-        if (isPasskeyCreationContext(context)) {
-            return this.passkeyStrategy.create(context);
-        }
-
-        if (isEOACreationContext(context)) {
-            return this.eoaStrategy.create(context);
-        }
-
-        if (context.existing == null) {
-            throw new ConfigError(`Unsupported wallet params:\n${context.walletParams}`);
-        }
-
-        const display = context.existing.signerConfig.display();
-        const inputSignerType = isPasskeyWalletParams(context.walletParams) ? "passkey" : "eoa";
-        throw new AdminMismatchError(
-            `Cannot create wallet with ${inputSignerType} signer for user ${
-                context.user.id
-            }', they already have a wallet with signer:\n'${JSON.stringify(display, null, 2)}'`,
-            display
-        );
-    }
-}

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

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

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

@@ -1,198 +0,0 @@
-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";
-import type { SmartAccount } from "permissionless/accounts";
-import type { EntryPoint } from "permissionless/types/entrypoint";
-
-import {
-    PasskeyIncompatibleAuthenticatorError,
-    PasskeyMismatchError,
-    PasskeyPromptError,
-    PasskeyRegistrationError,
-} from "../../../error";
-import type { AccountAndSigner, PasskeyCreationContext } from "../../../types/internal";
-import type { PasskeySigner, UserParams, WalletParams } from "../../../types/params";
-import type { PasskeySignerData, PasskeyValidatorSerializedData } from "../../../types/service";
-import { PasskeySignerConfig } from "./signer";
-import type { AccountCreationStrategy } from "./strategy";
-
-type PasskeyValidator = KernelValidator<EntryPoint, "WebAuthnValidator"> & {
-    getSerializedData: () => string;
-};
-export class PasskeyCreationStrategy implements AccountCreationStrategy {
-    constructor(
-        private readonly passkeyServerUrl: string,
-        private readonly apiKey: string
-    ) {}
-
-    public async create({
-        user,
-        publicClient,
-        walletParams,
-        entryPoint,
-        kernelVersion,
-        existing,
-    }: PasskeyCreationContext): Promise<AccountAndSigner> {
-        const inputPasskeyName = walletParams.signer.passkeyName ?? user.id;
-        if (existing != null && existing.signerConfig.data.passkeyName !== inputPasskeyName) {
-            throw new PasskeyMismatchError(
-                `User '${user.id}' has an existing wallet created with a passkey named '${existing.signerConfig.data.passkeyName}', this does match input passkey name '${inputPasskeyName}'.`,
-                existing.signerConfig.display()
-            );
-        }
-
-        try {
-            if (existing == null && walletParams.signer.onPrePasskeyRegistration != null) {
-                await walletParams.signer.onPrePasskeyRegistration();
-            }
-
-            const passkey = await this.getPasskey(user, inputPasskeyName, existing?.signerConfig.data);
-
-            const latestValidatorVersion = PasskeyValidatorContractVersion.V0_0_2;
-            const validatorContractVersion =
-                existing == null ? latestValidatorVersion : existing.signerConfig.data.validatorContractVersion;
-
-            const validator = await toPasskeyValidator(publicClient, {
-                webAuthnKey: passkey,
-                entryPoint,
-                validatorContractVersion,
-                kernelVersion,
-            });
-
-            const kernelAccount = await createKernelAccount(publicClient, {
-                plugins: { sudo: validator },
-                entryPoint,
-                kernelVersion,
-                deployedAccountAddress: existing?.address,
-            });
-
-            return {
-                signerConfig: this.getSignerConfig(validator, validatorContractVersion, inputPasskeyName),
-                account: this.decorate(kernelAccount, inputPasskeyName, walletParams),
-            };
-        } catch (error) {
-            if (walletParams.signer.onPasskeyRegistrationError != null) {
-                walletParams.signer.onPasskeyRegistrationError(error);
-            }
-            throw this.mapError(error, inputPasskeyName);
-        }
-    }
-
-    private async getPasskey(
-        user: UserParams,
-        passkeyName: string,
-        existing?: PasskeySignerData
-    ): Promise<WebAuthnKey> {
-        if (existing != null) {
-            return {
-                pubX: BigInt(existing.pubKeyX),
-                pubY: BigInt(existing.pubKeyY),
-                authenticatorId: existing.authenticatorId,
-                authenticatorIdHash: existing.authenticatorIdHash,
-            };
-        }
-
-        return toWebAuthnKey({
-            passkeyName,
-            passkeyServerUrl: this.passkeyServerUrl,
-            mode: WebAuthnMode.Register,
-            passkeyServerHeaders: this.createPasskeysServerHeaders(user),
-        });
-    }
-
-    private getSignerConfig(
-        validator: PasskeyValidator,
-        validatorContractVersion: PasskeyValidatorContractVersion,
-        passkeyName: string
-    ): PasskeySignerConfig {
-        return new PasskeySignerConfig({
-            ...deserializePasskeyValidatorData(validator.getSerializedData()),
-            passkeyName,
-            validatorContractVersion,
-            domain: window.location.hostname,
-            type: "passkeys",
-        });
-    }
-
-    private createPasskeysServerHeaders(user: UserParams) {
-        return {
-            "x-api-key": this.apiKey,
-            Authorization: `Bearer ${user.jwt}`,
-        };
-    }
-
-    private mapError(error: any, passkeyName: string) {
-        if (error.code === 0 && error.name === "DataError") {
-            return new PasskeyIncompatibleAuthenticatorError(passkeyName);
-        }
-
-        if (error.message === "Registration not verified") {
-            return new PasskeyRegistrationError(passkeyName);
-        }
-
-        if (error.code === "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY" && error.name === "NotAllowedError") {
-            return new PasskeyPromptError(passkeyName);
-        }
-
-        return error;
-    }
-
-    private decorate<Account extends KernelSmartAccount<EntryPoint>>(
-        account: Account,
-        passkeyName: string,
-        walletParams: WalletParams
-    ): Account {
-        return new Proxy(account, {
-            get: (target, prop, receiver) => {
-                const original = Reflect.get(target, prop, receiver);
-                if (typeof original !== "function" || typeof prop !== "string" || !isAccountSigningMethod(prop)) {
-                    return original;
-                }
-
-                const signer = walletParams.signer as PasskeySigner;
-                return async (...args: any[]) => {
-                    const isFirstTransaction = args?.[0]?.factoryData != null;
-                    if (
-                        isFirstTransaction &&
-                        prop === "signUserOperation" &&
-                        signer.type === "PASSKEY" &&
-                        signer.onFirstTimePasskeySigning != null
-                    ) {
-                        await signer.onFirstTimePasskeySigning();
-                    }
-                    try {
-                        return await original.call(target, ...args);
-                    } catch (error) {
-                        if (signer.onFirstTimePasskeySigningError != null) {
-                            await signer.onFirstTimePasskeySigningError(error);
-                        }
-                        throw this.mapError(error, passkeyName);
-                    }
-                };
-            },
-        });
-    }
-}
-
-const accountSigningMethods = [
-    "signMessage",
-    "signTypedData",
-    "signUserOperation",
-    "signTransaction",
-] as const satisfies readonly (keyof SmartAccount<EntryPoint>)[];
-
-function isAccountSigningMethod(method: string): method is (typeof accountSigningMethods)[number] {
-    return accountSigningMethods.includes(method as any);
-}
-
-const deserializePasskeyValidatorData = (params: string) => {
-    const uint8Array = base64ToBytes(params);
-    const jsonString = new TextDecoder().decode(uint8Array);
-
-    return JSON.parse(jsonString) as PasskeyValidatorSerializedData;
-};
-
-function base64ToBytes(base64: string) {
-    const binString = atob(base64);
-    return Uint8Array.from(binString, (m) => m.codePointAt(0) as number);
-}

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

@@ -1,44 +0,0 @@
-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

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

package/src/blockchain/wallets/clientDecorator.ts

@@ -1,128 +0,0 @@
-import type { SmartAccountClient } from "permissionless";
-import type { EntryPoint } from "permissionless/types/entrypoint";
-import { stringify } from "viem";
-
-import { SmartWalletError } from "../../error";
-import type { ErrorProcessor } from "../../error/processor";
-import { scwLogger } from "../../services";
-import { usesGelatoBundler } from "../../utils/blockchain";
-import type { SmartWalletChain } from "../chains";
-
-const transactionMethods = [
-    "sendTransaction",
-    "writeContract",
-    "sendUserOperation",
-] as const satisfies readonly (keyof SmartAccountClient<EntryPoint>)[];
-
-const signingMethods = [
-    "signMessage",
-    "signTypedData",
-] as const satisfies readonly (keyof SmartAccountClient<EntryPoint>)[];
-
-type TxnMethod = (typeof transactionMethods)[number];
-type SignMethod = (typeof signingMethods)[number];
-
-function isTxnMethod(method: string): method is TxnMethod {
-    return transactionMethods.includes(method as any);
-}
-
-function isSignMethod(method: string): method is SignMethod {
-    return signingMethods.includes(method as any);
-}
-
-/**
- * A decorator class for SmartAccountClient instances. It enhances the client with:
- * - Error handling & logging.
- * - Performance metrics.
- * - Automatic formatting of transactions for Gelato bundler compatibility.
- *  */
-export class ClientDecorator {
-    constructor(
-        private readonly errorProcessor: ErrorProcessor,
-        protected logger = scwLogger
-    ) {}
-
-    public decorate<Client extends SmartAccountClient<EntryPoint>>({
-        crossmintChain,
-        smartAccountClient,
-    }: {
-        crossmintChain: SmartWalletChain;
-        smartAccountClient: Client;
-    }): Client {
-        return new Proxy(smartAccountClient, {
-            get: (target, prop, receiver) => {
-                const originalMethod = Reflect.get(target, prop, receiver);
-
-                if (
-                    typeof originalMethod !== "function" ||
-                    typeof prop !== "string" ||
-                    !(isSignMethod(prop) || isTxnMethod(prop))
-                ) {
-                    return originalMethod;
-                }
-
-                return (...args: any[]) =>
-                    this.logger.logPerformance(`CrossmintSmartWallet.${prop}`, () =>
-                        this.execute(target, prop, originalMethod, args, crossmintChain)
-                    );
-            },
-        }) as Client;
-    }
-
-    private async execute<M extends TxnMethod | SignMethod>(
-        target: SmartAccountClient<EntryPoint>,
-        prop: M,
-        originalMethod: Function,
-        args: any[],
-        crossmintChain: SmartWalletChain
-    ) {
-        try {
-            this.logger.log(`[CrossmintSmartWallet.${prop}] - params: ${stringify(args)}`);
-            const processed = isTxnMethod(prop) ? this.processTxnArgs(prop, crossmintChain, args) : args;
-            return await originalMethod.call(target, ...processed);
-        } catch (error: any) {
-            const description = isTxnMethod(prop) ? "signing" : "sending transaction";
-            throw this.errorProcessor.map(
-                error,
-                new SmartWalletError(`Error ${description}: ${error.message}`, stringify(error))
-            );
-        }
-    }
-
-    private processTxnArgs(prop: TxnMethod, crossmintChain: SmartWalletChain, args: any[]): any[] {
-        if (prop === "sendUserOperation") {
-            const [{ userOperation, middleware, account }] = args as Parameters<
-                SmartAccountClient<EntryPoint>["sendUserOperation"]
-            >;
-            return [
-                {
-                    middleware,
-                    account,
-                    userOperation: this.addGelatoBundlerProperties(crossmintChain, userOperation),
-                },
-                ...args.slice(1),
-            ];
-        }
-
-        const [txn] = args as
-            | Parameters<SmartAccountClient<EntryPoint>["sendTransaction"]>
-            | Parameters<SmartAccountClient<EntryPoint>["writeContract"]>;
-
-        return [this.addGelatoBundlerProperties(crossmintChain, txn), ...args.slice(1)];
-    }
-
-    /*
-     * Chain that ZD uses Gelato as for bundler require special parameters:
-     * https://docs.zerodev.app/sdk/faqs/use-with-gelato#transaction-configuration
-     */
-    private addGelatoBundlerProperties(
-        crossmintChain: SmartWalletChain,
-        txnParams: { maxFeePerGas?: bigint; maxPriorityFeePerGas?: bigint }
-    ) {
-        if (usesGelatoBundler(crossmintChain)) {
-            return { ...txnParams, maxFeePerGas: "0x0" as any, maxPriorityFeePerGas: "0x0" as any };
-        }
-
-        return txnParams;
-    }
-}

package/src/blockchain/wallets/index.ts

@@ -1 +0,0 @@
-export * from "./EVMSmartWallet";