vite.config.ts

import react from '@vitejs/plugin-react';
import { defineConfig, Plugin } from 'vite';
import { nodePolyfills } from 'vite-plugin-node-polyfills';
import topLevelAwait from 'vite-plugin-top-level-await';
import wasm from 'vite-plugin-wasm';
import fs from 'node:fs';
import path from 'node:path';

const DEPLOYED_LOCAL_PATH = path.resolve(
  process.cwd(),
  'config/deployed.local.json'
);
const VIRTUAL_ID = '\0virtual:deployed-local-config';

/** Injects deployed.local.json via virtual module (avoids glob+gitignore issues). */
const injectDeployedLocal = (): Plugin => ({
  name: 'inject-deployed-local',
  resolveId(id) {
    if (id === 'virtual:deployed-local-config') return VIRTUAL_ID;
    return null;
  },
  load(id) {
    if (id !== VIRTUAL_ID) return null;
    try {
      const raw = fs.readFileSync(DEPLOYED_LOCAL_PATH, 'utf-8');
      return `export default ${raw};`;
    } catch {
      return 'export default {};';
    }
  },
  configureServer(server) {
    server.watcher.add(DEPLOYED_LOCAL_PATH);
    const maybeReload = (file: string) => {
      if (path.normalize(file) === path.normalize(DEPLOYED_LOCAL_PATH)) {
        const mod = server.moduleGraph.getModuleById(VIRTUAL_ID);
        if (mod) server.moduleGraph.invalidateModule(mod);
        server.ws.send({ type: 'full-reload' });
      }
    };
    server.watcher.on('change', maybeReload);
    server.watcher.on('add', maybeReload);
  },
});
/**
 * Plugin to fix static class field initialization issue with Rollup bundling.
 * When Rollup bundles classes, it transforms `class Foo {}` to `let Foo; Foo = class {}`
 * This breaks static initializers like `static ZERO = new AztecAddress(...)` because
 * they execute before the assignment completes.
 *
 * This plugin runs AFTER minification (writeBundle hook) and transforms the minified
 * pattern to a lazy getter that defers initialization.
 */
const fixStaticFieldInit = (): Plugin => ({
  name: 'fix-static-field-init',
  enforce: 'post',
  async writeBundle(options, bundle) {
    const fs = await import('fs');
    const path = await import('path');
    const outDir = options.dir || 'dist';

    for (const [fileName, chunk] of Object.entries(bundle)) {
      if (chunk.type === 'chunk' && fileName.endsWith('.js')) {
        const filePath = path.default.join(outDir, fileName);
        let code = fs.default.readFileSync(filePath, 'utf-8');

        // Pattern for minified code: static ZERO=new X(Y.alloc(32,0))
        // Both class name and Buffer get minified to short identifiers
        const minifiedPattern =
          /static ZERO=new (\w+)\((\w+)\.alloc\(32,0\)\)/g;

        if (minifiedPattern.test(code)) {
          code = code.replace(
            /static ZERO=new (\w+)\((\w+)\.alloc\(32,0\)\)/g,
            'static get ZERO(){return this._ZC||(this._ZC=new $1($2.alloc(32,0)))}'
          );
          fs.default.writeFileSync(filePath, code);
          console.log(`[fix-static-field-init] Patched ${fileName}`);
        }
      }
    }
  },
});

/**
 * Plugin to shim Node.js built-in modules that shouldn't run in browser.
 * Must run before nodePolyfills to intercept fs/promises correctly.
 */
const nodeBuiltinsShim = (): Plugin => ({
  name: 'node-builtins-shim',
  enforce: 'pre', // Run before other plugins
  resolveId(source) {
    // Intercept Node.js modules that need shimming
    if (
      source === 'fs/promises' ||
      source === 'fs' ||
      source === 'net' ||
      source === 'tty'
    ) {
      return `\0virtual:${source}`;
    }
    return null;
  },
  load(id) {
    // Provide shims for Node.js-only modules
    if (id === '\0virtual:fs/promises') {
      return `
        export const mkdir = () => Promise.reject(new Error('fs/promises not available in browser'));
        export const writeFile = () => Promise.reject(new Error('fs/promises not available in browser'));
        export const readFile = () => Promise.reject(new Error('fs/promises not available in browser'));
        export const rm = () => Promise.reject(new Error('fs/promises not available in browser'));
        export default { mkdir, writeFile, readFile, rm };
      `;
    }
    if (id === '\0virtual:fs') {
      return `
        export const existsSync = () => false;
        export const readFileSync = () => { throw new Error('fs not available in browser'); };
        export const writeFileSync = () => { throw new Error('fs not available in browser'); };
        export const mkdirSync = () => { throw new Error('fs not available in browser'); };
        export default { existsSync, readFileSync, writeFileSync, mkdirSync };
      `;
    }
    if (id === '\0virtual:net') {
      return `
        export const Socket = class Socket { constructor() { throw new Error('net not available in browser'); } };
        export const connect = () => { throw new Error('net not available in browser'); };
        export default { Socket, connect };
      `;
    }
    if (id === '\0virtual:tty') {
      return `
        export const isatty = () => false;
        export default { isatty };
      `;
    }
    return null;
  },
});

