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

package/src/utils/log.ts

@@ -1,115 +1,15 @@
-import { v4 as uuidv4 } from "uuid";
-
 import { logError, logInfo } from "../services/logging";
 import { SCW_SERVICE } from "./constants";
-import { isLocalhost } from "./helpers";
-
-export class LoggerWrapper {
-    constructor(className: string, private extraInfo = {}, private logIdempotencyKey = uuidv4()) {
-        return new Proxy(this, {
-            get: (target: any, propKey: PropertyKey, receiver: any) => {
-                const origMethod = target[propKey];
-                const identifierTag = `[${SCW_SERVICE} - ${className} - ${String(propKey)}]`;
-
-                if (typeof origMethod === "function") {
-                    return (...args: any[]) => {
-                        this.logInput(args, identifierTag);
-
-                        const result = origMethod.apply(target, args);
-                        if (result instanceof Promise) {
-                            return result
-                                .then((res: any) => {
-                                    this.logOutput(res, identifierTag);
-                                    return res;
-                                })
-                                .catch((err: any) => {
-                                    this.logError(err, identifierTag);
-                                    throw err;
-                                });
-                        } else {
-                            this.logOutput(result, identifierTag);
-                            return result;
-                        }
-                    };
-                }
-                return Reflect.get(target, propKey, receiver);
-            },
-        });
-    }
-
-    private logInput(args: object, identifierTag: string) {
-        logInfoIfNotInLocalhost(
-            `${identifierTag} input - ${beautify(args)} - extra_info - ${beautify(
-                this.extraInfo
-            )} - log_idempotency_key - ${this.logIdempotencyKey}`,
-            { args, ...this.extraInfo, logIdempotencyKey: this.logIdempotencyKey }
-        );
-    }
-
-    private logOutput(res: object, identifierTag: string) {
-        logInfoIfNotInLocalhost(
-            `${identifierTag} output - ${beautify(res)} - extra_info - ${beautify(
-                this.extraInfo
-            )} - log_idempotency_key - ${this.logIdempotencyKey}`,
-            {
-                res,
-                ...this.extraInfo,
-                logIdempotencyKey: this.logIdempotencyKey,
-            }
-        );
-    }
-
-    private logError(err: object, identifierTag: string) {
-        logError(
-            `${identifierTag} threw_error - ${err} - extra_info - ${beautify(this.extraInfo)} - log_idempotency_key - ${
-                this.logIdempotencyKey
-            }`,
-            { err, ...this.extraInfo }
-        );
-    }
-
-    protected logPerformance<T>(name: string, cb: () => Promise<T>) {
-        return logPerformance(name, cb, this.extraInfo);
-    }
-}
 
 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 };
-    logInfoIfNotInLocalhost(`[${SCW_SERVICE} - ${name} - TIME] - ${beautify(args)}`, { args });
+    logInfo(`[${SCW_SERVICE} - ${name} - TIME] - ${beautify(args)}`, { args });
     return result;
 }
 
