ethnotary 1.0.0

package/cli/utils/auth.js

@@ -0,0 +1,146 @@
+const { ethers } = require('ethers');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const ETHNOTARY_DIR = path.join(os.homedir(), '.ethnotary');
+const KEYSTORE_PATH = path.join(ETHNOTARY_DIR, 'keystore.json');
+
+// Ensure .ethnotary directory exists
+function ensureDir() {
+  if (!fs.existsSync(ETHNOTARY_DIR)) {
+    fs.mkdirSync(ETHNOTARY_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Get wallet from various sources (priority order):
+ * 1. --private-key flag
+ * 2. PRIVATE_KEY env var
+ * 3. Encrypted keystore (prompts for password)
+ */
+async function getWallet(options = {}) {
+  // Priority 1: Direct private key from CLI flag
+  if (options.privateKey) {
+    try {
+      return new ethers.Wallet(options.privateKey);
+    } catch (e) {
+      throw new Error(`Invalid private key provided: ${e.message}`);
+    }
+  }
+
+  // Priority 2: Environment variable
+  if (process.env.PRIVATE_KEY) {
+    try {
+      return new ethers.Wallet(process.env.PRIVATE_KEY);
+    } catch (e) {
+      throw new Error(`Invalid PRIVATE_KEY in environment: ${e.message}`);
+    }
+  }
+
+  // Priority 3: Encrypted keystore
+  if (keystoreExists()) {
+    if (!options.password) {
+      // In non-interactive mode (--json), we can't prompt
+      if (options.json) {
+        throw new Error('No private key provided. Use --private-key or set PRIVATE_KEY env var.');
+      }
+      // Interactive mode - prompt for password
+      const inquirer = require('inquirer');
+      const { password } = await inquirer.prompt([{
+        type: 'password',
+        name: 'password',
+        message: 'Enter keystore password:',
+        mask: '*'
+      }]);
+      options.password = password;
+    }
+    return await loadKeystore(options.password);
+  }
+
+  throw new Error('No wallet configured. Use --private-key, set PRIVATE_KEY env var, or run "ethnotary wallet init"');
+}
+
+/**
+ * Check if keystore file exists
+ */
+function keystoreExists() {
+  return fs.existsSync(KEYSTORE_PATH);
+}
+
+/**
+ * Create new wallet and save encrypted keystore
+ */
+async function createKeystore(password) {
+  ensureDir();
+  const wallet = ethers.Wallet.createRandom();
+  const encryptedJson = await wallet.encrypt(password);
+  fs.writeFileSync(KEYSTORE_PATH, encryptedJson);
+  return wallet;
+}
+
+/**
+ * Import existing key/mnemonic and save encrypted keystore
+ */
+async function importKeystore(keyOrMnemonic, password) {
+  ensureDir();
+  let wallet;
+  
+  // Try as mnemonic first
+  if (keyOrMnemonic.includes(' ')) {
+    try {
+      wallet = ethers.Wallet.fromPhrase(keyOrMnemonic);
+    } catch (e) {
+      throw new Error(`Invalid mnemonic phrase: ${e.message}`);
+    }
+  } else {
+    // Try as private key
+    try {
+      wallet = new ethers.Wallet(keyOrMnemonic);
+    } catch (e) {
+      throw new Error(`Invalid private key: ${e.message}`);
+    }
+  }
+
+  const encryptedJson = await wallet.encrypt(password);
+  fs.writeFileSync(KEYSTORE_PATH, encryptedJson);
+  return wallet;
+}
+
+/**
+ * Load and decrypt keystore
+ */
+async function loadKeystore(password) {
+  if (!keystoreExists()) {
+    throw new Error('No keystore found. Run "ethnotary wallet init" first.');
+  }
+  
+  const encryptedJson = fs.readFileSync(KEYSTORE_PATH, 'utf8');
+  try {
+    return await ethers.Wallet.fromEncryptedJson(encryptedJson, password);
+  } catch (e) {
+    throw new Error('Incorrect password or corrupted keystore');
+  }
+}
+
+/**
+ * Get wallet address from keystore without decrypting
+ */
+function getKeystoreAddress() {
+  if (!keystoreExists()) {
+    return null;
+  }
+  const encryptedJson = JSON.parse(fs.readFileSync(KEYSTORE_PATH, 'utf8'));
+  return encryptedJson.address ? `0x${encryptedJson.address}` : null;
+}
+
+module.exports = {
+  getWallet,
+  keystoreExists,
+  createKeystore,
+  importKeystore,
+  loadKeystore,
+  getKeystoreAddress,
+  ETHNOTARY_DIR,
+  KEYSTORE_PATH
+};

package/cli/utils/constants.js

@@ -0,0 +1,68 @@
+/**
+ * Centralized constants for ethnotary CLI
+ * 
+ * UPDATE THESE ADDRESSES when deploying new factory/verifier versions
+ */
+
+// Default MSA Factory address - same across all EVM networks via CREATE2
+const DEFAULT_MSA_FACTORY = '0x25115564780D3Da99623EaeB9f4eFE88eD801261';
+
+// Default PIN Verifier (Groth16Verifier) address - same across all EVM networks via CREATE2
+const DEFAULT_PIN_VERIFIER = '0x65ee46C4d21405f4a4C8e9d0F8a3832c1B885ab4';
+
+// MSAFactory ABI - functions needed for account creation
+const MSA_FACTORY_ABI = [
+  "function newMSA(address[] calldata _owners, uint _required, bytes32 _pinHash, string calldata _name) external payable returns (address)",
+  "function predictMSAAddress(address[] calldata _owners, uint _required, bytes32 _pinHash, string calldata _name) external view returns (address)",
+  "function notaryFee() view returns (uint256)",
+  "function pinVerifier() view returns (address)",
+  "event NewMSACreated(address indexed msaAddress)"
+];
+
+// MultiSig ABI - functions needed for account management
+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"
+];
+
+/**
+ * Get the factory address for a given network
+ * Priority: network-specific env var > generic env var > default
+ * 
+ * @param {string} network - Network key (e.g., 'sepolia', 'base-sepolia')
+ * @returns {string} Factory address
+ */
+function getFactoryAddress(network) {
+  if (network) {
+    const envKey = `${network.toUpperCase().replace('-', '_')}_FACTORY_ADDRESS`;
+    if (process.env[envKey]) {
+      return process.env[envKey];
+    }
+  }
+  return process.env.MSA_FACTORY_ADDRESS || DEFAULT_MSA_FACTORY;
+}
+
+/**
+ * Get the PIN verifier address
+ * Priority: env var > default
+ * 
+ * @returns {string} Verifier address
+ */
+function getVerifierAddress() {
+  return process.env.PIN_VERIFIER_ADDRESS || DEFAULT_PIN_VERIFIER;
+}
+
+module.exports = {
+  DEFAULT_MSA_FACTORY,
+  DEFAULT_PIN_VERIFIER,
+  MSA_FACTORY_ABI,
+  MULTISIG_ABI,
+  getFactoryAddress,
+  getVerifierAddress
+};

package/cli/utils/contacts.js

@@ -0,0 +1,131 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { ethers } = require('ethers');
+
+const ETHNOTARY_DIR = path.join(os.homedir(), '.ethnotary');
+const CONTACTS_PATH = path.join(ETHNOTARY_DIR, 'contacts.json');
+
+// Ensure .ethnotary directory exists
+function ensureDir() {
+  if (!fs.existsSync(ETHNOTARY_DIR)) {
+    fs.mkdirSync(ETHNOTARY_DIR, { recursive: true });
+  }
+}
+
+// Load contacts file
+function loadContacts() {
+  if (!fs.existsSync(CONTACTS_PATH)) {
+    return { contacts: {} };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CONTACTS_PATH, 'utf8'));
+  } catch (e) {
+    return { contacts: {} };
+  }
+}
+
+// Save contacts file
+function saveContacts(data) {
+  ensureDir();
+  fs.writeFileSync(CONTACTS_PATH, JSON.stringify(data, null, 2));
+}
+
+/**
+ * Add or update a contact for an owner address
+ * @param {string} address - Owner's Ethereum address
+ * @param {Object} contactInfo - Contact methods { telegram, whatsapp, email, webhook }
+ */
+function addContact(address, contactInfo) {
+  if (!ethers.isAddress(address)) {
+    throw new Error(`Invalid address: ${address}`);
+  }
+  
+  const normalizedAddress = ethers.getAddress(address);
+  const data = loadContacts();
+  
+  // Merge with existing contact info
+  data.contacts[normalizedAddress] = {
+    ...data.contacts[normalizedAddress],
+    ...contactInfo,
+    updatedAt: new Date().toISOString()
+  };
+  
+  saveContacts(data);
+  return data.contacts[normalizedAddress];
+}
+
+/**
+ * Get contact info for an address
+ */
+function getContact(address) {
+  if (!ethers.isAddress(address)) {
+    return null;
+  }
+  
+  const normalizedAddress = ethers.getAddress(address);
+  const data = loadContacts();
+  return data.contacts[normalizedAddress] || null;
+}
+
+/**
+ * Get contacts for multiple addresses
+ */
+function getContacts(addresses) {
+  const data = loadContacts();
+  const results = [];
+  
+  for (const address of addresses) {
+    if (ethers.isAddress(address)) {
+      const normalizedAddress = ethers.getAddress(address);
+      const contact = data.contacts[normalizedAddress];
+      if (contact) {
+        results.push({
+          address: normalizedAddress,
+          ...contact
+        });
+      }
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * List all contacts
+ */
+function listContacts() {
+  const data = loadContacts();
+  return Object.entries(data.contacts).map(([address, info]) => ({
+    address,
+    ...info
+  }));
+}
+
+/**
+ * Remove a contact
+ */
+function removeContact(address) {
+  if (!ethers.isAddress(address)) {
+    throw new Error(`Invalid address: ${address}`);
+  }
+  
+  const normalizedAddress = ethers.getAddress(address);
+  const data = loadContacts();
+  
+  if (!data.contacts[normalizedAddress]) {
+    throw new Error(`No contact found for address: ${address}`);
+  }
+  
+  delete data.contacts[normalizedAddress];
+  saveContacts(data);
+}
+
+module.exports = {
+  addContact,
+  getContact,
+  getContacts,
+  listContacts,
+  removeContact,
+  CONTACTS_PATH
+};

package/cli/utils/contracts.js

@@ -0,0 +1,269 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { ethers } = require('ethers');
+
+const ETHNOTARY_DIR = path.join(os.homedir(), '.ethnotary');
+const CONTRACTS_PATH = path.join(ETHNOTARY_DIR, 'contracts.json');
+
+// Ensure .ethnotary directory exists
+function ensureDir() {
+  if (!fs.existsSync(ETHNOTARY_DIR)) {
+    fs.mkdirSync(ETHNOTARY_DIR, { recursive: true });
+  }
+}
+
+// Load contracts file
+function loadContracts() {
+  if (!fs.existsSync(CONTRACTS_PATH)) {
+    return { contracts: {}, default: null };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CONTRACTS_PATH, 'utf8'));
+  } catch (e) {
+    return { contracts: {}, default: null };
+  }
+}
+
+// Save contracts file
+function saveContracts(data) {
+  ensureDir();
+  fs.writeFileSync(CONTRACTS_PATH, JSON.stringify(data, null, 2));
+}
+
+// Migrate old single-network format to new multi-network format
+function migrateContract(contract) {
+  if (contract.network && !contract.networks) {
+    // Old format: { network: "sepolia" } -> New format: { networks: ["sepolia"] }
+    return {
+      ...contract,
+      networks: [contract.network],
+      network: undefined // Remove old field
+    };
+  }
+  return contract;
+}
+
+/**
+ * Save a contract with alias
+ * @param {string} alias - Contract alias
+ * @param {string} address - Contract address
+ * @param {string|string[]} networks - Network(s) the contract is deployed on
+ * @param {string} label - Optional label
+ */
+function saveContract(alias, address, networks, label = '') {
+  if (!ethers.isAddress(address)) {
+    throw new Error(`Invalid address: ${address}`);
+  }
+  
+  // Normalize networks to array
+  const networkArray = Array.isArray(networks) ? networks : [networks];
+  
+  const data = loadContracts();
+  
+  // Check if contract already exists - merge networks if so
+  if (data.contracts[alias]) {
+    const existing = migrateContract(data.contracts[alias]);
+    const mergedNetworks = [...new Set([...existing.networks, ...networkArray])];
+    data.contracts[alias] = {
+      address: address,
+      networks: mergedNetworks,
+      created: existing.created,
+      updated: new Date().toISOString(),
+      label: label || existing.label || ''
+    };
+  } else {
+    data.contracts[alias] = {
+      address: address,
+      networks: networkArray,
+      created: new Date().toISOString(),
+      label: label || ''
+    };
+  }
+  
+  saveContracts(data);
+  return data.contracts[alias];
+}
+
+/**
+ * Add network(s) to an existing contract
+ */
+function addNetworkToContract(alias, networks) {
+  const data = loadContracts();
+  if (!data.contracts[alias]) {
+    throw new Error(`Contract alias not found: ${alias}`);
+  }
+  
+  const contract = migrateContract(data.contracts[alias]);
+  const networkArray = Array.isArray(networks) ? networks : [networks];
+  contract.networks = [...new Set([...contract.networks, ...networkArray])];
+  contract.updated = new Date().toISOString();
+  
+  data.contracts[alias] = contract;
+  saveContracts(data);
+  return contract;
+}
+
+/**
+ * Remove network from a contract
+ */
+function removeNetworkFromContract(alias, network) {
+  const data = loadContracts();
+  if (!data.contracts[alias]) {
+    throw new Error(`Contract alias not found: ${alias}`);
+  }
+  
+  const contract = migrateContract(data.contracts[alias]);
+  contract.networks = contract.networks.filter(n => n !== network);
+  contract.updated = new Date().toISOString();
+  
+  if (contract.networks.length === 0) {
+    throw new Error(`Cannot remove last network from contract. Use "ethnotary remove ${alias}" to delete the contract.`);
+  }
+  
+  data.contracts[alias] = contract;
+  saveContracts(data);
+  return contract;
+}
+
+/**
+ * Get contract by alias or address
+ * Returns { address, networks, label } or throws if not found
+ */
+function getContract(aliasOrAddress) {
+  // If it's a valid address, return it directly (no network info)
+  if (ethers.isAddress(aliasOrAddress)) {
+    return { address: aliasOrAddress, networks: [], label: null };
+  }
+
+  // Look up by alias
+  const data = loadContracts();
+  const contract = data.contracts[aliasOrAddress];
+  if (!contract) {
+    throw new Error(`Contract alias not found: ${aliasOrAddress}. Use "ethnotary list" to see saved contracts.`);
+  }
+  return migrateContract(contract);
+}
+
+/**
+ * Resolve address from alias, address, or default
+ */
+function resolveAddress(aliasOrAddress) {
+  if (aliasOrAddress) {
+    return getContract(aliasOrAddress).address;
+  }
+  
+  // Try default
+  const defaultContract = getDefaultContract();
+  if (defaultContract) {
+    return defaultContract.address;
+  }
+  
+  throw new Error('No address provided and no default contract set. Use --address or run "ethnotary contract default <alias>"');
+}
+
+/**
+ * List all saved contracts
+ */
+function listContracts() {
+  const data = loadContracts();
+  return Object.entries(data.contracts).map(([alias, contract]) => ({
+    alias,
+    ...migrateContract(contract),
+    isDefault: data.default === alias
+  }));
+}
+
+/**
+ * Remove a saved contract
+ */
+function removeContract(alias) {
+  const data = loadContracts();
+  if (!data.contracts[alias]) {
+    throw new Error(`Contract alias not found: ${alias}`);
+  }
+  delete data.contracts[alias];
+  if (data.default === alias) {
+    data.default = null;
+  }
+  saveContracts(data);
+}
+
+/**
+ * Get default contract
+ */
+function getDefaultContract() {
+  const data = loadContracts();
+  if (!data.default) {
+    return null;
+  }
+  const contract = data.contracts[data.default];
+  if (!contract) {
+    return null;
+  }
+  return { alias: data.default, ...contract };
+}
+
+/**
+ * Set default contract
+ */
+function setDefaultContract(alias) {
+  const data = loadContracts();
+  if (!data.contracts[alias]) {
+    throw new Error(`Contract alias not found: ${alias}`);
+  }
+  data.default = alias;
+  saveContracts(data);
+}
+
+/**
+ * Create a decoupled contract alias when sync fails
+ */
+function createDecoupledContract(originalAlias, address, network, label = '') {
+  const decoupledAlias = `${originalAlias}-${network}-decoupled`;
+  const data = loadContracts();
+  
+  data.contracts[decoupledAlias] = {
+    address: address,
+    networks: [network],
+    created: new Date().toISOString(),
+    label: label || `Decoupled from ${originalAlias}`,
+    decoupledFrom: originalAlias,
+    decoupledAt: new Date().toISOString()
+  };
+  
+  saveContracts(data);
+  return { alias: decoupledAlias, ...data.contracts[decoupledAlias] };
+}
+
+/**
+ * Get contract networks (for interoperability)
+ * If no aliasOrAddress provided, uses default contract
+ */
+function getContractNetworks(aliasOrAddress) {
+  if (!aliasOrAddress) {
+    const defaultContract = getDefaultContract();
+    if (defaultContract) {
+      return migrateContract(defaultContract).networks || [];
+    }
+    return [];
+  }
+  const contract = getContract(aliasOrAddress);
+  return contract.networks || [];
+}
+
+module.exports = {
+  saveContract,
+  getContract,
+  resolveAddress,
+  listContracts,
+  removeContract,
+  getDefaultContract,
+  setDefaultContract,
+  addNetworkToContract,
+  removeNetworkFromContract,
+  createDecoupledContract,
+  getContractNetworks,
+  migrateContract,
+  CONTRACTS_PATH
+};