@crossmint/client-sdk-smart-wallet 0.1.0

package/src/ABI/ERC721.json

@@ -0,0 +1,320 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "string",
+                "name": "name_",
+                "type": "string"
+            },
+            {
+                "internalType": "string",
+                "name": "symbol_",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "approved",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "Approval",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "operator",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "internalType": "bool",
+                "name": "approved",
+                "type": "bool"
+            }
+        ],
+        "name": "ApprovalForAll",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "Transfer",
+        "type": "event"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "approve",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            }
+        ],
+        "name": "balanceOf",
+        "outputs": [
+            {
+                "internalType": "uint256",
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "getApproved",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "owner",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "operator",
+                "type": "address"
+            }
+        ],
+        "name": "isApprovedForAll",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "name",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "ownerOf",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "safeTransferFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "operator",
+                "type": "address"
+            },
+            {
+                "internalType": "bool",
+                "name": "approved",
+                "type": "bool"
+            }
+        ],
+        "name": "setApprovalForAll",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes4",
+                "name": "interfaceId",
+                "type": "bytes4"
+            }
+        ],
+        "name": "supportsInterface",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "symbol",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "tokenURI",
+        "outputs": [
+            {
+                "internalType": "string",
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "from",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "to",
+                "type": "address"
+            },
+            {
+                "internalType": "uint256",
+                "name": "tokenId",
+                "type": "uint256"
+            }
+        ],
+        "name": "transferFrom",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    }
+]

package/src/SmartWalletSDK.test.ts

@@ -0,0 +1,32 @@
+import { SmartWalletSDK } from "./SmartWalletSDK";
+import { SmartWalletSDKInitParams } from "./types/Config";
+
+jest.mock("./services/logging");
+
+Object.defineProperty(global, "window", {
+    value: {
+        location: {
+            origin: "http://localhost",
+        },
+    },
+});
+
+describe("SmartWalletSDK", () => {
+    let sdk: SmartWalletSDK;
+    const mockInitParams: SmartWalletSDKInitParams = {
+        clientApiKey:
+            "sk_staging_A4vDwAp4t5az6fVQMpQK6qapBnAqgpxrrD35TaFQnyKgxehNbd959uZeaHjNCadWDXrgLRAK1CxeasZjtYEq4TbFkKMBBvbQ9oinAxQf8LbHsSYW2DMzT8fBko3YGLq9t7ZiXZjmgkTioxGVUUjyLtWLeBKwNUDLgpshWjaoR7pKRnSE9SqhwjQbiK62VKiBTdA3KvHsyG9k8mLMcKrDyfXp",
+    };
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        jest.clearAllMocks();
+        sdk = SmartWalletSDK.init(mockInitParams);
+    });
+
+    describe("init", () => {
+        it("should initialize the SDK correctly", () => {
+            expect(sdk).toBeInstanceOf(SmartWalletSDK);
+        });
+    });
+});

package/src/SmartWalletSDK.ts

@@ -0,0 +1,75 @@
+import { stringify } from "viem";
+
+import { EVMBlockchainIncludingTestnet, validateAPIKey } from "@crossmint/common-sdk-base";
+
+import { CrossmintWalletService } from "./api/CrossmintWalletService";
+import type { EVMSmartWallet } from "./blockchain/wallets";
+import { ClientDecorator } from "./blockchain/wallets/clientDecorator";
+import { SmartWalletService } from "./blockchain/wallets/service";
+import { SmartWalletSDKError } from "./error";
+import { ErrorProcessor } from "./error/processor";
+import { DatadogProvider } from "./services/logging/DatadogProvider";
+import type { SmartWalletSDKInitParams, UserParams, WalletParams } from "./types/Config";
+import { isClient } from "./utils/environment";
+import { LoggerWrapper, logPerformance } from "./utils/log";
+
+export class SmartWalletSDK extends LoggerWrapper {
+    private constructor(
+        private readonly smartWalletService: SmartWalletService,
+        private readonly errorProcessor: ErrorProcessor
+    ) {
+        super("SmartWalletSDK");
+    }
+
+    /**
+     * Initializes the SDK with the **client side** API key obtained from the Crossmint console.
+     * @throws error if the api key is not formatted correctly.
+     */
+    static init({ clientApiKey }: SmartWalletSDKInitParams): SmartWalletSDK {
+        if (!isClient()) {
+            throw new SmartWalletSDKError("Smart Wallet SDK should only be used client side.");
+        }
+
+        const validationResult = validateAPIKey(clientApiKey);
+        if (!validationResult.isValid) {
+            throw new Error("API key invalid");
+        }
+
+        const crossmintService = new CrossmintWalletService(clientApiKey);
+        const errorProcessor = new ErrorProcessor(new DatadogProvider());
+        return new SmartWalletSDK(
+            new SmartWalletService(crossmintService, new ClientDecorator(errorProcessor)),
+            errorProcessor
+        );
+    }
+
+    /**
+     * Retrieves or creates a wallet for the specified user.
+     * The default configuration is a `PasskeySigner` with the name, which is displayed to the user during creation or signing prompts, derived from the provided jwt.
+     *
+     * Example using the default passkey signer:
+     * ```ts
+     * const wallet = await smartWalletSDK.getOrCreateWallet({ jwt: "xxx" }, "base");
+     * ```
+     */
+    async getOrCreateWallet(
+        user: UserParams,
+        chain: EVMBlockchainIncludingTestnet,
+        walletParams: WalletParams = { signer: { type: "PASSKEY" } }
+    ): Promise<EVMSmartWallet> {
+        return logPerformance(
+            "GET_OR_CREATE_WALLET",
+            async () => {
+                try {
+                    return await this.smartWalletService.getOrCreate(user, chain, walletParams);
+                } catch (error: any) {
+                    throw this.errorProcessor.map(
+                        error,
+                        new SmartWalletSDKError(`Wallet creation failed: ${error.message}.`, stringify(error))
+                    );
+                }
+            },
+            { user, chain }
+        );
+    }
+}

