auramaxx 0.0.1

package/server/lib/transactions.ts

@@ -0,0 +1,123 @@
+/**
+ * Shared transaction recording and asset tracking helpers.
+ * Eliminates duplicated log+transaction+event boilerplate across route files.
+ */
+
+import { prisma } from './db';
+import { events } from './events';
+import { upsertTokenMetadata } from './token-metadata';
+import { normalizeAddress } from './address';
+
+/**
+ * Record a transaction: creates a Log entry, a Transaction record,
+ * and emits a txCreated WebSocket event.
+ */
+export async function recordTransaction(params: {
+  walletAddress: string;
+  txHash: string;
+  type: string;
+  status?: string;
+  amount?: string;
+  tokenAddress?: string;
+  tokenAmount?: string;
+  from: string;
+  to?: string;
+  description: string;
+  chain: string;
+  logTitle?: string;
+}): Promise<{ id: string }> {
+  await prisma.log.create({
+    data: {
+      walletAddress: params.walletAddress,
+      title: params.logTitle || `${params.type} Transaction`,
+      description: params.description,
+      txHash: params.txHash,
+    },
+  });
+
+  const norm = (addr: string) => normalizeAddress(addr, params.chain);
+
+  const tx = await prisma.transaction.create({
+    data: {
+      walletAddress: norm(params.from),
+      txHash: params.txHash,
+      type: params.type,
+      status: params.status || 'confirmed',
+      amount: params.amount,
+      tokenAddress: params.tokenAddress ? norm(params.tokenAddress) : undefined,
+      tokenAmount: params.tokenAmount,
+      from: norm(params.from),
+      to: params.to ? norm(params.to) : undefined,
+      description: params.description,
+      chain: params.chain,
+      executedAt: new Date(),
+    },
+  });
+
+  events.txCreated({
+    walletAddress: norm(params.from),
+    id: tx.id,
+    type: params.type,
+    txHash: params.txHash,
+    amount: params.amount,
+    tokenAddress: params.tokenAddress ? norm(params.tokenAddress) : undefined,
+    tokenAmount: params.tokenAmount,
+    description: params.description,
+  });
+
+  return tx;
+}
+
+/**
+ * Auto-track a token after a successful send/swap/launch:
+ * upserts TrackedAsset, emits asset:changed event, and kicks off metadata lookup.
+ */
+export async function autoTrackToken(params: {
+  walletAddress: string;
+  tokenAddress: string;
+  chain: string;
+  poolAddress?: string;
+  poolVersion?: string;
+  symbol?: string;
+  name?: string;
+}): Promise<void> {
+  const wallet = params.walletAddress.toLowerCase();
+  const token = params.tokenAddress.toLowerCase();
+
+  await prisma.trackedAsset.upsert({
+    where: {
+      walletAddress_tokenAddress_chain: {
+        walletAddress: wallet,
+        tokenAddress: token,
+        chain: params.chain,
+      },
+    },
+    create: {
+      walletAddress: wallet,
+      tokenAddress: token,
+      chain: params.chain,
+      ...(params.poolAddress && { poolAddress: params.poolAddress }),
+      ...(params.poolVersion && { poolVersion: params.poolVersion }),
+    },
+    update: {
+      updatedAt: new Date(),
+      ...(params.poolAddress && { poolAddress: params.poolAddress }),
+      ...(params.poolVersion && { poolVersion: params.poolVersion }),
+    },
+  });
+
+  events.assetChanged({
+    walletAddress: wallet,
+    tokenAddress: token,
+    ...(params.poolAddress && { poolAddress: params.poolAddress }),
+    ...(params.poolVersion && { poolVersion: params.poolVersion }),
+    ...(params.symbol && { symbol: params.symbol }),
+    ...(params.name && { name: params.name }),
+  });
+
+  upsertTokenMetadata(
+    token,
+    params.chain,
+    params.symbol ? { symbol: params.symbol, name: params.name } : undefined,
+  );
+}

package/server/lib/transport.ts

