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

package/src/blockchain/wallets/paymaster.ts

@@ -1,41 +0,0 @@
-import type { CrossmintWalletService } from "@/api/CrossmintWalletService";
-import type { Middleware } from "permissionless/actions/smartAccount";
-import type { PimlicoBundlerClient } from "permissionless/clients/pimlico";
-import type { EntryPoint } from "permissionless/types/entrypoint";
-
-import type { UserParams } from "../../types/params";
-import { usesGelatoBundler } from "../../utils/blockchain";
-import type { SmartWalletChain } from "../chains";
-
-export function usePaymaster(chain: SmartWalletChain) {
-    return !usesGelatoBundler(chain);
-}
-
-export function paymasterMiddleware({
-    bundlerClient,
-    entryPoint,
-    chain,
-    walletService,
-    user,
-}: {
-    bundlerClient: PimlicoBundlerClient<EntryPoint>;
-    entryPoint: EntryPoint;
-    chain: SmartWalletChain;
-    walletService: CrossmintWalletService;
-    user: UserParams;
-}): Middleware<EntryPoint> {
-    return {
-        middleware: {
-            gasPrice: async () => (await bundlerClient.getUserOperationGasPrice()).fast,
-            sponsorUserOperation: async ({ userOperation }) => {
-                const { sponsorUserOpParams } = await walletService.sponsorUserOperation(
-                    user,
-                    userOperation,
-                    entryPoint,
-                    chain
-                );
-                return sponsorUserOpParams;
-            },
-        },
-    };
-}

package/src/blockchain/wallets/service.ts

@@ -1,107 +0,0 @@
-import type { KernelSmartAccount } from "@zerodev/sdk";
-import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07, createSmartAccountClient } from "permissionless";
-import { createPimlicoBundlerClient } from "permissionless/clients/pimlico";
-import type { EntryPoint } from "permissionless/types/entrypoint";
-import { type HttpTransport, createPublicClient, http } from "viem";
-
-import { blockchainToChainId } from "@crossmint/common-sdk-base";
-
-import type { CrossmintWalletService } from "../../api/CrossmintWalletService";
-import type { SmartWalletClient } from "../../types/internal";
-import type { UserParams, WalletParams } from "../../types/params";
-import { CURRENT_VERSION, ZERO_DEV_TYPE } from "../../utils/constants";
-import { type SmartWalletChain, viemNetworks } from "../chains";
-import { getAlchemyRPC, getPimlicoBundlerRPC } from "../rpc";
-import { EVMSmartWallet } from "./EVMSmartWallet";
-import type { AccountConfigService } 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 crossmintService: CrossmintWalletService,
-        private readonly accountConfigService: AccountConfigService,
-        private readonly accountCreator: AccountCreator,
-        private readonly clientDecorator: ClientDecorator
-    ) {}
-
-    public async getOrCreate(
-        user: UserParams,
-        chain: SmartWalletChain,
-        walletParams: WalletParams
-    ): Promise<EVMSmartWallet> {
-        const {
-            config: { entryPointVersion, kernelVersion, existing, userWithId },
-            cached,
-        } = await this.accountConfigService.get(user, chain);
-
-        const publicClient = createPublicClient({ transport: http(getAlchemyRPC(chain)) });
-
-        const { account, signerConfig } = await this.accountCreator.get({
-            chain,
-            walletParams,
-            publicClient,
-            user: userWithId,
-            entryPoint: entryPointVersion === "v0.6" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,
-            kernelVersion,
-            existing,
-        });
-
-        if (existing == null) {
-            await this.crossmintService.idempotentCreateSmartWallet(user, {
-                type: ZERO_DEV_TYPE,
-                smartContractWalletAddress: account.address,
-                signerData: signerConfig.data,
-                version: CURRENT_VERSION,
-                baseLayer: "evm",
-                chainId: blockchainToChainId(chain),
-                entryPointVersion,
-                kernelVersion,
-            });
-        }
-
-        if (!cached) {
-            this.accountConfigService.cache({
-                entryPointVersion,
-                kernelVersion,
-                user: userWithId,
-                existing: { address: account.address, signerConfig },
-            });
-        }
-
-        return new EVMSmartWallet(
-            { wallet: this.smartAccountClient(chain, account, user), public: publicClient },
-            chain,
-            this.crossmintService
-        );
-    }
-
-    private smartAccountClient(
-        chain: SmartWalletChain,
-        account: KernelSmartAccount<EntryPoint, HttpTransport>,
-        user: UserParams
-    ): SmartWalletClient {
-        const transport = http(getPimlicoBundlerRPC(chain));
-        const bundlerConfig = { chain: viemNetworks[chain], entryPoint: account.entryPoint };
-        const bundlerClient = createPimlicoBundlerClient({ ...bundlerConfig, transport });
-        const smartAccountClient: SmartWalletClient = createSmartAccountClient({
-            account,
-            bundlerTransport: transport,
-            ...bundlerConfig,
-            ...(usePaymaster(chain) &&
-                paymasterMiddleware({
-                    bundlerClient,
-                    entryPoint: account.entryPoint,
-                    chain,
-                    walletService: this.crossmintService,
-                    user,
-                })),
-        });
-
-        return this.clientDecorator.decorate({
-            crossmintChain: chain,
-            smartAccountClient,
-        });
-    }
-}

