@crossmint/client-sdk-smart-wallet 0.1.24 → 0.1.26

package/src/blockchain/transfer.ts

@@ -1,54 +0,0 @@
-import { type Abi, type Account, type Address, erc20Abi, erc721Abi } from "viem";
-
-import erc1155Abi from "../ABI/ERC1155.json";
-import type { ERC20TransferType, SFTTransferType, TransferType } from "../types/token";
-
-type TransferInputParams = {
-    from: Account;
-    contract: Address;
-    to: Address;
-    config: TransferType;
-};
-
-type TransferSimulationParams = {
-    account: Account;
-    address: Address;
-    abi: Abi;
-    functionName: string;
-    args: any[];
-    tokenId?: string;
-};
-
-export function transferParams({ contract, config, from, to }: TransferInputParams): TransferSimulationParams {
-    switch (config.token.type) {
-        case "ft": {
-            return {
-                account: from,
-                address: contract,
-                abi: erc20Abi,
-                functionName: "transfer",
-                args: [to, (config as ERC20TransferType).amount],
-            };
-        }
-        case "sft": {
-            return {
-                account: from,
-                address: contract,
-                abi: erc1155Abi as Abi,
-                functionName: "safeTransferFrom",
-                args: [from.address, to, config.token.tokenId, (config as SFTTransferType).quantity, "0x00"],
-                tokenId: config.token.tokenId,
-            };
-        }
-        case "nft": {
-            return {
-                account: from,
-                address: contract,
-                abi: erc721Abi,
-                functionName: "safeTransferFrom",
-                args: [from.address, to, config.token.tokenId],
-                tokenId: config.token.tokenId,
-            };
-        }
-    }
-}

package/src/blockchain/wallets/EVMSmartWallet.ts

