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

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

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

package/src/blockchain/wallets/clientDecorator.ts

@@ -4,9 +4,8 @@ import { stringify } from "viem";
 
 import { SmartWalletError } from "../../error";
 import { ErrorProcessor } from "../../error/processor";
-import { logInfo } from "../../services/logging";
+import { scwLogger } from "../../services";
 import { usesGelatoBundler } from "../../utils/blockchain";
-import { logPerformance } from "../../utils/log";
 import { SmartWalletChain } from "../chains";
 
 const transactionMethods = [
@@ -38,7 +37,7 @@ function isSignMethod(method: string): method is SignMethod {
  * - Automatic formatting of transactions for Gelato bundler compatibility.
  *  */
 export class ClientDecorator {
-    constructor(private readonly errorProcessor: ErrorProcessor) {}
+    constructor(private readonly errorProcessor: ErrorProcessor, protected logger = scwLogger) {}
 
     public decorate<Client extends SmartAccountClient<EntryPoint>>({
         crossmintChain,
@@ -60,7 +59,7 @@ export class ClientDecorator {
                 }
 
                 return (...args: any[]) =>
-                    logPerformance(`CrossmintSmartWallet.${prop}`, () =>
+                    this.logger.logPerformance(`CrossmintSmartWallet.${prop}`, () =>
                         this.execute(target, prop, originalMethod, args, crossmintChain)
                     );
             },
@@ -76,7 +75,7 @@ export class ClientDecorator {
         crossmintChain: SmartWalletChain
     ) {
         try {
-            logInfo(`[CrossmintSmartWallet.${prop}] - params: ${stringify(args)}`);
+            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) {

package/src/blockchain/wallets/service.ts

@@ -12,7 +12,7 @@ import { CURRENT_VERSION, ZERO_DEV_TYPE } from "../../utils/constants";
 import { equalsIgnoreCase } from "../../utils/helpers";
 import { type SmartWalletChain, getBundlerRPC, viemNetworks } from "../chains";
 import { EVMSmartWallet } from "./EVMSmartWallet";
-import type { AccountConfigFacade } from "./account/config";
+import type { AccountConfigService } from "./account/config";
 import type { AccountCreator } from "./account/creator";
 import type { ClientDecorator } from "./clientDecorator";
 import { paymasterMiddleware, usePaymaster } from "./paymaster";
@@ -20,7 +20,7 @@ import { paymasterMiddleware, usePaymaster } from "./paymaster";
 export class SmartWalletService {
     constructor(
         private readonly crossmintService: CrossmintWalletService,
-        private readonly accountConfigFacade: AccountConfigFacade,
+        private readonly accountConfigService: AccountConfigService,
         private readonly accountCreator: AccountCreator,
         private readonly clientDecorator: ClientDecorator
     ) {}
@@ -30,28 +30,24 @@ export class SmartWalletService {
         chain: SmartWalletChain,
         walletParams: WalletParams
     ): Promise<EVMSmartWallet> {
-        const { entryPointVersion, kernelVersion, existingSignerConfig, smartContractWalletAddress, userId } =
-            await this.accountConfigFacade.get(user, chain);
+        const {
+            config: { entryPointVersion, kernelVersion, existing, userWithId },
+            cached,
+        } = await this.accountConfigService.get(user, chain);
+
         const publicClient = createPublicClient({ transport: http(getBundlerRPC(chain)) });
 
         const { account, signerConfig } = await this.accountCreator.get({
             chain,
             walletParams,
             publicClient,
-            user: { ...user, id: userId },
-            entryPoint: {
-                version: entryPointVersion,
-                address: entryPointVersion === "v0.6" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,
-            },
+            user: userWithId,
+            entryPoint: entryPointVersion === "v0.6" ? ENTRYPOINT_ADDRESS_V06 : ENTRYPOINT_ADDRESS_V07,
             kernelVersion,
-            existingSignerConfig,
+            existing,
         });
 
-        if (smartContractWalletAddress != null && !equalsIgnoreCase(smartContractWalletAddress, account.address)) {
-            throw new UserWalletAlreadyCreatedError(userId);
-        }
-
-        if (existingSignerConfig == null) {
+        if (existing == null) {
             await this.crossmintService.idempotentCreateSmartWallet(user, {
                 type: ZERO_DEV_TYPE,
                 smartContractWalletAddress: account.address,
@@ -64,6 +60,15 @@ export class SmartWalletService {
             });
         }
 
+        if (!cached) {
+            this.accountConfigService.cache({
+                entryPointVersion,
+                kernelVersion,
+                user: userWithId,
+                existing: { address: account.address, signerConfig },
+            });
+        }
+
         const kernelAccountClient: SmartWalletClient = createKernelAccountClient({
             account,
             chain: viemNetworks[chain],

package/src/error/processor.ts

@@ -1,11 +1,12 @@
 import { BaseError, stringify } from "viem";
 
+import { SDKLogger } from "@crossmint/client-sdk-base";
+
 import { SmartWalletError } from ".";
-import { DatadogProvider } from "../services/logging/DatadogProvider";
 import { SDK_VERSION } from "../utils/constants";
 
 export class ErrorProcessor {
-    constructor(private readonly logger: DatadogProvider) {}
+    constructor(private readonly logger: SDKLogger) {}
 
     public map(error: unknown, fallback: SmartWalletError): SmartWalletError | BaseError {
         this.record(error);
@@ -24,7 +25,7 @@ export class ErrorProcessor {
 
     private record(error: unknown) {
         const message = error instanceof Error ? error.message : String(error);
-        this.logger.logError(`Smart Wallet SDK Error: ${message}`, {
+        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),

package/src/services/index.ts

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

package/src/services/logger.ts

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

@@ -2,7 +2,7 @@ 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, HttpTransport, PublicClient } from "viem";
+import type { Address, Chain, HttpTransport, PublicClient } from "viem";
 
 import type { SmartWalletChain } from "../blockchain/chains";
 import type { EOASignerConfig, PasskeySignerConfig, SignerConfig } from "../blockchain/wallets/account/signer";
@@ -19,47 +19,53 @@ export function isSupportedEntryPointVersion(version: string): version is Suppor
     return SUPPORTED_ENTRYPOINT_VERSIONS.includes(version as any);
 }
 
-export interface WalletCreationParams {
+export interface PreExistingWalletProperties {
+    signerConfig: SignerConfig;
+    address: Address;
+}
+
+export interface WalletCreationContext {
     user: UserParams & { id: string };
     chain: SmartWalletChain;
     publicClient: PublicClient<HttpTransport>;
     walletParams: WalletParams;
-    entryPoint: { version: SupportedEntryPointVersion; address: EntryPoint };
+    entryPoint: EntryPoint;
     kernelVersion: SupportedKernelVersion;
-    existingSignerConfig?: SignerConfig;
+    existing?: PreExistingWalletProperties;
 }
 
-export interface PasskeyCreationParams extends WalletCreationParams {
+export interface PasskeyCreationContext extends WalletCreationContext {
     walletParams: WalletParams & { signer: PasskeySigner };
-    existingSignerConfig?: PasskeySignerConfig;
+    existing?: { signerConfig: PasskeySignerConfig; address: Address };
 }
 
-export interface EOACreationParams extends WalletCreationParams {
+export interface EOACreationContext extends WalletCreationContext {
     walletParams: WalletParams & { signer: EOASigner };
-    existingSignerConfig?: EOASignerConfig;
+    existing?: { signerConfig: EOASignerConfig; address: Address };
 }
 
-export function isPasskeyCreationParams(params: WalletCreationParams): params is PasskeyCreationParams {
-    const hasPasskeyWalletParams =
-        "signer" in params.walletParams &&
-        "type" in params.walletParams.signer &&
-        params.walletParams.signer.type === "PASSKEY";
+export function isPasskeyWalletParams(params: WalletParams): params is WalletParams & { signer: PasskeySigner } {
+    return "signer" in params && "type" in params.signer && params.signer.type === "PASSKEY";
+}
 
-    const signerIsPasskeyOrUndefined =
-        params.existingSignerConfig == null || params.existingSignerConfig.type === "passkeys";
+export function isPasskeyCreationContext(params: WalletCreationContext): params is PasskeyCreationContext {
+    const signerIsPasskeyOrUndefined = params.existing == null || params.existing.signerConfig.type === "passkeys";
 
-    return hasPasskeyWalletParams && signerIsPasskeyOrUndefined;
+    return isPasskeyWalletParams(params.walletParams) && 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"));
+export function isEOAWalletParams(params: WalletParams): params is WalletParams & { signer: EOASigner } {
+    return (
+        "signer" in params &&
+        (("type" in params.signer && params.signer.type === "VIEM_ACCOUNT") ||
+            ("request" in params.signer && typeof params.signer.request === "function"))
+    );
+}
 
-    const signerIsEOAOrUndefined = params.existingSignerConfig == null || params.existingSignerConfig.type === "eoa";
+export function isEOACreationContext(params: WalletCreationContext): params is EOACreationContext {
+    const signerIsEOAOrUndefined = params.existing == null || params.existing.signerConfig.type === "eoa";
 
-    return hasEOAWalletParams && signerIsEOAOrUndefined;
+    return isEOAWalletParams(params.walletParams) && signerIsEOAOrUndefined;
 }
 
 export interface AccountAndSigner {

package/src/utils/constants.ts

@@ -1,9 +1,5 @@
 export const ZERO_DEV_TYPE = "ZeroDev";
 export const CURRENT_VERSION = 0;
-export const DATADOG_CLIENT_TOKEN = "pub035be8a594b35be1887b6ba76c4029ca";
-export const CROSSMINT_DEV_URL = "http://localhost:3000/api";
-export const CROSSMINT_STG_URL = "https://staging.crossmint.com/api";
-export const CROSSMINT_PROD_URL = "https://www.crossmint.com/api";
 export const SCW_SERVICE = "SCW_SDK";
 export const SDK_VERSION = "0.1.0";
 export const API_VERSION = "2024-06-09";

package/src/utils/helpers.ts

@@ -1,11 +1,3 @@
-export function isLocalhost() {
-    if (process.env.NODE_ENV === "test") {
-        return false;
-    }
-
-    return window.location.origin.includes("localhost");
-}
-
 export function isEmpty(str: string | undefined | null): str is undefined | null {
     return !str || str.length === 0 || str.trim().length === 0;
 }

package/src/utils/test.ts

@@ -0,0 +1,24 @@
+import { SmartWalletConfig } from "../types/service";
+
+export const mockConfig: SmartWalletConfig = {
+    kernelVersion: "0.3.1",
+    entryPointVersion: "v0.7",
+    userId: "devlyn@paella.dev",
+    signers: [
+        {
+            signerData: {
+                entryPoint: "0x0000000071727De22E5E9d8BAf0edAc6f37da032",
+                validatorAddress: "0xbA45a2BFb8De3D24cA9D7F1B551E14dFF5d690Fd",
+                pubKeyX: "110311240024954100085667226472791468894960420468782293097673057837941382345525",
+                pubKeyY: "55639753423913323920634804373610812340711881298092778447611544058799129775494",
+                authenticatorIdHash: "0xb7f951026ad956257e41c16f5e6c1c8969968356c9a8a8df916fcceda53f5c6a",
+                authenticatorId: "u76dDdMEjTBgm68gbqfbaAlSoqE",
+                passkeyName: "devlyn@paella.dev",
+                validatorContractVersion: "0.0.2" as any,
+                domain: "localhost",
+                type: "passkeys",
+            },
+        },
+    ],
+    smartContractWalletAddress: "0x7EAf93269C06Af4236E08d16d5220Df5f964eD87",
+};

package/src/api/APIErrorService.ts

@@ -1,78 +0,0 @@
-import {
-    CrossmintServiceError,
-    JWTDecryptionError,
-    JWTExpiredError,
-    JWTIdentifierError,
-    JWTInvalidError,
-    OutOfCreditsError,
-} from "@crossmint/client-sdk-base";
-
-import {
-    AdminAlreadyUsedError,
-    SmartWalletError,
-    SmartWalletsNotEnabledError,
-    UserWalletAlreadyCreatedError,
-} from "../error";
-
-export 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";
-
-export class APIErrorService {
-    constructor(
-        private errors: Record<CrossmintAPIErrorCodes, (apiResponse: any) => SmartWalletError> = {
-            ERROR_JWT_INVALID: () => new JWTInvalidError(),
-            ERROR_JWT_DECRYPTION: () => new JWTDecryptionError(),
-            ERROR_JWT_EXPIRED: ({ expiredAt }: { expiredAt: string }) => new JWTExpiredError(new Date(expiredAt)),
-            ERROR_JWT_IDENTIFIER: ({ identifierKey }: { identifierKey: string }) =>
-                new JWTIdentifierError(identifierKey),
-            ERROR_USER_WALLET_ALREADY_CREATED: ({ userId }: { userId: string }) =>
-                new UserWalletAlreadyCreatedError(userId),
-            ERROR_ADMIN_SIGNER_ALREADY_USED: () => new AdminAlreadyUsedError(),
-            ERROR_PROJECT_NONCUSTODIAL_WALLETS_NOT_ENABLED: () => new SmartWalletsNotEnabledError(),
-        }
-    ) {}
-
-    async throwErrorFromResponse({
-        response,
-        onServerErrorMessage,
-    }: {
-        response: Response;
-        onServerErrorMessage: string;
-    }) {
-        if (response.ok) {
-            return;
-        }
-
-        if (response.status >= 500) {
-            throw new CrossmintServiceError(onServerErrorMessage, response.status);
-        }
-
-        if (response.status === 402) {
-            throw new OutOfCreditsError();
-        }
-
-        try {
-            const body = await response.json();
-            const code = body.code as CrossmintAPIErrorCodes | undefined;
-            if (code != null && this.errors[code] != null) {
-                throw this.errors[code](body);
-            }
-            if (body.message != null) {
-                throw new CrossmintServiceError(body.message, response.status);
-            }
-        } catch (e) {
-            if (e instanceof SmartWalletError) {
-                throw e;
-            }
-            console.error("Error parsing response", e);
-        }
-
-        throw new CrossmintServiceError(await response.text(), response.status);
-    }
-}

package/src/api/BaseCrossmintService.ts

@@ -1,81 +0,0 @@
-import { CrossmintServiceError } from "@crossmint/client-sdk-base";
-import { validateAPIKey } from "@crossmint/common-sdk-base";
-
-import { CROSSMINT_DEV_URL, CROSSMINT_PROD_URL, CROSSMINT_STG_URL } from "../utils/constants";
-import { logPerformance } from "../utils/log";
-import { APIErrorService } from "./APIErrorService";
-
-export abstract class BaseCrossmintService {
-    public crossmintAPIHeaders: Record<string, string>;
-    protected crossmintBaseUrl: string;
-    protected apiErrorService: APIErrorService;
-    private static urlMap: Record<string, string> = {
-        development: CROSSMINT_DEV_URL,
-        staging: CROSSMINT_STG_URL,
-        production: CROSSMINT_PROD_URL,
-    };
-
-    constructor(apiKey: string) {
-        const result = validateAPIKey(apiKey);
-        if (!result.isValid) {
-            throw new Error("API key invalid");
-        }
-        this.crossmintAPIHeaders = {
-            accept: "application/json",
-            "content-type": "application/json",
-            "x-api-key": apiKey,
-        };
-        this.crossmintBaseUrl = this.getUrlFromEnv(result.environment);
-        this.apiErrorService = new APIErrorService();
-    }
-
-    protected async fetchCrossmintAPI(
-        endpoint: string,
-        options: { body?: string; method: string } = { method: "GET" },
-        onServerErrorMessage: string,
-        authToken?: string
-    ) {
-        return logPerformance(
-            "FETCH_CROSSMINT_API",
-            async () => {
-                const url = `${this.crossmintBaseUrl}/${endpoint}`;
-                const { body, method } = options;
-
-                let response: Response;
-                try {
-                    response = await fetch(url, {
-                        body,
-                        method,
-                        headers: {
-                            ...this.crossmintAPIHeaders,
-                            ...(authToken != null && {
-                                Authorization: `Bearer ${authToken}`,
-                            }),
-                        },
-                    });
-                } catch (error) {
-                    throw new CrossmintServiceError(`Error fetching Crossmint API: ${error}`);
-                }
-
-                if (!response.ok) {
-                    await this.apiErrorService.throwErrorFromResponse({
-                        response,
-                        onServerErrorMessage,
-                    });
-                }
-
-                return await response.json();
-            },
-            { endpoint }
-        );
-    }
-
-    protected getUrlFromEnv(environment: string) {
-        const url = BaseCrossmintService.urlMap[environment];
-        if (!url) {
-            console.log(" CrossmintService.urlMap: ", BaseCrossmintService.urlMap);
-            throw new Error(`URL not found for environment: ${environment}`);
-        }
-        return url;
-    }
-}

package/src/services/logging/BrowserLoggerInterface.ts

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

@@ -1,15 +0,0 @@
-import { BrowserLoggerInterface } from "./BrowserLoggerInterface";
-
-export class ConsoleProvider implements BrowserLoggerInterface {
-    logInfo(message: string, context?: object) {
-        console.log(message, context);
-    }
-
-    logError(message: string, context?: object) {
-        console.error(message, context);
-    }
-
-    logWarn(message: string, context?: object) {
-        console.warn(message, context);
-    }
-}

package/src/services/logging/DatadogProvider.ts

@@ -1,39 +0,0 @@
-import { datadogLogs } from "@datadog/browser-logs";
-
-import { DATADOG_CLIENT_TOKEN, SCW_SERVICE } from "../../utils/constants";
-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

@@ -1,16 +0,0 @@
-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/utils/log.ts

@@ -1,49 +0,0 @@
-import { logError, logInfo } from "../services/logging";
-import { SCW_SERVICE } from "./constants";
-
-export async function logPerformance<T>(name: string, cb: () => Promise<T>, extraInfo?: object) {
-    const start = new Date().getTime();
-    const result = await cb();
-    const durationInMs = new Date().getTime() - start;
-    const args = { durationInMs, ...extraInfo };
-    logInfo(`[${SCW_SERVICE} - ${name} - TIME] - ${beautify(args)}`, { args });
-    return result;
-}
-
-function beautify(json: any) {
-    try {
-        return json != null ? JSON.stringify(json, null, 2) : json;
-    } catch (error) {
-        return stringifyAvoidingCircular(json);
-    }
-}
-
-function stringifyAvoidingCircular(json: any) {
-    // stringify an object, avoiding circular structures
-    // https://stackoverflow.com/a/31557814
-    const simpleObject: { [key: string]: any } = {};
-    for (const prop in json) {
-        if (!Object.prototype.hasOwnProperty.call(json, prop)) {
-            continue;
-        }
-        if (typeof json[prop] == "object") {
-            continue;
-        }
-        if (typeof json[prop] == "function") {
-            continue;
-        }
-        simpleObject[prop] = json[prop];
-    }
-    return JSON.stringify(simpleObject, null, 2); // returns cleaned up JSON
-}
-
-export function errorToJSON(error: Error | unknown) {
-    const errorToLog = error instanceof Error ? error : { message: "Unknown error", name: "Unknown error" };
-
-    if (!(errorToLog instanceof Error) && (errorToLog as any).constructor?.name !== "SyntheticBaseEvent") {
-        logError("ERROR_TO_JSON_FAILED", { error: errorToLog });
-        throw new Error("[errorToJSON] err is not instanceof Error nor SyntheticBaseEvent");
-    }
-
-    return JSON.parse(JSON.stringify(errorToLog, Object.getOwnPropertyNames(errorToLog)));
-}