ethnotary 1.0.0

package/cli/utils/notifications.js

@@ -0,0 +1,135 @@
+const { getContacts } = require('./contacts');
+
+const DEFAULT_BASE_URL = 'https://ethnotary.io';
+
+/**
+ * Generate approval URL for a transaction
+ * @param {number} txId - Transaction ID
+ * @param {string} network - Network name (e.g., 'sepolia')
+ * @param {string} contractAddress - MultiSig contract address
+ * @returns {string} Approval URL
+ */
+function generateApprovalUrl(txId, network, contractAddress) {
+  const baseUrl = process.env.ETHNOTARY_BASE_URL || DEFAULT_BASE_URL;
+  return `${baseUrl}/app/views/txn.html?txid=${txId}&network=${network}&address=${contractAddress}`;
+}
+
+/**
+ * Format approval request message
+ * @param {Object} txData - Transaction data
+ * @returns {string} Formatted message
+ */
+function formatApprovalMessage(txData) {
+  const lines = [
+    '🔔 MultiSig Approval Request',
+    '',
+    `Transaction #${txData.id} on ${txData.network}`,
+    `To: ${txData.destination}`,
+  ];
+
+  if (txData.value && txData.value !== '0 ETH') {
+    lines.push(`Value: ${txData.value}`);
+  }
+
+  if (txData.data && txData.data !== '0x') {
+    lines.push(`Data: ${txData.data.slice(0, 20)}...`);
+  }
+
+  lines.push('');
+  lines.push(`Confirmations: ${txData.confirmations}/${txData.required}`);
+  lines.push('');
+  lines.push(`👉 Review & Approve: ${txData.approvalUrl}`);
+
+  return lines.join('\n');
+}
+
+/**
+ * Get notification data for other owners (excluding sender)
+ * @param {string[]} owners - Array of owner addresses
+ * @param {string} senderAddress - Address of the transaction sender
+ * @param {Object} txData - Transaction data for message formatting
+ * @returns {Array} Array of notification objects for each owner with contact info
+ */
+function getNotificationData(owners, senderAddress, txData) {
+  // Filter out the sender
+  const otherOwners = owners.filter(
+    addr => addr.toLowerCase() !== senderAddress.toLowerCase()
+  );
+
+  // Get contacts for other owners
+  const contacts = getContacts(otherOwners);
+
+  // Build notification data for each owner with contact info
+  const notifications = [];
+
+  for (const owner of otherOwners) {
+    const contact = contacts.find(
+      c => c.address.toLowerCase() === owner.toLowerCase()
+    );
+
+    if (contact && (contact.telegram || contact.whatsapp || contact.webhook)) {
+      notifications.push({
+        address: owner,
+        telegram: contact.telegram || null,
+        whatsapp: contact.whatsapp || null,
+        webhook: contact.webhook || null,
+        message: formatApprovalMessage(txData)
+      });
+    }
+  }
+
+  return notifications;
+}
+
+/**
+ * Build complete notification payload for a transaction
+ * @param {Object} params - Parameters
+ * @param {number} params.transactionId - Transaction ID
+ * @param {string} params.network - Network name
+ * @param {string} params.contractAddress - MultiSig address
+ * @param {string} params.destination - Transaction destination
+ * @param {string} params.value - Transaction value
+ * @param {string} params.data - Transaction data
+ * @param {number} params.confirmations - Current confirmation count
+ * @param {number} params.required - Required confirmations
+ * @param {string[]} params.owners - Array of owner addresses
+ * @param {string} params.senderAddress - Sender's address
+ * @returns {Object} Notification payload
+ */
+function buildNotificationPayload(params) {
+  const approvalUrl = generateApprovalUrl(
+    params.transactionId,
+    params.network,
+    params.contractAddress
+  );
+
+  const txData = {
+    id: params.transactionId,
+    network: params.network,
+    destination: params.destination,
+    value: params.value,
+    data: params.data,
+    confirmations: params.confirmations,
+    required: params.required,
+    approvalUrl
+  };
+
+  const notifyOwners = getNotificationData(
+    params.owners,
+    params.senderAddress,
+    txData
+  );
+
+  return {
+    approvalUrl,
+    notifyOwners,
+    message: formatApprovalMessage(txData)
+  };
+}
+
+module.exports = {
+  generateApprovalUrl,
+  formatApprovalMessage,
+  getNotificationData,
+  buildNotificationPayload
+};

package/cli/utils/output.js