@@ -1,157 +0,0 @@
-import type {
-    Abi,
-    Address,
-    ContractFunctionArgs,
-    ContractFunctionName,
-    Hex,
-    HttpTransport,
-    PublicClient,
-    WriteContractParameters,
-} from "viem";
-
-import type { CrossmintWalletService } from "../../api/CrossmintWalletService";
-import { SmartWalletError } from "../../error";
-import type { SmartWalletClient } from "../../types/internal";
-import type { TransferType } from "../../types/token";
-import type { SmartWalletChain } from "../chains";
-import { transferParams } from "../transfer";
-import { type SendTransactionOptions, SendTransactionService } from "./SendTransactionService";
-
-/**
- * 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.
- */
-export class EVMSmartWallet {
-    public readonly chain: SmartWalletChain;
-
-    /**
-     * [viem](https://viem.sh/) clients that provide an interface for core wallet functionality.
-     */
-    public readonly client: {
-        /**
-         * An interface to interact with the smart wallet, execute transactions, sign messages, etc.
-         */
-        wallet: SmartWalletClient;
-
-        /**
-         * An interface to read onchain data, fetch transactions, retrieve account balances, etc. Corresponds to public [JSON-RPC API](https://ethereum.org/en/developers/docs/apis/json-rpc/) methods.
-         */
-        public: PublicClient;
-    };
-
-    constructor(
-        client: { public: PublicClient<HttpTransport>; wallet: SmartWalletClient },
-        chain: SmartWalletChain,
-        private readonly crossmintService: CrossmintWalletService,
-        private readonly sendTransactionService = new SendTransactionService(client)
-    ) {
-        this.chain = chain;
-        this.client = client;
-    }
-
-    /**
-     * The address of the smart wallet.
-     */
-    public get address() {
-        return this.client.wallet.account.address;
-    }
-
-    /**
-     * Transfers tokens from the smart wallet to a specified address.
-     * @param toAddress The recipient's address.
-     * @param config The transfer configuration, including token details and amount.
-     * @returns The transaction hash.
-     * @throws {SmartWalletError} If there's a chain mismatch between this wallet and the input configuration.
-     * @throws {SendTransactionError} If the transaction fails to send. Contains the error thrown by the viem client.
-     * @throws {SendTransactionExecutionRevertedError} A subclass of SendTransactionError if the transaction fails due to a contract execution error.
-     */
-    public async transferToken(toAddress: Address, config: TransferType): Promise<string> {
-        if (this.chain !== config.token.chain) {
-            throw new SmartWalletError(
-                `Chain mismatch: Expected ${config.token.chain}, but got ${this.chain}. Ensure you are interacting with the correct blockchain.`
-            );
-        }
-
-        return this.executeContract(
-            transferParams({
-                contract: config.token.contractAddress,
-                to: toAddress,
-                from: this.client.wallet.account,
-                config,
-            })
-        );
-    }
-
-    /**
-     * @returns A list of NFTs owned by the wallet.
-     */
-    public async nfts() {
-        return this.crossmintService.fetchNFTs(this.address, this.chain);
-    }
-
-    /**
-     * Sends a contract call transaction and returns the hash of a confirmed transaction.
-     * @param address the address of the contract to be called
-     * @param abi the ABI of the contract - ***should be defined as a typed variable*** to enable type checking of the contract arguments, see https://viem.sh/docs/typescript#type-inference for guidance
-     * @param functionName the name of the smart contract function to be called
-     * @param args the arguments to be passed to the function
-     * @returns The transaction hash.
-     * @throws `SendTransactionError` if the transaction fails to send. Contains the error thrown by the viem client.
-     * @throws `SendTransactionExecutionRevertedError`, a subclass of `SendTransactionError` if the transaction fails due to a contract execution error.
-     *
-     * **Passing a typed ABI:**
-     * @example
-     * const abi = [{
-     *   "inputs": [
-     *     {
-     *       "internalType": "address",
-     *         "name": "recipient",
-     *         "type": "address"
-     *       },
-     *   ],
-     *   "name": "mintNFT",
-     *   "outputs": [],
-     *   "stateMutability": "nonpayable",
-     *   "type": "function"
-     * }] as const;
-     *
-     * await wallet.executeContract({
-     *   address: contractAddress,
-     *   abi,
-     *   functionName: "mintNFT",
-     *   args: [recipientAddress],
-     * });
-     */
-    public async executeContract<
-        const TAbi extends Abi | readonly unknown[],
-        TFunctionName extends ContractFunctionName<TAbi, "nonpayable" | "payable"> = ContractFunctionName<
-            TAbi,
-            "nonpayable" | "payable"
-        >,
-        TArgs extends ContractFunctionArgs<TAbi, "nonpayable" | "payable", TFunctionName> = ContractFunctionArgs<
-            TAbi,
-            "nonpayable" | "payable",
-            TFunctionName
-        >,
-    >({
-        address,
-        abi,
-        functionName,
-        args,
-        value,
-        config,
-    }: Omit<WriteContractParameters<TAbi, TFunctionName, TArgs>, "chain" | "account"> & {
-        config?: Partial<SendTransactionOptions>;
-    }): Promise<Hex> {
-        return this.sendTransactionService.sendTransaction(
-            {
-                address,
-                abi: abi as Abi,
-                functionName,
-                args,
-                value,
-            },
-            config
-        );
-    }
-}

package/src/blockchain/wallets/SendTransactionService.test.ts