export default defineConfig(() => {
  const proxyConfig = {
    '/rpc': {
      target: 'http://localhost:8080',
      changeOrigin: true,
      rewrite: () => '/',
    },
    '/api/local-network-status': {
      target: 'http://localhost:8080',
      changeOrigin: true,
      rewrite: () => '/status',
    },
    '/api/testnet-status': {
      target: 'https://rpc.testnet.aztec-labs.com',
      changeOrigin: true,
      rewrite: () => '/status',
    },
    '/api/testnet': {
      target: 'https://rpc.testnet.aztec-labs.com',
      changeOrigin: true,
      rewrite: (path: string) => path.replace(/^\/api\/testnet/, '') || '/',
    },
  };

  return {
    // Suppress Rollup warnings that originate from node_modules and are not actionable.
    // @aztec/noir-protocol-circuits-types imports the same JSON artifact files both with
    // and without `{ type: 'json' }` assertions — nothing we can do without patching upstream.
    onLog(level, log, handler) {
      if (
        level === 'warn' &&
        log.message.includes('"type": "json" attributes') &&
        log.message.includes('node_modules')
      ) {
        return;
      }
      handler(level, log);
    },
    plugins: [
      nodeBuiltinsShim(), // Must be first to intercept before nodePolyfills
      injectDeployedLocal(),
      react(),
      wasm(),
      topLevelAwait(),
      fixStaticFieldInit(), // Fix static field initialization after bundling
      nodePolyfills({
        // Include specific polyfills that your Webpack config provided
        include: [
          'buffer',
          'crypto',
          'util',
          'assert',
          'process',
          'stream',
          'path',
          'events',
        ],
        globals: {
          Buffer: true,
          global: true,
          process: true,
        },
        // Exclude modules we're shimming ourselves
        exclude: ['fs', 'net', 'tty'],
      }),
    ],
    assetsInclude: ['**/*.wasm'],
    define: {
      global: 'globalThis',
    },
    worker: {
      format: 'es',
    },
    esbuild: {
      target: 'esnext',
      // Avoid TDZ issues from minified class static field initializers in
      // Aztec/Foundation classes (e.g. static ZERO = new Fr(...)).
      supported: {
        'class-static-field': false,
      },
    },
    resolve: {
      alias: {
        // Ensure artifact JSON imports resolve from src/artifacts
        '../target': path.resolve(__dirname, 'src/target'),
        // Additional polyfills for blockchain dependencies
        crypto: 'crypto-browserify',
        stream: 'stream-browserify',
        util: 'util',
        path: 'path-browserify',
        // Use browser-safe pino version
        pino: 'pino/browser.js',
        // Force specific hash.js path for proper CommonJS handling
        'hash.js': 'hash.js/lib/hash.js',
        // Fix sha3 CommonJS exports
        sha3: 'sha3/index.js',
        // Fix lodash.chunk CommonJS exports
        'lodash.chunk': 'lodash.chunk/index.js',
        // Fix lodash.times CommonJS exports
        'lodash.times': 'lodash.times/index.js',
        // Fix lodash.isequal CommonJS exports
        'lodash.isequal': 'lodash.isequal/index.js',
        // Fix lodash.pickby CommonJS exports
        'lodash.pickby': 'lodash.pickby/index.js',
        // Fix json-stringify-deterministic CommonJS exports
        'json-stringify-deterministic':
          'json-stringify-deterministic/lib/index.js',
      },
      dedupe: [
        '@aztec/foundation',
        '@aztec/circuits.js',
        '@noble/curves',
        '@noble/hashes',
      ],
    },
    server: {
      port: 3000,
      headers: {
        'Cross-Origin-Opener-Policy': 'same-origin',
        'Cross-Origin-Embedder-Policy': 'credentialless',
        'Cross-Origin-Resource-Policy': 'cross-origin',
      },
      fs: {
        allow: ['..'],
      },
      proxy: proxyConfig,
    },
    preview: {
      port: 3000,
      headers: {
        'Cross-Origin-Opener-Policy': 'same-origin',
        'Cross-Origin-Embedder-Policy': 'credentialless',
        'Cross-Origin-Resource-Policy': 'cross-origin',
      },
      proxy: proxyConfig,
    },
    build: {
      sourcemap: false, // Disable sourcemaps to reduce memory usage
      minify: 'esbuild',
      // Barretenberg WASM wrappers and ML artifact chunks are inherently large;
      // raise the limit so that only genuinely unexpected large chunks surface.
      chunkSizeWarningLimit: 50_000,
      target: 'esnext',
      commonjsOptions: {
        // Forces @aztec packages to be treated as ESM to prevent class identity errors
        defaultIsModuleExports: (id) => {
          if (id.includes('@aztec/')) {
            return false;
          }
          return 'auto';
        },
        exclude: [
          '@aztec/stdlib/**',
          '@aztec/foundation/**',
          '@aztec/aztec.js/**',
        ],
      },
      rollupOptions: {
        output: {
          format: 'es',
          preserveModules: false,
          inlineDynamicImports: false,
          interop: 'auto',
          manualChunks: (id: string) => {
            if (id.includes('@noble/curves') || id.includes('@noble/hashes')) {
              return 'vendor-noble';
            }
            if (id.includes('@aztec/foundation')) {
              return 'vendor-aztec-foundation';
            }
          },
          assetFileNames: (assetInfo) => {
            if (assetInfo.names.some((name) => name.endsWith('.wasm'))) {
              return 'assets/[name]-[hash][extname]';
            }
            return 'assets/[name]-[hash][extname]';
          },
        },
      },
    },
    optimizeDeps: {
      include: [
        'react',
        'react-dom',
        'react/jsx-runtime',
        'buffer',
        'crypto-browserify',
        'stream-browserify',
        'util',
        'path-browserify',
        '@tanstack/react-query',
      ],
      exclude: ['@aztec/noir-acvm_js', '@aztec/noir-noirc_abi', '@aztec/bb.js'],
      esbuildOptions: {
        define: {
          global: 'globalThis',
        },
      },
    },
  };
});