ZeroDev Smart Accounts Integration

Integration with ZeroDev (Smart Accounts)

ZeroDev is infrastructure for smart accounts based on Kernel — modular implementation of ERC-4337. Kernel supports plugins (validators, executors, hooks), making it one of most flexible smart account frameworks. ZeroDev provides bundler, paymaster and SDK for working with Kernel accounts.

Kernel — Modular Architecture

Kernel divides logic into:

• Validators — who can sign (EOA, multisig, passkey, session key)
• Executors — what can be done (custom execution logic)
• Hooks — pre/post execution (spending limits, access control)

This allows changing authentication logic without deploying new wallet.

Integration via ZeroDev SDK

import { createKernelAccount, createKernelAccountClient, createZeroDevPaymasterClient } from "@zerodev/sdk";
import { signerToEcdsaValidator } from "@zerodev/ecdsa-validator";
import { ENTRYPOINT_ADDRESS_V07, bundlerActions } from "permissionless";
import { http, createPublicClient } from "viem";
import { sepolia } from "viem/chains";

const publicClient = createPublicClient({
  chain: sepolia,
  transport: http(SEPOLIA_RPC_URL),
});

// Create ECDSA validator (standard EOA signature)
const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
  signer: walletClient,
  entryPoint: ENTRYPOINT_ADDRESS_V07,
});

// Create Kernel Account
const account = await createKernelAccount(publicClient, {
  plugins: { sudo: ecdsaValidator },
  entryPoint: ENTRYPOINT_ADDRESS_V07,
});

// Create client with paymaster
const kernelClient = createKernelAccountClient({
  account,
  chain: sepolia,
  entryPoint: ENTRYPOINT_ADDRESS_V07,
  bundlerTransport: http(BUNDLER_RPC),
  middleware: {
    sponsorUserOperation: async ({ userOperation }) => {
      const paymasterClient = createZeroDevPaymasterClient({
        chain: sepolia,
        entryPoint: ENTRYPOINT_ADDRESS_V07,
        transport: http(PAYMASTER_RPC),
      });
      return paymasterClient.sponsorUserOperation({ userOperation, entryPoint: ENTRYPOINT_ADDRESS_V07 });
    },
  },
});

const txHash = await kernelClient.sendTransaction({
  to: TARGET_ADDRESS,
  data: calldata,
});

Session Keys via ZeroDev

Session keys — killer feature of Kernel. User signs policy once, application works autonomously within this policy:

import { signerToSessionKeyValidator, ParamOperator } from "@zerodev/session-key";

// Create session key validator with limited rights
const sessionKeyValidator = await signerToSessionKeyValidator(publicClient, {
  signer: sessionKeySigner,       // temporary key (stored in app)
  validatorData: {
    paymaster: PAYMASTER_ADDRESS,
    permissions: [
      {
        target: GAME_CONTRACT,
        functionAbi: MOVE_ABI,
        valueLimit: parseEther("0.001"), // max 0.001 ETH per call
        args: [
          {
            offset: 0,
            condition: ParamOperator.LESS_THAN,
            value: pad(toHex(100n)), // first argument < 100
          },
        ],
      },
    ],
  },
});

Passkey Validator

ZeroDev supports WebAuthn passkeys as validator — biometric signature without private key:

import { toPasskeyValidator, toWebAuthnKey, WebAuthnMode } from "@zerodev/passkey-validator";

// Passkey registration
const webAuthnKey = await toWebAuthnKey({
  passkeyName: "My Account",
  passkeyServerUrl: PASSKEY_SERVER_URL,
  mode: WebAuthnMode.Register,
});

const passkeyValidator = await toPasskeyValidator(publicClient, {
  webAuthnKey,
  entryPoint: ENTRYPOINT_ADDRESS_V07,
});

ZeroDev integrates in 1-2 weeks. Main advantage over other AA providers — maturity of session keys and passkey support out of the box. Suitable for games, trading applications — anywhere you need frequent transactions without constant user confirmation.