package/src/error/index.ts

@@ -1,100 +0,0 @@
-import { CrossmintSDKError, SmartWalletErrorCode } from "@crossmint/client-sdk-base";
-
-import type { PasskeyDisplay, SignerDisplay } from "../types/service";
-
-export class SmartWalletError extends CrossmintSDKError {
-    constructor(message: string, details?: string, code: SmartWalletErrorCode = SmartWalletErrorCode.UNCATEGORIZED) {
-        super(message, code, details);
-    }
-}
-
-export class AdminMismatchError extends SmartWalletError {
-    public readonly required: SignerDisplay;
-    public readonly used?: SignerDisplay;
-
-    constructor(message: string, required: SignerDisplay, used?: SignerDisplay) {
-        super(message, SmartWalletErrorCode.ADMIN_MISMATCH);
-        this.required = required;
-        this.used = used;
-    }
-}
-
-export class PasskeyMismatchError extends SmartWalletError {
-    public readonly required: PasskeyDisplay;
-    public readonly used?: PasskeyDisplay;
-
-    constructor(message: string, required: PasskeyDisplay, used?: PasskeyDisplay) {
-        super(message, SmartWalletErrorCode.PASSKEY_MISMATCH);
-        this.required = required;
-        this.used = used;
-    }
-}
-
-export class UserWalletAlreadyCreatedError extends SmartWalletError {
-    public readonly code = SmartWalletErrorCode.USER_WALLET_ALREADY_CREATED;
-
-    constructor(userId: string) {
-        super(`The user with userId ${userId.toString()} already has a wallet created for this project`);
-    }
-}
-
-export class PasskeyPromptError extends SmartWalletError {
-    public passkeyName: string;
-
-    constructor(passkeyName: string) {
-        super(
-            `Prompt was either cancelled or timed out for passkey ${passkeyName}`,
-            undefined,
-            SmartWalletErrorCode.PASSKEY_PROMPT
-        );
-        this.passkeyName = passkeyName;
-    }
-}
-
-export class PasskeyRegistrationError extends SmartWalletError {
-    public passkeyName: string;
-
-    constructor(passkeyName: string) {
-        super(
-            `Registration for passkey ${passkeyName} failed, either the registration took too long, or passkey signature vaildation failed.`,
-            undefined,
-            SmartWalletErrorCode.PASSKEY_REGISTRATION
-        );
-        this.passkeyName = passkeyName;
-    }
-}
-
-export class PasskeyIncompatibleAuthenticatorError extends SmartWalletError {
-    public passkeyName: string;
-
-    constructor(passkeyName: string) {
-        super(
-            `User selected authenticator for passkey ${passkeyName} is not compatible with Crossmint's Smart Wallets.`,
-            undefined,
-            SmartWalletErrorCode.PASSKEY_INCOMPATIBLE_AUTHENTICATOR
-        );
-        this.passkeyName = passkeyName;
-    }
-}
-
-export class ConfigError extends SmartWalletError {
-    constructor(message: string) {
-        super(message, undefined, SmartWalletErrorCode.WALLET_CONFIG);
-    }
-}
-
-export class AdminAlreadyUsedError extends ConfigError {
-    public readonly code = SmartWalletErrorCode.ADMIN_SIGNER_ALREADY_USED;
-    constructor() {
-        super("This signer was already used to create another wallet. Please use a different signer.");
-    }
-}
-
-export class SmartWalletsNotEnabledError extends ConfigError {
-    public readonly code = SmartWalletErrorCode.SMART_WALLETS_NOT_ENABLED;
-    constructor() {
-        super(
-            "Smart wallets are not enabled for this project. They can be enabled on the project settings page in the developer console."
-        );
-    }
-}

