enigma-memory 0.1.17 → 0.1.22

package/packages/terminal-console/commands.mjs

@@ -0,0 +1,459 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { ANSI } from '../terminal-tui/merkle-tree-renderer.mjs';
+import { main as enigmaMain } from '../../apps/cli/bin/enigma.mjs';
+import { renderHelpCatalog, OFFICIAL_TOKEN_CA } from './banner.mjs';
+import { runConstellationAnimation, runMatrixStream, runSolanaHeartbeatStream } from './animations.mjs';
+import { probeSolanaRpc, formatSolanaStatusReport, formatSolanaAnchorVerificationReport } from './solana-rpc.mjs';
+import { PhantomBrowserBridge } from './phantom-bridge.mjs';
+import { AutoAnchorEngine } from './auto-anchor.mjs';
+
+export const DEFAULT_SOLANA_CLUSTER = 'mainnet-beta';
+
+export function normalizeReplArgv(rawArgv, defaultBundlePath) {
+  if (!Array.isArray(rawArgv) || rawArgv.length === 0) return [];
+
+  const command = String(rawArgv[0]).toLowerCase();
+  const rest = rawArgv.slice(1);
+  const flags = [];
+  const positional = [];
+
+  for (let i = 0; i < rest.length; i++) {
+    const token = rest[i];
+    if (token.startsWith('-')) {
+      flags.push(token);
+      if (i + 1 < rest.length && !rest[i + 1].startsWith('-')) {
+        flags.push(rest[i + 1]);
+        i++;
+      }
+    } else {
+      positional.push(token);
+    }
+  }
+
+  const hasFlag = (...names) => flags.some((f) => names.includes(f));
+  const result = [command];
+
+  if (command === 'remember') {
+    if (!hasFlag('--text', '-t', '--text-file', '--textFile') && positional.length > 0) {
+      result.push('--text', positional.join(' '));
+    }
+    result.push(...flags);
+  } else if (command === 'context') {
+    if (!hasFlag('--query', '-q', '--search') && positional.length > 0) {
+      result.push('--query', positional.join(' '));
+    }
+    result.push(...flags);
+  } else if (command === 'tui' || command === 'dashboard' || command === 'monitor') {
+    if (!hasFlag('--once')) {
+      result.push('--once');
+    }
+    result.push(...flags);
+  } else if (command === 'enclave') {
+    const sub = positional[0]?.toLowerCase() || 'cycle';
+    const subPositional = positional.slice(1);
+
+    if (sub === 'verify' || sub === 'verify-zeroization') {
+      result.push('verify-zeroization');
+      if (!hasFlag('--receipt', '-r') && subPositional.length > 0) {
+        result.push('--receipt', subPositional[0]);
+      }
+      result.push(...flags);
+    } else if (sub === 'attest') {
+      result.push('attest');
+      result.push(...flags);
+    } else {
+      result.push('cycle');
+      if (!hasFlag('--receipt-out', '--receiptOut', '--out') && subPositional.length > 0) {
+        result.push('--receipt-out', subPositional[0]);
+      }
+      result.push(...flags);
+    }
+  } else if (command === 'tree') {
+    if (!hasFlag('--depth', '-d') && positional.length > 0 && /^\d+$/.test(positional[0])) {
+      result.push('--depth', positional[0]);
+    }
+    result.push(...flags);
+  } else if (command === 'export') {
+    if (!hasFlag('--out', '-o') && positional.length > 0) {
+      result.push('--out', positional[0]);
+    }
+    result.push(...flags);
+  } else if (command === 'verify') {
+    if (!hasFlag('--export', '-e', '--file') && positional.length > 0) {
+      result.push('--export', positional[0]);
+    }
+    result.push(...flags);
+  } else {
+    result.push(...rest);
+  }
+
+  // Attach active bundle if needed and not supplied
+  const needsBundle = ['quickstart', 'remember', 'update', 'delete', 'context', 'doctor', 'tree', 'tui', 'dashboard', 'monitor', 'enclave', 'swarm', 'chain', 'export', 'status'].includes(command);
+  const hasBundleFlag = result.some((arg) => arg === '--bundle' || arg === '-b' || arg === '--file');
+  if (needsBundle && !hasBundleFlag) {
+    result.push('--bundle', defaultBundlePath);
+  }
+
+  return result;
+}
+
+export class TerminalSession {
+  constructor({
+    bundlePath = '.enigma/bundle.json',
+    color = true,
+    io = { stdout: process.stdout, stderr: process.stderr },
+    fetchFn = globalThis.fetch,
+  } = {}) {
+    this.bundlePath = bundlePath;
+    this.color = color;
+    this.io = io;
+    this.fetchFn = fetchFn;
+    this.phantomBridge = null;
+    this._connectedWallet = null;
+    this.activeAbortController = null;
+    this.autoAnchorEngine = new AutoAnchorEngine({
+      rootDir: dirname(this.bundlePath),
+      cluster: DEFAULT_SOLANA_CLUSTER,
+    });
+  }
+
+  get connectedWallet() {
+    return this.phantomBridge?.connectedWallet ?? this._connectedWallet ?? null;
+  }
+
+  set connectedWallet(wallet) {
+    this._connectedWallet = wallet;
+    if (this.phantomBridge) {
+      this.phantomBridge.connectedWallet = wallet;
+    }
+  }
+
+  setBundlePath(path) {
+    this.bundlePath = path;
+  }
+
+  async getVaultSummary() {
+    try {
+      const data = JSON.parse(await readFile(resolve(this.bundlePath), 'utf8'));
+      const activeAddresses = Array.isArray(data?.active_memory_addresses)
+        ? data.active_memory_addresses
+        : (Array.isArray(data?.vault?.active_memory_addresses)
+          ? data.vault.active_memory_addresses
+          : (Array.isArray(data?.activeAddresses) ? data.activeAddresses : []));
+      const activeCount = activeAddresses.length;
+      const root = data?.vault?.active_set_root || data?.vault?.set_root || data?.active_set_root || 'uninitialized';
+      const shortRoot = root.startsWith('sha256:') ? root.slice(0, 15) + '...' : root.slice(0, 8);
+      return { activeCount, shortRoot, initialized: Boolean(data?.vault || data?.schema) };
+    } catch {
+      return { activeCount: 0, shortRoot: 'uninitialized', initialized: false };
+    }
+  }
+
+  async renderPrompt() {
+    const summary = await this.getVaultSummary();
+    const c = (text, code) => (this.color ? `${code}${text}${ANSI.reset}` : text);
+
+    const vaultBadge = summary.initialized
+      ? `${c('vault:', ANSI.dimText)}${c(`active (${summary.activeCount})`, ANSI.green)} ${c(summary.shortRoot, ANSI.gray)}`
+      : `${c('vault:', ANSI.dimText)}${c('new', ANSI.amber)}`;
+
+    return `${c('enigma', `${ANSI.bold}${ANSI.amber}`)} [${vaultBadge}] ${c('>', ANSI.white)} `;
+  }
+
+  parseArgv(line) {
+    const trimmed = String(line || '').trim();
+    if (!trimmed) return [];
+
+    const tokens = [];
+    let current = '';
+    let inQuote = false;
+    let quoteChar = '';
+
+    for (let i = 0; i < trimmed.length; i++) {
+      const char = trimmed[i];
+      if (inQuote) {
+        if (char === quoteChar) {
+          inQuote = false;
+        } else {
+          current += char;
+        }
+      } else if (char === '"' || char === "'") {
+        inQuote = true;
+        quoteChar = char;
+      } else if (/\s/.test(char)) {
+        if (current) {
+          tokens.push(current);
+          current = '';
+        }
+      } else {
+        current += char;
+      }
+    }
+    if (current) tokens.push(current);
+    return tokens;
+  }
+
+  async executeCommand(line, { signal = undefined } = {}) {
+    const rawArgv = this.parseArgv(line);
+    if (rawArgv.length === 0) return 0;
+    const shouldStop = (signal || this.activeAbortController)
+      ? () => Boolean(signal?.aborted || this.activeAbortController?.signal?.aborted)
+      : undefined;
+
+    const command = rawArgv[0].toLowerCase();
+    const c = (text, code) => (this.color ? `${code}${text}${ANSI.reset}` : text);
+
+    // Shell-local builtins
+    switch (command) {
+      case 'help':
+      case '?':
+        this.io.stdout.write(renderHelpCatalog({ color: this.color }) + '\n');
+        return 0;
+
+      case 'token':
+      case 'ca':
+        this.io.stdout.write(`\n  ${c('ENIGMA OFFICIAL TOKEN COORDINATES', `${ANSI.bold}${ANSI.amber}`)}\n`);
+        this.io.stdout.write(`  ${c('Solana Mint CA:', ANSI.dimText)} ${c(OFFICIAL_TOKEN_CA, `${ANSI.bold}${ANSI.white}`)}\n`);
+        this.io.stdout.write(`  ${c('Solscan:', ANSI.dimText)}         https://solscan.io/token/${OFFICIAL_TOKEN_CA}\n`);
+        this.io.stdout.write(`  ${c('Pump.fun:', ANSI.dimText)}        https://pump.fun/coin/${OFFICIAL_TOKEN_CA}\n`);
+        this.io.stdout.write(`  ${c('Website:', ANSI.dimText)}         https://enigmamemory.com\n`);
+        this.io.stdout.write(`  ${c('X (Twitter):', ANSI.dimText)}     https://x.com/Engimamemory\n\n`);
+        return 0;
+
+      case 'solana': {
+        const sub = rawArgv[1]?.toLowerCase();
+        if (sub === 'submit' || sub === 'submit-solana') {
+          const args = rawArgv.slice(2);
+          const hasCluster = args.some((arg) => arg === '--cluster');
+          const hasFile = args.some((arg) => arg === '--file' || arg === '-f' || arg === '--in');
+          const defaultAnchorPath = resolve(this.bundlePath ? (this.bundlePath.includes('/') || this.bundlePath.includes('\\') ? this.bundlePath.replace(/[^/\\]+$/, 'anchor-batch.json') : 'anchor-batch.json') : 'anchor-batch.json');
+          const resolvedArgs = [...args];
+          if (!hasCluster) resolvedArgs.push('--cluster', DEFAULT_SOLANA_CLUSTER);
+          if (!hasFile && existsSync(defaultAnchorPath)) resolvedArgs.push('--file', defaultAnchorPath);
+          return await enigmaMain(['chain', 'submit-solana', ...resolvedArgs], this.io);
+        } else if (sub === 'verify-anchor' || sub === 'verify-solana' || sub === 'verify') {
+          const args = rawArgv.slice(2);
+          if (args.includes('--help') || args.includes('-h')) {
+            return await enigmaMain(['chain', 'verify-solana', ...args], this.io);
+          }
+          const hasCluster = args.some((arg) => arg === '--cluster');
+          const hasFile = args.some((arg) => arg === '--file' || arg === '-f' || arg === '--in');
+          const defaultAnchorPath = resolve(this.bundlePath ? (this.bundlePath.includes('/') || this.bundlePath.includes('\\') ? this.bundlePath.replace(/[^/\\]+$/, 'anchor-batch.json') : 'anchor-batch.json') : 'anchor-batch.json');
+          const verifyArgs = [...args];
+          if (!hasCluster) verifyArgs.push('--cluster', DEFAULT_SOLANA_CLUSTER);
+          if (!hasFile && existsSync(defaultAnchorPath)) verifyArgs.push('--file', defaultAnchorPath);
+          let output = '';
+          const verifyIo = {
+            ...this.io,
+            solanaFetch: this.fetchFn,
+            stdout: { write: (chunk) => { output += String(chunk); } },
+          };
+          const code = await enigmaMain(['chain', 'verify-solana', ...verifyArgs], verifyIo);
+          let report;
+          try { report = JSON.parse(output); } catch { report = null; }
+          if (report && typeof report === 'object') {
+            this.io.stdout.write('\n' + formatSolanaAnchorVerificationReport(report, { color: this.color }) + '\n');
+          } else if (output) {
+            this.io.stdout.write(output);
+          }
+          return code;
+        } else if (sub === 'stream' || sub === 'pulse' || sub === 'heartbeat' || sub === 'live') {
+          let cluster = DEFAULT_SOLANA_CLUSTER;
+          let rpcUrl = undefined;
+          let samples = undefined;
+          for (let i = 2; i < rawArgv.length; i++) {
+            if (rawArgv[i] === '--cluster' && rawArgv[i + 1]) cluster = rawArgv[++i];
+            else if (rawArgv[i] === '--rpc' && rawArgv[i + 1]) rpcUrl = rawArgv[++i];
+            else if ((rawArgv[i] === '--samples' || rawArgv[i] === '-n') && rawArgv[i + 1]) samples = Number(rawArgv[++i]) || 6;
+            else if (rawArgv[i] === '--once') samples = 1;
+          }
+          return await runSolanaHeartbeatStream(this.io, { cluster, rpcUrl, samples, fetchFn: this.fetchFn, color: this.color, bundlePath: this.bundlePath, shouldStop });
+        } else if (sub === 'anchor-bundle' || sub === 'anchor-vault') {
+          const args = rawArgv.slice(2);
+          const hasBundle = args.some((arg) => arg === '--bundle' || arg === '-b' || arg === '--file');
+          const hasCluster = args.some((arg) => arg === '--cluster');
+          const hasOut = args.some((arg) => arg === '--out' || arg === '-o');
+          const defaultOut = resolve(this.bundlePath ? (this.bundlePath.includes('/') || this.bundlePath.includes('\\') ? this.bundlePath.replace(/[^/\\]+$/, 'anchor-batch.json') : 'anchor-batch.json') : 'anchor-batch.json');
+          const finalArgs = [...args];
+          if (!hasBundle) finalArgs.push('--bundle', this.bundlePath);
+          if (!hasCluster) finalArgs.push('--cluster', DEFAULT_SOLANA_CLUSTER);
+          if (!hasOut) finalArgs.push('--out', defaultOut);
+          return await enigmaMain(['chain', 'anchor-bundle', ...finalArgs], this.io);
+        } else if (sub === 'anchor') {
+          return await enigmaMain(['chain', 'anchor', ...rawArgv.slice(2)], this.io);
+        } else if (sub === 'connect-phantom' || sub === 'connect') {
+          return await this.handleWalletConnect();
+        } else if (sub === 'auto-anchor' || sub === 'auto') {
+          return await this.handleAutoAnchor(rawArgv.slice(2));
+        } else if (!sub || sub === 'status' || sub === 'ping' || sub === 'health') {
+          // Extract cluster / rpc flag if provided
+          let cluster = DEFAULT_SOLANA_CLUSTER;
+          let rpcUrl = undefined;
+          for (let i = 2; i < rawArgv.length; i++) {
+            if (rawArgv[i] === '--cluster' && rawArgv[i + 1]) cluster = rawArgv[++i];
+            else if (rawArgv[i] === '--rpc' && rawArgv[i + 1]) rpcUrl = rawArgv[++i];
+          }
+          const probe = await probeSolanaRpc({ cluster, rpcUrl, fetchFn: this.fetchFn });
+          this.io.stdout.write('\n' + formatSolanaStatusReport(probe, { color: this.color }) + '\n');
+          return probe.ok === true ? 0 : 1;
+        } else {
+          this.io.stdout.write(`${c('Unknown solana subcommand:', ANSI.red)} "${sub}". Available: status, ping, health, stream, pulse, anchor, anchor-bundle, submit, verify-anchor, auto-anchor, connect-phantom\n`);
+        }
+      }
+
+      case 'wallet':
+      case 'phantom': {
+        const sub = (rawArgv[1] || 'status').toLowerCase();
+        if (sub === 'connect') {
+          return await this.handleWalletConnect();
+        } else if (sub === 'status') {
+          if (this.connectedWallet) {
+            this.io.stdout.write(`\n${c('Active Solana Wallet:', ANSI.green)} ${this.connectedWallet.publicKey}\n`);
+            this.io.stdout.write(`Cluster: ${this.connectedWallet.cluster || 'mainnet-beta'}\n`);
+            this.io.stdout.write(`Balance: ${this.connectedWallet.balance || '0.00'} SOL\n\n`);
+          } else {
+            this.io.stdout.write(`\n${c('Wallet Status:', ANSI.yellow)} Disconnected\nType "wallet connect" to open the Phantom browser companion.\n\n`);
+          }
+          return 0;
+        } else if (sub === 'disconnect') {
+          this.connectedWallet = null;
+          this.io.stdout.write(`${c('✔ Wallet disconnected.', ANSI.green)}\n`);
+          return 0;
+        } else {
+          this.io.stdout.write(`Available wallet commands: wallet connect, wallet status, wallet disconnect\n`);
+          return 1;
+        }
+      }
+      case 'auto-anchor': {
+        return await this.handleAutoAnchor(rawArgv.slice(1));
+      }
+
+      case 'constellation':
+        return await runConstellationAnimation(this.io, { color: this.color, shouldStop });
+
+      case 'matrix':
+        return await runMatrixStream(this.io, { color: this.color, shouldStop });
+
+      case 'stream':
+      case 'pulse':
+      case 'heartbeat': {
+        let cluster = DEFAULT_SOLANA_CLUSTER;
+        let rpcUrl = undefined;
+        let samples = undefined;
+        for (let i = 1; i < rawArgv.length; i++) {
+          if (rawArgv[i] === '--cluster' && rawArgv[i + 1]) cluster = rawArgv[++i];
+          else if (rawArgv[i] === '--rpc' && rawArgv[i + 1]) rpcUrl = rawArgv[++i];
+          else if ((rawArgv[i] === '--samples' || rawArgv[i] === '-n') && rawArgv[i + 1]) samples = Number(rawArgv[++i]) || 6;
+          else if (rawArgv[i] === '--once') samples = 1;
+        }
+        return await runSolanaHeartbeatStream(this.io, { cluster, rpcUrl, samples, fetchFn: this.fetchFn, color: this.color, bundlePath: this.bundlePath, shouldStop });
+      }
+      case 'bundle': {
+        const newPath = rawArgv[1];
+        if (!newPath) {
+          this.io.stdout.write(`Current bundle: ${this.bundlePath}\n`);
+        } else {
+          this.bundlePath = newPath;
+          this.io.stdout.write(`${c('Switched active bundle:', ANSI.green)} ${this.bundlePath}\n`);
+        }
+        return 0;
+      }
+
+      case 'clear':
+      case 'cls':
+        this.io.stdout.write('\x1b[2J\x1b[0;0H');
+        return 0;
+
+      case 'exit':
+      case 'quit':
+        return 'EXIT';
+    }
+
+    // Normalize REPL arguments (e.g. `remember "text"`, `context "query"`, `enclave verify <path>`)
+    const delegatedArgv = normalizeReplArgv(rawArgv, this.bundlePath);
+
+    // Pass color flag if disabled
+    if (!this.color && !delegatedArgv.includes('--no-color')) {
+      delegatedArgv.push('--no-color');
+    }
+
+    try {
+      return await enigmaMain(delegatedArgv, this.io);
+    } catch (err) {
+      this.io.stderr.write(`${c('Error:', ANSI.red)} ${err.message}\n`);
+      return 1;
+    }
+  }
+  async handleWalletConnect() {
+    const c = (text, code) => (this.color ? `${code}${text}${ANSI.reset}` : text);
+    this.io.stdout.write(`\n${c('⚡ Launching Phantom Browser Companion...', ANSI.cyan)}\n`);
+    try {
+      if (!this.phantomBridge) {
+        this.phantomBridge = new PhantomBrowserBridge({
+          port: 0,
+          cluster: 'mainnet-beta',
+          onWalletConnected: (wallet) => {
+            this.connectedWallet = wallet;
+          },
+        });
+        await this.phantomBridge.startServer();
+      } else {
+        this.phantomBridge.onWalletConnected = (wallet) => {
+          this.connectedWallet = wallet;
+        };
+      }
+      const session = this.phantomBridge.createSession();
+      const url = await this.phantomBridge.openInSystemBrowser(session.nonce);
+      this.io.stdout.write(`Companion URL opened: ${c(url, ANSI.yellow)}\n`);
+      this.io.stdout.write(`Approve and sign the authentication challenge in your Phantom browser extension.\n\n`);
+      return 0;
+    } catch (err) {
+      this.io.stderr.write(`${c('Wallet bridge error:', ANSI.red)} ${err.message}\n`);
+      return 1;
+    }
+  }
+
+  async handleAutoAnchor(args = []) {
+    const sub = (args[0] || 'status').toLowerCase();
+    const c = (txt, color) => (this.color ? `${color}${txt}${ANSI.reset}` : txt);
+
+    if (sub === 'status') {
+      const isCfg = this.autoAnchorEngine.isConfigured();
+      const signerPubkey = this.autoAnchorEngine.signerStore.getPublicKey();
+      const delegation = this.autoAnchorEngine.getDelegation();
+      const stats = this.autoAnchorEngine.outbox.getStats();
+
+      this.io.stdout.write(`\n${c('─── Enigma Auto-Anchor Engine Status ───', ANSI.cyan)}\n`);
+      this.io.stdout.write(`  Engine State:        ${isCfg ? c('CONFIGURED & ACTIVE', ANSI.green) : c('UNCONFIGURED', ANSI.yellow)}\n`);
+      this.io.stdout.write(`  Cluster:             ${DEFAULT_SOLANA_CLUSTER}\n`);
+      this.io.stdout.write(`  Signer Pubkey:       ${signerPubkey ? signerPubkey : c('(none - run auto-anchor setup)', ANSI.dimText)}\n`);
+      this.io.stdout.write(`  Delegation:          ${delegation ? c(`VALID (${delegation.authorization_hash.slice(0, 18)}...)`, ANSI.green) : c('(none)', ANSI.dimText)}\n`);
+      this.io.stdout.write(`  Outbox Pending:      ${stats.pendingCount} proofs\n`);
+      this.io.stdout.write(`  Anchored History:    ${stats.historicalCount} proofs\n\n`);
+      return 0;
+    } else if (sub === 'setup' || sub === 'enable') {
+      const setupResult = this.autoAnchorEngine.setupSigner();
+      this.io.stdout.write(`\n${c('✔ Automation Signer Initialized:', ANSI.green)} ${setupResult.publicKeyBase58}\n`);
+      this.io.stdout.write(`  Key custody secured via OS DPAPI/Keychain vault.\n`);
+      this.io.stdout.write(`  To activate auto-anchoring, connect your Phantom wallet in Desktop GUI or sign delegation.\n\n`);
+      return 0;
+    } else if (sub === 'process' || sub === 'sync') {
+      this.io.stdout.write(`\nProcessing pending proofs from auto-anchor outbox...\n`);
+      const result = await this.autoAnchorEngine.processNextOutboxItem({ force: true });
+      if (result && result.ok && result.item) {
+        this.io.stdout.write(`${c('✔ Successfully anchored proof:', ANSI.green)} ${result.item.solscanUrl}\n\n`);
+      } else if (result && result.skipped) {
+        this.io.stdout.write(`Outbox idle: ${result.reason}\n\n`);
+      } else {
+        const err = result?.error || 'Unknown outbox processing error';
+        this.io.stdout.write(`${c('✖ Auto-anchor processing failed:', ANSI.red)} ${err}\n\n`);
+      }
+      return (result && result.ok) ? 0 : 1;
+    } else {
+      this.io.stdout.write(`${c('Unknown auto-anchor action:', ANSI.red)} "${sub}". Available: status, setup, process\n`);
+      return 1;
+    }
+  }
+}

