gnoman 0.1.0

package/gnoman2.0/modules/sandbox/localFork.ts

@@ -0,0 +1,129 @@
+import { spawn, ChildProcessWithoutNullStreams } from 'child_process';
+import path from 'path';
+import { EventEmitter } from 'events';
+import fs from 'fs';
+
+export interface ForkOptions {
+  rpcUrl: string;
+  blockNumber?: number;
+  port?: number;
+  command?: string;
+  workspace?: string;
+}
+
+export interface ForkStatus {
+  active: boolean;
+  port?: number;
+  pid?: number;
+  startedAt?: string;
+  rpcUrl?: string;
+  blockNumber?: number;
+  command?: string;
+  error?: string;
+}
+
+export default class LocalFork extends EventEmitter {
+  private process: ChildProcessWithoutNullStreams | null = null;
+  private status: ForkStatus = { active: false };
+  private readonly allowedCommands: Set<string>;
+
+  constructor(private readonly logsDir: string) {
+    super();
+    const fromEnv = process.env.GNOMAN_FORK_ALLOWLIST?.split(',').map((value) => value.trim()).filter(Boolean);
+    const defaults = ['anvil'];
+    if (fromEnv && fromEnv.length > 0) {
+      this.allowedCommands = new Set(fromEnv.map((command) => command.toLowerCase()));
+      defaults.forEach((command) => this.allowedCommands.add(command));
+    } else {
+      this.allowedCommands = new Set(defaults.map((command) => command.toLowerCase()));
+    }
+  }
+
+  start(options: ForkOptions) {
+    if (this.process) {
+      throw new Error('Fork already running');
+    }
+
+    const port = options.port ?? 8545;
+    const command = this.sanitizeCommand(options.command);
+    const args = ['--fork-url', options.rpcUrl, '--port', String(port)];
+    if (options.blockNumber !== undefined) {
+      args.push('--fork-block-number', String(options.blockNumber));
+    }
+
+    const forkWorkspace = options.workspace ?? process.cwd();
+    const logFile = path.join(this.logsDir, `fork-${Date.now()}.log`);
+    const outStream = fs.createWriteStream(logFile, { flags: 'a' });
+
+    const child = spawn(command, args, {
+      cwd: forkWorkspace,
+      stdio: 'pipe'
+    });
+
+    child.on('error', (error) => {
+      outStream.write(String(error));
+      this.status = { active: false, error: (error as Error).message };
+      this.emit('error', (error as Error).message);
+    });
+
+    child.stdout.on('data', (data) => {
+      outStream.write(data);
+      this.emit('log', data.toString());
+    });
+
+    child.stderr.on('data', (data) => {
+      outStream.write(data);
+      this.emit('error', data.toString());
+    });
+
+    child.on('close', (code) => {
+      outStream.close();
+      this.process = null;
+      this.status = { active: false, error: code ? `Fork exited with code ${code}` : undefined };
+      this.emit('stop', this.status);
+    });
+
+    this.process = child;
+    this.status = {
+      active: true,
+      port,
+      pid: child.pid ?? undefined,
+      startedAt: new Date().toISOString(),
+      rpcUrl: `http://127.0.0.1:${port}`,
+      blockNumber: options.blockNumber,
+      command
+    };
+
+    this.emit('start', this.status);
+    return this.status;
+  }
+
+  stop() {
+    if (!this.process) {
+      return this.status;
+    }
+    this.process.kill('SIGTERM');
+    this.process = null;
+    this.status = { active: false };
+    this.emit('stop', this.status);
+    return this.status;
+  }
+
+  getStatus(): ForkStatus {
+    return this.status;
+  }
+
+  private sanitizeCommand(command?: string) {
+    const candidate = command?.trim() ?? 'anvil';
+    if (!/^[A-Za-z0-9._-]+$/.test(candidate)) {
+      throw new Error('Fork command contains unsupported characters');
+    }
+    if (candidate.includes('/') || candidate.includes('\\')) {
+      throw new Error('Fork command cannot include path separators');
+    }
+    if (!this.allowedCommands.has(candidate.toLowerCase())) {
+      throw new Error(`Fork command "${candidate}" is not permitted`);
+    }
+    return candidate;
+  }
+}

package/gnoman2.0/modules/sandbox/safe.abi.json