@@ -1,159 +0,0 @@
-import type { SmartAccountClient } from "permissionless";
-import type { SmartAccount } from "permissionless/accounts";
-import type { EntryPoint } from "permissionless/types";
-import {
-    type Address,
-    BaseError,
-    type Chain,
-    ContractFunctionRevertedError,
-    type PublicClient,
-    type SimulateContractReturnType,
-    type TransactionReceipt,
-    type Transport,
-    zeroAddress,
-} from "viem";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { mock } from "vitest-mock-extended";
-
-import {
-    EVMSendTransactionError,
-    EVMSendTransactionExecutionRevertedError,
-    SendTransactionService,
-} from "./SendTransactionService";
-
-function makeMockError<E extends Error, F extends object>(error: E, fields?: F): E & F {
-    const mockError = Object.create(error);
-    Object.assign(mockError, fields);
-    return mockError;
-}
-
-describe("SendTransactionService", () => {
-    const walletAddress: Address = "0xE898BBd704CCE799e9593a9ADe2c1cA0351Ab660";
-    const mockSmartAccount = mock<SmartAccount<EntryPoint>>({ address: walletAddress });
-    const mockPublicClient = mock<PublicClient>();
-    const mockAccountClient = mock<SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>>({
-        account: mockSmartAccount,
-    });
-    const sendTransactionService = new SendTransactionService({ public: mockPublicClient, wallet: mockAccountClient });
-
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-
-    it("Throws EVMSendTransactionExecutionRevertedError when a transaction simulation fails", async () => {
-        const mockError = makeMockError(BaseError.prototype, { walk: vi.fn() });
-        const mockRevertError = new ContractFunctionRevertedError({
-            abi: [],
-            functionName: "mockFunction",
-            message: "mockMessage",
-        });
-        mockRevertError.reason = "mockReason";
-        const mockRevertData = mock<ContractFunctionRevertedError["data"]>();
-        mockRevertError.data = mockRevertData;
-        mockError.walk.mockReturnValue(mockRevertError);
-        mockPublicClient.simulateContract.mockRejectedValue(mockError);
-        let rejected = false;
-        try {
-            await sendTransactionService.sendTransaction({
-                address: zeroAddress,
-                abi: [],
-                functionName: "mockFunction",
-                args: [],
-            });
-        } catch (e) {
-            rejected = true;
-            expect(e).toBeInstanceOf(EVMSendTransactionExecutionRevertedError);
-            expect((e as EVMSendTransactionExecutionRevertedError).stage).toBe("simulation");
-            expect((e as EVMSendTransactionExecutionRevertedError).reason).toBe("mockReason");
-            expect((e as EVMSendTransactionExecutionRevertedError).data == mockRevertData).toBe(true);
-        }
-        expect(rejected).toBe(true);
-    });
-
-    it("Throws EVMSendTransactionExecutionRevertedError when a transaction reverts on chain", async () => {
-        const mockReceipt = mock<TransactionReceipt>();
-        mockReceipt.status = "reverted";
-        mockPublicClient.waitForTransactionReceipt.mockResolvedValueOnce(mockReceipt);
-        let rejected = false;
-        try {
-            await sendTransactionService.sendTransaction({
-                address: zeroAddress,
-                abi: [],
-                functionName: "mockFunction",
-                args: [],
-            });
-        } catch (e) {
-            rejected = true;
-            expect(e).toBeInstanceOf(EVMSendTransactionExecutionRevertedError);
-            expect((e as EVMSendTransactionExecutionRevertedError).stage).toBe("execution");
-        }
-        expect(rejected).toBe(true);
-    });
-
-    it("Throws a confirmation error when a transaction confirmation fails", async () => {
-        const mockError = makeMockError(BaseError.prototype);
-        mockPublicClient.waitForTransactionReceipt.mockRejectedValue(mockError);
-        let rejected = false;
-        try {
-            await sendTransactionService.sendTransaction({
-                address: zeroAddress,
-                abi: [],
-                functionName: "mockFunction",
-                args: [],
-            });
-        } catch (e) {
-            rejected = true;
-            expect(e).toBeInstanceOf(EVMSendTransactionError);
-            expect((e as EVMSendTransactionError).stage).toBe("confirmation");
-        }
-        expect(rejected).toBe(true);
-    });
-
-    it("Throws EVMSendTransactionError when a transaction fails to send", async () => {
-        const mockError = makeMockError(BaseError.prototype);
-        mockAccountClient.writeContract.mockRejectedValue(mockError);
-        let rejected = false;
-        try {
-            await sendTransactionService.sendTransaction({
-                address: zeroAddress,
-                abi: [],
-                functionName: "mockFunction",
-                args: [],
-            });
-        } catch (e) {
-            rejected = true;
-            expect(e).toBeInstanceOf(EVMSendTransactionError);
-            expect((e as EVMSendTransactionError).stage).toBe("send");
-        }
-        expect(rejected).toBe(true);
-    });
-
-    it("Simulates before sending a transaction", async () => {
-        const mockReceipt = mock<TransactionReceipt>();
-        mockPublicClient.waitForTransactionReceipt.mockResolvedValueOnce(mockReceipt);
-        const callOrder: string[] = [];
-        mockPublicClient.simulateContract.mockImplementation(async () => {
-            callOrder.push("simulateContract");
-            return mock<SimulateContractReturnType>();
-        });
-        mockAccountClient.writeContract.mockImplementation(async () => {
-            callOrder.push("sendTransaction");
-            return "0xmockTxHash";
-        });
-        await expect(
-            sendTransactionService.sendTransaction({
-                address: zeroAddress,
-                abi: [],
-                functionName: "mockFunction",
-                args: [],
-            })
-        ).resolves.toBeDefined();
-        expect(callOrder).toEqual(["simulateContract", "sendTransaction"]);
-
-        expect(mockPublicClient.simulateContract).toHaveBeenCalledWith(
-            expect.objectContaining({
-                account: walletAddress,
-            })
-        );
-    });
-});