package/src/error/processor.ts

@@ -1,36 +0,0 @@
-import { BaseError, stringify } from "viem";
-
-import type { SDKLogger } from "@crossmint/client-sdk-base";
-
-import { SmartWalletError } from ".";
-import { SDK_VERSION } from "../utils/constants";
-
-export class ErrorProcessor {
-    constructor(private readonly logger: SDKLogger) {}
-
-    public map(error: unknown, fallback: SmartWalletError): SmartWalletError | BaseError {
-        this.record(error);
-
-        if (error instanceof SmartWalletError) {
-            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.error(`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

@@ -1,47 +0,0 @@
-export { blockchainToChainId, EVMBlockchainIncludingTestnet as Chain } from "@crossmint/common-sdk-base";
-
-export { EVMSmartWallet } from "./blockchain/wallets/EVMSmartWallet";
-
-export type {
-    SmartWalletSDKInitParams,
-    UserParams,
-    ViemAccount,
-    PasskeySigner,
-    ExternalSigner,
-    WalletParams,
-} from "./types/params";
-
-export type { SmartWalletChain as EVMSmartWalletChain } from "./blockchain/chains";
-
-export type { TransferType, ERC20TransferType, NFTTransferType, SFTTransferType } from "./types/token";
-
-export {
-    SmartWalletError,
-    UserWalletAlreadyCreatedError,
-    AdminAlreadyUsedError,
-    AdminMismatchError,
-    PasskeyMismatchError,
-    PasskeyPromptError,
-    PasskeyRegistrationError,
-    PasskeyIncompatibleAuthenticatorError,
-    ConfigError,
-    SmartWalletsNotEnabledError,
-} from "./error";
-
-export {
-    EVMSendTransactionError,
-    EVMSendTransactionExecutionRevertedError,
-} from "./blockchain/wallets/SendTransactionService";
-
-export {
-    SmartWalletErrorCode,
-    CrossmintSDKError,
-    CrossmintServiceError,
-    JWTDecryptionError,
-    JWTExpiredError,
-    JWTIdentifierError,
-    JWTInvalidError,
-    NotAuthorizedError,
-} from "@crossmint/client-sdk-base";
-
-export { SmartWalletSDK } from "./SmartWalletSDK";

package/src/services/index.ts

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

package/src/services/logger.ts

@@ -1,6 +0,0 @@
-import { SDKLogger, getBrowserLogger } from "@crossmint/client-sdk-base";
-
-import { SCW_SERVICE } from "../utils/constants";
-
-export const scwLogger = new SDKLogger(SCW_SERVICE);
-export const scwDatadogLogger = new SDKLogger(SCW_SERVICE, getBrowserLogger(SCW_SERVICE, { onlyDatadog: true }));

package/src/types/internal.ts

@@ -1,76 +0,0 @@
-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 { Address, Chain, HttpTransport, PublicClient } from "viem";
-
-import type { SmartWalletChain } from "../blockchain/chains";
-import type { EOASignerConfig, PasskeySignerConfig, SignerConfig } from "../blockchain/wallets/account/signer";
-import { SUPPORTED_ENTRYPOINT_VERSIONS, SUPPORTED_KERNEL_VERSIONS } from "../utils/constants";
-import type { ExternalSigner, PasskeySigner, UserParams, WalletParams } from "./params";
-
-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 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 PreExistingWalletProperties {
-    signerConfig: SignerConfig;
-    address: Address;
-}
-
-export interface WalletCreationContext {
-    user: UserParams & { id: string };
-    chain: SmartWalletChain;
-    publicClient: PublicClient<HttpTransport>;
-    walletParams: WalletParams;
-    entryPoint: EntryPoint;
-    kernelVersion: SupportedKernelVersion;
-    existing?: PreExistingWalletProperties;
-}
-
-export interface PasskeyCreationContext extends WalletCreationContext {
-    walletParams: WalletParams & { signer: PasskeySigner };
-    existing?: { signerConfig: PasskeySignerConfig; address: Address };
-}
-
-export interface EOACreationContext extends WalletCreationContext {
-    walletParams: WalletParams & { signer: ExternalSigner };
-    existing?: { signerConfig: EOASignerConfig; address: Address };
-}
-
-export function isPasskeyWalletParams(params: WalletParams): params is WalletParams & { signer: PasskeySigner } {
-    return "signer" in params && "type" in params.signer && params.signer.type === "PASSKEY";
-}
-
-export function isPasskeyCreationContext(params: WalletCreationContext): params is PasskeyCreationContext {
-    const signerIsPasskeyOrUndefined = params.existing == null || params.existing.signerConfig.type === "passkeys";
-
-    return isPasskeyWalletParams(params.walletParams) && signerIsPasskeyOrUndefined;
-}
-
-export function isEOAWalletParams(params: WalletParams): params is WalletParams & { signer: ExternalSigner } {
-    return (
-        "signer" in params &&
-        (("type" in params.signer && params.signer.type === "VIEM_ACCOUNT") ||
-            ("request" in params.signer && typeof params.signer.request === "function"))
-    );
-}
-
-export function isEOACreationContext(params: WalletCreationContext): params is EOACreationContext {
-    const signerIsEOAOrUndefined = params.existing == null || params.existing.signerConfig.type === "eoa";
-
-    return isEOAWalletParams(params.walletParams) && signerIsEOAOrUndefined;
-}
-
-export interface AccountAndSigner {
-    account: KernelSmartAccount<EntryPoint, HttpTransport>;
-    signerConfig: SignerConfig;
-}
-
-export type SmartWalletClient = SmartAccountClient<EntryPoint, HttpTransport, Chain, SmartAccount<EntryPoint>>;

package/src/types/params.ts

@@ -1,34 +0,0 @@
-import type { EIP1193Provider, LocalAccount } from "viem";
-
-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;
-    onPrePasskeyRegistration?: () => Promise<void> | void;
-    onPasskeyRegistrationError?: (error: unknown) => Promise<void>;
-    onFirstTimePasskeySigning?: () => Promise<void> | void;
-    onFirstTimePasskeySigningError?: (error: unknown) => Promise<void>;
-};
-
-export type ExternalSigner = EIP1193Provider | ViemAccount;
-export interface WalletParams {
-    signer: ExternalSigner | PasskeySigner;
-}

package/src/types/schema.ts

@@ -1,63 +0,0 @@
-import { PasskeyValidatorContractVersion } from "@zerodev/passkey-validator";
-import { isAddress, isHex } from "viem";
-import { z } from "zod";
-
-import { SUPPORTED_ENTRYPOINT_VERSIONS, SUPPORTED_KERNEL_VERSIONS } from "../utils/constants";
-
-const HexSchema = z.custom<`0x${string}`>((val): val is `0x${string}` => isHex(val as string), {
-    message: "Invalid hex string",
-});
-
-const evmAddressSchema = z.custom<`0x${string}`>((val): val is `0x${string}` => isAddress(val as string), {
-    message: "Invalid evm address",
-});
-
-export const EOASignerDataSchema = z.object({
-    eoaAddress: evmAddressSchema,
-    type: z.literal("eoa"),
-});
-
-export const PasskeyValidatorSerializedDataSchema = z.object({
-    entryPoint: evmAddressSchema,
-    validatorAddress: evmAddressSchema,
-    pubKeyX: z.string(),
-    pubKeyY: z.string(),
-    authenticatorIdHash: HexSchema,
-    authenticatorId: z.string(),
-});
-
-export const PasskeySignerDataSchema = PasskeyValidatorSerializedDataSchema.extend({
-    passkeyName: z.string(),
-    validatorContractVersion: z.nativeEnum(PasskeyValidatorContractVersion),
-    domain: z.string(),
-    type: z.literal("passkeys"),
-});
-
-export const SignerDataSchema = z.discriminatedUnion("type", [PasskeySignerDataSchema, EOASignerDataSchema]);
-
-export const SmartWalletConfigSchema = z.object({
-    kernelVersion: z.enum(SUPPORTED_KERNEL_VERSIONS, {
-        errorMap: (_, ctx) => ({
-            message: `Unsupported kernel version. Supported versions: ${SUPPORTED_KERNEL_VERSIONS.join(
-                ", "
-            )}. Version used: ${ctx.data}. Please contact support`,
-        }),
-    }),
-    entryPointVersion: z.enum(SUPPORTED_ENTRYPOINT_VERSIONS, {
-        errorMap: (_, ctx) => ({
-            message: `Unsupported entry point version. Supported versions: ${SUPPORTED_ENTRYPOINT_VERSIONS.join(
-                ", "
-            )}. Version used: ${ctx.data}. Please contact support`,
-        }),
-    }),
-    userId: z.string().min(1),
-    signers: z
-        .array(
-            z.object({
-                signerData: SignerDataSchema,
-            })
-        )
-        .min(0)
-        .max(1, "Invalid wallet signer configuration. Please contact support"),
-    smartContractWalletAddress: evmAddressSchema.optional(),
-});

package/src/types/service.ts

@@ -1,31 +0,0 @@
-import type { z } from "zod";
-
-import type { SupportedEntryPointVersion, SupportedKernelVersion } from "./internal";
-import type {
-    EOASignerDataSchema,
-    PasskeySignerDataSchema,
-    PasskeyValidatorSerializedDataSchema,
-    SignerDataSchema,
-    SmartWalletConfigSchema,
-} from "./schema";
-
-export type EOASignerData = z.infer<typeof EOASignerDataSchema>;
-export type PasskeyValidatorSerializedData = z.infer<typeof PasskeyValidatorSerializedDataSchema>;
-export type PasskeySignerData = z.infer<typeof PasskeySignerDataSchema>;
-export type SmartWalletConfig = z.infer<typeof SmartWalletConfigSchema>;
-export type SignerData = z.infer<typeof SignerDataSchema>;
-
-export type PasskeyDisplay = Pick<PasskeySignerData, "type" | "passkeyName" | "pubKeyX" | "pubKeyY">;
-export type SignerDisplay = EOASignerData | PasskeyDisplay;
-
-export type StoreSmartWalletParams = {
-    type: string;
-    smartContractWalletAddress: string;
-    signerData: SignerData;
-    sessionKeySignerAddress?: string;
-    version: number;
-    baseLayer: string;
-    chainId: number;
-    entryPointVersion: SupportedEntryPointVersion;
-    kernelVersion: SupportedKernelVersion;
-};

package/src/types/token.ts

@@ -1,29 +0,0 @@
-import type { Address } from "viem";
-
-import type { SmartWalletChain } from "../blockchain/chains";
-
-export interface EVMToken {
-    chain: SmartWalletChain;
-    contractAddress: Address;
-}
-
-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/utils/api.ts

@@ -1,39 +0,0 @@
-import { toHex } from "viem";
-
-function mapObject(data: any, fn: (value: unknown) => { value: unknown; replace: boolean }): any {
-    const result = fn(data);
-    if (result.replace) {
-        return result.value;
-    }
-    if (Array.isArray(data)) {
-        return data.map((item) => mapObject(item, fn));
-    } else if (data !== null && typeof data === "object") {
-        return Object.fromEntries(Object.entries(data).map(([key, value]) => [key, mapObject(value, fn)]));
-    }
-    return result.value;
-}
-
-export function bigintsToHex(data: any): any {
-    return mapObject(data, (value) => {
-        if (typeof value === "bigint") {
-            return { value: toHex(value), replace: true };
-        }
-        return { value, replace: false };
-    });
-}
-
-export function parseBigintAPIResponse(data: any): any {
-    return mapObject(data, (value) => {
-        if (
-            value != null &&
-            typeof value == "object" &&
-            "__xm_serializedType" in value &&
-            "value" in value &&
-            value.__xm_serializedType === "bigint" &&
-            typeof value.value === "string"
-        ) {
-            return { value: BigInt(value.value), replace: true };
-        }
-        return { value, replace: false };
-    });
-}

package/src/utils/blockchain.ts

@@ -1,5 +0,0 @@
-import type { SmartWalletChain } from "../blockchain/chains";
-
-export function usesGelatoBundler(chain: SmartWalletChain) {
-    return false;
-}

package/src/utils/constants.ts

@@ -1,9 +0,0 @@
-import { version } from "../../package.json";
-
-export const ZERO_DEV_TYPE = "ZeroDev";
-export const CURRENT_VERSION = 0;
-export const SCW_SERVICE = "SCW_SDK";
-export const SDK_VERSION = version;
-export const API_VERSION = "2024-06-09";
-export const SUPPORTED_KERNEL_VERSIONS = ["0.3.1", "0.3.0", "0.2.4"] as const;
-export const SUPPORTED_ENTRYPOINT_VERSIONS = ["v0.6", "v0.7"] as const;

package/src/utils/environment.ts

@@ -1,3 +0,0 @@
-export function isClient() {
-    return typeof window !== "undefined";
-}

package/src/utils/helpers.ts

@@ -1,7 +0,0 @@
-export function isEmpty(str: string | undefined | null): str is undefined | null {
-    return !str || str.length === 0 || str.trim().length === 0;
-}
-
-export function equalsIgnoreCase(a?: string, b?: string): boolean {
-    return a?.toLowerCase() === b?.toLowerCase();
-}