gnoman 0.1.0

package/gnoman2.0/backend/services/walletStore.ts

@@ -0,0 +1,179 @@
+import fs from 'fs';
+import path from 'path';
+import Database from 'better-sqlite3';
+import type { Statement } from 'better-sqlite3';
+
+export interface PersistedWalletRecord {
+  address: string;
+  alias?: string;
+  encryptedSecret: string;
+  iv: string;
+  salt: string;
+  hidden: boolean;
+  createdAt: string;
+  source: string;
+  publicKey?: string;
+  mnemonic?: string;
+  derivationPath?: string;
+  network?: string;
+  balance?: string;
+  privateKey: string;
+}
+
+const storageDir = path.join(process.cwd(), '.gnoman');
+if (!fs.existsSync(storageDir)) {
+  fs.mkdirSync(storageDir, { recursive: true, mode: 0o700 });
+}
+
+const databasePath = path.join(storageDir, 'wallets.db');
+const db = new Database(databasePath);
+
+try {
+  db.pragma('journal_mode = WAL');
+  db.pragma('synchronous = FULL');
+} catch (error) {
+  console.warn('Unable to configure wallet database pragmas', error);
+}
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS wallets (
+    address TEXT PRIMARY KEY COLLATE NOCASE,
+    alias TEXT,
+    encryptedSecret TEXT NOT NULL,
+    iv TEXT NOT NULL,
+    salt TEXT NOT NULL,
+    hidden INTEGER NOT NULL DEFAULT 0,
+    createdAt TEXT NOT NULL,
+    source TEXT NOT NULL,
+    publicKey TEXT,
+    mnemonic TEXT,
+    derivationPath TEXT,
+    network TEXT,
+    balance TEXT,
+    privateKey TEXT NOT NULL
+  )
+`);
+
+const ensureColumn = (name: string, type: string, defaultValue?: string) => {
+  try {
+    db.exec(
+      `ALTER TABLE wallets ADD COLUMN ${name} ${type}${
+        typeof defaultValue !== 'undefined' ? ` DEFAULT ${defaultValue}` : ''
+      }`
+    );
+  } catch (error) {
+    if (!(error instanceof Error) || !/duplicate column name/i.test(error.message)) {
+      throw error;
+    }
+  }
+};
+
+ensureColumn('publicKey', 'TEXT');
+ensureColumn('mnemonic', 'TEXT');
+ensureColumn('derivationPath', 'TEXT');
+ensureColumn('network', 'TEXT');
+ensureColumn('balance', 'TEXT');
+ensureColumn('privateKey', 'TEXT');
+
+const insertStatement: Statement = db.prepare(
+  `INSERT INTO wallets (address, alias, encryptedSecret, iv, salt, hidden, createdAt, source, publicKey, mnemonic, derivationPath, network, balance, privateKey)
+   VALUES (@address, @alias, @encryptedSecret, @iv, @salt, @hidden, @createdAt, @source, @publicKey, @mnemonic, @derivationPath, @network, @balance, @privateKey)
+   ON CONFLICT(address) DO UPDATE SET
+     alias = excluded.alias,
+     encryptedSecret = excluded.encryptedSecret,
+     iv = excluded.iv,
+     salt = excluded.salt,
+     hidden = excluded.hidden,
+     source = excluded.source,
+     publicKey = excluded.publicKey,
+     mnemonic = excluded.mnemonic,
+     derivationPath = excluded.derivationPath,
+     network = excluded.network,
+     balance = excluded.balance,
+     privateKey = excluded.privateKey`
+);
+
+const listStatement: Statement = db.prepare(`
+  SELECT address, alias, encryptedSecret, iv, salt, hidden, createdAt, source, publicKey, mnemonic, derivationPath, network, balance, privateKey
+  FROM wallets
+  ORDER BY datetime(createdAt) DESC
+`);
+
+const getStatement: Statement = db.prepare(`
+  SELECT address, alias, encryptedSecret, iv, salt, hidden, createdAt, source, publicKey, mnemonic, derivationPath, network, balance, privateKey
+  FROM wallets
+  WHERE address = ?
+`);
+
+const deleteStatement: Statement = db.prepare(`
+  DELETE FROM wallets
+  WHERE address = ?
+`);
+
+type WalletRow = {
+  address: string;
+  alias: string | null;
+  encryptedSecret: string;
+  iv: string;
+  salt: string;
+  hidden: number;
+  createdAt: string;
+  source: string;
+  publicKey: string | null;
+  mnemonic: string | null;
+  derivationPath: string | null;
+  network: string | null;
+  balance: string | null;
+  privateKey: string;
+};
+
+const mapRow = (row: WalletRow): PersistedWalletRecord => {
+  return {
+    address: row.address,
+    alias: row.alias ?? undefined,
+    encryptedSecret: row.encryptedSecret,
+    iv: row.iv,
+    salt: row.salt,
+    hidden: Boolean(row.hidden),
+    createdAt: row.createdAt,
+    source: row.source,
+    publicKey: row.publicKey ?? undefined,
+    mnemonic: row.mnemonic ?? undefined,
+    derivationPath: row.derivationPath ?? undefined,
+    network: row.network ?? undefined,
+    balance: row.balance ?? undefined,
+    privateKey: row.privateKey ?? ''
+  };
+};
+
+export const walletRepository = {
+  save(record: PersistedWalletRecord) {
+    insertStatement.run({
+      ...record,
+      alias: record.alias ?? null,
+      hidden: record.hidden ? 1 : 0,
+      publicKey: record.publicKey ?? null,
+      mnemonic: record.mnemonic ?? null,
+      derivationPath: record.derivationPath ?? null,
+      network: record.network ?? null,
+      balance: record.balance ?? null
+    });
+  },
+
+  list(): PersistedWalletRecord[] {
+    return (listStatement.all() as WalletRow[]).map((row) => mapRow(row));
+  },
+
+  find(address: string): PersistedWalletRecord | undefined {
+    const row = getStatement.get(address) as WalletRow | undefined;
+    if (!row) {
+      return undefined;
+    }
+    return mapRow(row);
+  },
+
+  delete(address: string): boolean {
+    const result = deleteStatement.run(address);
+    return result.changes > 0;
+  }
+};

package/gnoman2.0/backend/types/express-async-handler.d.ts

@@ -0,0 +1,13 @@
+declare module 'express-async-handler' {
+  import type { NextFunction, Request, RequestHandler, Response } from 'express';
+
+  type AsyncRequestHandler<P = any, ResBody = any, ReqBody = any, ReqQuery = any> = (
+    req: Request<P, ResBody, ReqBody, ReqQuery>,
+    res: Response<ResBody>,
+    next: NextFunction
+  ) => Promise<unknown> | unknown;
+
+  export default function asyncHandler<P = any, ResBody = any, ReqBody = any, ReqQuery = any>(
+    handler: AsyncRequestHandler<P, ResBody, ReqBody, ReqQuery>
+  ): RequestHandler<P, ResBody, ReqBody, ReqQuery>;
+}

package/gnoman2.0/backend/types/keyring.d.ts

@@ -0,0 +1,19 @@
+declare module 'keyring' {
+  interface KeyringApi {
+    load(ondone?: () => void): KeyringApi;
+    save(ondone?: () => void): KeyringApi;
+    store(key: string, value: string): KeyringApi;
+    storeEncrypted(key: string, value: string): KeyringApi;
+    retrieve(key: string): string | null;
+    retrieveEncrypted(key: string): string | null;
+    db?: Record<string, unknown>;
+  }
+
+  interface KeyringModule {
+    ALGORITHM: string;
+    instance(encryptionKey: string, keyringDatabase?: string): KeyringApi;
+  }
+
+  const api: KeyringModule;
+  export = api;
+}

package/gnoman2.0/backend/utils/abiResolver.ts

@@ -0,0 +1,208 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { ethers } from 'ethers';
+import { runtimeTelemetry } from '../services/runtimeTelemetryService';
+import { secretsResolver } from './secretsResolver';
+
+export type AbiResolveResult = {
+  abi: unknown[];
+  contractName: string;
+  source: 'cache' | 'sourcify' | 'etherscan' | 'manual-registry';
+  fetchedAt: string;
+  cachePath: string;
+  verified: boolean;
+  cached: boolean;
+};
+
+type IndexEntry = { address: string; contractName: string; source: string; abiHash: string; updatedAt: string };
+
+const root = path.join(process.cwd(), 'abi-cache');
+const manualRegistryPath = path.join(process.cwd(), 'abi', 'manual-registry.json');
+
+const chainDir = (chainId: number) => path.join(root, `${chainId}`);
+const abiPath = (chainId: number, address: string) => path.join(chainDir(chainId), `${address.toLowerCase()}.json`);
+const indexPath = (chainId: number) => path.join(chainDir(chainId), 'index.json');
+
+const readJson = <T>(filePath: string, fallback: T): T => {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8')) as T;
+  } catch (error) {
+    console.error(JSON.stringify({ event: 'CONFIG_EARLY_RETURN', fn: 'AbiResolver.readJson', reason: error instanceof Error ? error.message : String(error), filePath }));
+    return fallback;
+  }
+};
+
+const writeJson = (filePath: string, payload: unknown) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+};
+
+const normalizeAddress = (address: string) => ethers.getAddress(address).toLowerCase();
+
+export class AbiResolver {
+  async resolve(chainId: number, addressInput: string, contractNameHint?: string): Promise<AbiResolveResult> {
+    console.info(JSON.stringify({ event: 'ABI_RESOLVE start', address: addressInput, chainId }));
+    const address = normalizeAddress(addressInput);
+    const cachedPath = abiPath(chainId, address);
+    if (fs.existsSync(cachedPath)) {
+      const payload = readJson<{ abi: unknown[]; contractName?: string; source?: AbiResolveResult['source']; fetchedAt?: string; verified?: boolean }>(cachedPath, { abi: [] });
+      const result: AbiResolveResult = {
+        abi: Array.isArray(payload.abi) ? payload.abi : [],
+        contractName: payload.contractName ?? contractNameHint ?? address,
+        source: 'cache',
+        fetchedAt: payload.fetchedAt ?? new Date().toISOString(),
+        cachePath: cachedPath,
+        verified: payload.verified ?? true,
+        cached: true
+      };
+      this.logResolve(chainId, address, result);
+      console.debug(JSON.stringify({ event: 'TRACE', phase: 'exit', fn: 'AbiResolver.resolve', ok: true, source: 'cache' }));
+      return result;
+    }
+
+    const sourcify = await this.resolveFromSourcify(chainId, address);
+    if (sourcify) {
+      const persisted = this.persist(chainId, address, sourcify.abi, sourcify.contractName, 'sourcify', sourcify.verified);
+      console.debug(JSON.stringify({ event: 'TRACE', phase: 'exit', fn: 'AbiResolver.resolve', ok: true, source: 'sourcify' }));
+      return persisted;
+    }
+
+    const etherscan = await this.resolveFromEtherscan(chainId, address);
+    if (etherscan) {
+      const persisted = this.persist(chainId, address, etherscan.abi, etherscan.contractName, 'etherscan', true);
+      console.debug(JSON.stringify({ event: 'TRACE', phase: 'exit', fn: 'AbiResolver.resolve', ok: true, source: 'etherscan' }));
+      return persisted;
+    }
+
+    const manual = this.resolveFromManualRegistry(chainId, address, contractNameHint);
+    if (manual) {
+      const persisted = this.persist(chainId, address, manual.abi, manual.contractName, 'manual-registry', manual.verified);
+      console.debug(JSON.stringify({ event: 'TRACE', phase: 'exit', fn: 'AbiResolver.resolve', ok: true, source: 'manual-registry' }));
+      return persisted;
+    }
+
+    console.error(JSON.stringify({ event: 'ABI_RESOLVE_FAILED', reason: 'no-source-hit', chainId, address }));
+    console.debug(JSON.stringify({ event: 'TRACE', phase: 'exit', fn: 'AbiResolver.resolve', ok: false }));
+    throw new Error(`Unable to resolve ABI for chainId=${chainId} address=${address}`);
+  }
+
+  private async resolveFromSourcify(chainId: number, address: string) {
+    const url = `https://repo.sourcify.dev/contracts/full_match/${chainId}/${address}/metadata.json`;
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        console.info(JSON.stringify({ event: 'ABI_RESOLVE source=sourcify fail', chainId, address, reason: `http_${response.status}` }));
+        return null;
+      }
+      const payload = (await response.json()) as { output?: { abi?: unknown[] }; contractName?: string };
+      if (!Array.isArray(payload.output?.abi)) {
+        console.info(JSON.stringify({ event: 'ABI_RESOLVE source=sourcify fail', chainId, address, reason: 'missing_abi' }));
+        return null;
+      }
+      console.info(JSON.stringify({ event: 'ABI_RESOLVE source=sourcify success', chainId, address }));
+      return { abi: payload.output.abi, contractName: payload.contractName ?? address, verified: true };
+    } catch (error) {
+      console.error(JSON.stringify({ event: 'ABI_RESOLVE source=sourcify fail', chainId, address, reason: error instanceof Error ? error.message : String(error) }));
+      return null;
+    }
+  }
+
+  private async resolveFromEtherscan(chainId: number, address: string) {
+    const cacheKey = `${chainId}:${address.toLowerCase()}`;
+    const apiKey = await secretsResolver.resolve('ETHERSCAN_API_KEY', { required: true, failClosed: false });
+    if (!apiKey) {
+      console.error(JSON.stringify({ event: 'ABI_RESOLVE source=etherscan fail', chainId, address, reason: 'missing_key', attemptedNetwork: false, cacheKey }));
+      return null;
+    }
+    const endpoint = process.env.ETHERSCAN_BASE_URL?.trim() || 'https://api.etherscan.io/api';
+    const query = new URLSearchParams({ module: 'contract', action: 'getabi', address, chainid: `${chainId}`, apikey: apiKey });
+    const response = await fetch(`${endpoint}?${query.toString()}`);
+    if (!response.ok) {
+      const reason = response.status === 401 || response.status === 403 ? 'key_auth' : response.status === 404 ? 'unverified_or_missing' : response.status === 429 ? 'rate_limit' : `http_${response.status}`;
+      console.error(JSON.stringify({ event: 'ABI_RESOLVE source=etherscan fail', chainId, address, reason, attemptedNetwork: true, cacheKey }));
+      return null;
+    }
+    const payload = (await response.json()) as { status?: string; result?: string; message?: string };
+    if (payload.status !== '1' || !payload.result) {
+      console.error(JSON.stringify({ event: 'ABI_RESOLVE source=etherscan fail', chainId, address, reason: payload.message ?? 'invalid_payload', attemptedNetwork: true, cacheKey }));
+      return null;
+    }
+    try {
+      const abi = JSON.parse(payload.result) as unknown[];
+      console.info(JSON.stringify({ event: 'ABI_RESOLVE source=etherscan success', chainId, address, attemptedNetwork: true, cacheKey }));
+      return { abi, contractName: address };
+    } catch (error) {
+      console.error(JSON.stringify({ event: 'ABI_RESOLVE source=etherscan fail', chainId, address, reason: 'parse_error', attemptedNetwork: true, cacheKey, detail: error instanceof Error ? error.message : String(error) }));
+      return null;
+    }
+  }
+
+  private resolveFromManualRegistry(chainId: number, address: string, contractNameHint?: string) {
+    const registry = readJson<Record<string, Record<string, { abi: unknown[]; contractName?: string; verified?: boolean }>>>(manualRegistryPath, {});
+    const chainKey = `${chainId}`;
+    const byChain = registry[chainKey] ?? {};
+    const byAddress = byChain[address];
+    if (byAddress) {
+      return { abi: byAddress.abi, contractName: byAddress.contractName ?? contractNameHint ?? address, verified: Boolean(byAddress.verified) };
+    }
+    if (contractNameHint) {
+      const entries = Object.entries(byChain).filter(([, value]) => value.contractName === contractNameHint);
+      if (entries.length === 1) {
+        return { abi: entries[0][1].abi, contractName: contractNameHint, verified: Boolean(entries[0][1].verified) };
+      }
+      if (entries.length > 1) {
+        throw new Error(`Contract name ${contractNameHint} resolves to multiple addresses on chain ${chainId}`);
+      }
+    }
+    console.error(JSON.stringify({ event: 'ABI_RESOLVE source=manual-registry fail', chainId, address, reason: 'not_found' }));
+    return null;
+  }
+
+  private persist(
+    chainId: number,
+    address: string,
+    abi: unknown[],
+    contractName: string,
+    source: AbiResolveResult['source'],
+    verified: boolean
+  ): AbiResolveResult {
+    const fetchedAt = new Date().toISOString();
+    const cachePath = abiPath(chainId, address);
+    const payload = { abi, contractName, source, fetchedAt, verified };
+    writeJson(cachePath, payload);
+    const index = readJson<Record<string, IndexEntry>>(indexPath(chainId), {});
+    index[address] = {
+      address,
+      contractName,
+      source,
+      abiHash: crypto.createHash('sha256').update(JSON.stringify(abi)).digest('hex'),
+      updatedAt: fetchedAt
+    };
+    writeJson(indexPath(chainId), index);
+
+    const result: AbiResolveResult = { abi, contractName, source, fetchedAt, cachePath, verified, cached: false };
+    this.logResolve(chainId, address, result);
+    return result;
+  }
+
+  private logResolve(chainId: number, address: string, result: AbiResolveResult) {
+    const functionsCount = result.abi.filter(
+      (entry) => entry && typeof entry === 'object' && (entry as { type?: string }).type === 'function'
+    ).length;
+    const line = {
+      event: 'ABI_RESOLVED',
+      chainId,
+      address,
+      contractName: result.contractName,
+      source: result.source,
+      cached: result.cached,
+      functionsCount
+    };
+    console.info(JSON.stringify(line));
+    runtimeTelemetry.recordAbiResolve({ ...line, verified: result.verified, fetchedAt: result.fetchedAt });
+  }
+}
+
+export const abiResolver = new AbiResolver();