package/src/blockchain/wallets/SendTransactionService.ts

@@ -1,188 +0,0 @@
-import type { SmartAccountClient } from "permissionless";
-import type { EntryPoint } from "permissionless/_types/types";
-import type { SmartAccount } from "permissionless/accounts";
-import {
-    type Abi,
-    type Address,
-    BaseError,
-    type Chain,
-    ContractFunctionRevertedError,
-    type Hex,
-    type PublicClient,
-    type TransactionReceipt,
-    type Transport,
-} from "viem";
-
-import { CrossmintSDKError, WalletErrorCode } from "@crossmint/client-sdk-base";
-
-export type TransactionServiceTransactionRequest = {
-    address: Address;
-    abi: Abi;
-    functionName: string;
-    args: any;
-    value?: bigint;
-};
-
-export type SendTransactionFailureStage = "simulation" | "send" | "confirmation" | "execution";
-
-/**
- * Error thrown when a transaction fails to send.
- * @param viemError The error thrown by the viem client. See https://viem.sh/docs/glossary/errors.html
- */
-export class EVMSendTransactionError extends CrossmintSDKError {
-    constructor(
-        message: string,
-        public readonly viemError: BaseError,
-        public readonly stage: SendTransactionFailureStage,
-        code = WalletErrorCode.SEND_TRANSACTION_FAILED
-    ) {
-        super(message, code);
-    }
-}
-
-/**
- * Error thrown when a transaction fails due to a contract execution error.
- * @param viemError The error thrown by the viem client. See https://viem.sh/docs/glossary/errors.html
- * @param data The name and arguments of the revert error from the provided ABI
- * @param reason The revert error if it is a string and not an ABI error
- * @example
- * try {
- *   await wallet.executeContract({
- *     address: contractAddress,
- *     abi,
- *     functionName: "mintNFT",
- *     args: [recipientAddress],
- *   });
- * } catch (e) {
- *   if (e instanceof SendTransactionExecutionRevertedError) {
- *     alert(`Transaction reverted: ${e.message}`);
- *   }
- *   throw e;
- * }
- */
-export class EVMSendTransactionExecutionRevertedError extends EVMSendTransactionError {
-    constructor(
-        message: string,
-        public readonly viemError: BaseError,
-        revertError: ContractFunctionRevertedError,
-        public readonly txId: string | undefined,
-        public readonly stage: SendTransactionFailureStage,
-        public readonly data = revertError.data,
-        public readonly reason = revertError.reason
-    ) {
-        super(message, viemError, stage, WalletErrorCode.SEND_TRANSACTION_EXECUTION_REVERTED);
-    }
-}
-
-export interface SendTransactionOptions {
-    /**
-     * The number of confirmations to wait for before yielding the transaction hash.
-     */
-    confirmations: number;
-    /**
-     * The timeout in milliseconds to wait for a transaction to confirm before throwing an error.
-     */
-    transactionConfirmationTimeout: number;
-}
-
-export class SendTransactionService {
-    constructor(
-        private readonly client: {
-            public: PublicClient;
-            wallet: SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>;
-        },
-        private readonly defaultSendTransactionOptions: SendTransactionOptions = {
-            confirmations: 2,
-            transactionConfirmationTimeout: 30_000,
-        }
-    ) {}
-
-    async sendTransaction(
-        request: TransactionServiceTransactionRequest,
-        config: Partial<SendTransactionOptions> = {}
-    ): Promise<Hex> {
-        const { confirmations, transactionConfirmationTimeout } = this.getConfig(config);
-
-        await this.simulateCall(request, undefined, "simulation");
-
-        let hash;
-        try {
-            hash = await this.client.wallet.writeContract({
-                ...request,
-                account: this.client.wallet.account,
-                chain: this.client.wallet.chain,
-            });
-        } catch (e) {
-            if (e instanceof BaseError) {
-                throw new EVMSendTransactionError(e.message, e, "send");
-            }
-            throw e;
-        }
-
-        try {
-            const receipt = await this.client.public.waitForTransactionReceipt({
-                hash,
-                confirmations,
-                timeout: transactionConfirmationTimeout,
-            });
-            return await this.handleReceipt(receipt, request);
-        } catch (e) {
-            if (e instanceof BaseError) {
-                throw new EVMSendTransactionError(e.message, e, "confirmation");
-            }
-            throw e;
-        }
-    }
-
-    private getConfig(config: Partial<SendTransactionOptions>): SendTransactionOptions {
-        return {
-            ...this.defaultSendTransactionOptions,
-            ...config,
-        };
-    }
-
-    private async handleReceipt(receipt: TransactionReceipt, request: TransactionServiceTransactionRequest) {
-        if (receipt.status === "reverted") {
-            // This should revert and throw the full reason
-            await this.simulateCall(request, receipt.transactionHash, "execution");
-            // Otherwise, throw a generic error (this should practically never happen)
-            throw new EVMSendTransactionExecutionRevertedError(
-                "Transaction reverted but unable to detect the reason",
-                new ContractFunctionRevertedError({ abi: request.abi as Abi, functionName: request.functionName }),
-                new ContractFunctionRevertedError({ abi: request.abi as Abi, functionName: request.functionName }),
-                receipt.transactionHash,
-                "execution"
-            );
-        }
-        return receipt.transactionHash;
-    }
-
-    private async simulateCall(
-        request: TransactionServiceTransactionRequest,
-        passthroughTxId: string | undefined,
-        stage: SendTransactionFailureStage
-    ) {
-        try {
-            await this.client.public.simulateContract({
-                ...request,
-                account: this.client.wallet.account.address,
-                chain: this.client.public.chain,
-            });
-        } catch (e) {
-            if (e instanceof BaseError) {
-                const revertError = e.walk((err) => err instanceof ContractFunctionRevertedError);
-                if (revertError instanceof ContractFunctionRevertedError) {
-                    throw new EVMSendTransactionExecutionRevertedError(
-                        revertError.message,
-                        e,
-                        revertError,
-                        passthroughTxId,
-                        stage
-                    );
-                }
-                throw new EVMSendTransactionError(e.message, e, stage);
-            }
-            throw e;
-        }
-    }
-}

