@crossmint/client-sdk-smart-wallet 0.1.0

package/src/blockchain/wallets/service.ts

@@ -0,0 +1,193 @@
+import { type SignerData, displayPasskey } from "@/types/API";
+import { equalsIgnoreCase } from "@/utils/helpers";
+import { type KernelSmartAccount, 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 { blockchainToChainId } from "@crossmint/common-sdk-base";
+
+import type { CrossmintWalletService, EVMBlockchainIncludingTestnet } 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 { CURRENT_VERSION, ZERO_DEV_TYPE } from "../../utils/constants";
+import { getBundlerRPC, getViemNetwork } from "../BlockchainNetworks";
+import { EVMSmartWallet } from "./EVMSmartWallet";
+import { ClientDecorator } from "./clientDecorator";
+import { EOAAccountService, type EOAWalletParams } from "./eoa";
+import { PasskeyAccountService, isPasskeyParams } from "./passkey";
+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)
+        )
+    ) {}
+
+    public async getOrCreate(
+        user: UserParams,
+        chain: EVMBlockchainIncludingTestnet,
+        walletParams: WalletParams
+    ): Promise<EVMSmartWallet> {
+        const { entryPoint, kernelVersion, existingSignerConfig, smartContractWalletAddress, userId } =
+            await this.fetchConfig(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,
+            },
+            existingSignerConfig
+        );
+
+        if (smartContractWalletAddress != null && !equalsIgnoreCase(smartContractWalletAddress, account.address)) {
+            throw new UserWalletAlreadyCreatedError(userId);
+        }
+
+        if (existingSignerConfig == null) {
+            await this.crossmintWalletService.idempotentCreateSmartWallet(user, {
+                type: ZERO_DEV_TYPE,
+                smartContractWalletAddress: account.address,
+                signerData: signerData,
+                version: CURRENT_VERSION,
+                baseLayer: "evm",
+                chainId: blockchainToChainId(chain),
+                entryPointVersion: entryPoint.version,
+                kernelVersion,
+            });
+        }
+
+        const kernelAccountClient: SmartWalletClient = createKernelAccountClient({
+            account,
+            chain: getViemNetwork(chain),
+            entryPoint: account.entryPoint,
+            bundlerTransport: http(getBundlerRPC(chain)),
+            ...(usePaymaster(chain) && paymasterMiddleware({ entryPoint: account.entryPoint, chain })),
+        });
+
+        const smartAccountClient = this.clientDecorator.decorate({
+            crossmintChain: chain,
+            smartAccountClient: kernelAccountClient,
+        });
+
+        return new EVMSmartWallet(this.crossmintWalletService, smartAccountClient, publicClient, chain);
+    }
+
+    private async fetchConfig(
+        user: UserParams,
+        chain: EVMBlockchainIncludingTestnet
+    ): 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);
+    }
+}

package/src/error/index.ts