@@ -0,0 +1,123 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+class Output {
+  constructor(options = {}) {
+    this.jsonMode = options.json || false;
+    this.spinner = null;
+  }
+
+  // Output data - JSON if --json flag, formatted otherwise
+  print(data, options = {}) {
+    if (this.jsonMode) {
+      console.log(JSON.stringify(data, null, 2));
+    } else {
+      if (options.title) {
+        console.log(chalk.bold(options.title));
+      }
+      if (typeof data === 'string') {
+        console.log(data);
+      } else {
+        this.printFormatted(data);
+      }
+    }
+  }
+
+  printFormatted(data, indent = 0) {
+    const prefix = '  '.repeat(indent);
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        if (typeof item === 'object') {
+          console.log(`${prefix}${chalk.dim(`[${i}]`)}`);
+          this.printFormatted(item, indent + 1);
+        } else {
+          console.log(`${prefix}- ${item}`);
+        }
+      });
+    } else if (typeof data === 'object' && data !== null) {
+      Object.entries(data).forEach(([key, value]) => {
+        if (typeof value === 'object' && value !== null) {
+          console.log(`${prefix}${chalk.cyan(key)}:`);
+          this.printFormatted(value, indent + 1);
+        } else {
+          console.log(`${prefix}${chalk.cyan(key)}: ${value}`);
+        }
+      });
+    } else {
+      console.log(`${prefix}${data}`);
+    }
+  }
+
+  success(message) {
+    if (!this.jsonMode) {
+      console.log(chalk.green('✓'), message);
+    }
+  }
+
+  error(message, exitCode = 1) {
+    if (this.jsonMode) {
+      console.log(JSON.stringify({ error: message }));
+    } else {
+      console.error(chalk.red('✗'), message);
+    }
+    process.exit(exitCode);
+  }
+
+  warn(message) {
+    if (!this.jsonMode) {
+      console.log(chalk.yellow('⚠'), message);
+    }
+  }
+
+  info(message) {
+    if (!this.jsonMode) {
+      console.log(chalk.blue('ℹ'), message);
+    }
+  }
+
+  // Spinner - no-op in JSON mode
+  startSpinner(text) {
+    if (!this.jsonMode) {
+      this.spinner = ora(text).start();
+    }
+  }
+
+  updateSpinner(text) {
+    if (this.spinner) {
+      this.spinner.text = text;
+    }
+  }
+
+  succeedSpinner(text) {
+    if (this.spinner) {
+      this.spinner.succeed(text);
+      this.spinner = null;
+    }
+  }
+
+  failSpinner(text) {
+    if (this.spinner) {
+      this.spinner.fail(text);
+      this.spinner = null;
+    }
+  }
+
+  stopSpinner() {
+    if (this.spinner) {
+      this.spinner.stop();
+      this.spinner = null;
+    }
+  }
+}
+
+// Create output instance from command options
+function createOutput(options) {
+  return new Output({
+    json: options.json || options.parent?.opts()?.json || false
+  });
+}
+
+module.exports = {
+  Output,
+  createOutput
+};

package/cli/utils/pin.js

@@ -0,0 +1,89 @@
+const { poseidon1 } = require('poseidon-lite');
+
+/**
+ * Compute PIN hash using Poseidon hash function
+ * This hash is stored on-chain during contract creation
+ * @param {string|number} pin - The PIN to hash
+ * @returns {string} - Hex string of the hash (bytes32)
+ */
+function computePinHash(pin) {
+  const pinBigInt = BigInt(pin);
+  const hash = poseidon1([pinBigInt]);
+  return '0x' + hash.toString(16).padStart(64, '0');
+}
+
+/**
+ * Generate zkSNARK proof for PIN verification
+ * Used for account management operations (add/remove/replace owner)
+ * @param {string|number} pin - The PIN
+ * @param {string} pinHash - The stored PIN hash from contract
+ * @param {number} nonce - Current nonce from contract (unused - kept for API compatibility)
+ * @param {string} sender - The sender address (msg.sender)
+ * @returns {Object} - Proof components { pA, pB, pC }
+ */
+async function generateZkProof(pin, pinHash, nonce, sender) {
+  const snarkjs = require('snarkjs');
+  const path = require('path');
+  const fs = require('fs');
+
+  // Paths to circuit artifacts
+  const wasmPath = path.join(__dirname, '../../zkbuild/pin_verify_js/pin_verify.wasm');
+  const zkeyPath = path.join(__dirname, '../../zkbuild/pin_verify_final.zkey');
+
+  // Check if circuit artifacts exist
+  if (!fs.existsSync(wasmPath) || !fs.existsSync(zkeyPath)) {
+    throw new Error('zkSNARK circuit artifacts not found. Run compile_circuit.sh first.');
+  }
+
+  // Convert sender address to BigInt (remove 0x prefix)
+  const senderBigInt = BigInt(sender).toString();
+
+  // Prepare inputs - circuit expects: pinHash, sender (public) + pin (private)
+  // Note: nonce was removed from circuit for better UX
+  const input = {
+    pin: BigInt(pin).toString(),
+    pinHash: pinHash,
+    sender: senderBigInt
+  };
+
+  // Generate proof
+  const { proof, publicSignals } = await snarkjs.groth16.fullProve(
+    input,
+    wasmPath,
+    zkeyPath
+  );
+
+  // Format proof for Solidity verifier
+  const pA = [proof.pi_a[0], proof.pi_a[1]];
+  const pB = [
+    [proof.pi_b[0][1], proof.pi_b[0][0]],
+    [proof.pi_b[1][1], proof.pi_b[1][0]]
+  ];
+  const pC = [proof.pi_c[0], proof.pi_c[1]];
+
+  return { pA, pB, pC, publicSignals };
+}
+
+/**
+ * Verify a proof locally (for testing)
+ */
+async function verifyProofLocally(proof, publicSignals) {
+  const snarkjs = require('snarkjs');
+  const path = require('path');
+  const fs = require('fs');
+
+  const vkeyPath = path.join(__dirname, '../../zkbuild/verification_key.json');
+  
+  if (!fs.existsSync(vkeyPath)) {
+    throw new Error('Verification key not found.');
+  }
+
+  const vkey = JSON.parse(fs.readFileSync(vkeyPath, 'utf8'));
+  return await snarkjs.groth16.verify(vkey, publicSignals, proof);
+}
+
+module.exports = {
+  computePinHash,
+  generateZkProof,
+  verifyProofLocally
+};