gnoman 0.1.0

package/backend/services/vanityService.ts

@@ -0,0 +1,293 @@
+import { Worker } from 'worker_threads';
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+import { setSecureSetting } from './secureSettingsService';
+
+type VanityWorkerMessage =
+  | { type: 'progress'; attempts: number; elapsedMs: number }
+  | {
+      type: 'result';
+      address: string;
+      mnemonic?: string;
+      derivationPath?: string;
+      attempts: number;
+      elapsedMs: number;
+    }
+  | {
+      type: 'complete';
+      attempts: number;
+      elapsedMs: number;
+      cancelled: boolean;
+      success: boolean;
+    };
+
+export interface VanityJobOptions {
+  prefix?: string;
+  suffix?: string;
+  regex?: string;
+  derivationPath?: string;
+  maxAttempts?: number;
+  label?: string;
+  progressInterval?: number;
+}
+
+export interface VanityJobSummary {
+  id: string;
+  status: 'running' | 'completed' | 'cancelled' | 'failed';
+  attempts: number;
+  startedAt: string;
+  completedAt?: string;
+  address?: string;
+  etaMs?: number;
+  attemptRate?: number;
+  targetAttempts?: number;
+  label?: string;
+  pattern: Pick<VanityJobOptions, 'prefix' | 'suffix' | 'regex' | 'derivationPath'>;
+  message?: string;
+  mnemonicAlias?: string;
+  updatedAt?: string;
+}
+
+interface VanityJob extends VanityJobSummary {
+  worker?: Worker;
+}
+
+const jobStore = new Map<string, VanityJob>();
+
+const storageDir = path.join(process.cwd(), '.gnoman');
+if (!fs.existsSync(storageDir)) {
+  fs.mkdirSync(storageDir, { recursive: true });
+}
+const jobStorePath = path.join(storageDir, 'vanity-jobs.json');
+
+const resolveWorkerPath = () => {
+  const compiled = path.join(__dirname, '..', 'workers', 'vanityWorker.js');
+  if (fs.existsSync(compiled)) {
+    return { path: compiled, execArgv: [] as string[] };
+  }
+  const source = path.join(__dirname, '..', 'workers', 'vanityWorker.ts');
+  if (fs.existsSync(source)) {
+    try {
+      const register = require.resolve('ts-node/register');
+      return { path: source, execArgv: ['-r', register] };
+    } catch (error) {
+      console.warn(
+        'ts-node/register not found; run `npm run build:backend` to compile vanity workers before starting searches.'
+      );
+    }
+  }
+  return { path: compiled, execArgv: [] as string[] };
+};
+
+let lastPersistAt = 0;
+
+const persistJobs = (force = false) => {
+  const now = Date.now();
+  const payload = Array.from(jobStore.values()).map(({ worker: _worker, ...summary }) => summary);
+  if (!force && now - lastPersistAt < 1500) {
+    return;
+  }
+  lastPersistAt = now;
+  fs.promises.writeFile(jobStorePath, JSON.stringify(payload, null, 2)).catch((error) => {
+    console.warn('Failed to persist vanity job state', error);
+  });
+};
+
+const loadPersistedJobs = () => {
+  if (!fs.existsSync(jobStorePath)) {
+    return;
+  }
+  try {
+    const raw = fs.readFileSync(jobStorePath, 'utf8');
+    const entries = JSON.parse(raw) as VanityJobSummary[];
+    for (const entry of entries) {
+      const restored: VanityJob = {
+        ...entry,
+        updatedAt: entry.updatedAt ?? entry.completedAt ?? entry.startedAt
+      };
+      if (restored.status === 'running') {
+        restored.status = 'failed';
+        restored.message = 'Job interrupted by restart';
+        restored.completedAt = new Date().toISOString();
+      }
+      jobStore.set(restored.id, restored);
+    }
+  } catch (error) {
+    console.warn('Unable to restore vanity jobs', error);
+  }
+};
+
+loadPersistedJobs();
+
+export const startVanityJob = (options: VanityJobOptions) => {
+  const id = cryptoRandomId();
+  const { path: workerEntry, execArgv } = resolveWorkerPath();
+  const job: VanityJob = {
+    id,
+    status: 'running',
+    attempts: 0,
+    startedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    attemptRate: 0,
+    targetAttempts: calculateTargetAttempts(options),
+    label: options.label,
+    pattern: {
+      prefix: options.prefix,
+      suffix: options.suffix,
+      regex: options.regex,
+      derivationPath: options.derivationPath ?? "m/44'/60'/0'/0/0"
+    }
+  };
+  const worker = new Worker(workerEntry, {
+    workerData: {
+      prefix: options.prefix,
+      suffix: options.suffix,
+      regex: options.regex,
+      derivationPath: options.derivationPath ?? "m/44'/60'/0'/0/0",
+      maxAttempts: options.maxAttempts ?? 0,
+      progressInterval: options.progressInterval ?? 5000
+    },
+    execArgv
+  });
+  job.worker = worker;
+  jobStore.set(id, job);
+  persistJobs(true);
+
+  worker.on('message', async (message: VanityWorkerMessage) => {
+    if (message.type === 'progress') {
+      job.attempts = message.attempts;
+      job.attemptRate = calculateAttemptRate(message.attempts, message.elapsedMs);
+      job.etaMs = estimateEta(message.attempts, message.elapsedMs, job.targetAttempts);
+      job.updatedAt = new Date().toISOString();
+      return;
+    }
+    if (message.type === 'result') {
+      job.status = 'completed';
+      job.attempts = message.attempts;
+      job.completedAt = new Date().toISOString();
+      job.address = message.address;
+      job.etaMs = 0;
+      job.mnemonicAlias = `VANITY_${id}`;
+      job.attemptRate = calculateAttemptRate(message.attempts, message.elapsedMs);
+      job.updatedAt = new Date().toISOString();
+      await setSecureSetting(job.mnemonicAlias, {
+        mnemonic: message.mnemonic,
+        derivationPath: message.derivationPath,
+        address: message.address
+      }).catch((error) => {
+        job.message = `Unable to persist mnemonic: ${error instanceof Error ? error.message : String(error)}`;
+      });
+      worker.terminate().catch(() => undefined);
+      persistJobs(true);
+      return;
+    }
+    if (message.type === 'complete') {
+      job.status = message.cancelled ? 'cancelled' : 'failed';
+      job.message = message.cancelled ? 'Job cancelled' : 'Exceeded attempt budget';
+      job.attempts = message.attempts;
+      job.completedAt = new Date().toISOString();
+      job.attemptRate = calculateAttemptRate(message.attempts, message.elapsedMs);
+      job.updatedAt = new Date().toISOString();
+      worker.terminate().catch(() => undefined);
+      persistJobs(true);
+    }
+  });
+
+  worker.on('error', (error) => {
+    job.status = 'failed';
+    job.message = error.message;
+    job.completedAt = new Date().toISOString();
+    job.updatedAt = new Date().toISOString();
+    worker.terminate().catch(() => undefined);
+    persistJobs(true);
+  });
+
+  worker.on('exit', (code) => {
+    if (job.status === 'running' && code !== 0) {
+      job.status = 'failed';
+      job.message = `Worker exited with code ${code}`;
+      job.completedAt = new Date().toISOString();
+    }
+    delete job.worker;
+    job.updatedAt = new Date().toISOString();
+    persistJobs(true);
+  });
+
+  return job;
+};
+
+export const getVanityJob = (id: string) => {
+  const job = jobStore.get(id);
+  if (!job) {
+    return undefined;
+  }
+  return serializeJob(job);
+};
+
+export const cancelVanityJob = (id: string) => {
+  const job = jobStore.get(id);
+  if (!job) {
+    return undefined;
+  }
+  if (job.worker) {
+    job.worker.postMessage({ type: 'cancel' });
+    job.status = 'cancelled';
+    job.completedAt = new Date().toISOString();
+    job.message = 'Cancellation requested';
+    job.updatedAt = new Date().toISOString();
+  }
+  persistJobs(true);
+  return getVanityJob(id);
+};
+
+export const listVanityJobs = () => {
+  return Array.from(jobStore.values())
+    .map((job) => serializeJob(job))
+    .sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime());
+};
+
+function serializeJob(job: VanityJob): VanityJobSummary {
+  const { worker: _worker, ...summary } = job;
+  return summary;
+}
+
+function calculateAttemptRate(attempts: number, elapsedMs: number) {
+  if (attempts <= 0 || elapsedMs <= 0) {
+    return undefined;
+  }
+  const attemptsPerSecond = (attempts / elapsedMs) * 1000;
+  if (!Number.isFinite(attemptsPerSecond) || attemptsPerSecond <= 0) {
+    return undefined;
+  }
+  return attemptsPerSecond;
+}
+
+function estimateEta(attempts: number, elapsedMs: number, targetAttempts?: number) {
+  const attemptRate = calculateAttemptRate(attempts, elapsedMs);
+  if (!attemptRate) {
+    return undefined;
+  }
+  if (!targetAttempts || targetAttempts <= attempts) {
+    return 0;
+  }
+  const remaining = targetAttempts - attempts;
+  return Math.round((remaining / attemptRate) * 1000);
+}
+
+function calculateTargetAttempts(options: VanityJobOptions) {
+  if (options.regex) {
+    return undefined;
+  }
+  const prefixLength = options.prefix?.replace(/^0x/i, '').length ?? 0;
+  const suffixLength = options.suffix?.replace(/^0x/i, '').length ?? 0;
+  const nibbleCount = prefixLength + suffixLength;
+  if (nibbleCount <= 0) {
+    return undefined;
+  }
+  return Math.pow(16, nibbleCount);
+}
+
+function cryptoRandomId() {
+  return crypto.randomBytes(16).toString('hex');
+}

