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

package/src/error/index.ts

@@ -1,192 +1,100 @@
-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_PASSKEY_PROMPT: "smart-wallet:passkey.prompt",
-    ERROR_PASSKEY_INCOMPATIBLE_AUTHENTICATOR: "smart-wallet.passkey.incompatible-authenticator",
-    ERROR_PASSKEY_REGISTRATION: "smart-wallet:passkey.registration",
-    ERROR_ADMIN_SIGNER_ALREADY_USED: "smart-wallet:wallet-config.admin-signer-already-used",
-    ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED: "smart-wallet:wallet-config.non-custodial-wallets-not-enabled",
-    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;
-    }
-}
+import { CrossmintSDKError, SmartWalletErrorCode } from "@crossmint/client-sdk-base";
 
-export class TransferError extends SmartWalletSDKError {
-    constructor(message: string) {
-        super(message, undefined, SmartWalletErrors.TRANSFER);
-    }
-}
+import { PasskeyDisplay, SignerDisplay } from "../types/service";
 
-export class CrossmintServiceError extends SmartWalletSDKError {
-    public status?: number;
-
-    constructor(message: string, status?: number) {
-        super(message, undefined, SmartWalletErrors.CROSSMINT_SERVICE);
-        this.status = status;
+export class SmartWalletError extends CrossmintSDKError {
+    constructor(message: string, details?: string, code: SmartWalletErrorCode = SmartWalletErrorCode.UNCATEGORIZED) {
+        super(message, code, details);
     }
 }
 
-export class AdminMismatchError extends SmartWalletSDKError {
+export class AdminMismatchError extends SmartWalletError {
     public readonly required: SignerDisplay;
     public readonly used?: SignerDisplay;
 
     constructor(message: string, required: SignerDisplay, used?: SignerDisplay) {
-        super(message, SmartWalletErrors.ERROR_ADMIN_MISMATCH);
+        super(message, SmartWalletErrorCode.ADMIN_MISMATCH);
         this.required = required;
         this.used = used;
     }
 }
 
-export class PasskeyMismatchError extends SmartWalletSDKError {
+export class PasskeyMismatchError extends SmartWalletError {
     public readonly required: PasskeyDisplay;
     public readonly used?: PasskeyDisplay;
 
     constructor(message: string, required: PasskeyDisplay, used?: PasskeyDisplay) {
-        super(message, SmartWalletErrors.ERROR_PASSKEY_MISMATCH);
+        super(message, SmartWalletErrorCode.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;
+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 SmartWalletSDKError {
+export class PasskeyPromptError extends SmartWalletError {
     public passkeyName: string;
 
     constructor(passkeyName: string) {
         super(
             `Prompt was either cancelled or timed out for passkey ${passkeyName}`,
             undefined,
-            SmartWalletErrors.ERROR_PASSKEY_PROMPT
+            SmartWalletErrorCode.PASSKEY_PROMPT
         );
         this.passkeyName = passkeyName;
     }
 }
 
-export class PasskeyRegistrationError extends SmartWalletSDKError {
+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,
-            SmartWalletErrors.ERROR_PASSKEY_REGISTRATION
+            SmartWalletErrorCode.PASSKEY_REGISTRATION
         );
         this.passkeyName = passkeyName;
     }
 }
 
-export class PasskeyIncompatibleAuthenticatorError extends SmartWalletSDKError {
+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,
-            SmartWalletErrors.ERROR_PASSKEY_INCOMPATIBLE_AUTHENTICATOR
+            SmartWalletErrorCode.PASSKEY_INCOMPATIBLE_AUTHENTICATOR
         );
         this.passkeyName = passkeyName;
     }
 }
 
-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 {
+export class ConfigError extends SmartWalletError {
     constructor(message: string) {
-        super(message, undefined, SmartWalletErrors.ERROR_WALLET_CONFIG);
+        super(message, undefined, SmartWalletErrorCode.WALLET_CONFIG);
     }
 }
 
 export class AdminAlreadyUsedError extends ConfigError {
-    public readonly code = SmartWalletErrors.ERROR_ADMIN_SIGNER_ALREADY_USED;
+    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 NonCustodialWalletsNotEnabledError extends ConfigError {
-    public readonly code = SmartWalletErrors.ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED;
+export class SmartWalletsNotEnabledError extends ConfigError {
+    public readonly code = SmartWalletErrorCode.SMART_WALLETS_NOT_ENABLED;
     constructor() {
-        super("Non-custodial wallets are not enabled for this project");
+        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,17 +1,16 @@
-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 ".";
+import { SmartWalletError } from ".";
+import { DatadogProvider } from "../services/logging/DatadogProvider";
+import { SDK_VERSION } from "../utils/constants";
 
 export class ErrorProcessor {
     constructor(private readonly logger: DatadogProvider) {}
 
-    public map(error: unknown, fallback: SmartWalletSDKError): SmartWalletSDKError | BaseError {
+    public map(error: unknown, fallback: SmartWalletError): SmartWalletError | BaseError {
         this.record(error);
 
-        if (error instanceof SmartWalletSDKError) {
+        if (error instanceof SmartWalletError) {
             return error;
         }
 

package/src/index.ts

@@ -9,21 +9,13 @@ export type {
     PasskeySigner,
     EOASigner,
     WalletParams,
-} from "./types/Config";
+} from "./types/params";
 
-export type { TransferType, ERC20TransferType, NFTTransferType, SFTTransferType } from "./types/Tokens";
+export type { TransferType, ERC20TransferType, NFTTransferType, SFTTransferType } from "./types/token";
 
 export {
-    TransferError,
-    CrossmintServiceError,
-    SmartWalletSDKError,
-    JWTDecryptionError,
-    JWTExpiredError,
-    JWTIdentifierError,
-    JWTInvalidError,
-    NotAuthorizedError,
+    SmartWalletError,
     UserWalletAlreadyCreatedError,
-    OutOfCreditsError,
     AdminAlreadyUsedError,
     AdminMismatchError,
     PasskeyMismatchError,
@@ -31,7 +23,19 @@ export {
     PasskeyRegistrationError,
     PasskeyIncompatibleAuthenticatorError,
     ConfigError,
-    NonCustodialWalletsNotEnabledError,
+    SmartWalletsNotEnabledError,
 } from "./error";
 
+export {
+    SmartWalletErrorCode,
+    CrossmintSDKError,
+    CrossmintServiceError,
+    TransferError,
+    JWTDecryptionError,
+    JWTExpiredError,
+    JWTIdentifierError,
+    JWTInvalidError,
+    NotAuthorizedError,
+} from "@crossmint/client-sdk-base";
+
 export { SmartWalletSDK } from "./SmartWalletSDK";

package/src/services/logging/ConsoleProvider.ts

@@ -1,24 +1,15 @@
 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);
-        }
+        console.log(message, context);
     }
 
     logError(message: string, context?: object) {
-        if (LOG_IN_LOCALHOST) {
-            console.error(message, context);
-        }
+        console.error(message, context);
     }
 
     logWarn(message: string, context?: object) {
-        if (LOG_IN_LOCALHOST) {
-            console.warn(message, context);
-        }
+        console.warn(message, context);
     }
 }

package/src/services/logging/DatadogProvider.ts

@@ -1,6 +1,6 @@
-import { DATADOG_CLIENT_TOKEN, SCW_SERVICE } from "@/utils/constants";
 import { datadogLogs } from "@datadog/browser-logs";
 
+import { DATADOG_CLIENT_TOKEN, SCW_SERVICE } from "../../utils/constants";
 import { BrowserLoggerInterface } from "./BrowserLoggerInterface";
 
 export class DatadogProvider implements BrowserLoggerInterface {

package/src/types/internal.ts

@@ -2,22 +2,19 @@ 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 { Chain, HttpTransport, PublicClient } from "viem";
 
 import type { SmartWalletChain } from "../blockchain/chains";
-import type { SignerData } from "./API";
-import type { EntryPointDetails, UserParams, WalletParams } from "./Config";
+import type { EOASignerConfig, PasskeySignerConfig, SignerConfig } from "../blockchain/wallets/account/signer";
+import { SUPPORTED_ENTRYPOINT_VERSIONS, SUPPORTED_KERNEL_VERSIONS } from "../utils/constants";
+import type { EOASigner, PasskeySigner, UserParams, WalletParams } from "./params";
 
-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);
 }
@@ -27,23 +24,47 @@ export interface WalletCreationParams {
     chain: SmartWalletChain;
     publicClient: PublicClient<HttpTransport>;
     walletParams: WalletParams;
-    entryPoint: EntryPointDetails;
+    entryPoint: { version: SupportedEntryPointVersion; address: EntryPoint };
     kernelVersion: SupportedKernelVersion;
+    existingSignerConfig?: SignerConfig;
+}
+
+export interface PasskeyCreationParams extends WalletCreationParams {
+    walletParams: WalletParams & { signer: PasskeySigner };
+    existingSignerConfig?: PasskeySignerConfig;
+}
+
+export interface EOACreationParams extends WalletCreationParams {
+    walletParams: WalletParams & { signer: EOASigner };
+    existingSignerConfig?: EOASignerConfig;
+}
+
+export function isPasskeyCreationParams(params: WalletCreationParams): params is PasskeyCreationParams {
+    const hasPasskeyWalletParams =
+        "signer" in params.walletParams &&
+        "type" in params.walletParams.signer &&
+        params.walletParams.signer.type === "PASSKEY";
+
+    const signerIsPasskeyOrUndefined =
+        params.existingSignerConfig == null || params.existingSignerConfig.type === "passkeys";
+
+    return hasPasskeyWalletParams && signerIsPasskeyOrUndefined;
+}
+
+export function isEOACreationParams(params: WalletCreationParams): params is EOACreationParams {
+    const hasEOAWalletParams =
+        "signer" in params.walletParams &&
+        (("type" in params.walletParams.signer && params.walletParams.signer.type === "VIEM_ACCOUNT") ||
+            ("request" in params.walletParams.signer && typeof params.walletParams.signer.request === "function"));
+
+    const signerIsEOAOrUndefined = params.existingSignerConfig == null || params.existingSignerConfig.type === "eoa";
+
+    return hasEOAWalletParams && signerIsEOAOrUndefined;
 }
 
 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;
-};
+    signerConfig: SignerConfig;
+}
 
 export type SmartWalletClient = SmartAccountClient<EntryPoint, HttpTransport, Chain, SmartAccount<EntryPoint>>;

package/src/types/{Config.ts → params.ts}

@@ -1,8 +1,5 @@
-import type { EntryPoint } from "permissionless/types/entrypoint";
 import type { EIP1193Provider, LocalAccount } from "viem";
 
-import type { SupportedEntryPointVersion } from "./internal";
-
 export type SmartWalletSDKInitParams = {
     clientApiKey: string;
 };
@@ -31,5 +28,3 @@ export type EOASigner = EIP1193Provider | ViemAccount;
 export interface WalletParams {
     signer: EOASigner | PasskeySigner;
 }
-
-export type EntryPointDetails = { version: SupportedEntryPointVersion; address: EntryPoint };

package/src/types/schema.ts

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

@@ -0,0 +1,31 @@
+import { 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/utils/api.ts

@@ -0,0 +1,39 @@
+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/constants.ts

@@ -9,3 +9,5 @@ export const SDK_VERSION = "0.1.0";
 export const API_VERSION = "2024-06-09";
 export const BUNDLER_RPC = "https://rpc.zerodev.app/api/v2/bundler/";
 export const PAYMASTER_RPC = "https://rpc.zerodev.app/api/v2/paymaster/";
+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;