@zerodev/sdk 5.3.25 → 5.4.0-beta.0

package/actions/account-client/sendTransaction.ts

@@ -0,0 +1,134 @@
+// Copied from: https://github.com/pimlicolabs/permissionless.js/blob/main/packages/permissionless/actions/smartAccount/sendTransaction.ts
+
+import type {
+    Chain,
+    Client,
+    Hash,
+    SendTransactionParameters,
+    Transport
+} from "viem"
+import {
+    type SendUserOperationParameters,
+    type SmartAccount,
+    sendUserOperation,
+    waitForUserOperationReceipt
+} from "viem/account-abstraction"
+import { getAction, parseAccount } from "viem/utils"
+import { AccountNotFoundError } from "../../errors"
+
+/**
+ * Creates, signs, and sends a new transaction to the network.
+ * This function also allows you to sponsor this transaction if sender is a smartAccount
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/sendTransaction.html
+ * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/transactions/sending-transactions
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+ *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendTransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash.
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { sendTransaction } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
+export async function sendTransaction<
+    account extends SmartAccount | undefined,
+    chain extends Chain | undefined,
+    accountOverride extends SmartAccount | undefined = undefined,
+    chainOverride extends Chain | undefined = Chain | undefined,
+    calls extends readonly unknown[] = readonly unknown[]
+>(
+    client: Client<Transport, chain, account>,
+    args:
+        | SendTransactionParameters<chain, account, chainOverride>
+        | SendUserOperationParameters<account, accountOverride, calls>
+): Promise<Hash> {
+    let userOpHash: Hash
+
+    if ("to" in args) {
+        const {
+            account: account_ = client.account,
+            data,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            to,
+            value,
+            nonce
+        } = args
+
+        if (!account_) {
+            throw new AccountNotFoundError({
+                docsPath: "/docs/actions/wallet/sendTransaction"
+            })
+        }
+
+        const account = parseAccount(account_) as SmartAccount
+
+        if (!to) throw new Error("Missing to address")
+
+        userOpHash = await getAction(
+            client,
+            sendUserOperation,
+            "sendUserOperation"
+        )({
+            calls: [
+                {
+                    to,
+                    value: value || BigInt(0),
+                    data: data || "0x"
+                }
+            ],
+            account,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
+            nonce: nonce ? BigInt(nonce) : undefined
+        })
+    } else {
+        userOpHash = await getAction(
+            client,
+            sendUserOperation,
+            "sendUserOperation"
+        )({ ...args } as SendUserOperationParameters<account, accountOverride>)
+    }
+
+    const userOperationReceipt = await getAction(
+        client,
+        waitForUserOperationReceipt,
+        "waitForUserOperationReceipt"
+    )({
+        hash: userOpHash
+    })
+
+    return userOperationReceipt?.receipt.transactionHash
+}

package/actions/account-client/signMessage.ts

@@ -0,0 +1,75 @@
+// Copied from: https://github.com/pimlicolabs/permissionless.js/blob/main/packages/permissionless/actions/smartAccount/signMessage.ts
+
+import type {
+    Chain,
+    Client,
+    SignMessageParameters,
+    SignMessageReturnType,
+    Transport
+} from "viem"
+import type { SmartAccount } from "viem/account-abstraction"
+import { parseAccount } from "viem/utils"
+import { AccountNotFoundError } from "../../errors"
+
+/**
+ * Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signMessage.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`personal_sign`](https://docs.metamask.io/guide/signing-data.html#personal-sign)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * With the calculated signature, you can:
+ * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage.html) to verify the signature,
+ * - use [`recoverMessageAddress`](https://viem.sh/docs/utilities/recoverMessageAddress.html) to recover the signing address from a signature.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignMessageParameters}
+ * @returns The signed message. {@link SignMessageReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signMessage(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   message: 'hello world',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, custom } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signMessage(client, {
+ *   message: 'hello world',
+ * })
+ */
+export async function signMessage<TAccount extends SmartAccount | undefined>(
+    client: Client<Transport, Chain | undefined, TAccount>,
+    {
+        account: account_ = client.account,
+        message
+    }: SignMessageParameters<TAccount>
+): Promise<SignMessageReturnType> {
+    if (!account_)
+        throw new AccountNotFoundError({
+            docsPath: "/docs/actions/wallet/signMessage"
+        })
+
+    const account = parseAccount(account_) as SmartAccount
+
+    return account.signMessage({ message })
+}

