Examples

import { walletClient } from './client'
 
const authorization = await walletClient.signAuthorization({
  contractAddress: '0x…',
})
 
const hash = await walletClient.sendTransaction({
  authorizationList: [authorization],
  data: '0x',
  to: walletClient.account.address,
})

import { encodeFunctionData } from 'viem'
 
import kernelV3Abi from './abi'
import { walletClient } from './client'
 
const authorization = await walletClient.signAuthorization({
  contractAddress: ZERODEV_KERNEL_V3_IMPLEMENTATION_ADDRESS,
})
 
const hash = await walletClient.sendTransaction({
  authorizationList: [authorization],
  data: encodeFunctionData({
    abi: kernelV3Abi,
    functionName: 'initialize',
    args: [
      ROOT_VALIDATOR_ID,
      zeroAddress,
      walletClient.account.address,
      '0x',
      []
    ],
  }),
  to: walletClient.account.address,
})

import { concat, encodeFunctionData, encodeAbiParameters, keccak256, padHex } from 'viem'
import { readContract } from 'viem/actions';
import { sendUserOperation, entryPoint07Abi, entryPoint07Address } from 'viem/account-abstraction';
import { mainnet } from 'viem/chains'
 
import kernelV3ImplementationAbi from './abi'
import { publicClient, walletClient, bundlerClient, paymasterClient } from './clients'
 
const callGasLimit = 1000000n;
const verificationGasLimit = 2000000n;
const preVerificationGas = 100000n;
 
const executions = [
  {
    target: "0x0000000000000000000000000000000000000001",
    value: 0n,
    callData: "0xdeadbeef",
  },
  {
    target: "0x0000000000000000000000000000000000000002",
    value: 0n,
    callData: "0xbeefdead",
  },
]
 
const execMode =
  "0x0100000000000000000000000000000000000000000000000000000000000000";
const executionCalldata = encodeAbiParameters(
  [
    {
      type: "tuple[]",
      components: [
        {
          type: "address",
          name: "target",
        },
        {
          type: "uint256",
          name: "value",
        },
        {
          type: "bytes",
          name: "callData",
        },
      ],
    },
  ],
  [executions]
);
 
const callData = encodeFunctionData({
  abi: kernelV3ImplementationAbi,
  functionName: "execute",
  args: [execMode, executionCalldata],
});
 
const nonce = await readContract(publicClient, {
  address: entryPoint07Address,
  abi: entryPoint07Abi,
  functionName: "getNonce",
  args: [walletClient.account.address, nonceKey],
});
 
const { maxFeePerGas, maxPriorityFeePerGas } =
  await publicClient.estimateFeesPerGas();
 
const { paymasterPostOpGasLimit, paymasterVerificationGasLimit } =
  await paymasterClient.getPaymasterStubData({
    chainId: odysseyTestnet.id,
    entryPointAddress: entryPoint07Address,
    callData,
    callGasLimit,
    verificationGasLimit,
    preVerificationGas,
    maxFeePerGas,
    maxPriorityFeePerGas,
    nonce: actualNonce,
    sender: ownerAddress,
  });
 
const { paymaster, paymasterData } = await paymasterClient.getPaymasterData({
  chainId: odysseyTestnet.id,
  entryPointAddress: entryPoint07Address,
  callData,
  callGasLimit,
  verificationGasLimit,
  preVerificationGas,
  maxFeePerGas,
  maxPriorityFeePerGas,
  paymasterPostOpGasLimit,
  paymasterVerificationGasLimit,
  nonce: actualNonce,
  sender: ownerAddress,
});
 
const sender = walletClient.account.address;
const initCode = '0x';
const accountGasLimits = concat([
  padHex(verificationGasLimit.toString(16), { size: 16 }),
  padHex(callGasLimit.toString(16), { size: 16 }),
]);
const gasFees = concat([
  padHex(maxPriorityFeePerGas.toString(16), { size: 16 }),
  padHex(maxFeePerGas.toString(16), { size: 16 }),
]);
const paymasterAndData = concat([
  padHex(paymaster.toLowerCase(), { size: 20 }),
  padHex(paymasterVerificationGasLimit.toString(16), {
    size: 16,
  }),
  padHex(paymasterPostOpGasLimit.toString(16), { size: 16 }),
  paymasterData,
]);
 
const hashedInitCode = keccak256(initCode);
const hashedCallData = keccak256(callData);
const hashedPaymasterAndData = keccak256(paymasterAndData);
const packedUserOp = encodeAbiParameters(
  [
    { type: "address" },
    { type: "uint256" },
    { type: "bytes32" },
    { type: "bytes32" },
    { type: "bytes32" },
    { type: "uint256" },
    { type: "bytes32" },
    { type: "bytes32" },
  ],
  [
    sender,
    nonce,
    hashedInitCode,
    hashedCallData,
    accountGasLimits,
    preVerificationGas,
    gasFees,
    hashedPaymasterAndData,
  ]
);
const opHash = encodeAbiParameters(
  [{ type: "bytes32" }, { type: "address" }, { type: "uint256" }],
  [keccak256(packedUserOp), entryPoint07Address, BigInt(mainnet.id)]
);
 
const signature = await walletClient.signMessage({
  message: {
    raw: opHash,
  }
});
 
await sendUserOperation(bundlerClient, {
  entryPointAddress: entryPoint07Address,
  sender,
  nonce,
  callData,
  callGasLimit,
  verificationGasLimit,
  preVerificationGas,
  maxPriorityFeePerGas,
  maxFeePerGas,
  paymaster,
  paymasterData,
  paymasterPostOpGasLimit,
  paymasterVerificationGasLimit,
  signature,
});