Add possibility to load SPI program with metadata (#372)

* add possibility to load spi program with metadata

* Update src/pages/DebuggerContent.tsx

Co-authored-by: Tomek Drwięga <tomusdrw@users.noreply.github.com>

* bump host calls

* bump debugger adapter

---------

Co-authored-by: Tomek Drwięga <tomusdrw@users.noreply.github.com>

Author: mateuszsikora

package-lock.json

@@ -29,9 +29,7 @@
     "@radix-ui/react-tooltip": "^1.1.7",
     "@reduxjs/toolkit": "^2.2.8",
     "@tanstack/react-virtual": "^3.10.9",
-    "@typeberry/block": "0.0.1-447d5c4",
-    "@typeberry/jam-host-calls": "0.0.1-fece159",
-    "@typeberry/pvm-debugger-adapter": "0.1.0-d25aae0",
+    "@typeberry/pvm-debugger-adapter": "0.1.0-f7a7185",
     "@typeberry/spectool-wasm": "0.20.8",
     "@uiw/react-codemirror": "^4.23.6",
     "blake2b": "^2.1.4",

package.json

@@ -4,7 +4,7 @@ import { Textarea } from "@/components/ui/textarea";
 import { cn } from "@/lib/utils";
 import { hasPVMGeneratedStorage } from "@/store/debugger/debuggerSlice";
 import { useAppSelector } from "@/store/hooks";
-import { bytes, hash } from "@typeberry/jam-host-calls";
+import { bytes, hash } from "@typeberry/pvm-debugger-adapter";
 import { cloneDeep } from "lodash";
 import { XIcon } from "lucide-react";
 import { useEffect, useState } from "react";

src/components/HostCalls/trie-input/index.tsx

@@ -1,7 +1,9 @@
 import { NumeralSystem } from "@/context/NumeralSystem";
 import { WorkerState } from "@/store/workers/workersSlice";
 import { valueToNumeralSystem } from "../Instructions/utils";
-import { codec } from "@typeberry/block";
+import { block } from "@typeberry/pvm-debugger-adapter";
+
+const codec = block.codec;
 
 export type FindMemoryForWorkerType = (
   worker: WorkerState,

src/components/MemoryPreview/utils.ts

@@ -1,7 +1,7 @@
 import { Textarea } from "@/components/ui/textarea.tsx";
 import React, { useMemo, useState } from "react";
 import classNames from "classnames";
-import { bytes } from "@typeberry/block";
+import { bytes } from "@typeberry/pvm-debugger-adapter";
 import { logger } from "@/utils/loggerService";
 import { useAppSelector } from "@/store/hooks.ts";
 import { selectIsProgramInvalid } from "@/store/debugger/debuggerSlice.ts";

src/components/ProgramTextLoader/index.tsx

@@ -1,4 +1,4 @@
-import { block, bytes, hash, read } from "@typeberry/jam-host-calls";
+import { block, bytes, hash, read } from "@typeberry/pvm-debugger-adapter";
 import { Storage } from "../web-worker/types";
 
 export class ReadAccounts implements read.Accounts {

src/packages/host-calls/read.ts

@@ -1,4 +1,4 @@
-import { write, hash, block, bytes } from "@typeberry/jam-host-calls";
+import { write, hash, block, bytes } from "@typeberry/pvm-debugger-adapter";
 import { Storage } from "../web-worker/types";
 
 export class WriteAccounts implements write.Accounts {

src/packages/host-calls/write.ts

@@ -1,13 +1,28 @@
 import { HostCallIdentifiers } from "@/types/pvm";
 import { CommandStatus, PvmApiInterface, Storage } from "../types";
-import { read, Registers, write, Memory, gas } from "@typeberry/jam-host-calls";
+import {
+  read,
+  write,
+  gas,
+  HostCallRegisters,
+  Result,
+  interpreter,
+  numbers,
+  Registers,
+  IHostCallMemory,
+  IHostCallRegisters,
+  OK,
+  HostCallMemory,
+} from "@typeberry/pvm-debugger-adapter";
 import { WriteAccounts } from "@/packages/host-calls/write";
 import { isInternalPvm } from "../utils";
 import { ReadAccounts } from "@/packages/host-calls/read";
-import { tryAsServiceId } from "@typeberry/block";
-import { Gas, MemoryIndex, tryAsGas } from "@typeberry/pvm-debugger-adapter";
+import { block } from "@typeberry/pvm-debugger-adapter";
 import { WasmPvmShellInterface } from "../wasmBindgenShell";
 
+const { tryAsGas } = interpreter;
+const { tryAsU64 } = numbers;
+const { tryAsServiceId } = block;
 type HostCallParams = {
   pvm: PvmApiInterface | null;
   hostCallIdentifier: HostCallIdentifiers;
@@ -31,15 +46,15 @@ type HostCallResponse =
 class SimpleGas {
   pvm!: WasmPvmShellInterface;
 
-  get(): Gas {
+  get() {
     return tryAsGas(this.pvm.getGasLeft());
   }
-  set(gas: Gas) {
+  set(gas: interpreter.Gas) {
     if (this.pvm.setGasLeft) {
       this.pvm.setGasLeft(BigInt(gas));
     }
   }
-  sub(v: Gas) {
+  sub(v: interpreter.Gas) {
     const current = this.get();
     if (current > v) {
       this.set(tryAsGas(BigInt(current) - BigInt(v)));
@@ -61,76 +76,62 @@ const getGasCounter = (pvm: PvmApiInterface) => {
 
   return gas;
 };
-
-class SimpleRegisters implements Registers {
+class SimpleRegisters implements IHostCallRegisters {
   flatRegisters!: Uint8Array;
   pvm!: WasmPvmShellInterface;
 
-  getU32(registerIndex: number): number {
-    return Number(this.getU64(registerIndex) & 0xffff_ffffn);
-  }
-  getI32(registerIndex: number): number {
-    return Number(this.getU32(registerIndex)) >> 0;
-  }
-  setU32(registerIndex: number, value: number): void {
-    this.setU64(registerIndex, BigInt(value));
-  }
-  setI32(registerIndex: number, value: number): void {
-    this.setI64(registerIndex, BigInt(value));
+  get(registerIndex: number): numbers.U64 {
+    return tryAsU64(new BigUint64Array(this.flatRegisters.buffer)[registerIndex]);
   }
-  getU64(registerIndex: number): bigint {
-    return new BigUint64Array(this.flatRegisters.buffer)[registerIndex];
-  }
-  getI64(registerIndex: number): bigint {
-    return new BigInt64Array(this.flatRegisters.buffer)[registerIndex];
-  }
-  setU64(registerIndex: number, value: bigint): void {
+
+  set(registerIndex: number, value: numbers.U64): void {
     new BigUint64Array(this.flatRegisters.buffer)[registerIndex] = value;
     this.pvm.setRegisters(this.flatRegisters);
   }
-  setI64(registerIndex: number, value: bigint): void {
-    new BigInt64Array(this.flatRegisters.buffer)[registerIndex] = value;
-    this.pvm.setRegisters(this.flatRegisters);
-  }
 }
 
 const getRegisters = (pvm: PvmApiInterface) => {
   if (isInternalPvm(pvm)) {
-    return pvm.getInterpreter().getRegisters();
+    const regs = pvm.getInterpreter().getRegisters();
+    return new HostCallRegisters(regs);
   }
 
   const registers = new SimpleRegisters();
+  const regs = new Registers();
+  const rawRegs = new BigUint64Array(pvm.getRegisters().buffer);
+  regs.copyFrom(rawRegs);
   registers.flatRegisters = pvm.getRegisters();
   registers.pvm = pvm;
 
   return registers;
 };
 
-class SimpleMemory implements Memory {
+class SimpleMemory implements IHostCallMemory {
   pvm!: WasmPvmShellInterface;
   memorySize: number = 4096;
 
-  loadInto(result: Uint8Array, startAddress: MemoryIndex) {
-    const memoryDump = this.pvm.getPageDump(startAddress / this.memorySize);
+  loadInto(result: Uint8Array, startAddress: numbers.U64) {
+    const memoryDump = this.pvm.getPageDump(Number(startAddress / tryAsU64(this.memorySize)));
     result.set(memoryDump.subarray(0, result.length));
 
-    return null;
-  }
-  /* eslint-disable-next-line @typescript-eslint/no-unused-vars */
-  isWriteable(_destinationStart: MemoryIndex, _length: number) {
-    return true;
+    return Result.ok(OK);
   }
 
-  storeFrom(address: MemoryIndex, bytes: Uint8Array) {
+  storeFrom(address: numbers.U64, bytes: Uint8Array) {
     // TODO [ToDr] Either change the API to require handling multi-page writes or change this code to split the write into multiple pages.
-    this.pvm.setMemory(address, bytes);
-    return null;
+    this.pvm.setMemory(Number(address), bytes);
+    return Result.ok(OK);
+  }
+
+  getMemory() {
+    // TODO [MaSi]: This function is used only by `peek` and `poke` host calls, so dummy implementation is okay for now.
+    return new interpreter.Memory();
   }
 }
 
 const getMemory = (pvm: PvmApiInterface) => {
   if (isInternalPvm(pvm)) {
-    return pvm.getInterpreter().getMemory();
+    return new HostCallMemory(pvm.getInterpreter().getMemory());
   }
   const memory = new SimpleMemory();
   memory.pvm = pvm;
@@ -174,7 +175,7 @@ const hostCall = async ({
 
     return { hostCallIdentifier, storage, status: CommandStatus.SUCCESS };
   } else if (hostCallIdentifier === HostCallIdentifiers.GAS) {
-    const jamHostCall = new gas.Gas();
+    const jamHostCall = new gas.GasHostCall();
 
     await jamHostCall.execute(getGasCounter(pvm), getRegisters(pvm));
 

src/packages/web-worker/command-handlers/host-call.ts

@@ -2,13 +2,15 @@ import { InitialState, Pvm as InternalPvm, Status } from "@/types/pvm";
 import {
   createResults,
   instructionArgumentTypeMap,
+  interpreter,
   ProgramDecoder,
-  tryAsMemoryIndex,
-  tryAsSbrkIndex,
 } from "@typeberry/pvm-debugger-adapter";
 import { ArgsDecoder, Registers } from "@typeberry/pvm-debugger-adapter";
 import { byteToOpCodeMap } from "../../packages/pvm/pvm/assemblify";
-import { Pvm as InternalPvmInstance, MemoryBuilder as InternalPvmMemoryBuilder } from "@typeberry/pvm-debugger-adapter";
+import { Pvm as InternalPvmInstance } from "@typeberry/pvm-debugger-adapter";
+
+const { tryAsMemoryIndex, tryAsSbrkIndex, MemoryBuilder: InternalPvmMemoryBuilder } = interpreter;
+
 export const initPvm = async (pvm: InternalPvmInstance, program: Uint8Array, initialState: InitialState) => {
   const initialMemory = initialState.memory ?? [];
   const pageMap = initialState.pageMap ?? [];
@@ -34,7 +36,7 @@ export const initPvm = async (pvm: InternalPvmInstance, program: Uint8Array, ini
   const pageSize = 2 ** 12;
   const maxAddressFromPageMap = Math.max(...pageMap.map((page) => page.address + page.length));
   const hasMemoryLayout = maxAddressFromPageMap >= 0;
-  const heapStartIndex = tryAsSbrkIndex(hasMemoryLayout ? maxAddressFromPageMap + pageSize : 0);
+  const heapStartIndex = tryAsMemoryIndex(hasMemoryLayout ? maxAddressFromPageMap + pageSize : 0);
   const heapEndIndex = tryAsSbrkIndex(2 ** 32 - 2 * 2 ** 16 - 2 ** 24);
 
   const memory = memoryBuilder.finalize(heapStartIndex, heapEndIndex);

src/packages/web-worker/pvm.ts

@@ -1,7 +1,7 @@
 import { CurrentInstruction, ExpectedState, HostCallIdentifiers, InitialState } from "@/types/pvm";
 import { WasmPvmShellInterface } from "./wasmBindgenShell";
 import { Pvm as InternalPvm } from "@/types/pvm";
-import { bytes } from "@typeberry/jam-host-calls";
+import { bytes } from "@typeberry/pvm-debugger-adapter";
 import { SerializedFile } from "@/lib/utils.ts";
 
 type CommonWorkerResponseParams = { status: CommandStatus; error?: unknown; messageId: string };

src/packages/web-worker/types.ts

@@ -138,11 +138,12 @@ const DebuggerContent = () => {
                           dispatch(setIsProgramInvalid(true));
                         }
 
-                        function tryAsSpi(program: number[]) {
+                        function tryAsSpi(program: number[], withMetadata: boolean) {
                           try {
                             const { code, memory, registers } = Program.fromSpi(
                               new Uint8Array(program),
                               new Uint8Array(),
+                              withMetadata,
                             );
                             const regs = Array.from(registers.getAllU64()) as RegistersArray;
                             return {
@@ -156,7 +157,9 @@ const DebuggerContent = () => {
                         }
 
                         if (!error && program) {
-                          const maybeSpi = tryAsSpi(program.slice());
+                          const maybeSpiWithMetadata = tryAsSpi(program.slice(), true);
+                          const maybeSpiWithoutMetadata = tryAsSpi(program.slice(), false);
+                          const maybeSpi = maybeSpiWithoutMetadata || maybeSpiWithMetadata;
                           if (maybeSpi) {
                             debuggerActions.handleProgramLoad(maybeSpi);
                           } else {

src/pages/DebuggerContent.tsx

@@ -1,6 +1,6 @@
 import { Loader } from "@/components/ProgramLoader/Loader.tsx";
 import { useEffect, useRef } from "react";
-import { bytes } from "@typeberry/block";
+import { bytes } from "@typeberry/pvm-debugger-adapter";
 import { decodeStandardProgram } from "@typeberry/pvm-debugger-adapter";
 import { MemoryChunkItem, PageMapItem, RegistersArray } from "@/types/pvm.ts";
 import { useNavigate } from "react-router";

src/pages/ProgramLoader.tsx

@@ -9,7 +9,7 @@ import {
 import { DebuggerEcalliStorage } from "@/types/pvm";
 import { logger } from "@/utils/loggerService";
 import { SerializedError } from "@reduxjs/toolkit";
-import { bytes } from "@typeberry/jam-host-calls";
+import { bytes } from "@typeberry/pvm-debugger-adapter";
 
 const RESPONSE_WAIT_TIMEOUT = 60000;
 const getMessageId = () => Math.random().toString(36).substring(7);