package/actions/account-client/signTypedData.ts

@@ -0,0 +1,159 @@
+// Copied from: https://github.com/pimlicolabs/permissionless.js/blob/main/packages/permissionless/actions/smartAccount/signTypedData.ts
+
+import {
+    type Chain,
+    type Client,
+    type SignTypedDataParameters,
+    type SignTypedDataReturnType,
+    type Transport,
+    type TypedData,
+    type TypedDataDefinition,
+    type TypedDataDomain,
+    getTypesForEIP712Domain,
+    validateTypedData
+} from "viem"
+import type { SmartAccount } from "viem/account-abstraction"
+import { parseAccount } from "viem/utils"
+import { AccountNotFoundError } from "../../errors"
+
+/**
+ * Signs typed data and calculates an Ethereum-specific signature in [https://eips.ethereum.org/EIPS/eip-712](https://eips.ethereum.org/EIPS/eip-712): `sign(keccak256("\x19\x01" ‖ domainSeparator ‖ hashStruct(message)))`
+ *
+ * - Docs: https://viem.sh/docs/actions/wallet/signTypedData.html
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_signTypedData_v4`](https://docs.metamask.io/guide/signing-data.html#signtypeddata-v4)
+ *   - Local Accounts: Signs locally. No JSON-RPC request.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignTypedDataParameters}
+ * @returns The signed data. {@link SignTypedDataReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTypedData(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/wallet'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const signature = await signTypedData(client, {
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ * })
+ */
+export async function signTypedData<
+    const TTypedData extends TypedData | { [key: string]: unknown },
+    TPrimaryType extends string,
+    TAccount extends SmartAccount | undefined = SmartAccount | undefined
+>(
+    client: Client<Transport, Chain | undefined, TAccount>,
+    {
+        account: account_ = client.account,
+        domain,
+        message,
+        primaryType,
+        types: types_
+    }: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>
+): Promise<SignTypedDataReturnType> {
+    if (!account_) {
+        throw new AccountNotFoundError({
+            docsPath: "/docs/actions/wallet/signMessage"
+        })
+    }
+
+    const account = parseAccount(account_) as SmartAccount
+
+    const types = {
+        EIP712Domain: getTypesForEIP712Domain({ domain } as {
+            domain: TypedDataDomain
+        }),
+        ...(types_ as TTypedData)
+    }
+
+    validateTypedData({
+        domain,
+        message,
+        primaryType,
+        types
+    } as TypedDataDefinition)
+
+    return account.signTypedData({
+        domain,
+        primaryType,
+        types,
+        message
+    } as TypedDataDefinition)
+}

package/actions/account-client/signUserOperation.ts

@@ -1,80 +1,48 @@
-import type { SmartAccount } from "permissionless/accounts"
-import { prepareUserOperationRequest } from "permissionless/actions/smartAccount"
-import type {
-    PrepareUserOperationRequestParameters,
-    PrepareUserOperationRequestReturnType
-} from "permissionless/actions/smartAccount"
-import type {
-    EntryPoint,
-    GetEntryPointVersion,
-    Prettify,
-    UserOperation
-} from "permissionless/types"
-import {
-    AccountOrClientNotFoundError,
-    parseAccount
-} from "permissionless/utils"
 import type { Chain, Client, Transport } from "viem"
-import { getAction } from "viem/utils"
+import {
+    type PrepareUserOperationParameters,
+    type PrepareUserOperationReturnType,
+    type SmartAccount,
+    type UserOperation,
+    prepareUserOperation
+} from "viem/account-abstraction"
+import { getAction, parseAccount } from "viem/utils"
+import { AccountNotFoundError } from "../../errors"
 
 export type SignUserOperationParameters<
-    entryPoint extends EntryPoint,
-    TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends
-        | SmartAccount<entryPoint, string, TTransport, TChain>
-        | undefined =
-        | SmartAccount<entryPoint, string, TTransport, TChain>
-        | undefined
-> = PrepareUserOperationRequestParameters<
-    entryPoint,
-    TTransport,
-    TChain,
-    TAccount
->
+    account extends SmartAccount | undefined = SmartAccount | undefined,
+    accountOverride extends SmartAccount | undefined = SmartAccount | undefined,
+    calls extends readonly unknown[] = readonly unknown[]
+> = PrepareUserOperationParameters<account, accountOverride, calls>
 
