ethnotary 1.0.0

package/cli/utils/crosschain.js

@@ -0,0 +1,278 @@
+const { ethers } = require('ethers');
+const { getRpcUrl, validateNetwork } = require('./networks');
+const { getContractNetworks, createDecoupledContract } = require('./contracts');
+
+const MULTISIG_ABI = [
+  "function getOwners() view returns (address[])",
+  "function required() view returns (uint)",
+  "function isOwner(address) view returns (bool)",
+  "function pinHash() view returns (bytes32)",
+  "function pinNonce() view returns (uint256)",
+  "function addOwner(address accountOwner, uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC) public",
+  "function removeOwner(address accountOwner, uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC) public",
+  "function replaceOwner(address accountOwner, address newOwner, uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC) public",
+  "function changeRequirement(uint _required, uint[2] calldata _pA, uint[2][2] calldata _pB, uint[2] calldata _pC) public"
+];
+
+/**
+ * Fetch account state from all configured networks
+ */
+async function fetchAccountStateAcrossNetworks(aliasOrAddress, address) {
+  const networks = getContractNetworks(aliasOrAddress);
+  const states = [];
+  
+  for (const networkKey of networks) {
+    try {
+      const rpc = getRpcUrl(networkKey);
+      if (!rpc) continue;
+      
+      const provider = new ethers.JsonRpcProvider(rpc);
+      const multisig = new ethers.Contract(address, MULTISIG_ABI, provider);
+      
+      const [owners, required] = await Promise.all([
+        multisig.getOwners(),
+        multisig.required()
+      ]);
+      
+      states.push({
+        network: networkKey,
+        owners: owners.map(o => o.toLowerCase()),
+        required: Number(required),
+        success: true
+      });
+    } catch (err) {
+      states.push({
+        network: networkKey,
+        error: err.message,
+        success: false
+      });
+    }
+  }
+  
+  return states;
+}
+
+/**
+ * Check if account is in sync across all networks
+ * Returns { inSync: boolean, canonical: { owners, required }, discrepancies: [] }
+ */
+function analyzeAccountSync(states) {
+  const successfulStates = states.filter(s => s.success);
+  
+  if (successfulStates.length === 0) {
+    return { inSync: false, error: 'No networks responded', discrepancies: [] };
+  }
+  
+  if (successfulStates.length === 1) {
+    return { 
+      inSync: true, 
+      canonical: { 
+        owners: successfulStates[0].owners, 
+        required: successfulStates[0].required 
+      },
+      discrepancies: []
+    };
+  }
+  
+  // Find canonical state (most common configuration)
+  const configCounts = {};
+  for (const state of successfulStates) {
+    const key = JSON.stringify({ owners: state.owners.sort(), required: state.required });
+    configCounts[key] = (configCounts[key] || 0) + 1;
+  }
+  
+  // Get the most common configuration
+  const sortedConfigs = Object.entries(configCounts).sort((a, b) => b[1] - a[1]);
+  const canonicalConfig = JSON.parse(sortedConfigs[0][0]);
+  
+  // Find discrepancies
+  const discrepancies = [];
+  for (const state of successfulStates) {
+    const stateKey = JSON.stringify({ owners: state.owners.sort(), required: state.required });
+    const canonicalKey = JSON.stringify({ owners: canonicalConfig.owners.sort(), required: canonicalConfig.required });
+    
+    if (stateKey !== canonicalKey) {
+      const missingOwners = canonicalConfig.owners.filter(o => !state.owners.includes(o));
+      const extraOwners = state.owners.filter(o => !canonicalConfig.owners.includes(o));
+      
+      discrepancies.push({
+        network: state.network,
+        currentOwners: state.owners,
+        currentRequired: state.required,
+        missingOwners,
+        extraOwners,
+        requirementMismatch: state.required !== canonicalConfig.required
+      });
+    }
+  }
+  
+  return {
+    inSync: discrepancies.length === 0,
+    canonical: canonicalConfig,
+    discrepancies,
+    networkCount: successfulStates.length
+  };
+}
+
+/**
+ * Handle decoupling when an account operation fails on some networks
+ */
+function handleDecoupling(alias, address, failedNetworks, out) {
+  const chalk = require('chalk');
+  
+  if (failedNetworks.length === 0) return;
+  
+  out.warn(`\n⚠️  Account is now out of sync on ${failedNetworks.length} network(s):`);
+  
+  for (const { network, error } of failedNetworks) {
+    out.warn(`  - ${network}: ${error}`);
+    
+    // Create decoupled contract alias
+    const decoupled = createDecoupledContract(alias, address, network);
+    out.info(`  Created decoupled alias: ${decoupled.alias}`);
+  }
+  
+  out.info('\nTo re-sync accounts, run:');
+  out.info(chalk.white(`  ethnotary account sync --address ${alias}`));
+}
+
+/**
+ * Pre-flight check for account management operations across all networks
+ * Estimates gas and checks wallet balance on each network
+ * Returns { canProceed, networks: [{ network, gasEstimate, balance, sufficient, error }] }
+ */
+async function preflightAccountOperation(aliasOrAddress, address, walletAddress, operation, operationArgs) {
+  const networks = getContractNetworks(aliasOrAddress);
+  const results = [];
+  let allSufficient = true;
+  let hasErrors = false;
+  
+  for (const networkKey of networks) {
+    try {
+      const rpc = getRpcUrl(networkKey);
+      if (!rpc) {
+        results.push({
+          network: networkKey,
+          error: 'No RPC configured',
+          sufficient: false
+        });
+        hasErrors = true;
+        continue;
+      }
+      
+      const provider = new ethers.JsonRpcProvider(rpc);
+      const multisig = new ethers.Contract(address, MULTISIG_ABI, provider);
+      
+      // Get wallet balance
+      const balance = await provider.getBalance(walletAddress);
+      
+      // Get current gas price
+      const feeData = await provider.getFeeData();
+      const gasPrice = feeData.gasPrice || feeData.maxFeePerGas || ethers.parseUnits('20', 'gwei');
+      
+      // Use fixed gas estimates for account operations
+      // (Can't estimate with mock proof - zkSNARK verifier rejects invalid proofs)
+      // These are conservative estimates based on typical gas usage
+      let gasEstimate;
+      if (operation === 'addOwner' || operation === 'removeOwner') {
+        gasEstimate = 350000n; // ~300k typical + buffer
+      } else if (operation === 'replaceOwner') {
+        gasEstimate = 400000n; // slightly higher for replace
+      } else if (operation === 'changeRequirement') {
+        gasEstimate = 100000n; // simpler operation
+      } else {
+        gasEstimate = 350000n; // default
+      }
+      
+      // Verify contract exists on this network
+      try {
+        const code = await provider.getCode(address);
+        if (code === '0x') {
+          results.push({
+            network: networkKey,
+            error: 'Contract not deployed on this network',
+            balance: ethers.formatEther(balance),
+            sufficient: false
+          });
+          hasErrors = true;
+          allSufficient = false;
+          continue;
+        }
+      } catch (codeErr) {
+        // Continue with balance check even if code check fails
+      }
+      
+      // Add 20% buffer to gas estimate
+      const gasWithBuffer = (gasEstimate * 120n) / 100n;
+      const estimatedCost = gasWithBuffer * gasPrice;
+      const sufficient = balance >= estimatedCost;
+      
+      if (!sufficient) {
+        allSufficient = false;
+      }
+      
+      results.push({
+        network: networkKey,
+        gasEstimate: Number(gasWithBuffer),
+        gasPrice: ethers.formatUnits(gasPrice, 'gwei') + ' gwei',
+        estimatedCost: ethers.formatEther(estimatedCost) + ' ETH',
+        balance: ethers.formatEther(balance) + ' ETH',
+        sufficient,
+        error: null
+      });
+      
+    } catch (err) {
+      results.push({
+        network: networkKey,
+        error: err.message,
+        sufficient: false
+      });
+      hasErrors = true;
+      allSufficient = false;
+    }
+  }
+  
+  return {
+    canProceed: allSufficient && !hasErrors,
+    allSufficient,
+    hasErrors,
+    networks: results
+  };
+}
+
+/**
+ * Display preflight results to user
+ */
+function displayPreflightResults(preflight, out) {
+  const chalk = require('chalk');
+  
+  if (!out.json) {
+    console.log(chalk.cyan('\n📋 Pre-flight Check Results:\n'));
+    
+    for (const result of preflight.networks) {
+      if (result.error) {
+        console.log(chalk.red(`  ✗ ${result.network}: ${result.error}`));
+      } else if (!result.sufficient) {
+        console.log(chalk.yellow(`  ⚠ ${result.network}: Insufficient balance`));
+        console.log(chalk.gray(`      Balance: ${result.balance}`));
+        console.log(chalk.gray(`      Required: ~${result.estimatedCost}`));
+      } else {
+        console.log(chalk.green(`  ✓ ${result.network}: Ready`));
+        console.log(chalk.gray(`      Balance: ${result.balance}`));
+        console.log(chalk.gray(`      Est. cost: ~${result.estimatedCost}`));
+      }
+    }
+    console.log('');
+  }
+  
+  return preflight;
+}
+
+module.exports = {
+  MULTISIG_ABI,
+  fetchAccountStateAcrossNetworks,
+  analyzeAccountSync,
+  handleDecoupling,
+  preflightAccountOperation,
+  displayPreflightResults
+};

