zkSync Era - zkEVM Layer 2 Documentation

// Watch for transaction confirmation on zkSync Era
async function waitForTransaction(txHash) {
  const receipt = await provider.waitForTransaction(txHash, 1);

  // zkSync Era specific: Instant finality
  console.log('Transaction confirmed:', receipt.status === 1);
  console.log('Block number:', receipt.blockNumber);

  return receipt;
}

// Estimate gas for zkSync Era transaction
const gasEstimate = await provider.estimateGas(tx);

// Get current gas price
const gasPrice = await provider.getGasPrice();

// Calculate total cost (no L1 data fees on zkSync Era)
const totalCost = gasEstimate * gasPrice;

// zkSync Era supports paying fees with any ERC20 token
console.log('Total cost in ETH:', totalCost.toString());

// Query events with automatic retry and pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 10000; // zkSync Era supports larger batch sizes

  for (let i = fromBlock; i <= currentBlock; i += batchSize) {
    const batch = await contract.queryFilter(
      filter,
      i,
      Math.min(i + batchSize - 1, currentBlock)
    );
    events.push(...batch);
  }

  return events;
}

const batch = [
  { method: 'eth_blockNumber', params: [] },
  { method: 'eth_gasPrice', params: [] },
  { method: 'eth_getBalance', params: [address, 'latest'] }
];

const results = await provider.send(batch);

// Singleton pattern for provider
class ZkSyncProvider {
  static instance = null;

  static getInstance() {
    if (!this.instance) {
      this.instance = new JsonRpcProvider(
        'https://api-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY'
      );
    }
    return this.instance;
  }
}

const cache = new Map();

async function getCachedBlockData(blockNumber) {
  const key = `block_${blockNumber}`;

  if (!cache.has(key)) {
    const block = await provider.getBlock(blockNumber);
    cache.set(key, block);
  }

  return cache.get(key);
}

// Check ETH balance for gas fees
const balance = await provider.getBalance(address);
const gasEstimate = await provider.estimateGas(tx);
const gasPrice = await provider.getGasPrice();
const totalRequired = gasEstimate * gasPrice + tx.value;

if (balance < totalRequired) {
  console.log(`Need ${totalRequired - balance} more ETH`);
  // Alternative: Use paymaster for ERC20 fee payment
}

// Get current fee data
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  maxFeePerGas: feeData.maxFeePerGas,
  maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
  gasLimit: 21000n,
  type: 2 // EIP-1559 transaction
};

async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 2 ** i * 1000));
      } else {
        throw error;
      }
    }
  }
}

// Before (Ethereum)
const provider = new JsonRpcProvider('https://eth-rpc.example.com');

// After (zkSync Era)
const provider = new JsonRpcProvider(
  'https://api-zksync-era-mainnet-full.n.dwellir.com/YOUR_API_KEY'
);

// Smart contracts work identically (EVM compatible)
// Same tooling and libraries
// Account abstraction support
// Note: Different chain ID (324)
// Note: Separate block numbers
// Note: Zero-knowledge proof finality

// Test 1: Verify chain connection
const chainId = await provider.send('eth_chainId', []);
console.assert(parseInt(chainId, 16) === 324, 'Connected to zkSync Era');

// Test 2: Check latest block
const blockNumber = await provider.send('eth_blockNumber', []);
console.log('Latest block:', parseInt(blockNumber, 16));

// Test 3: Query a known contract (USDC)
const usdcBalance = await provider.send('eth_call', [{
  to: '0x3355df6D4c9C3035724Fd0e3914dE96A5a83aaf4',
  data: '0x70a08231000000000000000000000000000000000000000000000000000000000000800a'
}, 'latest']);
console.log('USDC balance call successful:', usdcBalance);