-export type SignUserOperationReturnType<entryPoint extends EntryPoint> =
-    PrepareUserOperationRequestReturnType<entryPoint>
+export type SignUserOperationReturnType = PrepareUserOperationReturnType
 
 export async function signUserOperation<
-    entryPoint extends EntryPoint,
-    TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends
-        | SmartAccount<entryPoint, string, TTransport, TChain>
-        | undefined =
-        | SmartAccount<entryPoint, string, TTransport, TChain>
-        | undefined
+    account extends SmartAccount | undefined = SmartAccount | undefined,
+    chain extends Chain | undefined = Chain | undefined,
+    accountOverride extends SmartAccount | undefined = undefined,
+    calls extends readonly unknown[] = readonly unknown[]
 >(
-    client: Client<TTransport, TChain, TAccount>,
-    args: Prettify<
-        SignUserOperationParameters<entryPoint, TTransport, TChain, TAccount>
-    >
-): Promise<SignUserOperationReturnType<entryPoint>> {
+    client: Client<Transport, chain, account>,
+    args: SignUserOperationParameters<account, accountOverride, calls>
+): Promise<SignUserOperationReturnType> {
     const { account: account_ = client.account } = args
-    if (!account_) throw new AccountOrClientNotFoundError()
+    if (!account_)
+        throw new AccountNotFoundError({
+            docsPath: "/docs/actions/wallet/sendTransaction"
+        })
 
-    const account = parseAccount(account_) as SmartAccount<
-        entryPoint,
-        string,
-        TTransport,
-        TChain
-    >
+    const account = parseAccount(account_) as SmartAccount
 
     const userOperation = await getAction(
         client,
-        prepareUserOperationRequest<entryPoint, TTransport, TChain, TAccount>,
-        "prepareUserOperationRequest"
-    )({ ...args, account } as PrepareUserOperationRequestParameters<
-        entryPoint,
-        TTransport,
-        TChain,
-        TAccount
-    >)
+        prepareUserOperation,
+        "prepareUserOperation"
+    )({ ...args, account } as PrepareUserOperationParameters)
 
     userOperation.signature = await account.signUserOperation(
-        userOperation as UserOperation<GetEntryPointVersion<entryPoint>>
+        userOperation as UserOperation
     )
 
-    return userOperation as SignUserOperationReturnType<entryPoint>
+    return userOperation
 }

package/actions/account-client/uninstallPlugin.ts

@@ -1,67 +1,49 @@
+import type { Chain, Client, Hash, Hex, Transport } from "viem"
 import {
-    type SendTransactionsWithPaymasterParameters,
-    sendTransactions
-} from "permissionless/actions/smartAccount"
-import type { EntryPoint, Prettify } from "permissionless/types"
+    type SendUserOperationParameters,
+    type SmartAccount,
+    sendUserOperation
+} from "viem/account-abstraction"
 import {
-    AccountOrClientNotFoundError,
+    concatHex,
+    encodeFunctionData,
+    getAction,
+    pad,
     parseAccount
-} from "permissionless/utils"
-import type { Chain, Client, Hash, Hex, Transport } from "viem"
-import { concatHex, encodeFunctionData, getAction, pad } from "viem/utils"
-import type { KernelSmartAccount } from "../../accounts/index.js"
+} from "viem/utils"
 import { KernelV3AccountAbi } from "../../accounts/kernel/abi/kernel_v_3_0_0/KernelAccountAbi.js"
 import { VALIDATOR_TYPE } from "../../constants.js"
+import { AccountNotFoundError } from "../../errors/index.js"
 import type {
     KernelValidator,
     KernelValidatorHook
 } from "../../types/kernel.js"
 
 export type UninstallPluginParameters<
-    entryPoint extends EntryPoint,
-    TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends
-        | KernelSmartAccount<entryPoint, TTransport, TChain>
-        | undefined =
-        | KernelSmartAccount<entryPoint, TTransport, TChain>
-        | undefined
-> = Prettify<
-    SendTransactionsWithPaymasterParameters<
-        entryPoint,
-        TTransport,
-        TChain,
-        TAccount
-    > & {
-        plugin: KernelValidator<entryPoint, string>
-        hook?: KernelValidatorHook
-    }
->
+    account extends SmartAccount | undefined = SmartAccount | undefined,
+    accountOverride extends SmartAccount | undefined = undefined,
+    calls extends readonly unknown[] = readonly unknown[]
+> = Partial<SendUserOperationParameters<account, accountOverride, calls>> & {
+    plugin: KernelValidator<string>
+    hook?: KernelValidatorHook
+}
 
 export async function uninstallPlugin<