package/cli/utils/networks.js

@@ -0,0 +1,335 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ETHNOTARY_DIR = path.join(os.homedir(), '.ethnotary');
+const CONFIG_PATH = path.join(ETHNOTARY_DIR, 'config.json');
+
+// Comprehensive network definitions
+const DEFAULT_NETWORKS = {
+  // Mainnets
+  ethereum: { name: 'Ethereum Mainnet', chainId: 1, testnet: false },
+  optimism: { name: 'Optimism', chainId: 10, testnet: false },
+  base: { name: 'Base', chainId: 8453, testnet: false },
+  arbitrum: { name: 'Arbitrum One', chainId: 42161, testnet: false },
+  'arbitrum-nova': { name: 'Arbitrum Nova', chainId: 42170, testnet: false },
+  'zksync-era': { name: 'zkSync Era', chainId: 324, testnet: false },
+  scroll: { name: 'Scroll', chainId: 534352, testnet: false },
+  'polygon-zkevm': { name: 'Polygon zkEVM', chainId: 1101, testnet: false },
+  linea: { name: 'Linea', chainId: 59144, testnet: false },
+  polygon: { name: 'Polygon PoS', chainId: 137, testnet: false },
+  gnosis: { name: 'Gnosis Chain', chainId: 100, testnet: false },
+  avalanche: { name: 'Avalanche C-Chain', chainId: 43114, testnet: false },
+  celo: { name: 'Celo', chainId: 42220, testnet: false },
+  soneium: { name: 'Soneium', chainId: 1868, testnet: false },
+  
+  // Testnets
+  sepolia: { name: 'Sepolia', chainId: 11155111, testnet: true },
+  'base-sepolia': { name: 'Base Sepolia', chainId: 84532, testnet: true },
+  'arbitrum-sepolia': { name: 'Arbitrum Sepolia', chainId: 421614, testnet: true },
+  'polygon-mumbai': { name: 'Polygon Mumbai', chainId: 80001, testnet: true },
+  'polygon-amoy': { name: 'Polygon Amoy', chainId: 80002, testnet: true },
+  'avalanche-fuji': { name: 'Avalanche Fuji', chainId: 43113, testnet: true }
+};
+
+// Build chain ID to network key mapping
+const CHAIN_ID_TO_NETWORK = {};
+for (const [key, config] of Object.entries(DEFAULT_NETWORKS)) {
+  CHAIN_ID_TO_NETWORK[config.chainId] = key;
+}
+
+// RPC provider suggestions
+const RPC_PROVIDERS = [
+  { name: 'Infura', url: 'https://infura.io' },
+  { name: 'Alchemy', url: 'https://alchemy.com' },
+  { name: 'QuickNode', url: 'https://quicknode.com' },
+  { name: 'PublicNode', url: 'https://publicnode.com' }
+];
+
+// Load config from ~/.ethnotary/config.json
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return { networks: {}, rpc: {} };
+  }
+  try {
+    const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+    if (!cfg.networks) cfg.networks = {};
+    if (!cfg.rpc) cfg.rpc = {};
+    return cfg;
+  } catch {
+    return { networks: {}, rpc: {} };
+  }
+}
+
+// Save config
+function saveConfig(config) {
+  if (!fs.existsSync(ETHNOTARY_DIR)) {
+    fs.mkdirSync(ETHNOTARY_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+// Get RPC URL for a network (config file > env var)
+function getRpcUrl(networkName) {
+  const cfg = loadConfig();
+  
+  // Priority 1: Config file
+  if (cfg.rpc[networkName]) {
+    return cfg.rpc[networkName];
+  }
+  
+  // Priority 2: Environment variable (legacy support)
+  const envVar = `${networkName.toUpperCase().replace(/-/g, '_')}_RPC_URL`;
+  if (process.env[envVar]) {
+    return process.env[envVar];
+  }
+  
+  return null;
+}
+
+const DEFAULT_NETWORK = 'sepolia';
+
+// Resolve network from name or chain ID
+function resolveNetwork(networkOrChainId) {
+  const cfg = loadConfig();
+  
+  // Check if it's a chain ID (number)
+  const chainId = parseInt(networkOrChainId);
+  if (!isNaN(chainId)) {
+    // Look up by chain ID
+    const networkKey = CHAIN_ID_TO_NETWORK[chainId];
+    if (networkKey) {
+      return { key: networkKey, config: DEFAULT_NETWORKS[networkKey] };
+    }
+    // Check custom networks
+    for (const [key, config] of Object.entries(cfg.networks || {})) {
+      if (config.chainId === chainId) {
+        return { key, config };
+      }
+    }
+    return null;
+  }
+  
+  // It's a network name - normalize it
+  const normalized = networkOrChainId.toLowerCase().trim();
+  
+  // Check default networks
+  if (DEFAULT_NETWORKS[normalized]) {
+    return { key: normalized, config: DEFAULT_NETWORKS[normalized] };
+  }
+  
+  // Check custom networks
+  if (cfg.networks && cfg.networks[normalized]) {
+    return { key: normalized, config: cfg.networks[normalized] };
+  }
+  
+  return null;
+}
+
+// Validate network and return helpful error if not found
+function validateNetwork(networkOrChainId) {
+  const resolved = resolveNetwork(networkOrChainId);
+  
+  if (!resolved) {
+    const chalk = require('chalk');
+    const allNetworks = { ...DEFAULT_NETWORKS, ...loadConfig().networks };
+    const networkList = Object.entries(allNetworks)
+      .map(([key, cfg]) => `  ${key} (${cfg.chainId})`)
+      .join('\n');
+    
+    console.log(chalk.red(`\n✗ Unknown network: "${networkOrChainId}"`));
+    console.log(chalk.yellow('\nPlease double-check the network name or chain ID.'));
+    console.log(chalk.gray('\nSupported networks:'));
+    console.log(chalk.gray(networkList));
+    console.log(chalk.cyan('\nTo add a custom network:'));
+    console.log(chalk.white(`  ethnotary config network <name> --chain-id <id> --rpc <url>`));
+    console.log(chalk.cyan('\nTo request support for a new network:'));
+    console.log(chalk.white('  https://github.com/ethnotary/cli/issues/new'));
+    
+    return null;
+  }
+  
+  return resolved;
+}
+
+// Ensure RPC is configured for a network, prompt if missing
+async function ensureRpcConfigured(networkKey, networkConfig, options = {}) {
+  const rpc = getRpcUrl(networkKey);
+  
+  if (rpc) {
+    return rpc;
+  }
+  
+  // In JSON mode, fail instead of prompting
+  if (options.json) {
+    const chalk = require('chalk');
+    console.log(chalk.red(`\n✗ No RPC URL configured for ${networkConfig.name}`));
+    console.log(chalk.cyan('\nTo configure an RPC URL, run:'));
+    console.log(chalk.white(`  ethnotary config rpc ${networkKey} --url <your-rpc-url>`));
+    return null;
+  }
+  
+  // Interactive prompt
+  return await promptForRpc(networkKey, networkConfig);
+}
+
+// Prompt for RPC URL if not configured
+async function promptForRpc(networkName, networkConfig) {
+  const inquirer = require('inquirer');
+  const chalk = require('chalk');
+  
+  console.log(chalk.yellow(`\n⚠️  No RPC URL configured for ${networkConfig.name}.`));
+  console.log(chalk.cyan('\nTo configure an RPC URL, run:'));
+  console.log(chalk.white(`  ethnotary config rpc ${networkName} --url <your-rpc-url>`));
+  console.log(chalk.gray('\nOr run interactively:'));
+  console.log(chalk.white(`  ethnotary config rpc ${networkName}`));
+  console.log(chalk.gray('\nWhere to get RPC URLs:'));
+  for (const provider of RPC_PROVIDERS) {
+    console.log(chalk.gray(`  • ${provider.name}: ${provider.url}`));
+  }
+  console.log('');
+  
+  const { rpcUrl } = await inquirer.prompt([{
+    type: 'input',
+    name: 'rpcUrl',
+    message: `Enter RPC URL for ${networkConfig.name}:`,
+    validate: (input) => {
+      if (!input.startsWith('http://') && !input.startsWith('https://')) {
+        return 'RPC URL must start with http:// or https://';
+      }
+      return true;
+    }
+  }]);
+  
+  // Save to config file
+  const cfg = loadConfig();
+  cfg.rpc[networkName] = rpcUrl;
+  saveConfig(cfg);
+  console.log(chalk.green(`✓ RPC URL saved to ~/.ethnotary/config.json\n`));
+  
+  return rpcUrl;
+}
+
+async function getNetwork(networkName) {
+  const cfg = loadConfig();
+  
+  // Get network config (custom > default)
+  const networkConfig = cfg.networks[networkName] || DEFAULT_NETWORKS[networkName];
+  if (!networkConfig) {
+    const available = [...Object.keys(DEFAULT_NETWORKS), ...Object.keys(cfg.networks)];
+    throw new Error(`Unknown network: ${networkName}. Available: ${[...new Set(available)].join(', ')}`);
+  }
+  
+  let rpc = getRpcUrl(networkName);
+  
+  // If no RPC configured, prompt for one
+  if (!rpc) {
+    rpc = await promptForRpc(networkName, networkConfig);
+  }
+  
+  return {
+    name: networkConfig.name,
+    rpc,
+    chainId: networkConfig.chainId
+  };
+}
+
+function listNetworks() {
+  const cfg = loadConfig();
+  const allNetworks = { ...DEFAULT_NETWORKS, ...cfg.networks };
+  
+  return Object.entries(allNetworks).map(([key, value]) => ({
+    key,
+    name: value.name,
+    chainId: value.chainId,
+    configured: !!getRpcUrl(key)
+  }));
+}
+
+// Parse multiple networks from comma-separated string (names or chain IDs)
+function parseNetworks(networkString) {
+  if (!networkString) return [];
+  
+  const parts = networkString.split(',').map(s => s.trim()).filter(Boolean);
+  const results = [];
+  const errors = [];
+  
+  for (const part of parts) {
+    const resolved = resolveNetwork(part);
+    if (resolved) {
+      results.push(resolved);
+    } else {
+      errors.push(part);
+    }
+  }
+  
+  return { networks: results, errors };
+}
+
+// Validate multiple networks and show helpful errors
+function validateNetworks(networkString) {
+  const { networks, errors } = parseNetworks(networkString);
+  
+  if (errors.length > 0) {
+    const chalk = require('chalk');
+    const allNetworks = { ...DEFAULT_NETWORKS, ...loadConfig().networks };
+    const networkList = Object.entries(allNetworks)
+      .map(([key, cfg]) => `  ${key} (${cfg.chainId})`)
+      .join('\n');
+    
+    console.log(chalk.red(`\n✗ Unknown network(s): ${errors.join(', ')}`));
+    console.log(chalk.yellow('\nPlease double-check the network name(s) or chain ID(s).'));
+    console.log(chalk.gray('\nSupported networks:'));
+    console.log(chalk.gray(networkList));
+    console.log(chalk.cyan('\nTo add a custom network:'));
+    console.log(chalk.white(`  ethnotary config network <name> --chain-id <id> --rpc <url>`));
+    console.log(chalk.cyan('\nTo request support for a new network:'));
+    console.log(chalk.white('  https://github.com/ethnotary/cli/issues/new'));
+    
+    return null;
+  }
+  
+  return networks;
+}
+
+// Ensure RPC is configured for multiple networks, prompt for missing ones
+async function ensureRpcsConfigured(networks, options = {}) {
+  const chalk = require('chalk');
+  const results = [];
+  
+  for (const { key, config } of networks) {
+    const rpc = getRpcUrl(key);
+    
+    if (rpc) {
+      results.push({ key, config, rpc });
+    } else {
+      if (options.json) {
+        console.log(chalk.red(`\n✗ No RPC URL configured for ${config.name}`));
+        console.log(chalk.cyan('\nTo configure an RPC URL, run:'));
+        console.log(chalk.white(`  ethnotary config rpc ${key} --url <your-rpc-url>`));
+        return null;
+      }
+      
+      // Interactive prompt
+      const promptedRpc = await promptForRpc(key, config);
+      results.push({ key, config, rpc: promptedRpc });
+    }
+  }
+  
+  return results;
+}
+
+module.exports = {
+  DEFAULT_NETWORKS,
+  DEFAULT_NETWORK,
+  CHAIN_ID_TO_NETWORK,
+  getNetwork,
+  listNetworks,
+  getRpcUrl,
+  resolveNetwork,
+  validateNetwork,
+  ensureRpcConfigured,
+  parseNetworks,
+  validateNetworks,
+  ensureRpcsConfigured
+};