EVM

npx capx-compose@latest my-app --plugins=evm
cd my-app
npm run dev

NEXT_PUBLIC_ALCHEMY_ID=your_alchemy_id
NEXT_PUBLIC_WALLET_CONNECT_ID=your_wc_id
NEXT_PUBLIC_DEFAULT_CHAIN=mainnet

import { createConfig, configureChains } from 'wagmi';
import { mainnet, polygon, arbitrum, optimism } from 'wagmi/chains';
import { alchemyProvider } from 'wagmi/providers/alchemy';
import { publicProvider } from 'wagmi/providers/public';

const { chains, publicClient } = configureChains(
  [mainnet, polygon, arbitrum, optimism],
  [
    alchemyProvider({ apiKey: process.env.NEXT_PUBLIC_ALCHEMY_ID }),
    publicProvider()
  ]
);

export const wagmiConfig = createConfig({
  autoConnect: true,
  connectors: [
    new MetaMaskConnector({ chains }),
    new WalletConnectConnector({
      chains,
      options: {
        projectId: process.env.NEXT_PUBLIC_WALLET_CONNECT_ID,
      },
    }),
  ],
  publicClient,
});

import { useContractRead } from 'wagmi';

function useTokenBalance(address: string) {
  const { data, isError, isLoading } = useContractRead({
    address: TOKEN_CONTRACT_ADDRESS,
    abi: ERC20_ABI,
    functionName: 'balanceOf',
    args: [address],
  });
  
  return { balance: data, isError, isLoading };
}

import { useContractWrite, usePrepareContractWrite } from 'wagmi';

function TransferToken() {
  const { config } = usePrepareContractWrite({
    address: TOKEN_CONTRACT_ADDRESS,
    abi: ERC20_ABI,
    functionName: 'transfer',
    args: [recipientAddress, amount],
  });
  
  const { write, isLoading } = useContractWrite(config);
  
  return (
    <button onClick={() => write?.()} disabled={!write || isLoading}>
      Transfer
    </button>
  );
}

import { ethers } from 'ethers';

async function deployContract() {
  const provider = new ethers.BrowserProvider(window.ethereum);
  const signer = await provider.getSigner();
  
  const Contract = new ethers.ContractFactory(abi, bytecode, signer);
  const contract = await Contract.deploy();
  await contract.waitForDeployment();
  
  return contract.target;
}

async function approveToken(spender: string, amount: bigint) {
  const contract = new ethers.Contract(tokenAddress, ERC20_ABI, signer);
  const tx = await contract.approve(spender, amount);
  await tx.wait();
}

async function getTokenMetadata(address: string) {
  const contract = new ethers.Contract(address, ERC20_ABI, provider);
  const [name, symbol, decimals] = await Promise.all([
    contract.name(),
    contract.symbol(),
    contract.decimals(),
  ]);
  
  return { name, symbol, decimals };
}

async function mintNFT(to: string, tokenURI: string) {
  const contract = new ethers.Contract(nftAddress, ERC721_ABI, signer);
  const tx = await contract.safeMint(to, tokenURI);
  const receipt = await tx.wait();
  
  // Get token ID from event
  const event = receipt.logs.find(log => log.eventName === 'Transfer');
  return event.args.tokenId;
}

async function getNFTMetadata(tokenId: number) {
  const contract = new ethers.Contract(nftAddress, ERC721_ABI, provider);
  const uri = await contract.tokenURI(tokenId);
  const response = await fetch(uri);
  return response.json();
}