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

package/dist/index.d.cts

@@ -1,19 +1,29 @@
 import { ObjectValues } from '@crossmint/common-sdk-base';
 export { EVMBlockchainIncludingTestnet as Chain, blockchainToChainId } from '@crossmint/common-sdk-base';
-import { LocalAccount, EIP1193Provider, HttpTransport, Chain, Hex, PublicClient } from 'viem';
-import { PasskeyValidatorContractVersion } from '@zerodev/passkey-validator';
-import { SmartAccountClient } from 'permissionless';
+import { LocalAccount, EIP1193Provider, HttpTransport, Chain, PublicClient } from 'viem';
+import { SmartAccountClient, UserOperation } from 'permissionless';
+import { EntryPoint, GetEntryPointVersion } from 'permissionless/types/entrypoint';
+import { CrossmintSDKError, SmartWalletErrorCode } from '@crossmint/client-sdk-base';
+export { CrossmintSDKError, CrossmintServiceError, JWTDecryptionError, JWTExpiredError, JWTIdentifierError, JWTInvalidError, NotAuthorizedError, SmartWalletErrorCode, TransferError } from '@crossmint/client-sdk-base';
+import { z } from 'zod';
 import { SmartAccount } from 'permissionless/accounts';
-import { EntryPoint } from 'permissionless/types/entrypoint';
+import { PasskeyValidatorContractVersion } from '@zerodev/passkey-validator';
 
 declare const SmartWalletChain: {
     readonly BASE: "base";
     readonly POLYGON: "polygon";
+    readonly OPTIMISM: "optimism";
+    readonly ARBITRUM: "arbitrum";
     readonly BASE_SEPOLIA: "base-sepolia";
     readonly POLYGON_AMOY: "polygon-amoy";
+    readonly OPTIMISM_SEPOLIA: "optimism-sepolia";
+    readonly ARBITRUM_SEPOLIA: "arbitrum-sepolia";
 };
 type SmartWalletChain = ObjectValues<typeof SmartWalletChain>;
 
+declare const SUPPORTED_KERNEL_VERSIONS: readonly ["0.3.1", "0.3.0", "0.2.4"];
+declare const SUPPORTED_ENTRYPOINT_VERSIONS: readonly ["v0.6", "v0.7"];
+
 type SmartWalletSDKInitParams = {
     clientApiKey: string;
 };
@@ -40,21 +50,231 @@ interface WalletParams {
     signer: EOASigner | PasskeySigner;
 }
 
-declare const SUPPORTED_KERNEL_VERSIONS: readonly ["0.3.1", "0.3.0", "0.2.4"];
 type SupportedKernelVersion = (typeof SUPPORTED_KERNEL_VERSIONS)[number];
-declare const SUPPORTED_ENTRYPOINT_VERSIONS: readonly ["v0.6", "v0.7"];
 type SupportedEntryPointVersion = (typeof SUPPORTED_ENTRYPOINT_VERSIONS)[number];
