Advanced Usage

import { isEthereumWallet } from '@dynamic-labs/ethereum-core';
import { useDynamicContext } from '@dynamic-labs/sdk-react-core';
import { DynamicWaasEVMConnector } from '@dynamic-labs/waas-evm';
import { isDynamicWaasConnector } from '@dynamic-labs/wallet-connector-core';

const SEPOLIA_CHAIN_ID = 11155111;
const SMART_ACCOUNT_ADDRESS = '0xd6CEDDe84be40893d153Be9d467CD6aD37875b28';

const { primaryWallet } = useDynamicContext();

const handleAuthorize = async () => {
  if (!primaryWallet) return;

  const { connector } = primaryWallet;
  if (!isEthereumWallet(primaryWallet)) {
    console.log('Primary wallet is not available or not an Ethereum wallet');
    return;
  }

  if (!connector || !isDynamicWaasConnector(connector)) {
    console.log('Connector is not a WaaS wallet connector');
    return;
  }

  const waasConnector = connector as DynamicWaasEVMConnector;

  try {
    const authorization = await waasConnector.signAuthorization({
      address: SMART_ACCOUNT_ADDRESS,
      chainId: SEPOLIA_CHAIN_ID,
      nonce: 0,
    });

    const connectorAddress = await waasConnector.getAddress();

    console.log('Authorization signed:', authorization);
    console.log('Connector address:', connectorAddress);
  } catch (err) {
    console.error('Error during authorization:', err);
  }
};

const connector = primaryWallet?.connector;

const kernelClient = connector.getAccountAbstractionProvider({
  withSponsorship: true,
});

const userOpHash = await kernelClient.sendUserOperation({
  callData: await kernelClient.account.encodeCalls([
    {
      data: "0x",
      to: zeroAddress,
      value: BigInt(0),
    },
    {
      data: "0x",
      to: zeroAddress,
      value: BigInt(0),
    },
  ]),
});

import { ZeroDevSmartWalletConnectorsWithConfig } from "@dynamic-labs/ethereum-aa";

<DynamicContextProvider
  settings={{
    environmentId: "YOUR_ENV_ID",
    walletConnectors: [
      ZeroDevSmartWalletConnectorsWithConfig({
        bundlerRpc: "CUSTOM_BUNDLER_RPC",
        paymasterRpc: "CUSTOM_PAYMASTER_RPC",
      }),
    ],
  }}
>
  {/* ... your app */}
</DynamicContextProvider>;

import { ZeroDevSmartWalletConnectorsWithConfig } from "@dynamic-labs/ethereum-aa";

<DynamicContextProvider
  settings={{
    environmentId: "YOUR_ENV_ID",
    walletConnectors: [
      ZeroDevSmartWalletConnectorsWithConfig({ bundlerProvider: "STACKUP" }),
    ],
  }}
>
  {/* ... your app */}
</DynamicContextProvider>;

import { isZeroDevConnector } from '@dynamic-labs/ethereum-aa';