package/gnoman2.0/backend/utils/http.ts

@@ -0,0 +1,6 @@
+import axios from 'axios';
+
+export const http = axios.create({
+  baseURL: process.env.ETHERSCAN_BASE_URL?.trim() || 'https://api.etherscan.io/api',
+  timeout: 10_000
+});

package/gnoman2.0/backend/utils/secretsResolver.ts

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+import { FileBackend } from '../../src/core/backends/fileBackend';
+import { SystemBackend } from '../../src/core/backends/systemBackend';
+import { runtimeTelemetry, type SecretsTelemetryEntry } from '../services/runtimeTelemetryService';
+
+type SourceName = 'env' | 'project-env' | 'encrypted-file' | 'keyring' | 'missing';
+
+type ResolveOpts = { required?: boolean; failClosed?: boolean };
+
+const projectEnvPath = path.join(process.cwd(), '.env');
+
+const parseDotEnv = (raw: string): Record<string, string> => {
+  const result: Record<string, string> = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const idx = trimmed.indexOf('=');
+    if (idx <= 0) continue;
+    const key = trimmed.slice(0, idx).trim();
+    const value = trimmed.slice(idx + 1).trim().replace(/^"|"$/g, '');
+    result[key] = value;
+  }
+  return result;
+};
+
+const redact = (value?: string | null) => {
+  if (!value) return '****';
+  if (value.length <= 4) return '****';
+  return `****${value.slice(-4)}`;
+};
+
+class SecretsResolver {
+  private projectEnv: Record<string, string> = {};
+
+  private encryptedFileSecrets: Record<string, string> = {};
+
+  private keyringSecrets: Record<string, string> = {};
+
+  private initialized = false;
+
+  private diagnostics = new Map<string, SecretsTelemetryEntry>();
+
+  private async loadProjectEnv() {
+    if (!fs.existsSync(projectEnvPath)) return;
+    this.projectEnv = parseDotEnv(fs.readFileSync(projectEnvPath, 'utf8'));
+  }
+
+  private async loadEncryptedFile() {
+    try {
+      const backend = new FileBackend();
+      await backend.initialize();
+      this.encryptedFileSecrets = await backend.list();
+    } catch (error) {
+      console.warn('Encrypted local secrets file unavailable.', error);
+    }
+  }
+
+  private hasGuiSession() {
+    return Boolean(process.env.DISPLAY && process.env.DBUS_SESSION_BUS_ADDRESS);
+  }
+
+  private async loadSystemKeyring() {
+    if (!this.hasGuiSession()) {
+      return;
+    }
+    try {
+      const backend = new SystemBackend();
+      await backend.initialize();
+      this.keyringSecrets = await backend.list();
+    } catch (error) {
+      console.warn('OS keyring unavailable.', error);
+    }
+  }
+
+  async initialize() {
+    if (this.initialized) return;
+    await this.loadProjectEnv();
+    await this.loadEncryptedFile();
+    await this.loadSystemKeyring();
+    this.initialized = true;
+  }
+
+  private setDiagnostic(key: string, source: SourceName, required: boolean, value?: string | null) {
+    const entry: SecretsTelemetryEntry = {
+      key,
+      required,
+      present: Boolean(value && value.trim()),
+      source,
+      redacted: redact(value)
+    };
+    this.diagnostics.set(key, entry);
+    runtimeTelemetry.setSecretsStatus(Array.from(this.diagnostics.values()));
+  }
+
+  async resolve(key: string, opts: ResolveOpts = {}): Promise<string | null> {
+    await this.initialize();
+    const required = Boolean(opts.required);
+    const envValue = process.env[key]?.trim();
+    if (envValue) {
+      this.setDiagnostic(key, 'env', required, envValue);
+      return envValue;
+    }
+
+    const projectValue = this.projectEnv[key]?.trim();
+    if (projectValue) {
+      this.setDiagnostic(key, 'project-env', required, projectValue);
+      return projectValue;
+    }
+
+    const fileValue = this.encryptedFileSecrets[key]?.trim();
+    if (fileValue) {
+      this.setDiagnostic(key, 'encrypted-file', required, fileValue);
+      return fileValue;
+    }
+
+    const keyringValue = this.keyringSecrets[key]?.trim();
+    if (keyringValue) {
+      this.setDiagnostic(key, 'keyring', required, keyringValue);
+      return keyringValue;
+    }
+
+    const checked = ['env', 'project-env', 'encrypted-file', this.hasGuiSession() ? 'keyring' : 'keyring-skipped'];
+    const payload = { event: 'MISSING_SECRET', key, checked };
+    console.error(JSON.stringify(payload));
+    this.setDiagnostic(key, 'missing', required, null);
+
+    if (required && opts.failClosed !== false) {
+      throw new Error(`Missing required secret: ${key}`);
+    }
+
+    return null;
+  }
+
+  getDiagnostics() {
+    return Array.from(this.diagnostics.values());
+  }
+
+  logBootSummary(requiredKeys: string[] = []) {
+    const summary = requiredKeys.map((key) => {
+      const existing = this.diagnostics.get(key);
+      return existing ?? { key, required: true, present: false, source: 'missing', redacted: '****' };
+    });
+    console.info(
+      JSON.stringify({ event: 'SECRETS_BOOT_STATUS', secrets: summary.map((entry) => ({ ...entry, value: entry.present ? entry.redacted : '****' })) })
+    );
+  }
+}
+
+export const secretsResolver = new SecretsResolver();