package/src/blockchain/wallets/account/cache.test.ts

@@ -1,67 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-import type { UserParams } from "../../../types/params";
-import { mockConfig } from "../../../utils/test";
-import { AccountConfigCache } from "./cache";
-
-// At the top of the file, after the imports
-const mockLocalStorage = {
-    getItem: vi.fn(),
-    setItem: vi.fn(),
-    removeItem: vi.fn(),
-    clear: vi.fn(),
-    length: 0,
-    key: vi.fn(),
-};
-
-vi.stubGlobal("localStorage", mockLocalStorage);
-
-vi.mock("@/services/logging");
-vi.mock("viem", () => ({
-    keccak256: vi.fn((input) => `mocked_keccak256_${input}`),
-    toHex: vi.fn((input) => `mocked_hex_${input}`),
-    isAddress: vi.fn(() => true),
-    isHex: vi.fn(() => true),
-}));
-
-describe("AccountConfigCache", () => {
-    let cache: AccountConfigCache;
-    const mockUser: UserParams = { jwt: "test_jwt" };
-    const cachePrefix = `smart-wallet-0.1.0`;
-
-    beforeEach(() => {
-        cache = new AccountConfigCache(cachePrefix);
-        vi.clearAllMocks();
-    });
-
-    describe("get", () => {
-        it("should return null if item is not in storage", () => {
-            mockLocalStorage.getItem.mockReturnValue(null);
-            const result = cache.get(mockUser);
-            expect(result).toBeNull();
-        });
-
-        it("should return parsed config if valid", () => {
-            mockLocalStorage.getItem.mockReturnValue(JSON.stringify(mockConfig));
-            const result = cache.get(mockUser);
-            expect(result).toEqual(mockConfig);
-        });
-
-        it("should return null and remove item if config is invalid", () => {
-            mockLocalStorage.getItem.mockReturnValue('{"invalidKey": "invalidValue"}');
-            const result = cache.get(mockUser);
-            expect(result).toBeNull();
-            expect(mockLocalStorage.removeItem).toHaveBeenCalled();
-        });
-    });
-
-    describe("set", () => {
-        it("should store the config in localStorage", () => {
-            cache.set(mockUser, mockConfig);
-            expect(mockLocalStorage.setItem).toHaveBeenCalledWith(
-                expect.stringContaining(cachePrefix),
-                JSON.stringify(mockConfig)
-            );
-        });
-    });
-});

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