-export function logInputOutput<T, A extends any[]>(fn: (...args: A) => T, functionName: string): (...args: A) => T {
-    return function (this: any, ...args: A): T {
-        const identifierTag = `[${SCW_SERVICE} - function: ${functionName}]`;
-        logInfoIfNotInLocalhost(`${identifierTag} input: ${beautify(args)}`, { args });
-
-        try {
-            const result = fn.apply(this, args);
-            if (result instanceof Promise) {
-                return result
-                    .then((res) => {
-                        logInfoIfNotInLocalhost(`${identifierTag} output: ${beautify(res)}`, { res });
-                        return res;
-                    })
-                    .catch((err) => {
-                        logError(`${identifierTag} threw_error: ${beautify(err)}`, { err });
-                        throw err;
-                    }) as T;
-            } else {
-                logInfoIfNotInLocalhost(`${identifierTag} output: ${beautify(result)}`, { res: result });
-                return result;
-            }
-        } catch (err) {
-            logError(`${identifierTag} threw_error: ${beautify(err)}`, { err });
-            throw err;
-        }
-    };
-}
-
 function beautify(json: any) {
     try {
         return json != null ? JSON.stringify(json, null, 2) : json;
@@ -137,14 +37,6 @@ function stringifyAvoidingCircular(json: any) {
     return JSON.stringify(simpleObject, null, 2); // returns cleaned up JSON
 }
 
-function logInfoIfNotInLocalhost(message: string, context?: object) {
-    if (isLocalhost()) {
-        console.log(message);
-        return;
-    }
-    logInfo(message, context);
-}
-
 export function errorToJSON(error: Error | unknown) {
     const errorToLog = error instanceof Error ? error : { message: "Unknown error", name: "Unknown error" };
 

package/src/utils/signer.ts

@@ -3,28 +3,26 @@ import type { SmartAccountSigner } from "permissionless/accounts";
 import { Address, EIP1193Provider } from "viem";
 
 import { SmartWalletChain } from "../blockchain/chains";
-import { SmartWalletSDKError } from "../error";
-import { ViemAccount, WalletParams } from "../types/Config";
-import { logInputOutput } from "./log";
+import { SmartWalletError } from "../error";
+import { ViemAccount, WalletParams } from "../types/params";
 
 type CreateOwnerSignerInput = {
     chain: SmartWalletChain;
     walletParams: WalletParams;
 };
 
-export const createOwnerSigner = logInputOutput(
-    async ({ walletParams }: CreateOwnerSignerInput): Promise<SmartAccountSigner<"custom", Address>> => {
-        if (isEIP1193Provider(walletParams.signer)) {
-            return await providerToSmartAccountSigner(walletParams.signer);
-        } else if (isAccount(walletParams.signer)) {
-            return walletParams.signer.account;
-        } else {
-            const signer = walletParams.signer as any;
-            throw new SmartWalletSDKError(`The signer type ${signer.type} is not supported`);
-        }
-    },
-    "createOwnerSigner"
-);
+export async function createOwnerSigner({
+    walletParams,
+}: CreateOwnerSignerInput): Promise<SmartAccountSigner<"custom", Address>> {
+    if (isEIP1193Provider(walletParams.signer)) {
+        return await providerToSmartAccountSigner(walletParams.signer);
+    } else if (isAccount(walletParams.signer)) {
+        return walletParams.signer.account;
+    } else {
+        const signer = walletParams.signer as any;
+        throw new SmartWalletError(`The signer type ${signer.type} is not supported`);
+    }
+}
 
 function isEIP1193Provider(signer: any): signer is EIP1193Provider {
     return signer && typeof signer.request === "function";

package/src/blockchain/wallets/eoa.ts

@@ -1,49 +0,0 @@
-import { EOASignerData } from "@/types/API";
-import type { EOASigner, WalletParams } from "@/types/Config";
-import { AccountAndSigner, WalletCreationParams } from "@/types/internal";
-import { equalsIgnoreCase } from "@/utils/helpers";
-import { createOwnerSigner } from "@/utils/signer";
-import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
-import { createKernelAccount } from "@zerodev/sdk";
-
-import { AdminMismatchError } from "../../error";
-
-export interface EOAWalletParams extends WalletCreationParams {
-    walletParams: WalletParams & { signer: EOASigner };
-}
-
-export class EOAAccountService {
-    public async get(
-        { chain, publicClient, entryPoint, walletParams, kernelVersion, user }: EOAWalletParams,
-        existingSignerConfig?: EOASignerData
-    ): Promise<AccountAndSigner> {
-        const eoa = await createOwnerSigner({
-            chain,
-            walletParams,
-        });
-
-        if (existingSignerConfig != null && !equalsIgnoreCase(eoa.address, existingSignerConfig.eoaAddress)) {
-            throw new AdminMismatchError(
-                `User '${user.id}' has an existing wallet with an eoa signer '${existingSignerConfig.eoaAddress}', this does not match input eoa signer '${eoa.address}'.`,
-                existingSignerConfig,
-                { type: "eoa", eoaAddress: existingSignerConfig.eoaAddress }
-            );
-        }
-
-        const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
-            signer: eoa,
-            entryPoint: entryPoint.address,
-            kernelVersion,
-        });
-        const account = await createKernelAccount(publicClient, {
-            plugins: {
-                sudo: ecdsaValidator,
-            },
-            index: BigInt(0),
-            entryPoint: entryPoint.address,
-            kernelVersion,
-        });
-
-        return { account, signerData: { eoaAddress: eoa.address, type: "eoa" } };
-    }
-}

package/src/types/API.ts

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

@@ -1,76 +0,0 @@
-import { logInfo } from "../services/logging";
-import { LoggerWrapper } from "./log";
-import * as logModule from "./log";
-
-jest.mock("../services/logging");
-
-describe("Log test", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    describe("LoggerWrapper", () => {
-        const addOne = (input: number): number => input + 1;
-
-        class BaseClass extends LoggerWrapper {
-            constructor() {
-                super("BaseClass");
-            }
-
-            someMethod(input: number): any {
-                return addOne(input);
-            }
-        }
-
-        it("should return the same value and log the input and output of myMethod", () => {
-            const base = new BaseClass();
-            const input = 2;
-            const result = base.someMethod(input);
-
-            expect(result).toEqual(addOne(input));
-            expect(logInfo).toHaveBeenCalledTimes(2);
-
-            const logInfoCalls = (logInfo as jest.MockedFunction<typeof logInfo>).mock.calls;
-            expect(logInfoCalls[0][0].includes("input")).toBeTruthy();
-            expect(logInfoCalls[0][0].includes(String(input))).toBeTruthy();
-            expect(logInfoCalls[1][0].includes("output")).toBeTruthy();
-            expect(logInfoCalls[1][0].includes(String(result))).toBeTruthy();
-        });
-    });
-
-    describe("logInputOutput", () => {
-        const addTwo = (input: number): number => input + 2;
-
-        it("should log the input and output of the function", () => {
-            const addTwoWithLogging = logModule.logInputOutput((arg: number) => addTwo(arg), "addTwo");
-
-            const input = 2;
-            const result = addTwoWithLogging(input);
-
-            expect(result).toEqual(addTwo(input));
-            expect(logInfo).toHaveBeenCalledTimes(2);
-
-            const logInfoCalls = (logInfo as jest.MockedFunction<typeof logInfo>).mock.calls;
-            expect(logInfoCalls[0][0].includes("input")).toBeTruthy();
-            expect(logInfoCalls[0][0].includes(String(input))).toBeTruthy();
-            expect(logInfoCalls[1][0].includes("output")).toBeTruthy();
-            expect(logInfoCalls[1][0].includes(String(result))).toBeTruthy();
-        });
-    });
-
-    describe("logPerformance", () => {
-        const addThree = async (input: number): Promise<number> => input + 3;
-
-        it("should log the time", async () => {
-            const input = 3;
-
-            const result = await logModule.logPerformance("addThreeString", () => addThree(input));
-
-            expect(result).toEqual(await addThree(input));
-            expect(logInfo).toHaveBeenCalledTimes(1);
-
-            const logInfoCalls = (logInfo as jest.MockedFunction<typeof logInfo>).mock.calls;
-            expect(logInfoCalls[0][0].includes("TIME")).toBeTruthy();
-        });
-    });
-});