package/gnoman2.0/backend/utils/signer.ts

@@ -0,0 +1,11 @@
+import { JsonRpcProvider, Wallet } from 'ethers';
+import { requireRpcUrl } from '../services/rpcService';
+
+export const createBackendSigner = async (preferredRpcUrl?: string) => {
+  const privateKey = process.env.PRIVATE_KEY?.trim();
+  if (!privateKey) {
+    throw new Error('PRIVATE_KEY is missing. Configure PRIVATE_KEY in the backend environment.');
+  }
+  const rpcUrl = await requireRpcUrl(preferredRpcUrl ?? process.env.RPC_URL);
+  return new Wallet(privateKey, new JsonRpcProvider(rpcUrl));
+};

package/gnoman2.0/backend/workers/vanityWorker.ts

@@ -0,0 +1,76 @@
+import { parentPort, workerData } from 'worker_threads';
+import { ethers } from 'ethers';
+
+interface VanityWorkerData {
+  prefix?: string;
+  suffix?: string;
+  regex?: string;
+  maxAttempts: number;
+  derivationPath: string;
+  progressInterval?: number;
+}
+
+const { prefix, suffix, regex: regexPattern, maxAttempts, derivationPath, progressInterval } =
+  workerData as VanityWorkerData;
+const normalizedPrefix = prefix?.replace(/^0x/i, '').toLowerCase();
+const normalizedSuffix = suffix?.replace(/^0x/i, '').toLowerCase();
+const regex = regexPattern ? new RegExp(regexPattern, 'i') : undefined;
+
+let cancelled = false;
+let attempts = 0;
+const startedAt = Date.now();
+const attemptModulo = Math.max(100, progressInterval ?? 5000);
+let lastReport = startedAt;
+
+parentPort?.on('message', (message: { type: 'cancel' }) => {
+  if (message.type === 'cancel') {
+    cancelled = true;
+  }
+});
+
+const reportProgress = () => {
+  parentPort?.postMessage({
+    type: 'progress',
+    attempts,
+    elapsedMs: Date.now() - startedAt
+  });
+};
+
+const matchesPattern = (address: string) => {
+  const normalized = address.toLowerCase().replace(/^0x/, '');
+  const prefixMatch = normalizedPrefix ? normalized.startsWith(normalizedPrefix) : true;
+  const suffixMatch = normalizedSuffix ? normalized.endsWith(normalizedSuffix) : true;
+  const regexMatch = regex ? regex.test(address) : true;
+  return prefixMatch && suffixMatch && regexMatch;
+};
+
+(async () => {
+  while (!cancelled && (maxAttempts <= 0 || attempts < maxAttempts)) {
+    const randomWallet = ethers.Wallet.createRandom();
+    const mnemonic = randomWallet.mnemonic;
+    const wallet = mnemonic ? ethers.HDNodeWallet.fromMnemonic(mnemonic, derivationPath) : randomWallet;
+    attempts += 1;
+    if (matchesPattern(wallet.address)) {
+      parentPort?.postMessage({
+        type: 'result',
+        address: wallet.address,
+        mnemonic: wallet.mnemonic?.phrase,
+        derivationPath: wallet.path,
+        attempts,
+        elapsedMs: Date.now() - startedAt
+      });
+      return;
+    }
+    if (attempts % attemptModulo === 0 || Date.now() - lastReport >= 2000) {
+      reportProgress();
+      lastReport = Date.now();
+    }
+  }
+  parentPort?.postMessage({
+    type: 'complete',
+    attempts,
+    elapsedMs: Date.now() - startedAt,
+    cancelled,
+    success: false
+  });
+})();

package/gnoman2.0/capacitor.config.ts

@@ -0,0 +1,13 @@
+import type { CapacitorConfig } from '@capacitor/cli';
+
+const config: CapacitorConfig = {
+  appId: 'com.gnoman.app',
+  appName: 'GNOMAN',
+  webDir: 'renderer/dist',
+  bundledWebRuntime: false,
+  server: {
+    androidScheme: 'https'
+  }
+};
+
+export default config;