-    entryPoint extends EntryPoint,
-    TTransport extends Transport = Transport,
-    TChain extends Chain | undefined = Chain | undefined,
-    TAccount extends
-        | KernelSmartAccount<entryPoint, TTransport, TChain>
-        | undefined =
-        | KernelSmartAccount<entryPoint, TTransport, TChain>
-        | undefined
+    account extends SmartAccount | undefined,
+    chain extends Chain | undefined,
+    accountOverride extends SmartAccount | undefined = undefined,
+    calls extends readonly unknown[] = readonly unknown[]
 >(
-    client: Client<TTransport, TChain, TAccount>,
-    args: Prettify<
-        UninstallPluginParameters<entryPoint, TTransport, TChain, TAccount>
-    >
+    client: Client<Transport, chain, account>,
+    args: UninstallPluginParameters<account, accountOverride, calls>
 ): Promise<Hash> {
-    const {
-        account: account_ = client.account,
-        middleware,
-        plugin,
-        hook
-    } = args
-    if (!account_) throw new AccountOrClientNotFoundError()
+    const { account: account_ = client.account, plugin, hook } = args
+    if (!account_)
+        throw new AccountNotFoundError({
+            docsPath: "/docs/actions/wallet/sendTransaction"
+        })
 
-    const account = parseAccount(account_) as KernelSmartAccount<entryPoint>
+    const account = parseAccount(account_) as SmartAccount
 
     let validatorId: Hex
     if (
@@ -85,11 +67,11 @@ export async function uninstallPlugin<
     const hookData = (await hook?.getEnableData(account.address)) ?? "0x"
     return await getAction(
         client,
-        sendTransactions<TTransport, TChain, TAccount, entryPoint>,
-        "sendTransactions"
+        sendUserOperation,
+        "sendUserOperation"
     )({
         ...args,
-        transactions: [
+        calls: [
             {
                 to: account.address,
                 data: encodeFunctionData({
@@ -100,7 +82,6 @@ export async function uninstallPlugin<
                 value: 0n
             }
         ],
-        account,
-        middleware
-    })
+        account
+    } as SendUserOperationParameters)
 }

package/actions/account-client/writeContract.ts

@@ -0,0 +1,72 @@
+// Copied from: https://github.com/pimlicolabs/permissionless.js/blob/main/packages/permissionless/actions/smartAccount/writeContract.ts
+
+import {
+    type Abi,
+    type Chain,
+    type Client,
+    type ContractFunctionArgs,
+    type ContractFunctionName,
+    type EncodeFunctionDataParameters,
+    type Hash,
+    type SendTransactionParameters,
+    type Transport,
+    type WriteContractParameters,
+    encodeFunctionData
+} from "viem"
+import type { SmartAccount } from "viem/account-abstraction"
+import { getAction } from "viem/utils"
+import { sendTransaction } from "./sendTransaction.js"
+
+export async function writeContract<
+    TChain extends Chain | undefined,
+    TAccount extends SmartAccount | undefined,
+    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>,
+    TChainOverride extends Chain | undefined = undefined
+>(
+    client: Client<Transport, TChain, TAccount>,
+    {
+        abi,
+        address,
+        args,
+        dataSuffix,
+        functionName,
+        ...request
+    }: WriteContractParameters<
+        TAbi,
+        TFunctionName,
+        TArgs,
+        TChain,
+        TAccount,
+        TChainOverride
+    >
+): Promise<Hash> {
+    const data = encodeFunctionData<TAbi, TFunctionName>({
+        abi,
+        args,
+        functionName
+    } as EncodeFunctionDataParameters<TAbi, TFunctionName>)
+
+    const hash = await getAction(
+        client,
+        sendTransaction<TAccount, undefined, undefined>,
+        "sendTransaction"
+    )({
+        data: `${data}${dataSuffix ? dataSuffix.replace("0x", "") : ""}`,
+        to: address,
+        ...request
+    } as unknown as SendTransactionParameters<
+        Chain | undefined,
+        TAccount,
+        undefined
+    >)
+    return hash
+}