package/backend/services/walletService.ts

@@ -0,0 +1,290 @@
+import crypto from 'crypto';
+import { ethers } from 'ethers';
+import type { Wallet, HDNodeWallet } from 'ethers';
+import { PersistedWalletRecord, walletRepository } from './walletStore';
+import { getBalance, requireRpcUrl } from './rpcService';
+
+interface WalletCreationOptions {
+  alias?: string;
+  password?: string;
+  hidden?: boolean;
+}
+
+const deriveKey = (password: string, salt: string) =>
+  crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha512');
+
+interface EncryptionResult {
+  encryptedSecret: string;
+  iv: string;
+  salt: string;
+}
+
+const encryptSecret = (secret: string, password: string): EncryptionResult => {
+  const salt = crypto.randomBytes(16).toString('hex');
+  const key = deriveKey(password, salt);
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  const encrypted = Buffer.concat([cipher.update(secret, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    encryptedSecret: Buffer.concat([encrypted, tag]).toString('hex'),
+    iv: iv.toString('hex'),
+    salt
+  };
+};
+
+const decryptSecret = (record: PersistedWalletRecord, password: string) => {
+  const key = deriveKey(password, record.salt);
+  const iv = Buffer.from(record.iv, 'hex');
+  const buffer = Buffer.from(record.encryptedSecret, 'hex');
+  const tag = buffer.subarray(buffer.length - 16);
+  const encrypted = buffer.subarray(0, buffer.length - 16);
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+  return decrypted.toString('utf8');
+};
+
+interface WalletMetadata {
+  address: string;
+  alias?: string;
+  hidden: boolean;
+  createdAt: string;
+  source: string;
+  network?: string;
+  balance?: string;
+}
+
+export interface WalletDetails extends WalletMetadata {
+  publicKey?: string;
+  mnemonic?: string;
+  derivationPath?: string;
+  privateKey: string;
+}
+
+interface MnemonicImportOptions extends WalletCreationOptions {
+  mnemonic: string;
+  derivationPath?: string;
+}
+
+interface PrivateKeyImportOptions extends WalletCreationOptions {
+  privateKey: string;
+}
+
+interface StoreOptions extends WalletCreationOptions {
+  source: string;
+}
+
+const sanitizeAlias = (alias?: string) => {
+  if (typeof alias !== 'string') {
+    return undefined;
+  }
+  const trimmed = alias.trim();
+  return trimmed.length > 0 ? trimmed : undefined;
+};
+
+const storeWallet = (
+  wallet: Wallet | HDNodeWallet,
+  {
+    alias,
+    password = crypto.randomUUID(),
+    hidden = false,
+    source,
+    network = 'mainnet',
+    balance,
+    mnemonic,
+    derivationPath
+  }: StoreOptions & { network?: string; balance?: string; mnemonic?: string; derivationPath?: string }
+): WalletMetadata => {
+  const normalizedAlias = sanitizeAlias(alias);
+  const encryptionResult = encryptSecret(wallet.privateKey, password);
+  const record: PersistedWalletRecord = {
+    address: wallet.address,
+    alias: normalizedAlias,
+    hidden,
+    createdAt: new Date().toISOString(),
+    source,
+    network,
+    balance,
+    publicKey: 'publicKey' in wallet ? wallet.publicKey : undefined,
+    mnemonic: mnemonic ?? ('mnemonic' in wallet ? wallet.mnemonic?.phrase : undefined),
+    derivationPath:
+      derivationPath ??
+      ('path' in wallet && typeof wallet.path === 'string' ? wallet.path : undefined),
+    privateKey: wallet.privateKey,
+    ...encryptionResult
+  };
+  walletRepository.save(record);
+  return {
+    address: wallet.address,
+    alias: normalizedAlias,
+    hidden,
+    source,
+    createdAt: record.createdAt,
+    network: record.network,
+    balance: record.balance
+  };
+};
+
+export const createRandomWallet = async (options: WalletCreationOptions) => {
+  const wallet = ethers.Wallet.createRandom();
+  return storeWallet(wallet, { ...options, source: 'generated', network: 'mainnet' });
+};
+
+export const importWalletFromMnemonic = async ({
+  mnemonic,
+  derivationPath,
+  ...rest
+}: MnemonicImportOptions) => {
+  const hdNode = ethers.HDNodeWallet.fromPhrase(mnemonic, undefined, derivationPath);
+  return storeWallet(hdNode, {
+    ...rest,
+    source: 'mnemonic',
+    derivationPath:
+      derivationPath ?? (typeof hdNode.path === 'string' ? hdNode.path : undefined),
+    mnemonic: hdNode.mnemonic?.phrase,
+    network: 'mainnet'
+  });
+};
+
+export const importWalletFromPrivateKey = async ({ privateKey, ...rest }: PrivateKeyImportOptions) => {
+  const wallet = new ethers.Wallet(privateKey);
+  return storeWallet(wallet, { ...rest, source: 'privateKey', network: 'mainnet' });
+};
+
+const normalizeTransactionInput = (value?: string) => {
+  if (!value) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : undefined;
+};
+
+export const generateVanityAddress = async ({
+  prefix,
+  suffix,
+  maxAttempts = 500000,
+  ...rest
+}: WalletCreationOptions & { prefix?: string; suffix?: string; maxAttempts?: number }) => {
+  const normalizedPrefix = prefix?.replace(/^0x/i, '').toLowerCase();
+  const normalizedSuffix = suffix?.toLowerCase();
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    const wallet = ethers.Wallet.createRandom();
+    const address = wallet.address.toLowerCase().replace(/^0x/, '');
+    const matchesPrefix = normalizedPrefix ? address.startsWith(normalizedPrefix) : true;
+    const matchesSuffix = normalizedSuffix ? address.endsWith(normalizedSuffix) : true;
+    if (matchesPrefix && matchesSuffix) {
+      return storeWallet(wallet, { ...rest, source: 'vanity' });
+    }
+    attempts += 1;
+  }
+  throw new Error('Unable to find vanity address within the maximum number of attempts.');
+};
+
+export const listWalletMetadata = async (): Promise<WalletMetadata[]> => {
+  const records = walletRepository.list();
+  const balances = await Promise.all(records.map((record) => getBalance(record.address)));
+  return records.map((record, index) => ({
+    address: record.address,
+    alias: record.alias,
+    hidden: record.hidden,
+    createdAt: record.createdAt,
+    source: record.source,
+    network: record.network,
+    balance: balances[index] ?? record.balance
+  }));
+};
+
+export const exportWallet = async (address: string, password: string) => {
+  const record = walletRepository.find(address);
+  if (!record) {
+    throw new Error('Wallet not found');
+  }
+  const privateKey = decryptSecret(record, password);
+  const wallet = new ethers.Wallet(privateKey);
+  return wallet.encrypt(password);
+};
+
+export const importWalletFromEncryptedJson = async ({
+  json,
+  password,
+  alias,
+  hidden
+}: {
+  json: string;
+  password: string;
+  alias?: string;
+  hidden?: boolean;
+}) => {
+  const wallet = await ethers.Wallet.fromEncryptedJson(json, password);
+  return storeWallet(wallet, {
+    alias,
+    password,
+    hidden: Boolean(hidden),
+    source: 'keystore',
+    network: 'mainnet'
+  });
+};
+
+export const getWalletDetails = async (address: string): Promise<WalletDetails> => {
+  const record = walletRepository.find(address);
+  if (!record) {
+    throw new Error('Wallet not found');
+  }
+  const liveBalance = await getBalance(record.address);
+  return {
+    address: record.address,
+    alias: record.alias,
+    hidden: record.hidden,
+    createdAt: record.createdAt,
+    source: record.source,
+    network: record.network,
+    balance: liveBalance ?? record.balance,
+    publicKey: record.publicKey,
+    mnemonic: record.mnemonic,
+    derivationPath: record.derivationPath,
+    privateKey: record.privateKey || 'Unavailable'
+  } satisfies WalletDetails;
+};
+
+export const sendWalletTransaction = async ({
+  address,
+  password,
+  to,
+  value,
+  data
+}: {
+  address: string;
+  password: string;
+  to: string;
+  value?: string;
+  data?: string;
+}) => {
+  const record = walletRepository.find(address);
+  if (!record) {
+    throw new Error('Wallet not found');
+  }
+  const rpcUrl = await requireRpcUrl();
+  const provider = new ethers.JsonRpcProvider(rpcUrl);
+  const privateKey = decryptSecret(record, password);
+  const wallet = new ethers.Wallet(privateKey, provider);
+  const normalizedTo = ethers.getAddress(to);
+  const normalizedValue = normalizeTransactionInput(value);
+  const normalizedData = normalizeTransactionInput(data);
+  const tx = await wallet.sendTransaction({
+    to: normalizedTo,
+    value: normalizedValue ? ethers.parseEther(normalizedValue) : 0n,
+    data: normalizedData
+  });
+  return { hash: tx.hash };
+};
+
+export const removeWallet = async (address: string) => {
+  const record = walletRepository.find(address);
+  if (!record) {
+    throw new Error('Wallet not found');
+  }
+  walletRepository.delete(address);
+  return { address };
+};