@crossmint/client-sdk-smart-wallet 0.1.0

package/src/utils/constants.ts

@@ -0,0 +1,31 @@
+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 ZD_ETHEREUM_PROJECT_ID = "9ee29857-8077-404b-9a9a-31eeea996a4a";
+export const ZD_POLYGON_PROJECT_ID = "023d4a21-d801-4450-b629-24439ab1369d";
+export const ZD_BSC_PROJECT_ID = "3d166617-da86-494b-9348-e8a13343bc04";
+export const ZD_OPTIMISM_PROJECT_ID = "e9314f9e-a13d-414f-b965-c591a0248243";
+export const ZD_ARBITRUM_PROJECT_ID = "1641cd99-c1ef-404a-9d26-a9dc67b1ba51";
+export const ZD_GOERLI_PROJECT_ID = "3cfecfb6-9d7d-4ef6-acaa-ac8f79f6cd5a";
+export const ZD_SEPOLIA_PROJECT_ID = "7ff22858-06f0-4f3a-8b46-5b41d8c75d0e";
+export const ZD_AMOY_PROJECT_ID = "3b24773b-d91e-4c01-8ce5-04807463bbca";
+export const ZD_ZKATANA_PROJECT_ID = "d54706a0-304b-419e-8a33-03c26ba3f0e9";
+export const ZD_ZKYOTO_PROJECT_ID = "ce986d52-4f27-4a2b-b429-eb2322f15f32";
+export const ZD_ASTAR_PROJECT_ID = "6204f336-643f-41af-94e1-f8d146c91675";
+export const ZD_BASE_SEPOLIA_PROJECT_ID = "3eb830c5-f91b-48e0-bb7d-dc30103a60b2";
+export const ZD_OPTIMISM_SEPOLIA_PROJECT_ID = "6188b92b-993e-4f39-be22-56e4806416a8";
+export const ZD_ARBITRUM_SEPOLIA_PROJECT_ID = "8b8b6d1a-184c-4198-8f29-c07e63aad595";
+export const ZD_BASE_PROJECT_ID = "5535aa3b-4f9c-45af-9c38-0072369564a3";
+export const ZD_ARBITRUM_NOVA_PROJECT_ID = "b6a6db7c-65de-4f74-9d8f-f70d9c083531";
+export const RELAY_API_KEY = "c8999b7e-8bb7-416d-a854-dac8632f9ee6_crossmint";
+export const SCW_SERVICE = "SCW_SDK";
+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 PM_BASE_SEPOLIA_RPC =
+    "https://api.developer.coinbase.com/rpc/v1/base-sepolia/6BTAmOQZ0x1YWtI24hIKKqdHWmVP1UXf";
+export const PM_BASE_RPC = "https://api.developer.coinbase.com/rpc/v1/base/6BTAmOQZ0x1YWtI24hIKKqdHWmVP1UXf";

package/src/utils/environment.ts

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

package/src/utils/helpers.ts

@@ -0,0 +1,15 @@
+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;
+}
+
+export function equalsIgnoreCase(a?: string, b?: string): boolean {
+    return a?.toLowerCase() === b?.toLowerCase();
+}

package/src/utils/log.test.ts

@@ -0,0 +1,76 @@
+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();
+        });
+    });
+});

package/src/utils/log.ts

@@ -0,0 +1,157 @@
+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 });
+    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;
+    } 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
+}
+
+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" };
+
+    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)));
+}

package/src/utils/signer.ts

@@ -0,0 +1,36 @@
+import { providerToSmartAccountSigner } from "permissionless";
+import type { SmartAccountSigner } from "permissionless/accounts";
+import { Address, EIP1193Provider } from "viem";
+
+import { EVMBlockchainIncludingTestnet } from "@crossmint/common-sdk-base";
+
+import { SmartWalletSDKError } from "../error";
+import { ViemAccount, WalletParams } from "../types/Config";
+import { logInputOutput } from "./log";
+
+type CreateOwnerSignerInput = {
+    chain: EVMBlockchainIncludingTestnet;
+    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"
+);
+
+function isEIP1193Provider(signer: any): signer is EIP1193Provider {
+    return signer && typeof signer.request === "function";
+}
+
+export function isAccount(signer: any): signer is ViemAccount {
+    return signer && signer.type === "VIEM_ACCOUNT";
+}