Fix SPI args loading

Author: tomusdrw

package-lock.json

@@ -61,6 +61,13 @@ export const Loader = ({ setIsDialogOpen }: { setIsDialogOpen?: (val: boolean) =
     setCurrentStep("upload");
   }, [programLoad]);
 
+  // Auto-switch to RAW mode when a trace is loaded
+  useEffect(() => {
+    if (traceContent !== null) {
+      setIsManualMode(true);
+    }
+  }, [traceContent]);
+
   const handleFileUpload = useCallback((output: ProgramUploadFileOutput, trace?: string) => {
     setProgramLoad(output);
     if (trace) {
@@ -120,11 +127,13 @@ export const Loader = ({ setIsDialogOpen }: { setIsDialogOpen?: (val: boolean) =
 
         // For SPI programs, update PC and encode parameters
         if (loadedProgram?.spiProgram) {
-          // Parse the encoded SPI arguments (either auto-generated or manually entered)
-          const parsedArgs = bytes.BytesBlob.parseBlob(encodedSpiArgs);
+          // Use SPI args from trace if available, otherwise use auto-generated/manual ones
+          const spiArgsToUse = loadedProgram.spiArgs
+            ? loadedProgram.spiArgs
+            : bytes.BytesBlob.parseBlob(encodedSpiArgs).raw;
 
-          // Set the encoded parameters as SPI arguments
-          dispatch(setSpiArgs(parsedArgs.raw));
+          // Set the SPI arguments
+          dispatch(setSpiArgs(spiArgsToUse));
 
           // Extract and set service ID from entrypoint parameters
           let serviceId: number;

src/components/ProgramLoader/Loader.tsx

@@ -131,6 +131,7 @@ function tryParseTraceFile(content: string, fileName: string, initialState: Expe
           memory: chunks,
           gas,
         },
+        spiArgs,
       },
       traceContent: content,
     };

src/components/ProgramLoader/loading-utils.ts

@@ -7,6 +7,7 @@ export type ProgramUploadFileOutput = {
   exampleName?: string;
   kind: string;
   spiProgram: SpiProgram | null;
+  spiArgs?: Uint8Array;
 };
 
 export type ProgramUploadFileInput = {

src/components/ProgramLoader/types.ts

@@ -761,95 +761,14 @@ function formatTermination(term: TerminationEntry): string {
  * @param hostCallIndex The ecalli index being executed
  * @param readMemory Function to read memory for comparison
  */
-export function findHostCallEntry(
-  trace: ParsedTrace,
-  indexInTrace: number,
-  pc: number,
-  gas: bigint,
+function collectStateMismatches(
+  entry: HostCallEntry,
   registers: bigint[],
-  hostCallIndex: number,
+  gas: bigint,
   readMemory?: (address: number, length: number) => Uint8Array | null,
-): HostCallLookupResult {
-  // Get remaining entries from the current index
-  const remainingEntries = trace.hostCalls.slice(indexInTrace);
-
-  // Try to find an exact match by PC and host call index
-  const matchingEntries = remainingEntries.filter((hc) => hc.pc === pc && hc.gas <= gas);
-
-  if (matchingEntries.length === 0) {
-    return { entry: null, mismatches: [] };
-  }
-
-  // First try to find an entry whose hostCallIndex matches exactly
-  // Prefer exact index match even if gas is slightly higher
-  const exactIndexMatch = remainingEntries.find((hc) => hc.index === hostCallIndex && hc.pc === pc);
-
-  // If we have an exact index match with acceptable gas, use it
-  if (exactIndexMatch && exactIndexMatch.gas <= gas) {
-    const mismatches: StateMismatch[] = [];
-
-    // Check gas
-    if (exactIndexMatch.gas !== gas) {
-      mismatches.push({
-        field: "gas",
-        expected: exactIndexMatch.gas.toString(),
-        actual: gas.toString(),
-      });
-    }
-
-    // Check registers
-    for (const [idx, expectedValue] of exactIndexMatch.registers) {
-      const actualValue = registers[idx] ?? 0n;
-      if (expectedValue !== actualValue) {
-        mismatches.push({
-          field: "register",
-          expected: `r${idx}=0x${expectedValue.toString(16)}`,
-          actual: `r${idx}=0x${actualValue.toString(16)}`,
-          details: `Register ${idx}`,
-        });
-      }
-    }
-
-    // Check memory reads if readMemory function is provided
-    if (readMemory) {
-      for (const mr of exactIndexMatch.memoryReads) {
-        const actualData = readMemory(mr.address, mr.length);
-        if (actualData) {
-          const expectedHex = Array.from(mr.data)
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join("");
-          const actualHex = Array.from(actualData)
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join("");
-          if (expectedHex !== actualHex) {
-            mismatches.push({
-              field: "memread",
-              expected: `0x${expectedHex}`,
-              actual: `0x${actualHex}`,
-              details: `Memory at 0x${mr.address.toString(16)} (${mr.length} bytes)`,
-            });
-          }
-        }
-      }
-    }
-
-    return { entry: exactIndexMatch, mismatches };
-  }
-
-  // Fall back to first matching entry by PC and gas
-  const entry = matchingEntries[0];
+): StateMismatch[] {
   const mismatches: StateMismatch[] = [];
 
-  // Check PC
-  if (entry.index !== hostCallIndex) {
-    mismatches.push({
-      field: "index",
-      expected: entry.index.toString(),
-      actual: hostCallIndex.toString(),
-    });
-  }
-
-  // Check gas
   if (entry.gas !== gas) {
     mismatches.push({
       field: "gas",
@@ -858,7 +777,6 @@ export function findHostCallEntry(
     });
   }
 
-  // Check registers
   for (const [idx, expectedValue] of entry.registers) {
     const actualValue = registers[idx] ?? 0n;
     if (expectedValue !== actualValue) {
@@ -871,7 +789,6 @@ export function findHostCallEntry(
     }
   }
 
-  // Check memory reads if readMemory function is provided
   if (readMemory) {
     for (const mr of entry.memoryReads) {
       const actualData = readMemory(mr.address, mr.length);
@@ -894,6 +811,46 @@ export function findHostCallEntry(
     }
   }
 
+  return mismatches;
+}
+
+export function findHostCallEntry(
+  trace: ParsedTrace,
+  indexInTrace: number,
+  pc: number,
+  gas: bigint,
+  registers: bigint[],
+  hostCallIndex: number,
+  readMemory?: (address: number, length: number) => Uint8Array | null,
+): HostCallLookupResult {
+  const remainingEntries = trace.hostCalls.slice(indexInTrace);
+
+  const exactIndexMatch = remainingEntries.find((hc) => hc.index === hostCallIndex && hc.pc === pc);
+
+  if (exactIndexMatch) {
+    const mismatches = collectStateMismatches(exactIndexMatch, registers, gas, readMemory);
+    return { entry: exactIndexMatch, mismatches };
+  }
+
+  const matchingEntries = remainingEntries.filter((hc) => hc.pc === pc && hc.gas <= gas);
+
+  if (matchingEntries.length === 0) {
+    return { entry: null, mismatches: [] };
+  }
+
+  const entry = matchingEntries[0];
+  const mismatches: StateMismatch[] = [];
+
+  if (entry.index !== hostCallIndex) {
+    mismatches.push({
+      field: "index",
+      expected: entry.index.toString(),
+      actual: hostCallIndex.toString(),
+    });
+  }
+
+  mismatches.push(...collectStateMismatches(entry, registers, gas, readMemory));
+
   return { entry, mismatches };
 }