@@ -0,0 +1,148 @@
+import { PasskeyDisplay, SignerDisplay } from "@/types/API";
+
+export const SmartWalletErrors = {
+    NOT_AUTHORIZED: "smart-wallet:not-authorized",
+    TRANSFER: "smart-wallet:transfer.error",
+    CROSSMINT_SERVICE: "smart-wallet:crossmint-service.error",
+    ERROR_JWT_EXPIRED: "smart-wallet:not-authorized.jwt-expired",
+    ERROR_JWT_INVALID: "smart-wallet:not-authorized.jwt-invalid",
+    ERROR_JWT_DECRYPTION: "smart-wallet:not-authorized.jwt-decryption",
+    ERROR_JWT_IDENTIFIER: "smart-wallet:not-authorized.jwt-identifier",
+    ERROR_USER_WALLET_ALREADY_CREATED: "smart-wallet:user-wallet-already-created.error",
+    ERROR_OUT_OF_CREDITS: "smart-wallet:out-of-credits.error",
+    ERROR_WALLET_CONFIG: "smart-wallet:wallet-config.error",
+    ERROR_ADMIN_MISMATCH: "smart-wallet:wallet-config.admin-mismatch",
+    ERROR_PASSKEY_MISMATCH: "smart-wallet:wallet-config.passkey-mismatch",
+    ERROR_ADMIN_SIGNER_ALREADY_USED: "smart-wallet:wallet-config.admin-signer-already-used",
+    UNCATEGORIZED: "smart-wallet:uncategorized", // catch-all error code
+} as const;
+export type SmartWalletErrorCode = (typeof SmartWalletErrors)[keyof typeof SmartWalletErrors];
+
+export class SmartWalletSDKError extends Error {
+    public readonly code: SmartWalletErrorCode;
+    public readonly details?: string;
+
+    constructor(message: string, details?: string, code: SmartWalletErrorCode = SmartWalletErrors.UNCATEGORIZED) {
+        super(message);
+        this.details = details;
+        this.code = code;
+    }
+}
+
+export class TransferError extends SmartWalletSDKError {
+    constructor(message: string) {
+        super(message, undefined, SmartWalletErrors.TRANSFER);
+    }
+}
+
+export class CrossmintServiceError extends SmartWalletSDKError {
+    public status?: number;
+
+    constructor(message: string, status?: number) {
+        super(message, undefined, SmartWalletErrors.CROSSMINT_SERVICE);
+        this.status = status;
+    }
+}
+
+export class AdminMismatchError extends SmartWalletSDKError {
+    public readonly required: SignerDisplay;
+    public readonly used?: SignerDisplay;
+
+    constructor(message: string, required: SignerDisplay, used?: SignerDisplay) {
+        super(message, SmartWalletErrors.ERROR_ADMIN_MISMATCH);
+        this.required = required;
+        this.used = used;
+    }
+}
+
+export class PasskeyMismatchError extends SmartWalletSDKError {
+    public readonly required: PasskeyDisplay;
+    public readonly used?: PasskeyDisplay;
+
+    constructor(message: string, required: PasskeyDisplay, used?: PasskeyDisplay) {
+        super(message, SmartWalletErrors.ERROR_PASSKEY_MISMATCH);
+        this.required = required;
+        this.used = used;
+    }
+}
+
+export class NotAuthorizedError extends SmartWalletSDKError {
+    constructor(message: string) {
+        super(message, undefined, SmartWalletErrors.NOT_AUTHORIZED);
+    }
+}
+
+export class JWTExpiredError extends NotAuthorizedError {
+    public readonly code = SmartWalletErrors.ERROR_JWT_EXPIRED;
+
+    /**
+     * The expiry time of the JWT as an ISO 8601 timestamp.
+     */
+    public readonly expiredAt: string;
+
+    constructor(expiredAt: Date) {
+        super(`JWT provided expired at timestamp ${expiredAt}`);
+        this.expiredAt = expiredAt.toISOString();
+    }
+}
+
+export class JWTInvalidError extends NotAuthorizedError {
+    public readonly code = SmartWalletErrors.ERROR_JWT_INVALID;
+    constructor() {
+        super("Invalid JWT provided");
+    }
+}
+
+export class JWTDecryptionError extends NotAuthorizedError {
+    public readonly code = SmartWalletErrors.ERROR_JWT_DECRYPTION;
+    constructor() {
+        super("Error decrypting JWT");
+    }
+}
+
+export class JWTIdentifierError extends NotAuthorizedError {
+    public readonly code = SmartWalletErrors.ERROR_JWT_IDENTIFIER;
+    public readonly identifierKey: string;
+
+    constructor(identifierKey: string) {
+        super(`Missing required identifier '${identifierKey}' in the JWT`);
+        this.identifierKey = identifierKey;
+    }
+}
+
+export class UserWalletAlreadyCreatedError extends SmartWalletSDKError {
+    public readonly code = SmartWalletErrors.ERROR_USER_WALLET_ALREADY_CREATED;
+
+    constructor(userId: string) {
+        super(`The user with userId ${userId.toString()} already has a wallet created for this project`);
+    }
+}
+
+export class OutOfCreditsError extends SmartWalletSDKError {
+    constructor(message?: string) {
+        super(
+            "You've run out of Crossmint API credits. Visit https://docs.crossmint.com/docs/errors for more information",
+            undefined,
+            SmartWalletErrors.ERROR_OUT_OF_CREDITS
+        );
+    }
+}
+
+export class ConfigError extends SmartWalletSDKError {
+    constructor(message: string) {
+        super(message, undefined, SmartWalletErrors.ERROR_WALLET_CONFIG);
+    }
+}
+
+export class AdminAlreadyUsedError extends ConfigError {
+    public readonly code = SmartWalletErrors.ERROR_ADMIN_SIGNER_ALREADY_USED;
+    constructor() {
+        super("This signer was already used to create another wallet. Please use a different signer.");
+    }
+}
+
+export class NonCustodialWalletsNotEnabledError extends ConfigError {
+    constructor() {
+        super("Non-custodial wallets are not enabled for this project");
+    }
+}