@@ -0,0 +1,82 @@
+[
+  {
+    "inputs": [
+      { "internalType": "address", "name": "owner", "type": "address" }
+    ],
+    "name": "isOwner",
+    "outputs": [
+      { "internalType": "bool", "name": "", "type": "bool" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "owner", "type": "address" },
+      { "internalType": "uint256", "name": "_threshold", "type": "uint256" }
+    ],
+    "name": "addOwnerWithThreshold",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "prevOwner", "type": "address" },
+      { "internalType": "address", "name": "owner", "type": "address" },
+      { "internalType": "uint256", "name": "_threshold", "type": "uint256" }
+    ],
+    "name": "removeOwner",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "owner", "type": "address" },
+      { "internalType": "address", "name": "newOwner", "type": "address" }
+    ],
+    "name": "swapOwner",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      { "internalType": "address", "name": "to", "type": "address" },
+      { "internalType": "uint256", "name": "value", "type": "uint256" },
+      { "internalType": "bytes", "name": "data", "type": "bytes" },
+      { "internalType": "uint8", "name": "operation", "type": "uint8" },
+      { "internalType": "uint256", "name": "safeTxGas", "type": "uint256" },
+      { "internalType": "uint256", "name": "baseGas", "type": "uint256" },
+      { "internalType": "uint256", "name": "gasPrice", "type": "uint256" },
+      { "internalType": "address", "name": "gasToken", "type": "address" },
+      { "internalType": "address", "name": "refundReceiver", "type": "address" },
+      { "internalType": "bytes", "name": "signatures", "type": "bytes" }
+    ],
+    "name": "execTransaction",
+    "outputs": [
+      { "internalType": "bool", "name": "success", "type": "bool" }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "getOwners",
+    "outputs": [
+      { "internalType": "address[]", "name": "", "type": "address[]" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "nonce",
+    "outputs": [
+      { "internalType": "uint256", "name": "", "type": "uint256" }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  }
+]

package/gnoman2.0/modules/sandbox/sandboxManager.ts

@@ -0,0 +1,154 @@
+import fs from 'fs';
+import path from 'path';
+import { getAddress } from 'ethers';
+import { parseAbi, validateFunctionExists, requireSafeAbi } from './abiLoader';
+import type {
+  AbiMetadata,
+  ContractSimulationRequest,
+  ContractSimulationResult,
+  SafeSimulationRequest,
+  SandboxLogEntry
+} from './types';
+import LocalFork from './localFork';
+import { simulateContractCall, simulateOnFork } from './contractSimulator';
+
+const LOG_DIRECTORY = path.join(__dirname, 'logs');
+const HISTORY_LIMIT = 100;
+
+export default class SandboxManager {
+  private abiRegistry: Map<string, AbiMetadata> = new Map();
+  private history: SandboxLogEntry[] = [];
+  private fork: LocalFork;
+  private logDirectory: string;
+
+  constructor(logDir: string = LOG_DIRECTORY) {
+    this.logDirectory = logDir;
+    if (!fs.existsSync(this.logDirectory)) {
+      fs.mkdirSync(this.logDirectory, { recursive: true });
+    }
+    this.fork = new LocalFork(this.logDirectory);
+    this.bootstrapHistory();
+  }
+
+  private bootstrapHistory() {
+    const files = fs
+      .readdirSync(this.logDirectory)
+      .filter((file) => file.endsWith('.json'))
+      .map((file) => path.join(this.logDirectory, file))
+      .sort();
+
+    files.slice(-HISTORY_LIMIT).forEach((file) => {
+      try {
+        const content = fs.readFileSync(file, 'utf8');
+        const parsed = JSON.parse(content) as SandboxLogEntry;
+        this.history.push(parsed);
+      } catch (error) {
+        console.error('Failed to parse sandbox log', error);
+      }
+    });
+  }
+
+  private persist(result: SandboxLogEntry) {
+    const fileName = path.join(this.logDirectory, `${result.id}.json`);
+    const replacer = (_key: string, value: unknown) => (typeof value === 'bigint' ? value.toString() : value);
+    fs.writeFileSync(fileName, JSON.stringify(result, replacer, 2));
+  }
+
+  getHistory(): SandboxLogEntry[] {
+    return [...this.history].reverse();
+  }
+
+  clearHistory() {
+    this.history = [];
+    const files = fs.readdirSync(this.logDirectory).filter((file) => file.endsWith('.json'));
+    for (const file of files) {
+      fs.unlinkSync(path.join(this.logDirectory, file));
+    }
+  }
+
+  loadAbi(abi: string, name?: string): AbiMetadata {
+    const metadata = parseAbi({ abi, name });
+    this.abiRegistry.set(metadata.name, metadata);
+    return metadata;
+  }
+
+  getAbi(name: string): AbiMetadata | undefined {
+    return this.abiRegistry.get(name);
+  }
+
+  listAbis(): AbiMetadata[] {
+    return Array.from(this.abiRegistry.values());
+  }
+
+  async simulate(metadata: AbiMetadata, request: ContractSimulationRequest): Promise<ContractSimulationResult> {
+    validateFunctionExists(metadata, request.functionName);
+    const forkStatus = this.fork.getStatus();
+    const hasManagedFork = Boolean(forkStatus.active && forkStatus.rpcUrl);
+    const wantsFork = Boolean(request.fork);
+    const hasRemoteFork = Boolean(request.forkRpcUrl);
+
+    let runOnFork = false;
+    let executionRpcUrl = request.rpcUrl;
+
+    if (hasManagedFork && wantsFork) {
+      runOnFork = true;
+      executionRpcUrl = forkStatus.rpcUrl as string;
+    } else if (!hasManagedFork && wantsFork && hasRemoteFork) {
+      runOnFork = true;
+      executionRpcUrl = request.forkRpcUrl as string;
+    }
+
+    const sanitized = {
+      ...request,
+      rpcUrl: executionRpcUrl,
+      fork: runOnFork,
+      contractAddress: getAddress(request.contractAddress)
+    };
+
+    const result = runOnFork
+      ? await simulateOnFork(metadata, sanitized, executionRpcUrl)
+      : await simulateContractCall(metadata, sanitized);
+
+    const entry: SandboxLogEntry = {
+      ...result
+    };
+
+    this.history.push(entry);
+    if (this.history.length > HISTORY_LIMIT) {
+      this.history = this.history.slice(-HISTORY_LIMIT);
+    }
+    this.persist(entry);
+
+    return result;
+  }
+
+  async simulateSafe(request: SafeSimulationRequest) {
+    const safeAbi = requireSafeAbi();
+    const result = await this.simulate(safeAbi, {
+      rpcUrl: request.rpcUrl,
+      contractAddress: request.safeAddress,
+      functionName: request.functionName,
+      parameters: request.parameters,
+      value: request.value,
+      fork: request.fork,
+      forkBlockNumber: request.forkBlockNumber,
+      forkRpcUrl: request.forkRpcUrl,
+      gasLimit: request.gasLimit,
+      from: request.from
+    });
+
+    return result;
+  }
+
+  startFork(rpcUrl: string, blockNumber?: number, port?: number, command?: string) {
+    return this.fork.start({ rpcUrl, blockNumber, port, command });
+  }
+
+  stopFork() {
+    return this.fork.stop();
+  }
+
+  forkStatus() {
+    return this.fork.getStatus();
+  }
+}

package/gnoman2.0/modules/sandbox/types.ts

@@ -0,0 +1,84 @@
+import type { InterfaceAbi } from 'ethers';
+
+export interface AbiLoadRequest {
+  abi: string | InterfaceAbi;
+  name?: string;
+}
+
+export interface AbiFunctionInput {
+  name: string;
+  type: string;
+  internalType?: string;
+  indexed?: boolean;
+}
+
+export interface AbiFunctionDescription {
+  name: string;
+  stateMutability: string;
+  inputs: AbiFunctionInput[];
+  outputs: AbiFunctionInput[];
+  payable: boolean;
+  constant: boolean;
+}
+
+export interface SimulationParameterMap {
+  [parameterName: string]: unknown;
+}
+
+export interface ContractSimulationRequest {
+  rpcUrl: string;
+  contractAddress: string;
+  functionName: string;
+  parameters: SimulationParameterMap;
+  value?: string;
+  fork?: boolean;
+  forkBlockNumber?: number;
+  forkRpcUrl?: string;
+  gasLimit?: string;
+  from?: string;
+}
+
+export interface ContractSimulationResult {
+  id: string;
+  timestamp: string;
+  success: boolean;
+  network: {
+    chainId: number;
+    name: string;
+  } | null;
+  gasUsed?: string;
+  gasEstimate?: string;
+  gasLimit?: string;
+  returnData?: unknown;
+  decodedReturnData?: unknown;
+  logs?: Array<Record<string, unknown>>;
+  error?: string;
+  revertReason?: string;
+  trace?: unknown;
+  callData: string;
+  functionName: string;
+  contractAddress: string;
+  parameters: SimulationParameterMap;
+  forkMode: boolean;
+  rpcUrl: string;
+  value?: string;
+}
+
+export interface SafeSimulationRequest extends ContractSimulationRequest {
+  safeAddress: string;
+  safeNonce?: number;
+  safeThreshold?: number;
+  operation?: number;
+  gasToken?: string;
+  refundReceiver?: string;
+}
+
+export interface SandboxLogEntry extends ContractSimulationResult {
+  signer?: string;
+}
+
+export interface AbiMetadata {
+  name: string;
+  abi: InterfaceAbi;
+  functions: AbiFunctionDescription[];
+}

package/gnoman2.0/modules/sandbox/ui/LogViewer.tsx

@@ -0,0 +1,30 @@
+import type { SandboxLogEntry } from '../types';
+
+interface LogViewerProps {
+  logs: SandboxLogEntry[];
+  onReplay: (entry: SandboxLogEntry) => void;
+}
+
+const LogViewer = ({ logs, onReplay }: LogViewerProps) => (
+  <div className="space-y-3">
+    {logs.map((entry) => (
+      <div key={entry.id} className="rounded border border-slate-800 bg-slate-950/50 p-3">
+        <div className="flex items-center justify-between text-xs text-slate-400">
+          <span>{new Date(entry.timestamp).toLocaleString()}</span>
+          <button
+            className="rounded border border-purple-400 px-2 py-1 text-purple-200 hover:bg-purple-500/10"
+            onClick={() => onReplay(entry)}
+          >
+            Replay
+          </button>
+        </div>
+        <pre className="mt-2 max-h-52 overflow-auto whitespace-pre-wrap break-words text-[11px] text-slate-200">
+          {JSON.stringify(entry, null, 2)}
+        </pre>
+      </div>
+    ))}
+    {!logs.length && <p className="text-sm text-slate-500">No simulations recorded yet.</p>}
+  </div>
+);
+
+export default LogViewer;

package/gnoman2.0/modules/sandbox/ui/ParameterForm.tsx

@@ -0,0 +1,49 @@
+import { useEffect } from 'react';
+import type { AbiFunctionDescription } from '../types';
+import { buildParameterFields } from '../formBuilder';
+
+interface ParameterFormProps {
+  fn?: AbiFunctionDescription;
+  values: Record<string, string>;
+  onChange: (name: string, value: string) => void;
+}
+
+const inputClass =
+  'mt-1 w-full rounded border border-slate-700 bg-slate-900 p-2 text-sm text-slate-200 focus:border-purple-500 focus:outline-none';
+
+const ParameterForm = ({ fn, values, onChange }: ParameterFormProps) => {
+  useEffect(() => {
+    if (!fn) return;
+    fn.inputs.forEach((input, index) => {
+      const key = input.name || `arg_${index}`;
+      if (!(key in values)) {
+        onChange(key, '');
+      }
+    });
+  }, [fn, values, onChange]);
+
+  if (!fn) {
+    return <p className="text-sm text-slate-500">Load an ABI to configure parameters.</p>;
+  }
+
+  const fields = buildParameterFields(fn);
+
+  return (
+    <div className="space-y-3">
+      {fields.map((field) => (
+        <label key={field.name} className="text-sm text-slate-300">
+          {field.name}
+          <input
+            className={inputClass}
+            value={values[field.name] ?? ''}
+            placeholder={field.placeholder}
+            onChange={(event) => onChange(field.name, event.target.value)}
+          />
+        </label>
+      ))}
+      {!fields.length && <p className="text-sm text-slate-500">No parameters required.</p>}
+    </div>
+  );
+};
+
+export default ParameterForm;