-type PasskeyValidatorSerializedData = {
-    passkeyServerUrl: string;
-    entryPoint: Hex;
-    validatorAddress: Hex;
+type SmartWalletClient = SmartAccountClient<EntryPoint, HttpTransport, Chain, SmartAccount<EntryPoint>>;
+
+declare const EOASignerDataSchema: z.ZodObject<{
+    eoaAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    type: z.ZodLiteral<"eoa">;
+}, "strip", z.ZodTypeAny, {
+    type: "eoa";
+    eoaAddress: `0x${string}`;
+}, {
+    type: "eoa";
+    eoaAddress: `0x${string}`;
+}>;
+declare const PasskeySignerDataSchema: z.ZodObject<{
+    entryPoint: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    validatorAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    pubKeyX: z.ZodString;
+    pubKeyY: z.ZodString;
+    authenticatorIdHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    authenticatorId: z.ZodString;
+    passkeyName: z.ZodString;
+    validatorContractVersion: z.ZodNativeEnum<typeof PasskeyValidatorContractVersion>;
+    domain: z.ZodString;
+    type: z.ZodLiteral<"passkeys">;
+}, "strip", z.ZodTypeAny, {
+    type: "passkeys";
+    entryPoint: `0x${string}`;
+    domain: string;
+    validatorAddress: `0x${string}`;
     pubKeyX: string;
     pubKeyY: string;
-    authenticatorIdHash: Hex;
+    authenticatorIdHash: `0x${string}`;
     authenticatorId: string;
-};
-type SmartWalletClient = SmartAccountClient<EntryPoint, HttpTransport, Chain, SmartAccount<EntryPoint>>;
+    passkeyName: string;
+    validatorContractVersion: PasskeyValidatorContractVersion;
+}, {
+    type: "passkeys";
+    entryPoint: `0x${string}`;
+    domain: string;
+    validatorAddress: `0x${string}`;
+    pubKeyX: string;
+    pubKeyY: string;
+    authenticatorIdHash: `0x${string}`;
+    authenticatorId: string;
+    passkeyName: string;
+    validatorContractVersion: PasskeyValidatorContractVersion;
+}>;
+declare const SignerDataSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    entryPoint: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    validatorAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    pubKeyX: z.ZodString;
+    pubKeyY: z.ZodString;
+    authenticatorIdHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    authenticatorId: z.ZodString;
+    passkeyName: z.ZodString;
+    validatorContractVersion: z.ZodNativeEnum<typeof PasskeyValidatorContractVersion>;
+    domain: z.ZodString;
+    type: z.ZodLiteral<"passkeys">;
+}, "strip", z.ZodTypeAny, {
+    type: "passkeys";
+    entryPoint: `0x${string}`;
+    domain: string;
+    validatorAddress: `0x${string}`;
+    pubKeyX: string;
+    pubKeyY: string;
+    authenticatorIdHash: `0x${string}`;
+    authenticatorId: string;
+    passkeyName: string;
+    validatorContractVersion: PasskeyValidatorContractVersion;
+}, {
+    type: "passkeys";
+    entryPoint: `0x${string}`;
+    domain: string;
+    validatorAddress: `0x${string}`;
+    pubKeyX: string;
+    pubKeyY: string;
+    authenticatorIdHash: `0x${string}`;
+    authenticatorId: string;
+    passkeyName: string;
+    validatorContractVersion: PasskeyValidatorContractVersion;
+}>, z.ZodObject<{
+    eoaAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+    type: z.ZodLiteral<"eoa">;
+}, "strip", z.ZodTypeAny, {
+    type: "eoa";
+    eoaAddress: `0x${string}`;
+}, {
+    type: "eoa";
+    eoaAddress: `0x${string}`;
+}>]>;
+declare const SmartWalletConfigSchema: z.ZodObject<{
+    kernelVersion: z.ZodEnum<["0.3.1", "0.3.0", "0.2.4"]>;
+    entryPointVersion: z.ZodEnum<["v0.6", "v0.7"]>;
+    userId: z.ZodString;
+    signers: z.ZodArray<z.ZodObject<{
+        signerData: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            entryPoint: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            validatorAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            pubKeyX: z.ZodString;
+            pubKeyY: z.ZodString;
+            authenticatorIdHash: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            authenticatorId: z.ZodString;
+            passkeyName: z.ZodString;
+            validatorContractVersion: z.ZodNativeEnum<typeof PasskeyValidatorContractVersion>;
+            domain: z.ZodString;
+            type: z.ZodLiteral<"passkeys">;
+        }, "strip", z.ZodTypeAny, {
+            type: "passkeys";
+            entryPoint: `0x${string}`;
+            domain: string;
+            validatorAddress: `0x${string}`;
+            pubKeyX: string;
+            pubKeyY: string;
+            authenticatorIdHash: `0x${string}`;
+            authenticatorId: string;
+            passkeyName: string;
+            validatorContractVersion: PasskeyValidatorContractVersion;
+        }, {
+            type: "passkeys";
+            entryPoint: `0x${string}`;
+            domain: string;
+            validatorAddress: `0x${string}`;
+            pubKeyX: string;
+            pubKeyY: string;
+            authenticatorIdHash: `0x${string}`;
+            authenticatorId: string;
+            passkeyName: string;
+            validatorContractVersion: PasskeyValidatorContractVersion;
+        }>, z.ZodObject<{
+            eoaAddress: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
+            type: z.ZodLiteral<"eoa">;
+        }, "strip", z.ZodTypeAny, {
+            type: "eoa";
+            eoaAddress: `0x${string}`;
+        }, {
+            type: "eoa";
+            eoaAddress: `0x${string}`;
+        }>]>;
+    }, "strip", z.ZodTypeAny, {
+        signerData: {
+            type: "eoa";
+            eoaAddress: `0x${string}`;
+        } | {
+            type: "passkeys";
+            entryPoint: `0x${string}`;
+            domain: string;
+            validatorAddress: `0x${string}`;
+            pubKeyX: string;
+            pubKeyY: string;
+            authenticatorIdHash: `0x${string}`;
+            authenticatorId: string;
+            passkeyName: string;
+            validatorContractVersion: PasskeyValidatorContractVersion;
+        };
+    }, {
+        signerData: {
+            type: "eoa";
+            eoaAddress: `0x${string}`;
+        } | {
+            type: "passkeys";
+            entryPoint: `0x${string}`;
+            domain: string;
+            validatorAddress: `0x${string}`;
+            pubKeyX: string;
+            pubKeyY: string;
+            authenticatorIdHash: `0x${string}`;
+            authenticatorId: string;
+            passkeyName: string;
+            validatorContractVersion: PasskeyValidatorContractVersion;
+        };
+    }>, "many">;
+    smartContractWalletAddress: z.ZodOptional<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>>;
+}, "strip", z.ZodTypeAny, {
+    kernelVersion: "0.3.1" | "0.3.0" | "0.2.4";
+    entryPointVersion: "v0.6" | "v0.7";
+    userId: string;
+    signers: {
+        signerData: {
+            type: "eoa";
+            eoaAddress: `0x${string}`;
+        } | {
+            type: "passkeys";
+            entryPoint: `0x${string}`;
+            domain: string;
+            validatorAddress: `0x${string}`;
+            pubKeyX: string;
+            pubKeyY: string;
+            authenticatorIdHash: `0x${string}`;
+            authenticatorId: string;
+            passkeyName: string;
+            validatorContractVersion: PasskeyValidatorContractVersion;
+        };
+    }[];
+    smartContractWalletAddress?: `0x${string}` | undefined;
+}, {
+    kernelVersion: "0.3.1" | "0.3.0" | "0.2.4";
+    entryPointVersion: "v0.6" | "v0.7";
+    userId: string;
+    signers: {
+        signerData: {
+            type: "eoa";
+            eoaAddress: `0x${string}`;
+        } | {
+            type: "passkeys";
+            entryPoint: `0x${string}`;
+            domain: string;
+            validatorAddress: `0x${string}`;
+            pubKeyX: string;
+            pubKeyY: string;
+            authenticatorIdHash: `0x${string}`;
+            authenticatorId: string;
+            passkeyName: string;
+            validatorContractVersion: PasskeyValidatorContractVersion;
+        };
+    }[];
+    smartContractWalletAddress?: `0x${string}` | undefined;
+}>;
 