package/src/error/processor.ts

@@ -0,0 +1,36 @@
+import { logError } from "@/services/logging";
+import { DatadogProvider } from "@/services/logging/DatadogProvider";
+import { SDK_VERSION } from "@/utils/constants";
+import { BaseError, stringify } from "viem";
+
+import { SmartWalletSDKError } from ".";
+
+export class ErrorProcessor {
+    constructor(private readonly logger: DatadogProvider) {}
+
+    public map(error: unknown, fallback: SmartWalletSDKError): SmartWalletSDKError | BaseError {
+        this.record(error);
+
+        if (error instanceof SmartWalletSDKError) {
+            return error;
+        }
+
+        // Allow viem errors, which are generally pretty friendly.
+        if (error instanceof BaseError) {
+            return error;
+        }
+
+        return fallback;
+    }
+
+    private record(error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        this.logger.logError(`Smart Wallet SDK Error: ${message}`, {
+            stack: error instanceof Error ? error.stack : undefined,
+            name: error instanceof Error ? error.name : "UnknownError",
+            details: stringify(error),
+            domain: window.location.hostname,
+            sdk_version: SDK_VERSION,
+        });
+    }
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+export { EVMBlockchainIncludingTestnet as Blockchain, blockchainToChainId } from "@crossmint/common-sdk-base";
+
+export { EVMSmartWallet } from "./blockchain/wallets/EVMSmartWallet";
+
+export type {
+    SmartWalletSDKInitParams,
+    UserParams,
+    ViemAccount,
+    PasskeySigner,
+    EOASigner,
+    WalletParams,
+} from "./types/Config";
+
+export type { TransferType, ERC20TransferType, NFTTransferType, SFTTransferType } from "./types/Tokens";
+
+export {
+    TransferError,
+    CrossmintServiceError,
+    SmartWalletSDKError,
+    JWTDecryptionError,
+    JWTExpiredError,
+    JWTIdentifierError,
+    JWTInvalidError,
+    NotAuthorizedError,
+    UserWalletAlreadyCreatedError,
+    OutOfCreditsError,
+    AdminAlreadyUsedError,
+    AdminMismatchError,
+    PasskeyMismatchError,
+    ConfigError,
+    NonCustodialWalletsNotEnabledError,
+} from "./error";
+
+export { SmartWalletSDK } from "./SmartWalletSDK";

package/src/services/logging/BrowserLoggerInterface.ts

@@ -0,0 +1,5 @@
+export interface BrowserLoggerInterface {
+    logInfo(message: string, context?: unknown): void;
+    logError(message: string, context?: unknown): void;
+    logWarn(message: string, context?: unknown): void;
+}

package/src/services/logging/ConsoleProvider.ts

@@ -0,0 +1,24 @@
+import { BrowserLoggerInterface } from "./BrowserLoggerInterface";
+
+// Set to true to enable logging on local development
+const LOG_IN_LOCALHOST = false;
+
+export class ConsoleProvider implements BrowserLoggerInterface {
+    logInfo(message: string, context?: object) {
+        if (LOG_IN_LOCALHOST) {
+            console.log(message, context);
+        }
+    }
+
+    logError(message: string, context?: object) {
+        if (LOG_IN_LOCALHOST) {
+            console.error(message, context);
+        }
+    }
+
+    logWarn(message: string, context?: object) {
+        if (LOG_IN_LOCALHOST) {
+            console.warn(message, context);
+        }
+    }
+}

package/src/services/logging/DatadogProvider.ts

@@ -0,0 +1,39 @@
+import { DATADOG_CLIENT_TOKEN, SCW_SERVICE } from "@/utils/constants";
+import { datadogLogs } from "@datadog/browser-logs";
+
+import { BrowserLoggerInterface } from "./BrowserLoggerInterface";
+
+export class DatadogProvider implements BrowserLoggerInterface {
+    logInfo(message: string, context?: object) {
+        log(message, "info", context);
+    }
+
+    logError(message: string, context?: object) {
+        log(message, "error", context);
+    }
+
+    logWarn(message: string, context?: object) {
+        log(message, "warn", context);
+    }
+}
+
+function log(message: string, loggerType: "info" | "error" | "warn", contextParam?: object) {
+    const _context = contextParam ? { ...contextParam, service: SCW_SERVICE } : { service: SCW_SERVICE };
+
+    init();
+    datadogLogs.logger[loggerType](message, _context);
+}
+
+function init() {
+    const isDatadogInitialized = datadogLogs.getInternalContext() != null;
+    if (isDatadogInitialized) {
+        return;
+    }
+
+    datadogLogs.init({
+        clientToken: DATADOG_CLIENT_TOKEN,
+        site: "datadoghq.com",
+        forwardErrorsToLogs: false,
+        sampleRate: 100,
+    });
+}

package/src/services/logging/index.ts

@@ -0,0 +1,16 @@
+import { isClient } from "../../utils/environment";
+import { isLocalhost } from "../../utils/helpers";
+import { ConsoleProvider } from "./ConsoleProvider";
+import { DatadogProvider } from "./DatadogProvider";
+
+function getBrowserLogger() {
+    if (isClient() && isLocalhost()) {
+        return new ConsoleProvider();
+    }
+
+    return new DatadogProvider();
+}
+
+const { logInfo, logWarn, logError } = getBrowserLogger();
+
+export { logInfo, logWarn, logError };

package/src/types/API.ts

@@ -0,0 +1,40 @@
+import { PasskeyValidatorContractVersion } from "@zerodev/passkey-validator";
+
+import { PasskeyValidatorSerializedData, SupportedEntryPointVersion, SupportedKernelVersion } from "./internal";
+
+export type StoreSmartWalletParams = {
+    type: string;
+    smartContractWalletAddress: string;
+    signerData: SignerData;
+    sessionKeySignerAddress?: string;
+    version: number;
+    baseLayer: string;
+    chainId: number;
+    entryPointVersion: SupportedEntryPointVersion;
+    kernelVersion: SupportedKernelVersion;
+};
+
+export type SignerData = EOASignerData | PasskeySignerData;
+
+export interface EOASignerData {
+    eoaAddress: string;
+    type: "eoa";
+}
+
+export type PasskeySignerData = PasskeyValidatorSerializedData & {
+    passkeyName: string;
+    validatorContractVersion: PasskeyValidatorContractVersion;
+    domain: string;
+    type: "passkeys";
+};
+
+export type PasskeyDisplay = Pick<PasskeySignerData, "type" | "passkeyName" | "pubKeyX" | "pubKeyY">;
+export type SignerDisplay = EOASignerData | PasskeyDisplay;
+export function displayPasskey(data: PasskeySignerData): PasskeyDisplay {
+    return {
+        pubKeyX: data.pubKeyX,
+        pubKeyY: data.pubKeyY,
+        passkeyName: data.passkeyName,
+        type: "passkeys",
+    };
+}

package/src/types/Config.ts

@@ -0,0 +1,35 @@
+import type { EntryPoint } from "permissionless/types/entrypoint";
+import type { EIP1193Provider, LocalAccount } from "viem";
+
+import type { SupportedEntryPointVersion } from "./internal";
+
+export type SmartWalletSDKInitParams = {
+    clientApiKey: string;
+};
+
+export type UserParams = {
+    jwt: string;
+};
+
+export type ViemAccount = {
+    type: "VIEM_ACCOUNT";
+    account: LocalAccount & { source: "custom" };
+};
+
+export type PasskeySigner = {
+    type: "PASSKEY";
+
+    /**
+     * Displayed to the user during passkey registration or signing prompts.
+     * If not provided, a default name identifier within the JWT
+     * that is specified in the project settings (typically `sub`) will be used.
+     */
+    passkeyName?: string;
+};
+
+export type EOASigner = EIP1193Provider | ViemAccount;
+export interface WalletParams {
+    signer: EOASigner | PasskeySigner;
+}
+
+export type EntryPointDetails = { version: SupportedEntryPointVersion; address: EntryPoint };

package/src/types/Tokens.ts

@@ -0,0 +1,27 @@
+import { EVMBlockchainIncludingTestnet } from "@crossmint/common-sdk-base";
+
+export interface EVMToken {
+    chain: EVMBlockchainIncludingTestnet;
+    contractAddress: string;
+}
+
+export interface NFTEVMToken extends EVMToken {
+    tokenId: string;
+    type: "nft";
+}
+
+export interface SFTEVMToken extends EVMToken {
+    tokenId: string;
+    type: "sft";
+}
+
+export interface ERC2OEVMToken extends EVMToken {
+    type: "ft";
+}
+
+export type TokenType = "nft" | "sft" | "ft";
+
+export type ERC20TransferType = { token: ERC2OEVMToken; amount: bigint };
+export type SFTTransferType = { token: SFTEVMToken; quantity: number };
+export type NFTTransferType = { token: NFTEVMToken };
+export type TransferType = ERC20TransferType | SFTTransferType | NFTTransferType;

package/src/types/internal.ts

@@ -0,0 +1,50 @@
+import type { KernelSmartAccount } from "@zerodev/sdk";
+import type { SmartAccountClient } from "permissionless";
+import type { SmartAccount } from "permissionless/accounts";
+import type { EntryPoint } from "permissionless/types/entrypoint";
+import type { Chain, Hex, HttpTransport, PublicClient } from "viem";
+
+import type { EVMBlockchainIncludingTestnet } from "@crossmint/common-sdk-base";
+
+import type { SignerData } from "./API";
+import type { EntryPointDetails, UserParams, WalletParams } from "./Config";
+
+export const SUPPORTED_KERNEL_VERSIONS = ["0.3.1", "0.3.0", "0.2.4"] as const;
+export type SupportedKernelVersion = (typeof SUPPORTED_KERNEL_VERSIONS)[number];
+
+export function isSupportedKernelVersion(version: string): version is SupportedKernelVersion {
+    return SUPPORTED_KERNEL_VERSIONS.includes(version as any);
+}
+
+export const SUPPORTED_ENTRYPOINT_VERSIONS = ["v0.6", "v0.7"] as const;
+export type SupportedEntryPointVersion = (typeof SUPPORTED_ENTRYPOINT_VERSIONS)[number];
+
+export function isSupportedEntryPointVersion(version: string): version is SupportedEntryPointVersion {
+    return SUPPORTED_ENTRYPOINT_VERSIONS.includes(version as any);
+}
+
+export interface WalletCreationParams {
+    user: UserParams & { id: string };
+    chain: EVMBlockchainIncludingTestnet;
+    publicClient: PublicClient<HttpTransport>;
+    walletParams: WalletParams;
+    entryPoint: EntryPointDetails;
+    kernelVersion: SupportedKernelVersion;
+}
+
+export interface AccountAndSigner {
+    account: KernelSmartAccount<EntryPoint, HttpTransport>;
+    signerData: SignerData;
+}
+
+export type PasskeyValidatorSerializedData = {
+    passkeyServerUrl: string;
+    entryPoint: Hex;
+    validatorAddress: Hex;
+    pubKeyX: string;
+    pubKeyY: string;
+    authenticatorIdHash: Hex;
+    authenticatorId: string;
+};
+
+export type SmartWalletClient = SmartAccountClient<EntryPoint, HttpTransport, Chain, SmartAccount<EntryPoint>>;

package/src/utils/blockchain.ts

@@ -0,0 +1,15 @@
+import { EVMBlockchainIncludingTestnet } from "@crossmint/common-sdk-base";
+
+function isPolygonCDK(chain: EVMBlockchainIncludingTestnet) {
+    const polygonCDKchains: EVMBlockchainIncludingTestnet[] = [
+        EVMBlockchainIncludingTestnet.ZKYOTO,
+        EVMBlockchainIncludingTestnet.ZKATANA,
+        EVMBlockchainIncludingTestnet.ASTAR_ZKEVM,
+        EVMBlockchainIncludingTestnet.HYPERSONIC_TESTNET,
+    ];
+    return polygonCDKchains.includes(chain);
+}
+
+export function usesGelatoBundler(chain: EVMBlockchainIncludingTestnet) {
+    return isPolygonCDK(chain);
+}