@@ -0,0 +1,84 @@
+/**
+ * Transport Security - Encrypted password transport for unlock/setup
+ *
+ * Generates an ephemeral RSA keypair on server startup. Frontend fetches
+ * the public key via /auth/connect and encrypts passwords with RSA-OAEP
+ * before sending.
+ *
+ * Security properties:
+ * - RSA private key never leaves server memory
+ * - Keypair regenerates on restart (aligns with existing security model)
+ * - RSA-OAEP provides semantic security (same plaintext → different ciphertext)
+ */
+
+import { generateKeyPairSync, privateDecrypt, constants } from 'crypto';
+import { HttpError } from './error';
+
+// Ephemeral RSA keypair - regenerates every restart
+// This aligns with the security model: server restart = forced re-authentication
+const { publicKey, privateKey } = generateKeyPairSync('rsa', {
+  modulusLength: 2048,
+  publicKeyEncoding: { type: 'spki', format: 'pem' },
+  privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+});
+
+console.log('[Transport] RSA keypair generated for encrypted password transport');
+
+/**
+ * Get the server's public key (PEM format)
+ * Frontend uses this to encrypt passwords before sending
+ */
+export function getPublicKey(): string {
+  return publicKey;
+}
+
+/**
+ * Get the server's private key (PEM format) — for test use only.
+ * In production this key never leaves the process; tests need it
+ * to decrypt tokens encrypted with the matching public key.
+ */
+export function getPrivateKey(): string {
+  return privateKey;
+}
+
+/**
+ * Decrypt a password that was encrypted with our public key
+ * @param encrypted Base64-encoded RSA-OAEP encrypted password
+ * @returns Decrypted plaintext password
+ * @throws Error if decryption fails (wrong key, corrupted data, etc.)
+ */
+export function decryptPassword(encrypted: string): string {
+  const buffer = Buffer.from(encrypted, 'base64');
+  const decrypted = privateDecrypt(
+    {
+      key: privateKey,
+      padding: constants.RSA_PKCS1_OAEP_PADDING,
+      oaepHash: 'sha256'
+    },
+    buffer
+  );
+  return decrypted.toString('utf8');
+}
+
+/**
+ * Decrypt and validate an encrypted password from a request body.
+ * Throws HttpError with appropriate status codes on failure.
+ */
+export function parseEncryptedPassword(encrypted: unknown): string {
+  if (!encrypted || typeof encrypted !== 'string') {
+    throw new HttpError(400, 'Encrypted password is required');
+  }
+  let password: string;
+  try {
+    password = decryptPassword(encrypted);
+  } catch {
+    throw new HttpError(400, 'Failed to decrypt password. Server may have restarted - refetch public key.');
+  }
+  if (!password) {
+    throw new HttpError(400, 'Password is required');
+  }
+  if (password.length < 8) {
+    throw new HttpError(400, 'Password must be at least 8 characters');
+  }
+  return password;
+}

package/server/lib/txhistory/decoder.ts

