gnoman 0.1.0

package/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/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/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/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;