const App = () => {
  const { primaryWallet } = useDynamicContext();

  useEffect(() => {
    const { connector } = primaryWallet;

    const getKernelClient = async () => {
      if (!isZeroDevConnector(connector)) {
        return;
      }

      // ensure that the kernel client has been loaded successfully
      await connector.getNetwork();

      const params = {
        // if you have gas sponsorship enabled, set `withSponsorship` to `true`, else omit
        withSponsorship: true
      };
      const kernelClient = connector.getAccountAbstractionProvider(params);
    }
  ...
}

import { useEffect, useState } from "react";
import {
  useDynamicContext,
  DynamicContextProvider,
  DynamicWidget,
} from "@dynamic-labs/sdk-react-core";
import {
  isZeroDevConnector,
  ZeroDevSmartWalletConnectors,
} from "@dynamic-labs/ethereum-aa";
import { EthereumWalletConnectors } from "@dynamic-labs/ethereum";

const SignerAddress = () => {
  const { primaryWallet } = useDynamicContext();
  const [signerAddress, setSignerAddress] = useState("");

  useEffect(() => {
    if (!primaryWallet) {
      return;
    }

    const {
      connector,
       address, // This is your smart wallet address
    } = primaryWallet;

    if (!isZeroDevConnector(connector)) {
      return;
    }

    const signerConnector = connector.eoaConnector;

    if (!signerConnector) {
      return;
    }

    const getAddress = async () => {
      const address = await signerConnector.getAddress();

      if (!address) {
        return;
      }

      setSignerAddress(address);
    };
    getAddress();
  }, [primaryWallet]);

  return <span>My Signer address: {signerAddress}</span>;
};

const App = () => (
  <DynamicContextProvider
    settings={{
      environmentId: "YOUR_ENVIRONMENT_ID",
      walletConnectors: [
        EthereumWalletConnectors,
        ZeroDevSmartWalletConnectors,
      ],
    }}
  >
    <DynamicWidget />

    <SignerAddress />
  </DynamicContextProvider>
);

export default App;

import { usePromptMfaAuth, useSignEip7702Authorization, useUserWallets } from '@dynamic-labs/sdk-react-core';
import { isZeroDevConnector } from '@dynamic-labs/ethereum-aa';

export function SignEip7702WithMfa() {
  const promptMfaAuth = usePromptMfaAuth();
  const { signEip7702Authorization } = useSignEip7702Authorization();
  const userWallets = useUserWallets();

  // Find the ZeroDev smart wallet
  const zerodevWallet = userWallets.find((wallet) =>
    isZeroDevConnector(wallet.connector),
  );

  // Step 1: Authenticate MFA, sign the authorization, and inject it into the connector
  const handleMfaAndSign = async () => {
    if (!zerodevWallet || !isZeroDevConnector(zerodevWallet.connector)) {
      throw new Error('No ZeroDev wallet available');
    }

    // Prompt the user to complete MFA — the SDK stores the token in state automatically
    const mfaToken = await promptMfaAuth({ createMfaToken: true });
    if (!mfaToken) throw new Error('MFA verification failed');

    // Sign the EIP-7702 authorization — the SDK consumes the MFA token from state
    const auth = await signEip7702Authorization({ chainId: 11155111 }); // replace with your chain ID

    // Inject the signed auth into the connector so the kernel client is rebuilt with it
    await zerodevWallet.connector.setEip7702Auth(auth);
  };

  // Step 2: Execute a transaction — the kernel client already has the pre-signed auth baked in
  const handleExecuteTransaction = async () => {
    if (!zerodevWallet || !isZeroDevConnector(zerodevWallet.connector)) {
      throw new Error('No ZeroDev wallet available');
    }

    const kernelClient = zerodevWallet.connector.getAccountAbstractionProvider();
    if (!kernelClient) throw new Error('Kernel client not available');

    const hash = await kernelClient.sendTransaction({
      data: '0x',
      to: '0xRecipientAddress',
      value: parseEther('0.001'),
    });

    console.log('Transaction hash:', hash);
  };

  return (
    <div>
      <button onClick={handleMfaAndSign}>Step 1: Authenticate MFA & Sign Authorization</button>
      <button onClick={handleExecuteTransaction}>Step 2: Execute Transaction</button>
    </div>
  );
}

import { FC, FormEventHandler, useState } from 'react';
import { getERC20PaymasterApproveCall } from '@zerodev/sdk';
import { createZeroDevPaymasterClient } from '@zerodev/sdk/clients';
import { getEntryPoint, KERNEL_V3_3 } from '@zerodev/sdk/constants';
import { Hex, http, parseEther } from 'viem';
import { createEcdsaKernelAccountClientWith7702 } from '@dynamic-labs/ethereum-aa';
import { chainsMap, isEthereumWallet } from '@dynamic-labs/ethereum-core';
import { useDynamicContext, useSmartWallets } from '@dynamic-labs/sdk-react-core';
import { isDynamicWaasConnector } from '@dynamic-labs/wallet-connector-core';

export const ERC20PaymasterExample: FC = () => {
  const { primaryWallet } = useDynamicContext();
  const { getEOAWallet } = useSmartWallets();

  const [address, setAddress] = useState('');
  const [amount, setAmount] = useState('');
  const [erc20TokenAddress, setErc20TokenAddress] = useState(
    '0x036CbD53842c5426634e7929541eC2318f3dCF7e' // Example token address
  );
  const [result, setResult] = useState('');

  if (!primaryWallet || !isEthereumWallet(primaryWallet)) {
    return <div>ERC20 paymaster is only supported for Ethereum wallets</div>;
  }

  const onSubmit: FormEventHandler<HTMLFormElement> = async (event) => {
    event.preventDefault();

    try {
      setResult('Creating ZeroDev kernel client...');

      const eoaWallet = getEOAWallet(primaryWallet);
      if (!eoaWallet) throw new Error('No EOA wallet found');
      if (!isDynamicWaasConnector(eoaWallet.connector)) {
        throw new Error('Connector is not a Dynamic Waas connector');
      }

      // Get the signer from the primary wallet
      const signer = await eoaWallet.connector.getWalletClient();
      const network = await primaryWallet.getNetwork();
      if (!network) throw new Error('No network found');

      const chain = chainsMap[network.toString()];
      if (!chain) throw new Error(`Unsupported chain: ${network}`);

      // ZeroDev configuration - replace with your actual project ID
      const projectId = 'YOUR_ZERODEV_PROJECT_ID';
      const entryPoint = getEntryPoint('0.7');

      setResult('Creating kernel client with ERC20 paymaster...');

      // Create the kernel client with EIP-7702 and ERC20 paymaster, use createEcdsaKernelAccountClient if you are not using EIP-7702
      const kernelClient = await createEcdsaKernelAccountClientWith7702({
        apiKernelVersion: KERNEL_V3_3, // Use KERNEL_V3_3 for EIP-7702 compatibility or get this info from our dashboard
        chain,
        enableKernelV3Migration: true, // If you want to migrate users to the new kernel version
        entryPoint,
        kernelVersion: KERNEL_V3_3, // Use KERNEL_V3_3 for EIP-7702 compatibility or get this info from our dashboard
        paymaster: erc20TokenAddress as Hex, // Use your ERC20 token address here
        projectId,
        signer,
      });

      // Create paymaster client for approval
      const paymasterClient = createZeroDevPaymasterClient({
        chain,
        transport: http(`https://rpc.zerodev.app/api/v2/paymaster/${projectId}`),
      });

      setResult('Sending transaction with ERC20 approval...');

      // Prepare the transaction with batched approval
      const value = parseEther(amount);
      const callData = await kernelClient.account.encodeCalls([
        // The ERC20 approval for paymaster
        await getERC20PaymasterApproveCall(paymasterClient, {
          approveAmount: parseEther('0.1'),
          entryPoint,
          gasToken: erc20TokenAddress as Hex,
        }),
        // The actual transaction call
        {
          data: '0x' as Hex,
          to: address as Hex,
          value,
        },
      ]);

      // Send the user operation
      const hash = await kernelClient.sendUserOperation({ callData });
      setResult(`Transaction sent! User operation hash: ${hash}`);

      // Wait for the transaction receipt
      const receipt = await kernelClient.waitForUserOperationReceipt({ hash });
      setResult(`Transaction confirmed! Receipt: ${JSON.stringify(receipt, null, 2)}`);
    } catch (error) {
      setResult(`Transaction failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
    }
  };

  return (
    <form onSubmit={onSubmit}>
      <div>
        <label htmlFor="address">Target address</label>
        <input
          value={address}
          onChange={({ target }) => setAddress(target.value)}
          name="address"
          id="address"
          type="text"
          required
          placeholder="0x..."
        />
      </div>

      <div>
        <label htmlFor="amount">Transaction amount (in ETH)</label>
        <input
          value={amount}
          onChange={({ target }) => setAmount(target.value)}
          name="amount"
          id="amount"
          type="text"
          required
          placeholder="0.05"
        />
      </div>

      <div>
        <label htmlFor="erc20TokenAddress">ERC20 Paymaster Token Address</label>
        <input
          value={erc20TokenAddress}
          onChange={({ target }) => setErc20TokenAddress(target.value)}
          name="erc20TokenAddress"
          id="erc20TokenAddress"
          type="text"
          required
          placeholder="0xA0b86a33E6441b8b5d865Db8a6E05e70b4cfB4be"
        />
      </div>

      <button type="submit">
        Send with ZeroDev (EIP-7702 + ERC20 Paymaster)
      </button>

      {result && (
        <pre style={{ whiteSpace: 'pre-wrap' }}>
          {result}
        </pre>
      )}
    </form>
  );
};