@@ -1,43 +0,0 @@
-import { keccak256, toHex } from "viem";
-
-import type { UserParams } from "../../../types/params";
-import { SmartWalletConfigSchema } from "../../../types/schema";
-import type { SmartWalletConfig } from "../../../types/service";
-
-export class AccountConfigCache {
-    constructor(private readonly keyPrefix: string) {}
-
-    public set(user: UserParams, config: SmartWalletConfig) {
-        localStorage.setItem(this.key(user), JSON.stringify(config));
-    }
-
-    public get(user: UserParams): SmartWalletConfig | null {
-        const key = this.key(user);
-        const data = localStorage.getItem(key);
-        if (data == null) {
-            return null;
-        }
-
-        const result = SmartWalletConfigSchema.safeParse(JSON.parse(data));
-        if (!result.success) {
-            localStorage.removeItem(key);
-            return null;
-        }
-
-        return result.data;
-    }
-
-    public clear() {
-        for (let i = 0; i < localStorage.length; i++) {
-            const key = localStorage.key(i);
-            if (key && key.startsWith(this.keyPrefix)) {
-                localStorage.removeItem(key);
-                i--; // Decrement i since we've removed an item
-            }
-        }
-    }
-
-    private key(user: UserParams) {
-        return `${this.keyPrefix}-${keccak256(toHex(user.jwt))}`;
-    }
-}