Overview

export type SourceMapEntry = {
  readonly start: number;          // Byte offset in source
  readonly length: number;         // Length in source
  readonly fileIndex: number;      // Source file index
  readonly jump: "i" | "o" | "-"; // Jump type
  readonly modifierDepth?: number; // Modifier depth
};

export type SourceMap = {
  readonly raw: string;            // Raw semicolon-separated string
  readonly entries: readonly SourceMapEntry[];
};

import * as SourceMap from '@tevm/voltaire/SourceMap';
import * as Bytecode from '@tevm/voltaire/Bytecode';

// Get source map from compilation output
const sourceMap = SourceMap.from(compiledOutput.sourceMap);

// Trace execution
const instructions = Bytecode.parseInstructions(bytecode);
for (const [i, instr] of instructions.entries()) {
  const entry = SourceMap.getEntryAt(sourceMap, i);
  if (entry) {
    console.log(`PC ${i}: opcode ${instr.opcode}`);
    console.log(`  Source: offset ${entry.start}, length ${entry.length}`);
    console.log(`  File: ${entry.fileIndex}`);
    console.log(`  Jump: ${entry.jump}`);
  }
}

import * as SourceMap from '@tevm/voltaire/SourceMap';

// Map revert at PC to source location
function getSourceLocation(pc: number, sourceMap: SourceMap.SourceMap) {
  const entry = SourceMap.getEntryAt(sourceMap, pc);
  if (!entry) return null;

  return {
    file: sourceFiles[entry.fileIndex],
    start: entry.start,
    end: entry.start + entry.length,
    code: sourceFiles[entry.fileIndex]?.slice(entry.start, entry.start + entry.length),
  };
}

// Use in error handling
try {
  // Execute contract call
} catch (error) {
  if (error.data?.revertPc) {
    const location = getSourceLocation(error.data.revertPc, sourceMap);
    console.log(`Reverted at: ${location?.file}:${location?.start}`);
    console.log(`Code: ${location?.code}`);
  }
}

import * as SourceMap from '@tevm/voltaire/SourceMap';

// Track executed PCs
const executedPcs = new Set<number>();

// During execution
function recordExecution(pc: number) {
  executedPcs.add(pc);
}

// Calculate coverage
function calculateCoverage(sourceMap: SourceMap.SourceMap) {
  const coveredLines = new Set<string>();

  for (const pc of executedPcs) {
    const entry = SourceMap.getEntryAt(sourceMap, pc);
    if (entry) {
      const key = `${entry.fileIndex}:${entry.start}`;
      coveredLines.add(key);
    }
  }

  const totalEntries = sourceMap.entries.length;
  const coverage = (coveredLines.size / totalEntries) * 100;
  console.log(`Coverage: ${coverage.toFixed(2)}%`);
}

s:l:f:j:m;s:l:f:j:m;...

0:50:0:-;::1:i;