package/packages/terminal-console/delegation.mjs

@@ -0,0 +1,152 @@
+// Enigma Sovereign AI Memory — Dual-Key Delegation Layer
+// Formats, hashes, and cryptographically verifies one-time owner delegation authorizations.
+
+import crypto from 'node:crypto';
+import { decodeBase58 } from './phantom-bridge.mjs';
+
+const ED25519_SPKI_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+export const MAX_AUTO_ANCHOR_FEE_LAMPORTS = 5000;
+export const DEFAULT_DELEGATION_EXPIRY_DAYS = 30;
+export const MAX_DELEGATION_TTL_DAYS = 90;
+export const DELEGATION_POLICY_MEMO_ONLY = 'spl-memo-proof-anchoring-only';
+
+export function normalizeDescriptor(descriptor) {
+  return {
+    schema: 'enigma.delegated_signer_authorization.v1',
+    owner_pubkey: descriptor.owner_pubkey || descriptor.ownerPubkey,
+    signer_pubkey: descriptor.signer_pubkey || descriptor.signerPubkey,
+    cluster: descriptor.cluster || 'mainnet-beta',
+    policy: descriptor.policy || DELEGATION_POLICY_MEMO_ONLY,
+    max_fee_lamports: Number(descriptor.max_fee_lamports || descriptor.maxFeeLamports || MAX_AUTO_ANCHOR_FEE_LAMPORTS),
+    issued_at: descriptor.issued_at || descriptor.issuedAt,
+    expires_at: descriptor.expires_at || descriptor.expiresAt,
+  };
+}
+
+export function computeAuthorizationHash(descriptor) {
+  const canonical = normalizeDescriptor(descriptor);
+  return 'sha256:' + crypto.createHash('sha256').update(JSON.stringify(canonical)).digest('hex');
+}
+
+export function buildDelegationChallenge(descriptor) {
+  const norm = normalizeDescriptor(descriptor);
+  const authHash = descriptor.authorization_hash || descriptor.authorizationHash || computeAuthorizationHash(norm);
+  return [
+    'Enigma Auto-Anchor Delegation Authorization',
+    `Schema: enigma.delegated_signer_authorization.v1`,
+    `Owner Address: ${norm.owner_pubkey}`,
+    `Automation Signer: ${norm.signer_pubkey}`,
+    `Cluster: ${norm.cluster}`,
+    `Policy: ${norm.policy}`,
+    `Max Fee Cap: ${norm.max_fee_lamports} lamports`,
+    `Issued At: ${norm.issued_at}`,
+    `Expires At: ${norm.expires_at}`,
+    `Authorization Hash: ${authHash}`,
+    'Statement: Authorize this local automation signer to broadcast mathematical Merkle root timestamps to Solana Mainnet on your behalf with zero private data on-chain.',
+  ].join('\n');
+}
+
+export function createDelegationArtifact({
+  ownerPubkey,
+  signerPubkey,
+  cluster = 'mainnet-beta',
+  policy = DELEGATION_POLICY_MEMO_ONLY,
+  maxFeeLamports = MAX_AUTO_ANCHOR_FEE_LAMPORTS,
+  issuedAt = undefined,
+  expiresAt = undefined,
+  ownerSignature,
+}) {
+  const issued = issuedAt || new Date().toISOString();
+  const expiry = expiresAt || new Date(Date.now() + DEFAULT_DELEGATION_EXPIRY_DAYS * 24 * 60 * 60 * 1000).toISOString();
+  const descriptor = {
+    schema: 'enigma.delegated_signer_authorization.v1',
+    owner_pubkey: ownerPubkey,
+    signer_pubkey: signerPubkey,
+    cluster,
+    policy,
+    max_fee_lamports: Number(maxFeeLamports),
+    issued_at: issued,
+    expires_at: expiry,
+  };
+  const authHash = computeAuthorizationHash(descriptor);
+  return {
+    ...descriptor,
+    owner_signature: ownerSignature,
+    authorization_hash: authHash,
+  };
+}
+
+export function verifyDelegationArtifact(artifact, { expectedCluster = 'mainnet-beta' } = {}) {
+  if (!artifact || typeof artifact !== 'object' || artifact.schema !== 'enigma.delegated_signer_authorization.v1') {
+    return { ok: false, error: 'Invalid delegation schema' };
+  }
+  if (!artifact.owner_pubkey || !artifact.signer_pubkey) {
+    return { ok: false, error: 'Missing owner or signer public keys' };
+  }
+  if (artifact.cluster !== expectedCluster) {
+    return { ok: false, error: `Cluster mismatch: artifact authorized for ${artifact.cluster}, expected ${expectedCluster}` };
+  }
+  if (artifact.policy !== DELEGATION_POLICY_MEMO_ONLY) {
+    return { ok: false, error: `Unauthorized policy: ${artifact.policy}` };
+  }
+
+  const feeCap = Number(artifact.max_fee_lamports);
+  if (!Number.isInteger(feeCap) || feeCap <= 0 || feeCap > MAX_AUTO_ANCHOR_FEE_LAMPORTS) {
+    return { ok: false, error: `Invalid fee cap: must be an integer between 1 and ${MAX_AUTO_ANCHOR_FEE_LAMPORTS} lamports` };
+  }
+
+  const issuedTime = Date.parse(artifact.issued_at);
+  const expiryTime = Date.parse(artifact.expires_at);
+
+  if (Number.isNaN(issuedTime) || Number.isNaN(expiryTime)) {
+    return { ok: false, error: 'Malformed non-ISO issued_at or expires_at timestamp' };
+  }
+  if (issuedTime > Date.now() + 60000) {
+    return { ok: false, error: 'issued_at is in the future' };
+  }
+  if (expiryTime <= issuedTime) {
+    return { ok: false, error: 'expires_at must be strictly after issued_at' };
+  }
+  const maxTtlMs = MAX_DELEGATION_TTL_DAYS * 24 * 60 * 60 * 1000;
+  if (expiryTime > issuedTime + maxTtlMs) {
+    return { ok: false, error: `expires_at exceeds maximum TTL of ${MAX_DELEGATION_TTL_DAYS} days` };
+  }
+  if (expiryTime < Date.now()) {
+    return { ok: false, error: 'Delegation authorization has expired' };
+  }
+
+  const expectedHash = computeAuthorizationHash(artifact);
+  if (artifact.authorization_hash !== expectedHash) {
+    return { ok: false, error: 'Authorization hash mismatch: descriptor fields were modified' };
+  }
+
+  const ownerBytes = decodeBase58(artifact.owner_pubkey, 32);
+  if (!ownerBytes || ownerBytes.length !== 32) {
+    return { ok: false, error: 'Invalid owner public key Base58' };
+  }
+
+  const challenge = buildDelegationChallenge(artifact);
+  const spki = Buffer.concat([ED25519_SPKI_PREFIX, ownerBytes]);
+  const pubKeyObj = crypto.createPublicKey({ key: spki, format: 'der', type: 'spki' });
+
+  let sigBytes;
+  if (Buffer.isBuffer(artifact.owner_signature)) {
+    sigBytes = artifact.owner_signature;
+  } else if (typeof artifact.owner_signature === 'string') {
+    const base58Decoded = decodeBase58(artifact.owner_signature, 64);
+    if (base58Decoded && base58Decoded.length === 64) {
+      sigBytes = base58Decoded;
+    } else {
+      sigBytes = Buffer.from(artifact.owner_signature, 'base64');
+    }
+  } else {
+    return { ok: false, error: 'Malformed owner signature format' };
+  }
+
+  if (!sigBytes || sigBytes.length !== 64) {
+    return { ok: false, error: 'Invalid 64-byte Ed25519 signature length' };
+  }
+
+  const isValid = crypto.verify(null, Buffer.from(challenge, 'utf8'), pubKeyObj, sigBytes);
+  return { ok: isValid, error: isValid ? null : 'Signature verification failed' };
+}

package/packages/terminal-console/index.mjs

@@ -0,0 +1,5 @@
+export { renderTerminalBanner, renderHelpCatalog, OFFICIAL_TOKEN_CA } from './banner.mjs';
+export { TerminalSession, normalizeReplArgv } from './commands.mjs';
+export { runTerminalConsole, createCompleter } from './repl.mjs';
+export { runConstellationAnimation, runMatrixStream, runSolanaHeartbeatStream } from './animations.mjs';
+export { probeSolanaRpc, formatSolanaStatusReport, formatSolanaAnchorVerificationReport, fetchSolanaStreamMetrics, SOLANA_RPC_CLUSTERS } from './solana-rpc.mjs';