@@ -0,0 +1,262 @@
+/**
+ * Log Decoder
+ * ===========
+ * Decodes raw EVM logs into structured DecodedEvent objects.
+ * Handles Transfer (ERC-20/721), Swap (V2/V3/V4), WETH Deposit/Withdrawal, Approval.
+ */
+
+import { decodeAbiParameters } from 'viem';
+import { EVENT_SIGNATURES, TOPIC_TO_EVENT } from './signatures';
+
+// --- Types ---
+
+export interface DecodedEvent {
+  type: string; // 'transfer' | 'approval' | 'swap_v2' | 'swap_v3' | 'swap_v4' | 'weth_deposit' | 'weth_withdrawal' | 'unknown'
+  txHash: string;
+  logIndex: number;
+  blockNumber: bigint;
+  contractAddress: string;
+  params: Record<string, unknown>;
+}
+
+export interface RawLog {
+  address: string;
+  topics: string[];
+  data: string;
+  transactionHash: string;
+  logIndex: number;
+  blockNumber: bigint;
+}
+
+// --- Helpers ---
+
+/** Extract a 20-byte address from a 32-byte topic */
+export function extractAddress(topic: string): string {
+  return '0x' + topic.slice(26).toLowerCase();
+}
+
+// --- Decoder ---
+
+function decodeTransfer(log: RawLog): DecodedEvent {
+  const isERC721 = log.topics.length === 4; // ERC-721: 3 indexed (from, to, tokenId)
+  const from = extractAddress(log.topics[1]);
+  const to = extractAddress(log.topics[2]);
+
+  if (isERC721) {
+    const tokenId = BigInt(log.topics[3]);
+    return {
+      type: 'transfer_nft',
+      txHash: log.transactionHash,
+      logIndex: log.logIndex,
+      blockNumber: log.blockNumber,
+      contractAddress: log.address.toLowerCase(),
+      params: { from, to, tokenId },
+    };
+  }
+
+  // ERC-20: 2 indexed (from, to), 1 non-indexed (amount)
+  const [amount] = decodeAbiParameters(
+    [{ name: 'amount', type: 'uint256' }],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'transfer',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { from, to, amount },
+  };
+}
+
+function decodeApproval(log: RawLog): DecodedEvent {
+  const owner = extractAddress(log.topics[1]);
+  const spender = extractAddress(log.topics[2]);
+
+  // ERC-721 Approval has tokenId indexed (4 topics, no/empty data)
+  if (log.topics.length === 4) {
+    const tokenId = BigInt(log.topics[3]);
+    return {
+      type: 'approval_nft',
+      txHash: log.transactionHash,
+      logIndex: log.logIndex,
+      blockNumber: log.blockNumber,
+      contractAddress: log.address.toLowerCase(),
+      params: { owner, spender, tokenId },
+    };
+  }
+
+  // ERC-20 Approval: amount in data
+  const [amount] = decodeAbiParameters(
+    [{ name: 'amount', type: 'uint256' }],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'approval',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { owner, spender, amount },
+  };
+}
+
+function decodeSwapV2(log: RawLog): DecodedEvent {
+  const sender = extractAddress(log.topics[1]);
+  const to = extractAddress(log.topics[2]);
+  const [amount0In, amount1In, amount0Out, amount1Out] = decodeAbiParameters(
+    [
+      { name: 'amount0In', type: 'uint256' },
+      { name: 'amount1In', type: 'uint256' },
+      { name: 'amount0Out', type: 'uint256' },
+      { name: 'amount1Out', type: 'uint256' },
+    ],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'swap_v2',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { sender, to, amount0In, amount1In, amount0Out, amount1Out },
+  };
+}
+
+function decodeSwapV3(log: RawLog): DecodedEvent {
+  const sender = extractAddress(log.topics[1]);
+  const recipient = extractAddress(log.topics[2]);
+  const [amount0, amount1, sqrtPriceX96, liquidity, tick] = decodeAbiParameters(
+    [
+      { name: 'amount0', type: 'int256' },
+      { name: 'amount1', type: 'int256' },
+      { name: 'sqrtPriceX96', type: 'uint160' },
+      { name: 'liquidity', type: 'uint128' },
+      { name: 'tick', type: 'int24' },
+    ],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'swap_v3',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { sender, recipient, amount0, amount1, sqrtPriceX96, liquidity, tick },
+  };
+}
+
+function decodeSwapV4(log: RawLog): DecodedEvent {
+  const poolId = log.topics[1];
+  const sender = extractAddress(log.topics[2]);
+  const [amount0, amount1, sqrtPriceX96, liquidity, tick, fee] = decodeAbiParameters(
+    [
+      { name: 'amount0', type: 'int128' },
+      { name: 'amount1', type: 'int128' },
+      { name: 'sqrtPriceX96', type: 'uint160' },
+      { name: 'liquidity', type: 'uint128' },
+      { name: 'tick', type: 'int24' },
+      { name: 'fee', type: 'uint24' },
+    ],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'swap_v4',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { poolId, sender, amount0, amount1, sqrtPriceX96, liquidity, tick, fee },
+  };
+}
+
+function decodeWethDeposit(log: RawLog): DecodedEvent {
+  const dst = extractAddress(log.topics[1]);
+  const [wad] = decodeAbiParameters(
+    [{ name: 'wad', type: 'uint256' }],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'weth_deposit',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { dst, wad },
+  };
+}
+
+function decodeWethWithdrawal(log: RawLog): DecodedEvent {
+  const src = extractAddress(log.topics[1]);
+  const [wad] = decodeAbiParameters(
+    [{ name: 'wad', type: 'uint256' }],
+    log.data as `0x${string}`,
+  );
+  return {
+    type: 'weth_withdrawal',
+    txHash: log.transactionHash,
+    logIndex: log.logIndex,
+    blockNumber: log.blockNumber,
+    contractAddress: log.address.toLowerCase(),
+    params: { src, wad },
+  };
+}
+
+/** Decode a batch of raw logs into structured events */
+export function decodeLogs(logs: RawLog[]): DecodedEvent[] {
+  const decoded: DecodedEvent[] = [];
+
+  for (const log of logs) {
+    if (!log.topics || log.topics.length === 0) continue;
+
+    const topic0 = log.topics[0];
+    const eventKey = TOPIC_TO_EVENT[topic0];
+
+    try {
+      switch (eventKey) {
+        case 'TRANSFER':
+          decoded.push(decodeTransfer(log));
+          break;
+        case 'APPROVAL':
+          decoded.push(decodeApproval(log));
+          break;
+        case 'SWAP_V2':
+          decoded.push(decodeSwapV2(log));
+          break;
+        case 'SWAP_V3':
+          decoded.push(decodeSwapV3(log));
+          break;
+        case 'SWAP_V4':
+          decoded.push(decodeSwapV4(log));
+          break;
+        case 'WETH_DEPOSIT':
+          decoded.push(decodeWethDeposit(log));
+          break;
+        case 'WETH_WITHDRAWAL':
+          decoded.push(decodeWethWithdrawal(log));
+          break;
+        default:
+          decoded.push({
+            type: 'unknown',
+            txHash: log.transactionHash,
+            logIndex: log.logIndex,
+            blockNumber: log.blockNumber,
+            contractAddress: log.address.toLowerCase(),
+            params: { topic0 },
+          });
+      }
+    } catch {
+      // Malformed log data — skip
+      decoded.push({
+        type: 'unknown',
+        txHash: log.transactionHash,
+        logIndex: log.logIndex,
+        blockNumber: log.blockNumber,
+        contractAddress: log.address.toLowerCase(),
+        params: { topic0, error: 'decode_failed' },
+      });
+    }
+  }
+
+  return decoded;
+}