+type EOASignerData = z.infer<typeof EOASignerDataSchema>;
+type PasskeySignerData = z.infer<typeof PasskeySignerDataSchema>;
+type SmartWalletConfig = z.infer<typeof SmartWalletConfigSchema>;
+type SignerData = z.infer<typeof SignerDataSchema>;
+type PasskeyDisplay = Pick<PasskeySignerData, "type" | "passkeyName" | "pubKeyX" | "pubKeyY">;
+type SignerDisplay = EOASignerData | PasskeyDisplay;
 type StoreSmartWalletParams = {
     type: string;
     smartContractWalletAddress: string;
@@ -66,139 +286,59 @@ type StoreSmartWalletParams = {
     entryPointVersion: SupportedEntryPointVersion;
     kernelVersion: SupportedKernelVersion;
 };
-type SignerData = EOASignerData | PasskeySignerData;
-interface EOASignerData {
-    eoaAddress: string;
-    type: "eoa";
-}
-type PasskeySignerData = PasskeyValidatorSerializedData & {
-    passkeyName: string;
-    validatorContractVersion: PasskeyValidatorContractVersion;
-    domain: string;
-    type: "passkeys";
-};
-type PasskeyDisplay = Pick<PasskeySignerData, "type" | "passkeyName" | "pubKeyX" | "pubKeyY">;
-type SignerDisplay = EOASignerData | PasskeyDisplay;
 
-declare class LoggerWrapper {
-    private extraInfo;
-    private logIdempotencyKey;
-    constructor(className: string, extraInfo?: {}, logIdempotencyKey?: string);
-    private logInput;
-    private logOutput;
-    private logError;
-    protected logPerformance<T>(name: string, cb: () => Promise<T>): Promise<T>;
-}
-
-declare const SmartWalletErrors: {
-    readonly NOT_AUTHORIZED: "smart-wallet:not-authorized";
-    readonly TRANSFER: "smart-wallet:transfer.error";
-    readonly CROSSMINT_SERVICE: "smart-wallet:crossmint-service.error";
-    readonly ERROR_JWT_EXPIRED: "smart-wallet:not-authorized.jwt-expired";
-    readonly ERROR_JWT_INVALID: "smart-wallet:not-authorized.jwt-invalid";
-    readonly ERROR_JWT_DECRYPTION: "smart-wallet:not-authorized.jwt-decryption";
-    readonly ERROR_JWT_IDENTIFIER: "smart-wallet:not-authorized.jwt-identifier";
-    readonly ERROR_USER_WALLET_ALREADY_CREATED: "smart-wallet:user-wallet-already-created.error";
-    readonly ERROR_OUT_OF_CREDITS: "smart-wallet:out-of-credits.error";
-    readonly ERROR_WALLET_CONFIG: "smart-wallet:wallet-config.error";
-    readonly ERROR_ADMIN_MISMATCH: "smart-wallet:wallet-config.admin-mismatch";
-    readonly ERROR_PASSKEY_MISMATCH: "smart-wallet:wallet-config.passkey-mismatch";
-    readonly ERROR_PASSKEY_PROMPT: "smart-wallet:passkey.prompt";
-    readonly ERROR_PASSKEY_INCOMPATIBLE_AUTHENTICATOR: "smart-wallet.passkey.incompatible-authenticator";
-    readonly ERROR_PASSKEY_REGISTRATION: "smart-wallet:passkey.registration";
-    readonly ERROR_ADMIN_SIGNER_ALREADY_USED: "smart-wallet:wallet-config.admin-signer-already-used";
-    readonly ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED: "smart-wallet:wallet-config.non-custodial-wallets-not-enabled";
-    readonly UNCATEGORIZED: "smart-wallet:uncategorized";
-};
-type SmartWalletErrorCode = (typeof SmartWalletErrors)[keyof typeof SmartWalletErrors];
-declare class SmartWalletSDKError extends Error {
-    readonly code: SmartWalletErrorCode;
-    readonly details?: string;
+declare class SmartWalletError extends CrossmintSDKError {
     constructor(message: string, details?: string, code?: SmartWalletErrorCode);
 }
-declare class TransferError extends SmartWalletSDKError {
-    constructor(message: string);
-}
-declare class CrossmintServiceError extends SmartWalletSDKError {
-    status?: number;
-    constructor(message: string, status?: number);
-}
-declare class AdminMismatchError extends SmartWalletSDKError {
+declare class AdminMismatchError extends SmartWalletError {
     readonly required: SignerDisplay;
     readonly used?: SignerDisplay;
     constructor(message: string, required: SignerDisplay, used?: SignerDisplay);
 }
-declare class PasskeyMismatchError extends SmartWalletSDKError {
+declare class PasskeyMismatchError extends SmartWalletError {
     readonly required: PasskeyDisplay;
     readonly used?: PasskeyDisplay;
     constructor(message: string, required: PasskeyDisplay, used?: PasskeyDisplay);
 }
-declare class NotAuthorizedError extends SmartWalletSDKError {
-    constructor(message: string);
-}
-declare class JWTExpiredError extends NotAuthorizedError {
-    readonly code: "smart-wallet:not-authorized.jwt-expired";
-    /**
-     * The expiry time of the JWT as an ISO 8601 timestamp.
-     */
-    readonly expiredAt: string;
-    constructor(expiredAt: Date);
-}
-declare class JWTInvalidError extends NotAuthorizedError {
-    readonly code: "smart-wallet:not-authorized.jwt-invalid";
-    constructor();
-}
-declare class JWTDecryptionError extends NotAuthorizedError {
-    readonly code: "smart-wallet:not-authorized.jwt-decryption";
-    constructor();
-}
-declare class JWTIdentifierError extends NotAuthorizedError {
-    readonly code: "smart-wallet:not-authorized.jwt-identifier";
-    readonly identifierKey: string;
-    constructor(identifierKey: string);
-}
-declare class UserWalletAlreadyCreatedError extends SmartWalletSDKError {
-    readonly code: "smart-wallet:user-wallet-already-created.error";
+declare class UserWalletAlreadyCreatedError extends SmartWalletError {
+    readonly code: "smart-wallet:user-wallet-already-created";
     constructor(userId: string);
 }
-declare class PasskeyPromptError extends SmartWalletSDKError {
+declare class PasskeyPromptError extends SmartWalletError {
     passkeyName: string;
     constructor(passkeyName: string);
 }
-declare class PasskeyRegistrationError extends SmartWalletSDKError {
+declare class PasskeyRegistrationError extends SmartWalletError {
     passkeyName: string;
     constructor(passkeyName: string);
 }
-declare class PasskeyIncompatibleAuthenticatorError extends SmartWalletSDKError {
+declare class PasskeyIncompatibleAuthenticatorError extends SmartWalletError {
     passkeyName: string;
     constructor(passkeyName: string);
 }
-declare class OutOfCreditsError extends SmartWalletSDKError {
-    constructor(message?: string);
-}
-declare class ConfigError extends SmartWalletSDKError {
+declare class ConfigError extends SmartWalletError {
     constructor(message: string);
 }
 declare class AdminAlreadyUsedError extends ConfigError {
-    readonly code: "smart-wallet:wallet-config.admin-signer-already-used";
+    readonly code: "smart-wallet:config.admin-signer-already-used";
     constructor();
 }
-declare class NonCustodialWalletsNotEnabledError extends ConfigError {
-    readonly code: "smart-wallet:wallet-config.non-custodial-wallets-not-enabled";
+declare class SmartWalletsNotEnabledError extends ConfigError {
+    readonly code: "smart-wallet:not-enabled";
     constructor();
 }
 
 type CrossmintAPIErrorCodes = "ERROR_JWT_INVALID" | "ERROR_JWT_DECRYPTION" | "ERROR_JWT_IDENTIFIER" | "ERROR_JWT_EXPIRED" | "ERROR_USER_WALLET_ALREADY_CREATED" | "ERROR_ADMIN_SIGNER_ALREADY_USED" | "ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED";
 declare class APIErrorService {
     private errors;
-    constructor(errors?: Partial<Record<CrossmintAPIErrorCodes, (apiResponse: any) => SmartWalletSDKError>>);
+    constructor(errors?: Record<CrossmintAPIErrorCodes, (apiResponse: any) => SmartWalletError>);
     throwErrorFromResponse({ response, onServerErrorMessage, }: {
         response: Response;
         onServerErrorMessage: string;
     }): Promise<void>;
 }
 
-declare abstract class BaseCrossmintService extends LoggerWrapper {
+declare abstract class BaseCrossmintService {
     crossmintAPIHeaders: Record<string, string>;
     protected crossmintBaseUrl: string;
     protected apiErrorService: APIErrorService;
@@ -212,16 +352,11 @@ declare abstract class BaseCrossmintService extends LoggerWrapper {
 }
 
 declare class CrossmintWalletService extends BaseCrossmintService {
-    idempotentCreateSmartWallet(user: UserParams, input: StoreSmartWalletParams): Promise<any>;
-    getSmartWalletConfig(user: UserParams, chain: SmartWalletChain): Promise<{
-        kernelVersion: string;
-        entryPointVersion: string;
-        userId: string;
-        signers: {
-            signerData: SignerData;
-        }[];
-        smartContractWalletAddress?: string;
+    idempotentCreateSmartWallet(user: UserParams, input: StoreSmartWalletParams): Promise<void>;
+    sponsorUserOperation<E extends EntryPoint>(user: UserParams, userOp: UserOperation<GetEntryPointVersion<E>>, entryPoint: E, chain: SmartWalletChain): Promise<{
+        sponsorUserOpParams: UserOperation<GetEntryPointVersion<E>>;
     }>;
+    getSmartWalletConfig(user: UserParams, chain: SmartWalletChain): Promise<SmartWalletConfig>;
     fetchNFTs(address: string, chain: SmartWalletChain): Promise<any>;
     getPasskeyServerUrl(): string;
 }
@@ -258,7 +393,7 @@ type TransferType = ERC20TransferType | SFTTransferType | NFTTransferType;
  * Smart wallet interface for EVM chains enhanced with Crossmint capabilities.
  * Core functionality is exposed via [viem](https://viem.sh/) clients within the `client` property of the class.
  */
-declare class EVMSmartWallet extends LoggerWrapper {
+declare class EVMSmartWallet {
     private readonly crossmintService;
     private readonly accountClient;
     readonly chain: SmartWalletChain;
@@ -290,7 +425,7 @@ declare class EVMSmartWallet extends LoggerWrapper {
     nfts(): Promise<any>;
 }
 
-declare class SmartWalletSDK extends LoggerWrapper {
+declare class SmartWalletSDK {
     private readonly smartWalletService;
     private readonly errorProcessor;
     private constructor();
@@ -311,4 +446,4 @@ declare class SmartWalletSDK extends LoggerWrapper {
     getOrCreateWallet(user: UserParams, chain: SmartWalletChain, walletParams?: WalletParams): Promise<EVMSmartWallet>;
 }
 
-export { AdminAlreadyUsedError, AdminMismatchError, ConfigError, CrossmintServiceError, type EOASigner, type ERC20TransferType, EVMSmartWallet, JWTDecryptionError, JWTExpiredError, JWTIdentifierError, JWTInvalidError, type NFTTransferType, NonCustodialWalletsNotEnabledError, NotAuthorizedError, OutOfCreditsError, PasskeyIncompatibleAuthenticatorError, PasskeyMismatchError, PasskeyPromptError, PasskeyRegistrationError, type PasskeySigner, type SFTTransferType, SmartWalletSDK, SmartWalletSDKError, type SmartWalletSDKInitParams, TransferError, type TransferType, type UserParams, UserWalletAlreadyCreatedError, type ViemAccount, type WalletParams };
+export { AdminAlreadyUsedError, AdminMismatchError, ConfigError, type EOASigner, type ERC20TransferType, EVMSmartWallet, type NFTTransferType, PasskeyIncompatibleAuthenticatorError, PasskeyMismatchError, PasskeyPromptError, PasskeyRegistrationError, type PasskeySigner, type SFTTransferType, SmartWalletError, SmartWalletSDK, type SmartWalletSDKInitParams, SmartWalletsNotEnabledError, type TransferType, type UserParams, UserWalletAlreadyCreatedError, type ViemAccount, type WalletParams };