@reality.eth/contracts 3.2.25 → 3.2.27

package/scripts/deploy.js

@@ -18,20 +18,7 @@ const deployed_at = null;
 var undef;
 
 const defaultConfigs = {
-    //maxFeePerGas:         610000000000,
-    //maxPriorityFeePerGas:  10000000000,
-    //gasPrice: 70000000000,
-    //gasPrice:   10000000000,
-    // gasPrice:   100000000,
-    // gasPrice: 10000, // optimism 1000000,
-    /// gasPrice: 5000000000,
-    //gasLimit: 6000000, // optimism 4500000
     gasLimit: 4500000,
-    //etherscanApiKey: 'TPA4BFDDIH8Q7YBQ4JMGN6WDDRRPAV6G34'
-    //gasLimit: 155734867 // arbitrum
-    //gasLimit: 7000000
-    //gasLimit:   800035294
-    // gasLimit: 4291955938
 }
 const task = process.argv[2]
 const version = process.argv[3]
@@ -74,6 +61,7 @@ const chains = {
     'backstopTestnet1': 88558801
 }
 const non_infura_chains = {
+    'mainnet': 'http://127.0.0.1:8545',
     'gnosis': 'https://gnosis.oat.farm',
     'scroll-alpha-testnet': 'https://alpha-rpc.scroll.io/l2',
     'sokol': 'https://sokol.poa.network',
@@ -94,7 +82,7 @@ const non_infura_chains = {
     'kintsugi': 'https://rpc.kintsugi.themerge.dev',
     'monad': 'https://rpc.monad.xyz',
     'mumbai': 'https://matic-mumbai.chainstacklabs.com',
-    'sepolia': 'https://sepolia.backstop.technology/', // 'https://rpc.sepolia.org',
+    'sepolia': 'http://127.0.0.1:8546',
     'holesky': 'https://ethereum-holesky.publicnode.com',
     'telosevm': 'https://mainnet.telos.net/evm',
     'unichain': 'https://mainnet.unichain.org',
@@ -252,25 +240,17 @@ function realityETHName() {
     return tmpl;
 }
 
+// Fetch current fee data and return EIP-1559 overrides: { maxFeePerGas, maxPriorityFeePerGas }.
+// tip comes from eth_maxPriorityFeePerGas (actual market rate, not ethers v5's hardcoded 1.5 gwei).
+// maxFeePerGas = baseFee * 2 + tip (gives headroom for a few blocks of fee movement).
 async function waitForGas(provider) {
-    if (!defaultConfigs.maxFeePerGas) {
-        return true;
-    }
-    // console.log('in waitForGas');
-    const sleep = (milliseconds) => {
-      return new Promise(resolve => setTimeout(resolve, milliseconds))
-    }
-
-    const f = await provider.getFeeData()
-     console.log('fee', f)
-throw new Error();
-return;
-    if (f.gasPrice.gt(ethers.BigNumber.from(defaultConfigs.maxFeePerGas))) {
-        console.log('Gas is too expensive, got', f.gasPrice.toString(), 'but you will only pay ', defaultConfigs.maxFeePerGas, ', retrying...')
-        await sleep(2000);
-        await waitForGas(provider);
-    } 
-    return true;
+    const block = await provider.getBlock('latest');
+    const base = block.baseFeePerGas || ethers.BigNumber.from(0);
+    const tipHex = await provider.send('eth_maxPriorityFeePerGas', []);
+    const tip = ethers.BigNumber.from(tipHex);
+    const maxFee = base.mul(2).add(tip);
+    console.log('base fee:', base.toString(), 'tip:', tip.toString(), 'maxFee:', maxFee.toString());
+    return { maxFeePerGas: maxFee, maxPriorityFeePerGas: tip };
 }
 
 async function deployRealityETH() {
@@ -287,7 +267,8 @@ async function deployRealityETH() {
     txt = txt + ' (from address ' + signer.address + ')';
     console.log(txt);
 
-    await waitForGas(provider);
+    const feeOverrides = await waitForGas(provider);
+    const txConfig = { ...defaultConfigs, ...feeOverrides };
 
     if (deployed_at) {
 
@@ -311,7 +292,7 @@ async function deployRealityETH() {
         }
 
     } else {
-        confac.deploy(defaultConfigs).then(function(result) {
+        confac.deploy(txConfig).then(function(result) {
             const txid = result.deployTransaction.hash;
             const address = result.address;
             console.log('storing address', address);
@@ -327,7 +308,7 @@ async function deployRealityETH() {
                 }
 
                 //console.log('result was', result);
-                store_deployed_contract(tmpl, chain_id, token_name, settings); 
+                store_deployed_contract(tmpl, chain_id, token_name, settings);
                 if (isERC20()) {
                     console.log('Setting token')
                     result.setToken(token_address);
@@ -442,9 +423,10 @@ async function deployFactory() {
     txt = txt + ' (from address ' + signer.address + ')';
     console.log(txt);
 
-    await waitForGas(provider);
+    const feeOverrides = await waitForGas(provider);
+    const txConfig = { ...defaultConfigs, ...feeOverrides };
 
-    confac.deploy(lib, defaultConfigs).then(function(result) {
+    confac.deploy(lib, txConfig).then(function(result) {
         const txid = result.deployTransaction.hash;
         const address = result.address;
         console.log('storing address', address);

package/scripts/fetch-templates.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+// Fetches all templates from every deployed RealityETH contract across all chains.
+//
+// The contracts().templates(id) view returns the block number where
+// LogNewTemplate was emitted for that template ID, or 0 if it doesn't exist.
+// We call it for IDs 0, 1, 2, ... stopping at the first 0.
+// For each unique block number we get a single pinpoint getLogs call that
+// retrieves all LogNewTemplate events in that block for that contract.
+//
+// Usage:
+//   cd packages/contracts && node scripts/fetch-templates.js
+//
+// Output: generated/custom-templates.json
+//
+// Errors (e.g. RPC nodes that don't serve old logs) are written to _errors in
+// the output so the file can be checked in and specific failures retried later
+// with a different RPC.
+
+'use strict';
+const fs   = require('fs');
+const path = require('path');
+const ethers = require('ethers');
+
+const CONTRACTS_JSON  = path.join(__dirname, '../generated/contracts.json');
+const SUPPORTED_JSON  = path.join(__dirname, '../chains/supported.json');
+const CHAINID_NET_JSON = path.join(__dirname, '../chains/chainid.network.json');
+const OUTPUT_PATH     = path.join(__dirname, '../generated/custom-templates.json');
+
+const TEMPLATES_ABI = [
+  'function templates(uint256 template_id) view returns (uint256)',
+];
+
+const LOG_TEMPLATE_TOPIC = ethers.utils.id('LogNewTemplate(uint256,address,string)');
+
+const iface = new ethers.utils.Interface([
+  'event LogNewTemplate(uint256 indexed template_id, address indexed user, string question_text)',
+]);
+
+function sleep(ms) { return new Promise(r => setTimeout(r, ms)); }
+
+async function fetchForContract(prov, chainId, address, existingTemplates, errors) {
+  const rc = new ethers.Contract(address, TEMPLATES_ABI, prov);
+  const templates = Object.assign({}, existingTemplates);
+  const blocksQueried = new Set();
+
+  for (let id = 0; ; id++) {
+    let blockNum;
+    try {
+      const bn = await rc.templates(id);
+      blockNum = bn.toNumber();
+    } catch (err) {
+      const msg = err.message || String(err);
+      console.error(`  ✗ templates(${id}): ${msg.slice(0, 120)}`);
+      errors.push({ chainId, contract: address, templateId: id, phase: 'templates()', error: msg });
+      break;
+    }
+
+    if (blockNum === 0) {
+      console.log(`  templates(${id}) = 0  — done (${id} template${id !== 1 ? 's' : ''})`);
+      break;
+    }
+
+    console.log(`  templates(${id}) = block ${blockNum}`);
+
+    if (!blocksQueried.has(blockNum)) {
+      blocksQueried.add(blockNum);
+      try {
+        const logs = await prov.getLogs({
+          address,
+          topics: [LOG_TEMPLATE_TOPIC],
+          fromBlock: blockNum,
+          toBlock:   blockNum,
+        });
+        for (const log of logs) {
+          try {
+            const parsed = iface.parseLog(log);
+            const tid  = parsed.args.template_id.toString();
+            const text = parsed.args.question_text;
+            templates[tid] = text;
+            console.log(`    ✓ template ${tid}: ${text.slice(0, 80)}${text.length > 80 ? '…' : ''}`);
+          } catch (parseErr) {
+            console.error(`    ✗ log parse failed: ${parseErr.message}`);
+          }
+        }
+        await sleep(150);
+      } catch (logErr) {
+        const msg = logErr.message || String(logErr);
+        console.error(`  ✗ getLogs(block ${blockNum}): ${msg.slice(0, 120)}`);
+        errors.push({ chainId, contract: address, block: blockNum, phase: 'getLogs', error: msg });
+        // Don't break — continue to next template ID in case we can get the block number at least
+      }
+    }
+
+    await sleep(150);
+  }
+
+  return templates;
+}
+
+function pickRpc(chainId, supported, publicRpcs) {
+  // Highest priority: env var (same convention as the indexer's .env.local)
+  const envRpc = process.env[`PONDER_RPC_URL_${chainId}`];
+  if (envRpc) return envRpc;
+  if (supported[chainId]?.hostedRPC) return supported[chainId].hostedRPC;
+  // Fall back to first public (non-template) HTTP RPC from chainid.network.json
+  const pub = (publicRpcs[chainId] || []).find(r => !r.includes('${') && r.startsWith('http'));
+  return pub || null;
+}
+
+async function main() {
+  const allContracts = JSON.parse(fs.readFileSync(CONTRACTS_JSON, 'utf8'));
+  const supported    = JSON.parse(fs.readFileSync(SUPPORTED_JSON, 'utf8'));
+  const cidList      = JSON.parse(fs.readFileSync(CHAINID_NET_JSON, 'utf8'));
+  const publicRpcs   = Object.fromEntries(
+    cidList.filter(c => c.chainId).map(c => [String(c.chainId), c.rpc || []])
+  );
+
+  // Load existing output so we can skip already-complete contracts
+  let existing = { _errors: [] };
+  if (fs.existsSync(OUTPUT_PATH)) {
+    try {
+      existing = JSON.parse(fs.readFileSync(OUTPUT_PATH, 'utf8'));
+      console.log(`Loaded existing output from ${OUTPUT_PATH}`);
+    } catch { /* start fresh */ }
+  }
+
+  const output   = { _errors: [] };
+  let totalContracts = 0;
+  let skipped = 0;
+
+  for (const [chainId, tokenMap] of Object.entries(allContracts)) {
+    const rpcUrl = pickRpc(chainId, supported, publicRpcs);
+    if (!rpcUrl) {
+      console.log(`\nChain ${chainId}: no RPC available, skipping`);
+      continue;
+    }
+
+    output[chainId] = output[chainId] || {};
+
+    // Collect unique RealityETH contract addresses — skip arbitrators etc.
+    const seen = new Set();
+    const toFetch = [];
+    for (const [token, vers] of Object.entries(tokenMap)) {
+      for (const [ver, info] of Object.entries(vers)) {
+        if (!info.address) continue;
+        if (!ver.includes('RealityETH')) continue;
+        const lc = info.address.toLowerCase();
+        if (seen.has(lc)) continue;
+        seen.add(lc);
+        toFetch.push({ address: lc, ver, token });
+      }
+    }
+
+    if (!toFetch.length) continue;
+
+    const prov = new ethers.providers.JsonRpcProvider(rpcUrl, {
+      chainId: Number(chainId),
+      name:    `chain-${chainId}`,
+    });
+
+    for (const { address, ver } of toFetch) {
+      totalContracts++;
+      const chainExisting = existing[chainId] || {};
+      const contractExisting = chainExisting[address];
+
+      // Skip if already marked complete in a previous run
+      if (contractExisting && contractExisting._complete) {
+        console.log(`\nChain ${chainId} ${ver} ${address}  — already complete, skipping`);
+        output[chainId][address] = contractExisting;
+        skipped++;
+        continue;
+      }
+
+      console.log(`\nChain ${chainId}  ${ver}  ${address}  (via ${rpcUrl.slice(0, 50)})`);
+
+      const contractErrors = [];
+      const templates = await fetchForContract(
+        prov, chainId, address,
+        contractExisting || {}, contractErrors
+      );
+      output._errors.push(...contractErrors);
+
+      // Only mark complete if no getLogs errors — incomplete contracts will be
+      // retried automatically on the next run (e.g. with a better RPC set via env).
+      const hasLogGaps = contractErrors.some(e => e.phase === 'getLogs');
+      templates._complete = !hasLogGaps;
+      output[chainId][address] = templates;
+
+      // Save after every contract so progress isn't lost on failure
+      fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+    }
+  }
+
+  // Final save
+  fs.writeFileSync(OUTPUT_PATH, JSON.stringify(output, null, 2));
+
+  console.log(`\n${'='.repeat(60)}`);
+  console.log(`Done. ${totalContracts} contract(s) processed (${skipped} skipped as already complete).`);
+  console.log(`Output: ${OUTPUT_PATH}`);
+
+  if (output._errors.length > 0) {
+    console.log(`\n${output._errors.length} error(s) — check _errors in the output file:`);
+    for (const e of output._errors) {
+      console.log(`  chain ${e.chainId}  ${e.contract}  ${e.phase}${e.block ? `  block ${e.block}` : `  id ${e.templateId}`}: ${e.error.slice(0, 80)}`);
+    }
+  } else {
+    console.log('No errors.');
+  }
+}
+
+main().catch(err => {
+  console.error('\nFatal error:', err.message || err);
+  process.exit(1);
+});

package/scripts/generate_chains_json.js

@@ -77,10 +77,22 @@ for (var ci = 0; ci< chain_id_list.length; ci++) {
         chainparams['network_name'] = our_data['network_name'];
     }
 
+    if (our_data['display_name']) {
+        chainparams['display_name'] = our_data['display_name'];
+    }
+
     if (our_data['deprecated']) {
         chainparams['deprecated'] = true;
     }
 
+    if (our_data['realityETHIndexerSupport']) {
+        chainparams['realityETHIndexerSupport'] = true;
+    }
+
+    if (our_data['blocksPerDay']) {
+        chainparams['blocksPerDay'] = our_data['blocksPerDay'];
+    }
+
     chainparams['blockExplorerUrls'] = [];
     if ('explorers' in chain_info) {
         for(var exi in chain_info['explorers']) {

package/scripts/generate_contract_token_lookup.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+// Generates generated/contract_token_lookup.json:
+//   { chainId: { contractAddress: { symbol, decimals, approx_1_usd } } }
+// Used by both the custom indexer and ponder to compute USD bond values.
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const GEN_DIR      = path.join(__dirname, '..', 'generated');
+const CONTRACTS    = JSON.parse(fs.readFileSync(path.join(GEN_DIR, 'contracts.json'), 'utf8'));
+const TOKENS       = JSON.parse(fs.readFileSync(path.join(GEN_DIR, 'tokens.json'), 'utf8'));
+
+const lookup = {};
+
+for (const [chainId, tokenMap] of Object.entries(CONTRACTS)) {
+  for (const [symbol, contractMap] of Object.entries(tokenMap)) {
+    const tokenInfo = TOKENS[symbol];
+    if (!tokenInfo) {
+      console.warn(`  Unknown token symbol: ${symbol} (chain ${chainId})`);
+      continue;
+    }
+    const { decimals, approx_1_usd } = tokenInfo;
+    if (approx_1_usd == null) {
+      console.warn(`  No approx_1_usd for ${symbol} — run update_token_prices.js first`);
+      continue;
+    }
+    if (!lookup[chainId]) lookup[chainId] = {};
+    for (const contractDef of Object.values(contractMap)) {
+      const addr = contractDef.address.toLowerCase();
+      lookup[chainId][addr] = { symbol, decimals, approx_1_usd };
+    }
+  }
+}
+
+const outPath = path.join(GEN_DIR, 'contract_token_lookup.json');
+fs.writeFileSync(outPath, JSON.stringify(lookup, null, 2) + '\n');
+console.log(`Written: ${outPath}`);
+console.log(`Chains: ${Object.keys(lookup).length}, contracts: ${Object.values(lookup).reduce((s, m) => s + Object.keys(m).length, 0)}`);

package/scripts/generate_indexer_config.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// AUTO-GENERATES two files from contracts.json + chains.json:
+//   packages/indexer/active-chains.json      — chain list for sync.js ACTIVE_CHAINS
+//   packages/indexer/scripts/chains-config.json — chain/explorer config for fetch-event-blocks.js
+//
+// Reads realityETHIndexerSupport, indexer_batch_size, indexer_name, and explorer_api_*
+// fields from supported.json to drive generation.
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const contractsDir = path.resolve(__dirname, '..');
+const contracts    = JSON.parse(fs.readFileSync(path.join(contractsDir, 'generated/contracts.json'), 'utf8'));
+const chains       = JSON.parse(fs.readFileSync(path.join(contractsDir, 'generated/chains.json'), 'utf8'));
+const supported    = JSON.parse(fs.readFileSync(path.join(contractsDir, 'chains/supported.json'), 'utf8'));
+
+const ETHERSCAN_V2  = 'https://api.etherscan.io/v2/api';
+const DEFAULT_BATCH = 5_000;
+
+// Skip arbitrators and pre-release versions.
+function isSkipped(ver) {
+  return ver.startsWith('Arbitrator') || ver.endsWith('-rc1') || ver.endsWith('-rc2');
+}
+
+// Name used in indexer logs and as the fetch-event-blocks.js CHAINS key.
+// Prefers supported.json indexer_name, then normalized network_name.
+function indexerName(id) {
+  const sup = supported[String(id)] || {};
+  if (sup.indexer_name) return sup.indexer_name;
+  const nn = chains[String(id)]?.network_name;
+  if (!nn) return `chain_${id}`;
+  return nn.toLowerCase().replace(/[-\s]+/g, '_');
+}
+
+// Short label for the contracts[] name field in chains-config.json.
+// Must be unique within each chain since it's used as a meta key for HWM tracking.
+function contractLabel(token, ver) {
+  const m = ver.match(/-(\d+\.\d+)$/);
+  const v = m ? m[1] : '?';
+  return ver.startsWith('RealityETH_ERC20-') ? `ERC20-${token}-v${v}` : `v${v}`;
+}
+
+// Chain IDs that have realityETHIndexerSupport set in chains.json.
+const indexedIds = Object.keys(chains)
+  .map(Number)
+  .filter(id => chains[String(id)]?.realityETHIndexerSupport)
+  .sort((a, b) => a - b);
+
+const activeChains = [];
+const chainsConfig = {};
+
+for (const chainId of indexedIds) {
+  const sup     = supported[String(chainId)] || {};
+  const byToken = contracts[String(chainId)] || {};
+  const name    = indexerName(chainId);
+
+  // Collect all non-skipped contract addresses with their start blocks.
+  const entries = [];
+  for (const [token, byVersion] of Object.entries(byToken)) {
+    for (const [ver, data] of Object.entries(byVersion)) {
+      if (isSkipped(ver)) continue;
+      const addrs = Array.isArray(data.address) ? data.address : [data.address];
+      for (const addr of addrs.filter(Boolean)) {
+        entries.push({
+          address:    addr.toLowerCase(),
+          startBlock: data.block || 0,
+          label:      contractLabel(token, ver),
+        });
+      }
+    }
+  }
+  if (!entries.length) continue;
+  entries.sort((a, b) => a.startBlock - b.startBlock);
+
+  // active-chains.json entry (consumed by sync.js mkChain).
+  activeChains.push({
+    id:             chainId,
+    name,
+    batchSize:      sup.indexer_batch_size || DEFAULT_BATCH,
+    noExplorerRefresh: !!sup.no_explorer_refresh,
+    startBlock:     entries[0].startBlock,
+    addresses:      entries.map(e => e.address),
+  });
+
+  // chains-config.json entry (consumed by fetch-event-blocks.js).
+  // Default: Etherscan V2 with chainId param and ETHERSCAN_API_KEY.
+  // Overrides come from explorer_api_* fields in supported.json.
+  const apiUrl     = sup.explorer_api_url || ETHERSCAN_V2;
+  const apiKeyEnv  = 'explorer_api_key_env' in sup ? sup.explorer_api_key_env : 'ETHERSCAN_API_KEY';
+  const apiKeyReq  = sup.explorer_api_key_required || false;
+  const apiChainId = sup.explorer_api_no_chain_id ? null : chainId;
+
+  chainsConfig[name] = {
+    chainId:        apiChainId,
+    apiUrl,
+    apiKeyEnv,
+    apiKeyRequired: apiKeyReq,
+    contracts:      entries.map(e => ({ address: e.address, startBlock: e.startBlock, name: e.label })),
+  };
+}
+
+const activeChainPath  = path.resolve(contractsDir, '../indexer/active-chains.json');
+const chainsConfigPath = path.resolve(contractsDir, '../indexer/scripts/chains-config.json');
+
+fs.writeFileSync(activeChainPath,  JSON.stringify(activeChains,  null, 2) + '\n');
+console.log('Wrote', activeChainPath);
+
+fs.writeFileSync(chainsConfigPath, JSON.stringify(chainsConfig, null, 2) + '\n');
+console.log('Wrote', chainsConfigPath);