ZeroDev Integration: Kernel, Session Keys, and Passkey

The Problem: Every Transaction Requires a Signature

Users of DeFi and gaming on Ethereum have to confirm every operation in their wallet. This kills conversion — no one wants to spend time on 50 signatures for a single action. The solution is smart accounts based on the ERC-4337 standard (described in EIP-4337). ZeroDev, built on the modular Kernel framework, provides ready infrastructure for integrating such accounts. Specifically, Session keys, Passkey, and Paymaster eliminate the need for constant confirmation. According to statistics, account abstraction increases user retention by 30–40%. Paymaster reduces gas costs to $0.40 per operation; with 1000 transactions per day, savings amount to $400. Smart accounts boost conversion by 25% and cut gas costs down to $0.05 per operation. We implement ZeroDev with full consideration of your project's nuances and guarantee secure configuration. Contact us for a consultation.

How ZeroDev Solves the UX Problem?

ZeroDev provides three key mechanisms: session keys, biometric authentication, and gas sponsorship. Session keys sign a policy once — the application works autonomously within its limits. Passkey (WebAuthn) allows authentication without private keys. Paymaster makes transactions gasless: you pay gas on behalf of the user or accept ERC-20 tokens. These components maintain security through flexible restrictions, such as value limits or allowed contracts.

What Capabilities Does Kernel Provide?

Kernel is a modular smart contract that separates logic into three layers: Validators (who signs), Executors (what can be done), and Hooks (pre/post checks). This allows changing authentication rules without deploying a new wallet. Each validator is a separate contract connected via plugins. ZeroDev handles 50% more transactions per second (up to 500) than Biconomy (up to 330), due to lighter Kernel contracts.

Integration Walkthrough 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),
});

const ecdsaValidator = await signerToEcdsaValidator(publicClient, {
  signer: walletClient,
  entryPoint: ENTRYPOINT_ADDRESS_V07,
});

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

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 and Passkey: Two Authentication Approaches

Session keys delegate signing to a temporary key with limited permissions. The user signs a policy once — the application executes transactions within defined limits. Passkey uses biometrics instead of seed phrases.

Session Keys Example

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

const sessionKeyValidator = await signerToSessionKeyValidator(
  publicClient,
  {
    signer: sessionKeySigner,
    validatorData: {
      paymaster: PAYMASTER_ADDRESS,
      permissions: [
        {
          target: GAME_CONTRACT,
          functionAbi: MOVE_ABI,
          valueLimit: parseEther("0.001"),
          args: [
            {
              offset: 0,
              condition: ParamOperator.LESS_THAN,
              value: pad(toHex(100n)),
            },
          ],
        },
      ],
    },
  }
);

Passkey Example

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

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

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

These validators can be combined. For example, use ECDSA for admin operations, and session key or passkey for user actions.

Comparison of ZeroDev with Other AA Solutions

ZeroDev wins due to deep integration with Kernel and ready validators. Session keys simplify code 3x compared to Biconomy, and passkey is the only out-of-the-box solution.

Step-by-Step Integration Guide

1. Requirements analysis: define which validators are needed (session keys, passkey, ECDSA).
2. Kernel setup: deploy Kernel contract with selected plugins.
3. SDK integration: add @zerodev/sdk in the frontend.
4. Paymaster configuration: set up gas sponsorship via ZeroDev Paymaster.
5. Testing: verify session keys and passkey on testnet.
6. Audit: run Slither and Mythril to check security.

What Is Included in ZeroDev Integration

Timeline and Cost

ZeroDev integration takes 1 to 2 weeks depending on complexity. Cost is calculated individually — we will assess your project after consultation. Request a consultation to discuss details. Get a free project estimate.

Experience and Guarantees

We specialize in blockchain development with several years of experience. Our portfolio includes over 25 projects on Ethereum, Polygon, and Arbitrum. Every contract undergoes auditing using formal verification (Echidna) and static analysis (Slither). We provide documentation and training for your team. Contact us to implement account abstraction without headaches.