Zora - Creator Economy & NFT L2 Documentation

// Mint NFT with creator rewards
async function mintNFTWithRewards(contract, to, tokenURI) {
  const tx = {
    to: contract.address,
    data: contract.interface.encodeFunctionData('mint', [to, tokenURI]),
    // Zora rewards: 0.000777 ETH per mint
    value: parseEther('0.000777')
  };

  const receipt = await provider.sendTransaction(tx);

  // Check for creator reward distribution
  const rewardEvents = receipt.logs.filter(log =>
    log.topics[0] === creatorRewardEventSignature
  );

  return { receipt, rewards: rewardEvents };
}

// Watch for NFT transfers in real-time
const nftFilter = {
  address: contractAddress,
  topics: [
    '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef', // Transfer
    null, // from (any)
    null  // to (any)
  ]
};

provider.on(nftFilter, (log) => {
  const transfer = parseLog(log);
  console.log(`NFT ${transfer.tokenId} transferred from ${transfer.from} to ${transfer.to}`);
});

// Calculate total creator rewards
async function getCreatorEarnings(creatorAddress, fromBlock = 0) {
  const rewardFilter = {
    address: ZORA_REWARDS_CONTRACT,
    topics: [
      '0x...', // RewardPaid event signature
      ethers.utils.hexZeroPad(creatorAddress, 32)
    ]
  };

  const logs = await provider.getLogs({
    ...rewardFilter,
    fromBlock,
    toBlock: 'latest'
  });

  const totalRewards = logs.reduce((sum, log) => {
    const reward = parseLog(log);
    return sum.add(reward.amount);
  }, BigNumber.from(0));

  return totalRewards;
}

// Batch query NFT metadata
async function getNFTBatch(contractAddress, tokenIds) {
  const contract = new Contract(contractAddress, erc721Abi, provider);
  const batchSize = 50; // Zora recommended batch size

  const results = [];
  for (let i = 0; i < tokenIds.length; i += batchSize) {
    const batch = tokenIds.slice(i, i + batchSize);

    const promises = batch.map(async (tokenId) => ({
      tokenId,
      owner: await contract.ownerOf(tokenId),
      tokenURI: await contract.tokenURI(tokenId),
    }));

    const batchResults = await Promise.all(promises);
    results.push(...batchResults);
  }

  return results;
}

// Batch mint for gas efficiency
async function batchMintNFTs(contract, recipients, tokenURIs) {
  const batchData = recipients.map((to, i) =>
    contract.interface.encodeFunctionData('mint', [to, tokenURIs[i]])
  );

  const multicallData = contract.interface.encodeFunctionData('multicall', [batchData]);

  return await contract.multicall(batchData, {
    value: parseEther((0.000777 * recipients.length).toString())
  });
}

const metadataCache = new Map();

async function getCachedMetadata(tokenURI) {
  if (!metadataCache.has(tokenURI)) {
    const response = await fetch(tokenURI);
    const metadata = await response.json();
    metadataCache.set(tokenURI, metadata);
  }

  return metadataCache.get(tokenURI);
}

// Listen for all creator-relevant events
const eventFilters = [
  { topics: [transferEventSignature] }, // NFT transfers
  { topics: [mintEventSignature] },     // New mints
  { topics: [saleEventSignature] },     // Marketplace sales
  { topics: [rewardEventSignature] }    // Creator rewards
];

eventFilters.forEach(filter => {
  provider.on(filter, handleCreatorEvent);
});

function handleCreatorEvent(log) {
  const eventType = identifyEventType(log);

  switch(eventType) {
    case 'TRANSFER':
      updateOwnershipRecords(log);
      break;
    case 'MINT':
      trackNewCreation(log);
      break;
    case 'SALE':
      updateCreatorEarnings(log);
      break;
    case 'REWARD':
      distributeMintRewards(log);
      break;
  }
}

// Always include mint reward in NFT transactions
const mintTx = {
  to: nftContract.address,
  data: mintData,
  value: parseEther('0.000777'), // Required for Zora rewards
  gasLimit: 100000n
};

async function safeGetTokenURI(contract, tokenId) {
  try {
    return await contract.tokenURI(tokenId);
  } catch (error) {
    if (error.reason === 'ERC721: invalid token ID') {
      return null; // Token doesn't exist yet
    }
    throw error; // Re-throw other errors
  }
}

async function mintWithRetry(contract, params, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await contract.mint(...params);
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        const delay = Math.min(2 ** i * 1000, 10000); // Cap at 10s
        await new Promise(r => setTimeout(r, delay));
      } else {
        throw error;
      }
    }
  }
}

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

// After (Zora L2)
const provider = new JsonRpcProvider(
  'https://api-zora-mainnet.n.dwellir.com/YOUR_API_KEY'
);

// Same NFT standards (ERC-721, ERC-1155)
// Same tooling and libraries work
// Dramatically lower fees
// Note: Different chain ID (7777777)
// Note: Creator rewards system (0.000777 ETH)
// Note: L1 data fees apply

// Enhanced creator benefits on Zora:
// - Built-in mint rewards (0.000777 ETH per mint)
// - Lower gas fees than Polygon
// - Native creator tools and royalty enforcement
// - Better Ethereum ecosystem integration