package/src/api/APIErrorService.ts

@@ -0,0 +1,72 @@
+import {
+    AdminAlreadyUsedError,
+    CrossmintServiceError,
+    JWTDecryptionError,
+    JWTExpiredError,
+    JWTIdentifierError,
+    JWTInvalidError,
+    NonCustodialWalletsNotEnabledError,
+    OutOfCreditsError,
+    SmartWalletSDKError,
+    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: Partial<Record<CrossmintAPIErrorCodes, (apiResponse: any) => SmartWalletSDKError>> = {
+            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 NonCustodialWalletsNotEnabledError(),
+        }
+    ) {}
+
+    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) {
+            console.error("Error parsing response", e);
+        }
+
+        throw new CrossmintServiceError(await response.text(), response.status);
+    }
+}

package/src/api/BaseCrossmintService.ts

@@ -0,0 +1,82 @@
+import { validateAPIKey } from "@crossmint/common-sdk-base";
+
+import { CrossmintServiceError } from "../error";
+import { CROSSMINT_DEV_URL, CROSSMINT_PROD_URL, CROSSMINT_STG_URL } from "../utils/constants";
+import { LoggerWrapper, logPerformance } from "../utils/log";
+import { APIErrorService } from "./APIErrorService";
+
+export abstract class BaseCrossmintService extends LoggerWrapper {
+    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) {
+        super("BaseCrossmintService");
+        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/api/CrossmintWalletService.test.ts

@@ -0,0 +1,42 @@
+import { CROSSMINT_STG_URL } from "../utils/constants";
+import { CrossmintWalletService } from "./CrossmintWalletService";
+
+jest.mock("../services/logging", () => ({
+    logError: jest.fn(),
+    logInfo: jest.fn(),
+}));
+
+jest.mock("../utils/helpers", () => {
+    return {
+        isLocalhost: jest.fn().mockReturnValue(true),
+    };
+});
+
+describe("CrossmintService", () => {
+    let crossmintService: CrossmintWalletService;
+    const apiKey =
+        "sk_staging_A4vDwAp4t5az6fVQMpQK6qapBnAqgpxrrD35TaFQnyKgxehNbd959uZeaHjNCadWDXrgLRAK1CxeasZjtYEq4TbFkKMBBvbQ9oinAxQf8LbHsSYW2DMzT8fBko3YGLq9t7ZiXZjmgkTioxGVUUjyLtWLeBKwNUDLgpshWjaoR7pKRnSE9SqhwjQbiK62VKiBTdA3KvHsyG9k8mLMcKrDyfXp";
+
+    beforeEach(() => {
+        crossmintService = new CrossmintWalletService(apiKey);
+    });
+
+    describe("constructor", () => {
+        it("should initialize with correct headers and base URL", () => {
+            expect(crossmintService).toBeDefined();
+
+            expect(crossmintService["crossmintAPIHeaders"]).toEqual({
+                accept: "application/json",
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+            });
+
+            // Check if the base URL is correctly set to the staging URL
+            expect(crossmintService["crossmintBaseUrl"]).toBe(CROSSMINT_STG_URL);
+        });
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+});

package/src/api/CrossmintWalletService.ts

@@ -0,0 +1,50 @@
+import { SignerData, StoreSmartWalletParams } from "@/types/API";
+import type { UserParams } from "@/types/Config";
+import { API_VERSION } from "@/utils/constants";
+
+import type { EVMBlockchainIncludingTestnet } from "@crossmint/common-sdk-base";
+
+import { BaseCrossmintService } from "./BaseCrossmintService";
+
+export { EVMBlockchainIncludingTestnet } from "@crossmint/common-sdk-base";
+
+export class CrossmintWalletService extends BaseCrossmintService {
+    async idempotentCreateSmartWallet(user: UserParams, input: StoreSmartWalletParams) {
+        return this.fetchCrossmintAPI(
+            `${API_VERSION}/sdk/smart-wallet`,
+            { method: "PUT", body: JSON.stringify(input) },
+            "Error creating abstract wallet. Please contact support",
+            user.jwt
+        );
+    }
+
+    async getSmartWalletConfig(
+        user: UserParams,
+        chain: EVMBlockchainIncludingTestnet
+    ): Promise<{
+        kernelVersion: string;
+        entryPointVersion: string;
+        userId: string;
+        signers: { signerData: SignerData }[];
+        smartContractWalletAddress?: string;
+    }> {
+        return this.fetchCrossmintAPI(
+            `${API_VERSION}/sdk/smart-wallet/config?chain=${chain}`,
+            { method: "GET" },
+            "Error getting smart wallet version configuration. Please contact support",
+            user.jwt
+        );
+    }
+
+    async fetchNFTs(address: string, chain: EVMBlockchainIncludingTestnet) {
+        return this.fetchCrossmintAPI(
+            `v1-alpha1/wallets/${chain}:${address}/nfts`,
+            { method: "GET" },
+            `Error fetching NFTs for wallet: ${address}`
+        );
+    }
+
+    public getPasskeyServerUrl(): string {
+        return this.crossmintBaseUrl + "/internal/passkeys";
+    }
+}