Make fields of execution mode optional with defaults

packages/permissionless/actions/erc7579/supportsExecutionMode.test.ts

@@ -63,6 +63,59 @@ describe.each(getCoreSmartAccounts())(
                     supportsExecutionModeBatchCallBeforeDeployPostDeploy
                 ).toBe(true)
 
+                expect(supportsExecutionModeBatchCallBeforeDeploy).toBe(
+                    supportsExecutionModeBatchCallBeforeDeployPostDeploy
+                )
+            }
+        )
+        testWithRpc.skipIf(!getErc7579SmartAccountClient)(
+            "supportsExecutionMode",
+            async ({ rpc }) => {
+                const { anvilRpc, altoRpc, paymasterRpc } = rpc
+
+                if (!getErc7579SmartAccountClient) {
+                    throw new Error("getErc7579SmartAccountClient not defined")
+                }
+
+                const smartClient = await getErc7579SmartAccountClient({
+                    entryPoint: ENTRYPOINT_ADDRESS_V07,
+                    privateKey: generatePrivateKey(),
+                    altoRpc: altoRpc,
+                    anvilRpc: anvilRpc,
+                    paymasterClient: getPimlicoPaymasterClient({
+                        entryPoint: ENTRYPOINT_ADDRESS_V07,
+                        paymasterRpc
+                    })
+                })
+
+                const supportsExecutionModeBatchCallBeforeDeploy =
+                    await supportsExecutionMode(smartClient as any, {
+                        account: smartClient.account as any,
+                        type: "delegatecall"
+                    })
+
+                expect(supportsExecutionModeBatchCallBeforeDeploy).toBe(true)
+
+                // deploy account
+                await smartClient.sendTransaction({
+                    to: zeroAddress,
+                    value: 0n,
+                    data: "0x"
+                })
+
+                const supportsExecutionModeBatchCallBeforeDeployPostDeploy =
+                    await supportsExecutionMode(smartClient as any, {
+                        account: smartClient.account as any,
+                        type: "batchcall",
+                        revertOnError: false,
+                        selector: "0x0",
+                        context: "0x"
+                    })
+
+                expect(
+                    supportsExecutionModeBatchCallBeforeDeployPostDeploy
+                ).toBe(true)
+
                 expect(supportsExecutionModeBatchCallBeforeDeploy).toBe(
                     supportsExecutionModeBatchCallBeforeDeployPostDeploy
                 )

packages/permissionless/actions/erc7579/supportsExecutionMode.ts

@@ -20,9 +20,9 @@ export type CallType = "call" | "delegatecall" | "batchcall"
 
 export type ExecutionMode<callType extends CallType> = {
     type: callType
-    revertOnError: boolean
-    selector: Hex
-    context: Hex
+    revertOnError?: boolean
+    selector?: Hex
+    context?: Hex
 }
 
 export type SupportsExecutionModeParameters<
@@ -33,8 +33,8 @@ export type SupportsExecutionModeParameters<
     callType extends CallType = CallType
 > = GetAccountParameter<TEntryPoint, TSmartAccount> & ExecutionMode<callType>
 
-function parseCallType(executionMode: CallType) {
-    switch (executionMode) {
+function parseCallType(callType: CallType) {
+    switch (callType) {
         case "call":
             return "0x00"
         case "delegatecall":
@@ -56,8 +56,8 @@ export function encodeExecutionMode<callType extends CallType>({
             toHex(toBytes(parseCallType(type), { size: 1 })),
             toHex(toBytes(revertOnError ? "0x01" : "0x00", { size: 1 })),
             toHex(toBytes("0x0", { size: 4 })),
-            toHex(toBytes(selector, { size: 4 })),
-            toHex(toBytes(context, { size: 22 }))
+            toHex(toBytes(selector ?? "0x", { size: 4 })),
+            toHex(toBytes(context ?? "0x", { size: 22 }))
         ]
     )
 }

packages/permissionless/actions/smartAccount.test.ts

@@ -0,0 +1,198 @@
+import type {
+    Abi,
+    Account,
+    Address,
+    Chain,
+    Client,
+    Hash,
+    Hex,
+    SignTypedDataParameters,
+    Transport,
+    TypedData
+} from "viem"
+import type { SignMessageParameters } from "viem"
+import { describe, expectTypeOf, test } from "vitest"
+import type { SmartAccount } from "../accounts"
+import type { BundlerRpcSchema } from "../types/bundler"
+import type {
+    ENTRYPOINT_ADDRESS_V06_TYPE,
+    EntryPoint
+} from "../types/entrypoint"
+import {
+    type DeployContractParametersWithPaymaster,
+    type PrepareUserOperationRequestParameters,
+    type PrepareUserOperationRequestReturnType,
+    type SendTransactionWithPaymasterParameters,
+    type SendTransactionsWithPaymasterParameters,
+    type SendUserOperationParameters,
+    type WriteContractWithPaymasterParameters,
+    deployContract,
+    prepareUserOperationRequest,
+    sendTransaction,
+    sendTransactions,
+    sendUserOperation,
+    signMessage,
+    signTypedData,
+    writeContract
+} from "./smartAccount"
+
+describe("index", () => {
+    test("sendUserOperation", () => {
+        expectTypeOf(deployContract).toBeFunction()
+        expectTypeOf(deployContract)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(deployContract)
+            .parameter(1)
+            .toMatchTypeOf<DeployContractParametersWithPaymaster<EntryPoint>>()
+        expectTypeOf(deployContract).returns.toMatchTypeOf<Promise<Hash>>()
+    })
+    test("prepareUserOperationRequest", () => {
+        expectTypeOf(prepareUserOperationRequest).toBeFunction()
+        expectTypeOf(prepareUserOperationRequest)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(prepareUserOperationRequest)
+            .parameter(1)
+            .toMatchTypeOf<PrepareUserOperationRequestParameters<EntryPoint>>()
+        expectTypeOf(prepareUserOperationRequest).returns.toMatchTypeOf<
+            Promise<PrepareUserOperationRequestReturnType<EntryPoint>>
+        >()
+    })
+    test("sendTransaction", () => {
+        expectTypeOf(sendTransaction).toBeFunction()
+        expectTypeOf(sendTransaction)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(sendTransaction)
+            .parameter(1)
+            .toMatchTypeOf<SendTransactionWithPaymasterParameters<EntryPoint>>()
+        expectTypeOf(sendTransaction).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("sendTransactions", () => {
+        expectTypeOf(sendTransactions).toBeFunction()
+        expectTypeOf(sendTransactions)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(sendTransactions)
+            .parameter(1)
+            .toMatchTypeOf<
+                SendTransactionsWithPaymasterParameters<EntryPoint>
+            >()
+        expectTypeOf(sendTransactions).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("writeContract", () => {
+        expectTypeOf(writeContract).toBeFunction()
+        expectTypeOf(writeContract)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(
+            writeContract<
+                ENTRYPOINT_ADDRESS_V06_TYPE,
+                Chain,
+                SmartAccount<ENTRYPOINT_ADDRESS_V06_TYPE>,
+                Abi
+            >
+        )
+            .parameter(1)
+            .toMatchTypeOf<
+                WriteContractWithPaymasterParameters<
+                    ENTRYPOINT_ADDRESS_V06_TYPE,
+                    Chain,
+                    SmartAccount<ENTRYPOINT_ADDRESS_V06_TYPE>,
+                    Abi
+                >
+            >()
+        expectTypeOf(writeContract).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("sendUserOperation", () => {
+        expectTypeOf(sendUserOperation).toBeFunction()
+        expectTypeOf(sendUserOperation)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(sendUserOperation)
+            .parameter(1)
+            .toMatchTypeOf<SendUserOperationParameters<EntryPoint>>()
+        expectTypeOf(sendUserOperation).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("signMessage", () => {
+        expectTypeOf(signMessage).toBeFunction()
+        expectTypeOf(signMessage)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(signMessage)
+            .parameter(1)
+            .toMatchTypeOf<SignMessageParameters<SmartAccount<EntryPoint>>>()
+        expectTypeOf(signMessage).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+    test("signTypedData", () => {
+        expectTypeOf(signTypedData).toBeFunction()
+        expectTypeOf(signTypedData)
+            .parameter(0)
+            .toMatchTypeOf<
+                Client<
+                    Transport,
+                    Chain | undefined,
+                    Account | undefined,
+                    BundlerRpcSchema<EntryPoint>
+                >
+            >()
+        expectTypeOf(
+            signTypedData<EntryPoint, TypedData, string, undefined, undefined>
+        )
+            .parameter(1)
+            .toMatchTypeOf<
+                SignTypedDataParameters<TypedData, string, undefined>
+            >()
+        expectTypeOf(signTypedData).returns.toMatchTypeOf<Promise<Hex>>()
+    })
+})