@crossmint/client-sdk-smart-wallet 0.1.8 → 0.1.10

package/src/blockchain/rpc.ts

@@ -1,6 +1,9 @@
+import { blockchainToChainId } from "@crossmint/common-sdk-base";
+
 import { SmartWalletChain } from "./chains";
 
 const ALCHEMY_API_KEY = "-7M6vRDBDknwvMxnqah_jbcieWg0qad9";
+const PIMLICO_API_KEY = "pim_9dKmQPxiTCvtbUNF7XFBbA";
 
 export const ALCHEMY_RPC_SUBDOMAIN: Record<SmartWalletChain, string> = {
     polygon: "polygon-mainnet",
@@ -16,3 +19,7 @@ export const ALCHEMY_RPC_SUBDOMAIN: Record<SmartWalletChain, string> = {
 export function getAlchemyRPC(chain: SmartWalletChain): string {
     return `https://${ALCHEMY_RPC_SUBDOMAIN[chain]}.g.alchemy.com/v2/${ALCHEMY_API_KEY}`;
 }
+
+export function getPimlicoBundlerRPC(chain: SmartWalletChain): string {
+    return `https://api.pimlico.io/v2/${blockchainToChainId(chain)}/rpc?apikey=${PIMLICO_API_KEY}`;
+}

package/src/blockchain/wallets/EVMSmartWallet.ts

@@ -1,4 +1,14 @@
-import { type HttpTransport, type PublicClient, isAddress, publicActions } from "viem";
+import {
+    Abi,
+    ContractFunctionArgs,
+    ContractFunctionName,
+    Hex,
+    type HttpTransport,
+    type PublicClient,
+    WriteContractParameters,
+    isAddress,
+    publicActions,
+} from "viem";
 
 import { TransferError } from "@crossmint/client-sdk-base";
 
@@ -8,6 +18,7 @@ import { SmartWalletClient } from "../../types/internal";
 import type { TransferType } from "../../types/token";
 import { SmartWalletChain } from "../chains";
 import { transferParams } from "../transfer";
+import { SendTransactionOptions, SendTransactionService } from "./SendTransactionService";
 
 /**
  * Smart wallet interface for EVM chains enhanced with Crossmint capabilities.
@@ -30,6 +41,7 @@ export class EVMSmartWallet {
          */
         public: PublicClient;
     };
+    private readonly sendTransactionService: SendTransactionService;
 
     constructor(
         private readonly crossmintService: CrossmintWalletService,
@@ -43,6 +55,7 @@ export class EVMSmartWallet {
             wallet: accountClient,
             public: publicClient,
         };
+        this.sendTransactionService = new SendTransactionService(publicClient);
     }
 
     /**
@@ -110,4 +123,71 @@ export class EVMSmartWallet {
     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,
+            },
+            this.accountClient,
+            config
+        );
+    }
 }

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

@@ -0,0 +1,163 @@
+import { SmartAccountClient } from "permissionless";
+import { SmartAccount } from "permissionless/accounts";
+import { EntryPoint } from "permissionless/types";
+import {
+    BaseError,
+    Chain,
+    ContractFunctionRevertedError,
+    PublicClient,
+    SimulateContractReturnType,
+    TransactionReceipt,
+    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 mockPublicClient = mock<PublicClient>();
+    const mockAccountClient = mock<SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>>();
+    const sendTransactionService = new SendTransactionService(mockPublicClient);
+
+    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: [],
+                },
+                mockAccountClient
+            );
+        } 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: [],
+                },
+                mockAccountClient
+            );
+        } 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: [],
+                },
+                mockAccountClient
+            );
+        } 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: [],
+                },
+                mockAccountClient
+            );
+        } 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: [],
+                },
+                mockAccountClient
+            )
+        ).resolves.toBeDefined();
+        expect(callOrder).toEqual(["simulateContract", "sendTransaction"]);
+    });
+});

package/src/blockchain/wallets/SendTransactionService.ts

@@ -0,0 +1,186 @@
+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 publicClient: PublicClient,
+        private defaultSendTransactionOptions: SendTransactionOptions = {
+            confirmations: 2,
+            transactionConfirmationTimeout: 30_000,
+        }
+    ) {}
+
+    async sendTransaction(
+        request: TransactionServiceTransactionRequest,
+        client: SmartAccountClient<EntryPoint, Transport, Chain, SmartAccount<EntryPoint>>,
+        config: Partial<SendTransactionOptions> = {}
+    ): Promise<Hex> {
+        const { confirmations, transactionConfirmationTimeout } = this.getConfig(config);
+
+        await this.simulateCall(request, undefined, "simulation");
+
+        let hash;
+        try {
+            hash = await client.writeContract({
+                ...request,
+                account: client.account,
+                chain: client.chain,
+            });
+        } catch (e) {
+            if (e instanceof BaseError) {
+                throw new EVMSendTransactionError(e.message, e, "send");
+            }
+            throw e;
+        }
+
+        try {
+            const receipt = await this.publicClient.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.publicClient.simulateContract({
+                ...request,
+                account: request.address,
+                chain: this.publicClient.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/paymaster.ts

@@ -1,5 +1,6 @@
 import { CrossmintWalletService } from "@/api/CrossmintWalletService";
 import { Middleware } from "permissionless/actions/smartAccount";
+import { PimlicoBundlerClient } from "permissionless/clients/pimlico";
 import { EntryPoint } from "permissionless/types/entrypoint";
 
 import { UserParams } from "../../types/params";
@@ -11,11 +12,13 @@ export function usePaymaster(chain: SmartWalletChain) {
 }
 
 export function paymasterMiddleware({
+    bundlerClient,
     entryPoint,
     chain,
     walletService,
     user,
 }: {
+    bundlerClient: PimlicoBundlerClient<EntryPoint>;
     entryPoint: EntryPoint;
     chain: SmartWalletChain;
     walletService: CrossmintWalletService;
@@ -23,6 +26,7 @@ export function paymasterMiddleware({
 }): Middleware<EntryPoint> {
     return {
         middleware: {
+            gasPrice: async () => (await bundlerClient.getUserOperationGasPrice()).fast,
             sponsorUserOperation: async ({ userOperation }) => {
                 const { sponsorUserOpParams } = await walletService.sponsorUserOperation(
                     user,

package/src/blockchain/wallets/service.ts

@@ -1,6 +1,8 @@
-import { createKernelAccountClient } from "@zerodev/sdk";
-import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07 } from "permissionless";
-import { createPublicClient, http } from "viem";
+import { KernelSmartAccount } from "@zerodev/sdk";
+import { ENTRYPOINT_ADDRESS_V06, ENTRYPOINT_ADDRESS_V07, createSmartAccountClient } from "permissionless";
+import { createPimlicoBundlerClient } from "permissionless/clients/pimlico";
+import { EntryPoint } from "permissionless/types/entrypoint";
+import { HttpTransport, createPublicClient, http } from "viem";
 
 import { blockchainToChainId } from "@crossmint/common-sdk-base";
 
@@ -8,8 +10,8 @@ import type { CrossmintWalletService } from "../../api/CrossmintWalletService";
 import type { SmartWalletClient } from "../../types/internal";
 import type { UserParams, WalletParams } from "../../types/params";
 import { CURRENT_VERSION, ZERO_DEV_TYPE } from "../../utils/constants";
-import { type SmartWalletChain, getBundlerRPC, viemNetworks } from "../chains";
-import { getAlchemyRPC } from "../rpc";
+import { type SmartWalletChain, viemNetworks } from "../chains";
+import { getAlchemyRPC, getPimlicoBundlerRPC } from "../rpc";
 import { EVMSmartWallet } from "./EVMSmartWallet";
 import type { AccountConfigService } from "./account/config";
 import type { AccountCreator } from "./account/creator";
@@ -68,13 +70,29 @@ export class SmartWalletService {
             });
         }
 
-        const kernelAccountClient: SmartWalletClient = createKernelAccountClient({
+        return new EVMSmartWallet(
+            this.crossmintService,
+            this.smartAccountClient(chain, account, user),
+            publicClient,
+            chain
+        );
+    }
+
+    private smartAccountClient(
+        chain: SmartWalletChain,
+        account: KernelSmartAccount<EntryPoint, HttpTransport>,
+        user: UserParams
+    ): SmartWalletClient {
+        const transport = http(getPimlicoBundlerRPC(chain));
+        const bundlerConfig = { chain: viemNetworks[chain], entryPoint: account.entryPoint };
+        const bundlerClient = createPimlicoBundlerClient({ ...bundlerConfig, transport });
+        const smartAccountClient: SmartWalletClient = createSmartAccountClient({
             account,
-            chain: viemNetworks[chain],
-            entryPoint: account.entryPoint,
-            bundlerTransport: http(getBundlerRPC(chain)),
+            bundlerTransport: transport,
+            ...bundlerConfig,
             ...(usePaymaster(chain) &&
                 paymasterMiddleware({
+                    bundlerClient,
                     entryPoint: account.entryPoint,
                     chain,
                     walletService: this.crossmintService,
@@ -82,11 +100,9 @@ export class SmartWalletService {
                 })),
         });
 
-        const smartAccountClient = this.clientDecorator.decorate({
+        return this.clientDecorator.decorate({
             crossmintChain: chain,
-            smartAccountClient: kernelAccountClient,
+            smartAccountClient,
         });
-
-        return new EVMSmartWallet(this.crossmintService, smartAccountClient, publicClient, chain);
     }
 }

package/src/utils/constants.ts

@@ -3,7 +3,5 @@ export const CURRENT_VERSION = 0;
 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 SUPPORTED_KERNEL_VERSIONS = ["0.3.1", "0.3.0", "0.2.4"] as const;
 export const SUPPORTED_ENTRYPOINT_VERSIONS = ["v0.6", "v0.7"] as const;