@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/jam-host-calls/general/gas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/gas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElD,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACpF,OAAO,EAAE,KAAK,YAAY,EAAsC,MAAM,2BAA2B,CAAC;AAClG,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAG3E;;;;;;GAMG;AACH,qBAAa,WAAY,YAAW,eAAe;aAKrB,gBAAgB,EAAE,SAAS;IAJvD,KAAK,iIAAyB;IAC9B,YAAY,4HAAqB;IACjC,eAAe,uEAAqB;gBAER,gBAAgB,EAAE,SAAS;IAEvD,OAAO,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC;CAMtF"}

package/packages/jam/jam-host-calls/general/gas.js

@@ -0,0 +1,26 @@
+import { tryAsU64 } from "#@typeberry/numbers";
+import { traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { logger } from "../logger.js";
+/**
+ * Return remaining gas to the PVM.
+ *
+ * NOTE it should be the gas left is AFTER this function is invoked.
+ *
+ * https://graypaper.fluffylabs.dev/#/9a08063/311301311301?v=0.6.6
+ */
+export class GasHostCall {
+    currentServiceId;
+    index = tryAsHostCallIndex(0);
+    basicGasCost = tryAsSmallGas(10);
+    tracedRegisters = traceRegisters(7);
+    constructor(currentServiceId) {
+        this.currentServiceId = currentServiceId;
+    }
+    execute(gas, regs) {
+        const gasValue = gas.get();
+        logger.trace `[${this.currentServiceId}] GAS <- ${gasValue}`;
+        regs.set(7, tryAsU64(gasValue));
+        return Promise.resolve(undefined);
+    }
+}

package/packages/jam/jam-host-calls/general/gas.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gas.test.d.ts.map

package/packages/jam/jam-host-calls/general/gas.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/gas.test.ts"],"names":[],"mappings":""}

package/packages/jam/jam-host-calls/general/gas.test.js

@@ -0,0 +1,33 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceId } from "#@typeberry/block";
+import { HostCallRegisters } from "#@typeberry/pvm-host-calls";
+import { tryAsGas } from "#@typeberry/pvm-interface";
+import { gasCounter } from "#@typeberry/pvm-interpreter";
+import { emptyRegistersBuffer } from "../utils.js";
+import { GasHostCall } from "./gas.js";
+const REGISTER = 7;
+describe("HostCalls: Gas", () => {
+    it("should write U32 gas to register", () => {
+        const currentServiceId = tryAsServiceId(10_000);
+        const gas = new GasHostCall(currentServiceId);
+        const counter = gasCounter(tryAsGas(10_000));
+        const regs = new HostCallRegisters(emptyRegistersBuffer());
+        assert.deepStrictEqual(regs.get(REGISTER), 0n);
+        // when
+        gas.execute(counter, regs);
+        // then
+        assert.deepStrictEqual(regs.get(REGISTER), 10000n);
+    });
+    it("should write U64 gas to register", () => {
+        const currentServiceId = tryAsServiceId(10_000);
+        const gas = new GasHostCall(currentServiceId);
+        const counter = gasCounter(tryAsGas(2n ** 64n - 1n));
+        const regs = new HostCallRegisters(emptyRegistersBuffer());
+        assert.deepStrictEqual(regs.get(REGISTER), 0n);
+        // when
+        gas.execute(counter, regs);
+        // then
+        assert.deepStrictEqual(regs.get(REGISTER), 2n ** 64n - 1n);
+    });
+});

package/packages/jam/jam-host-calls/general/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./fetch.js";
+export * from "./gas.js";
+export * from "./info.js";
+export * from "./log.js";
+export * from "./lookup.js";
+export * from "./missing.js";
+export * from "./read.js";
+export * from "./results.js";
+export * from "./write.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/jam/jam-host-calls/general/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC"}

package/packages/jam/jam-host-calls/general/index.js

@@ -0,0 +1,9 @@
+export * from "./fetch.js";
+export * from "./gas.js";
+export * from "./info.js";
+export * from "./log.js";
+export * from "./lookup.js";
+export * from "./missing.js";
+export * from "./read.js";
+export * from "./results.js";
+export * from "./write.js";

package/packages/jam/jam-host-calls/general/info.d.ts

@@ -0,0 +1,83 @@
+import { type ServiceId } from "#@typeberry/block";
+import type { HostCallHandler, HostCallMemory, HostCallRegisters } from "#@typeberry/pvm-host-calls";
+import { PvmExecution } from "#@typeberry/pvm-host-calls";
+import { type IGasCounter } from "#@typeberry/pvm-interface";
+import { ServiceAccountInfo } from "#@typeberry/state";
+/** Account data interface for info host calls. */
+export interface AccountsInfo {
+    /** Get account info. */
+    getServiceInfo(serviceId: ServiceId | null): ServiceAccountInfo | null;
+}
+export declare const LEN_REG: number;
+/**
+ * Return info about some account.
+ *
+ * `E(a_c, E8(a_b, a_t, a_g , a_m, a_o), E4(a_i), E8(a_f), E4(a_r, a_a, a_p))`
+ * c = code hash
+ * b = balance
+ * t = threshold balance
+ * g = minimum gas for accumulate
+ * m = minimum gas for on transfer
+ * o = total number of octets stored.
+ * i = number of items in the storage
+ * f = gratis storage (can bring down whole threshold cost to zero)
+ * r = creation timeslot
+ * a = last accumulation timeslot
+ * p = parent service
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/333b00333b00?v=0.7.2
+ */
+export declare class Info implements HostCallHandler {
+    readonly currentServiceId: ServiceId;
+    private readonly account;
+    index: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"HostCallIndex[U32]">;
+    basicGasCost: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"SmallGas[U32]">;
+    tracedRegisters: (number & import("@typeberry/utils").WithOpaque<"register index">)[];
+    constructor(currentServiceId: ServiceId, account: AccountsInfo);
+    execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined | PvmExecution>;
+}
+/**
+ * Service account details with threshold balance.
+ *
+ * Used exclusively by `info` host call.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/33920033b500?v=0.7.2
+ */
+export declare const codecServiceAccountInfoWithThresholdBalance: import("@typeberry/codec").Descriptor<{
+    codeHash: import("@typeberry/bytes").Bytes<32>;
+    balance: import("@typeberry/numbers").U64;
+    thresholdBalance: import("@typeberry/numbers").U64;
+    accumulateMinGas: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    onTransferMinGas: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    storageUtilisationBytes: import("@typeberry/numbers").U64;
+    storageUtilisationCount: import("@typeberry/numbers").U32;
+    gratisStorage: import("@typeberry/numbers").U64;
+    created: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    lastAccumulation: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    parentService: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+}, import("@typeberry/codec").ViewOf<{
+    codeHash: import("@typeberry/bytes").Bytes<32>;
+    balance: import("@typeberry/numbers").U64;
+    thresholdBalance: import("@typeberry/numbers").U64;
+    accumulateMinGas: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    onTransferMinGas: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    storageUtilisationBytes: import("@typeberry/numbers").U64;
+    storageUtilisationCount: import("@typeberry/numbers").U32;
+    gratisStorage: import("@typeberry/numbers").U64;
+    created: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    lastAccumulation: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    parentService: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+}, import("@typeberry/codec").SimpleDescriptorRecord<{
+    codeHash: import("@typeberry/bytes").Bytes<32>;
+    balance: import("@typeberry/numbers").U64;
+    thresholdBalance: import("@typeberry/numbers").U64;
+    accumulateMinGas: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    onTransferMinGas: bigint & import("@typeberry/numbers").WithBytesRepresentation<8> & import("@typeberry/utils").WithOpaque<"ServiceGas[u64]">;
+    storageUtilisationBytes: import("@typeberry/numbers").U64;
+    storageUtilisationCount: import("@typeberry/numbers").U32;
+    gratisStorage: import("@typeberry/numbers").U64;
+    created: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    lastAccumulation: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"TimeSlot[u32]">;
+    parentService: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"ServiceId[u32]">;
+}>>>;
+//# sourceMappingURL=info.d.ts.map

package/packages/jam/jam-host-calls/general/info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkD,MAAM,kBAAkB,CAAC;AAKlG,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACpG,OAAO,EAAE,YAAY,EAAsC,MAAM,2BAA2B,CAAC;AAC7F,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAC3E,OAAO,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAMtD,kDAAkD;AAClD,MAAM,WAAW,YAAY;IAC3B,wBAAwB;IACxB,cAAc,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,kBAAkB,GAAG,IAAI,CAAC;CACxE;AAMD,eAAO,MAAM,OAAO,QACsF,CAAC;AAE3G;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,IAAK,YAAW,eAAe;aAMxB,gBAAgB,EAAE,SAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,KAAK,iIAAyB;IAC9B,YAAY,4HAAqB;IACjC,eAAe,uEAAsD;gBAGnD,gBAAgB,EAAE,SAAS,EAC1B,OAAO,EAAE,YAAY;IAGlC,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC;CA8CrH;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAevD,CAAC"}

package/packages/jam/jam-host-calls/general/info.js

@@ -0,0 +1,97 @@
+import { tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { BytesBlob } from "#@typeberry/bytes";
+import { codec, Encoder } from "#@typeberry/codec";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { minU64, tryAsU64 } from "#@typeberry/numbers";
+import { PvmExecution, traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { ServiceAccountInfo } from "#@typeberry/state";
+import { Compatibility, GpVersion, TestSuite } from "#@typeberry/utils";
+import { logger } from "../logger.js";
+import { getServiceIdOrCurrent } from "../utils.js";
+import { HostCallResult } from "./results.js";
+const IN_OUT_REG = 7;
+const OFFSET_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9 : 11;
+export const LEN_REG = Compatibility.isSuite(TestSuite.W3F_DAVXY) || Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 10 : 12;
+/**
+ * Return info about some account.
+ *
+ * `E(a_c, E8(a_b, a_t, a_g , a_m, a_o), E4(a_i), E8(a_f), E4(a_r, a_a, a_p))`
+ * c = code hash
+ * b = balance
+ * t = threshold balance
+ * g = minimum gas for accumulate
+ * m = minimum gas for on transfer
+ * o = total number of octets stored.
+ * i = number of items in the storage
+ * f = gratis storage (can bring down whole threshold cost to zero)
+ * r = creation timeslot
+ * a = last accumulation timeslot
+ * p = parent service
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/333b00333b00?v=0.7.2
+ */
+export class Info {
+    currentServiceId;
+    account;
+    index = tryAsHostCallIndex(5);
+    basicGasCost = tryAsSmallGas(10);
+    tracedRegisters = traceRegisters(IN_OUT_REG, 8, OFFSET_REG, LEN_REG);
+    constructor(currentServiceId, account) {
+        this.currentServiceId = currentServiceId;
+        this.account = account;
+    }
+    async execute(_gas, regs, memory) {
+        // t
+        const serviceId = getServiceIdOrCurrent(IN_OUT_REG, regs, this.currentServiceId);
+        // o
+        const outputStart = regs.get(8);
+        // v
+        const accountInfo = this.account.getServiceInfo(serviceId);
+        const encodedInfo = accountInfo === null
+            ? BytesBlob.empty()
+            : Encoder.encodeObject(codecServiceAccountInfoWithThresholdBalance, {
+                ...accountInfo,
+                thresholdBalance: ServiceAccountInfo.calculateThresholdBalance(accountInfo.storageUtilisationCount, accountInfo.storageUtilisationBytes, accountInfo.gratisStorage),
+            });
+        const valueLength = tryAsU64(encodedInfo.length);
+        // f
+        const offset = minU64(regs.get(OFFSET_REG), valueLength);
+        // l
+        const length = minU64(regs.get(LEN_REG), tryAsU64(valueLength - offset));
+        // NOTE: casting to `Number` is safe in both places, since we are always bounded
+        // by the actual `encodedInfo.length`, which is equal `96`.
+        const chunk = encodedInfo.raw.subarray(Number(offset), Number(offset + length));
+        const writeResult = memory.storeFrom(outputStart, chunk);
+        if (writeResult.isError) {
+            logger.trace `[${this.currentServiceId}] INFO(${serviceId}, off: ${offset}, len: ${length}) <- PANIC`;
+            return PvmExecution.Panic;
+        }
+        logger.trace `[${this.currentServiceId}] INFO(${serviceId}, off: ${offset}, len: ${length}) <- ${BytesBlob.blobFrom(chunk)}`;
+        if (accountInfo === null) {
+            regs.set(IN_OUT_REG, HostCallResult.NONE);
+            return;
+        }
+        regs.set(IN_OUT_REG, valueLength);
+    }
+}
+/**
+ * Service account details with threshold balance.
+ *
+ * Used exclusively by `info` host call.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/33920033b500?v=0.7.2
+ */
+export const codecServiceAccountInfoWithThresholdBalance = codec.object({
+    codeHash: codec.bytes(HASH_SIZE),
+    balance: codec.u64,
+    thresholdBalance: codec.u64,
+    accumulateMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
+    onTransferMinGas: codec.u64.convert((i) => i, tryAsServiceGas),
+    storageUtilisationBytes: codec.u64,
+    storageUtilisationCount: codec.u32,
+    gratisStorage: codec.u64,
+    created: codec.u32.convert((x) => x, tryAsTimeSlot),
+    lastAccumulation: codec.u32.convert((x) => x, tryAsTimeSlot),
+    parentService: codec.u32.convert((x) => x, tryAsServiceId),
+}, "ServiceAccountInfoWithThresholdBalance");

package/packages/jam/jam-host-calls/general/info.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=info.test.d.ts.map

package/packages/jam/jam-host-calls/general/info.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"info.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/info.test.ts"],"names":[],"mappings":""}

package/packages/jam/jam-host-calls/general/info.test.js

@@ -0,0 +1,142 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceGas, tryAsServiceId, tryAsTimeSlot } from "#@typeberry/block";
+import { Bytes, BytesBlob } from "#@typeberry/bytes";
+import { Decoder, tryAsExactBytes } from "#@typeberry/codec";
+import { tryAsU32, tryAsU64 } from "#@typeberry/numbers";
+import { HostCallMemory, HostCallRegisters, PvmExecution } from "#@typeberry/pvm-host-calls";
+import { tryAsGas } from "#@typeberry/pvm-interface";
+import { gasCounter } from "#@typeberry/pvm-interpreter";
+import { MemoryBuilder, tryAsMemoryIndex } from "#@typeberry/pvm-interpreter/memory/index.js";
+import { tryAsSbrkIndex } from "#@typeberry/pvm-interpreter/memory/memory-index.js";
+import { PAGE_SIZE } from "#@typeberry/pvm-interpreter/spi-decoder/memory-conts.js";
+import { ServiceAccountInfo } from "#@typeberry/state";
+import { TestAccounts } from "../externalities/test-accounts.js";
+import { emptyRegistersBuffer } from "../utils.js";
+import { codecServiceAccountInfoWithThresholdBalance, Info, LEN_REG } from "./info.js";
+import { HostCallResult } from "./results.js";
+const SERVICE_ID_REG = 7;
+const RESULT_REG = SERVICE_ID_REG;
+const DEST_START_REG = 8;
+const gas = gasCounter(tryAsGas(0));
+const serviceAccountInfoSize = tryAsExactBytes(codecServiceAccountInfoWithThresholdBalance.sizeHint);
+function prepareRegsAndMemory(serviceId, accountInfoLength = serviceAccountInfoSize) {
+    const pageStart = 2 ** 16;
+    const memStart = pageStart + PAGE_SIZE - accountInfoLength - 1;
+    const registers = new HostCallRegisters(emptyRegistersBuffer());
+    registers.set(SERVICE_ID_REG, tryAsU64(serviceId));
+    registers.set(DEST_START_REG, tryAsU64(memStart));
+    registers.set(LEN_REG, tryAsU64(serviceAccountInfoSize));
+    const builder = new MemoryBuilder();
+    builder.setWriteablePages(tryAsMemoryIndex(pageStart), tryAsMemoryIndex(pageStart + PAGE_SIZE));
+    const memory = new HostCallMemory(builder.finalize(tryAsMemoryIndex(0), tryAsSbrkIndex(0)));
+    const readRaw = () => {
+        const result = new Uint8Array(Number(registers.get(LEN_REG)));
+        assert.strictEqual(memory.loadInto(result, tryAsU64(memStart)).isOk, true);
+        return BytesBlob.blobFrom(result);
+    };
+    return {
+        registers,
+        memory,
+        readRaw,
+        readInfo: () => {
+            const data = readRaw();
+            return Decoder.decodeObject(codecServiceAccountInfoWithThresholdBalance, data);
+        },
+    };
+}
+describe("HostCalls: Info", () => {
+    const serviceComp = {
+        gratisStorage: tryAsU64(1024),
+        created: tryAsTimeSlot(10),
+        lastAccumulation: tryAsTimeSlot(15),
+        parentService: tryAsServiceId(1),
+    };
+    it("should write account info data into memory", async () => {
+        const serviceId = tryAsServiceId(10_000);
+        const currentServiceId = serviceId;
+        const accounts = new TestAccounts(currentServiceId);
+        const info = new Info(currentServiceId, accounts);
+        const { registers, memory, readInfo } = prepareRegsAndMemory(serviceId);
+        const storageUtilisationBytes = tryAsU64(10_000);
+        const storageUtilisationCount = tryAsU32(1_000);
+        const thresholdBalance = ServiceAccountInfo.calculateThresholdBalance(storageUtilisationCount, storageUtilisationBytes, serviceComp.gratisStorage);
+        accounts.details.set(serviceId, ServiceAccountInfo.create({
+            codeHash: Bytes.fill(32, 5).asOpaque(),
+            balance: tryAsU64(150_000),
+            accumulateMinGas: tryAsServiceGas(0n),
+            onTransferMinGas: tryAsServiceGas(0n),
+            storageUtilisationBytes,
+            storageUtilisationCount,
+            ...serviceComp,
+        }));
+        // when
+        const result = await info.execute(gas, registers, memory);
+        // then
+        assert.strictEqual(result, undefined);
+        assert.deepStrictEqual(registers.get(RESULT_REG), 96n);
+        assert.deepStrictEqual(readInfo(), {
+            ...accounts.details.get(serviceId),
+            thresholdBalance,
+        });
+    });
+    it("should write ONLY PART of account info data into memory", async () => {
+        const serviceId = tryAsServiceId(10_000);
+        const currentServiceId = serviceId;
+        const accounts = new TestAccounts(currentServiceId);
+        const info = new Info(currentServiceId, accounts);
+        const { registers, memory, readRaw } = prepareRegsAndMemory(serviceId);
+        registers.set(LEN_REG, tryAsU64(10));
+        const storageUtilisationBytes = tryAsU64(10_000);
+        const storageUtilisationCount = tryAsU32(1_000);
+        accounts.details.set(serviceId, ServiceAccountInfo.create({
+            codeHash: Bytes.fill(32, 5).asOpaque(),
+            balance: tryAsU64(150_000),
+            accumulateMinGas: tryAsServiceGas(0n),
+            onTransferMinGas: tryAsServiceGas(0n),
+            storageUtilisationBytes,
+            storageUtilisationCount,
+            ...serviceComp,
+        }));
+        // when
+        const result = await info.execute(gas, registers, memory);
+        // then
+        assert.strictEqual(result, undefined);
+        assert.deepStrictEqual(registers.get(RESULT_REG), 96n);
+        assert.deepStrictEqual(readRaw().toString(), "0x05050505050505050505");
+    });
+    it("should write none if account info is missing", async () => {
+        const currentServiceId = tryAsServiceId(15_000);
+        const accounts = new TestAccounts(currentServiceId);
+        const info = new Info(currentServiceId, accounts);
+        const serviceId = tryAsServiceId(10_000);
+        const { registers, memory } = prepareRegsAndMemory(serviceId);
+        // when
+        const result = await info.execute(gas, registers, memory);
+        // then
+        assert.strictEqual(result, undefined);
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.NONE);
+    });
+    it("should panic if not enough memory allocated", async () => {
+        const serviceId = tryAsServiceId(10_000);
+        const currentServiceId = serviceId;
+        const accounts = new TestAccounts(currentServiceId);
+        const info = new Info(serviceId, accounts);
+        const { registers, memory } = prepareRegsAndMemory(serviceId, 10);
+        const storageUtilisationBytes = tryAsU64(10_000);
+        const storageUtilisationCount = tryAsU32(1_000);
+        accounts.details.set(serviceId, ServiceAccountInfo.create({
+            codeHash: Bytes.fill(32, 5).asOpaque(),
+            balance: tryAsU64(150_000),
+            accumulateMinGas: tryAsServiceGas(0n),
+            onTransferMinGas: tryAsServiceGas(0n),
+            storageUtilisationBytes,
+            storageUtilisationCount,
+            ...serviceComp,
+        }));
+        // when
+        const result = await info.execute(gas, registers, memory);
+        // then
+        assert.strictEqual(result, PvmExecution.Panic);
+    });
+});

package/packages/jam/jam-host-calls/general/log.d.ts

@@ -0,0 +1,17 @@
+import type { ServiceId } from "#@typeberry/block";
+import type { HostCallHandler, HostCallMemory, HostCallRegisters } from "#@typeberry/pvm-host-calls";
+import { type IGasCounter } from "#@typeberry/pvm-interface";
+/**
+ * Log message to the console
+ *
+ * https://docs.jamcha.in/knowledge/testing/pvm/host-call-log
+ */
+export declare class LogHostCall implements HostCallHandler {
+    readonly currentServiceId: ServiceId;
+    index: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"HostCallIndex[U32]">;
+    basicGasCost: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"SmallGas[U32]">;
+    tracedRegisters: (number & import("@typeberry/utils").WithOpaque<"register index">)[];
+    constructor(currentServiceId: ServiceId);
+    execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined>;
+}
+//# sourceMappingURL=log.d.ts.map

package/packages/jam/jam-host-calls/general/log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/log.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEpG,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAmB3E;;;;GAIG;AACH,qBAAa,WAAY,YAAW,eAAe;aAMrB,gBAAgB,EAAE,SAAS;IALvD,KAAK,iIAA2B;IAChC,YAAY,4HAA2F;IAEvG,eAAe,uEAAoB;gBAEP,gBAAgB,EAAE,SAAS;IAEjD,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,CAAC;CAqBtG"}

package/packages/jam/jam-host-calls/general/log.js

@@ -0,0 +1,50 @@
+import { traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { Compatibility, GpVersion, safeAllocUint8Array } from "#@typeberry/utils";
+import { logger } from "../logger.js";
+import { clampU64ToU32 } from "../utils.js";
+import { HostCallResult } from "./results.js";
+const decoder = new TextDecoder("utf8");
+var Levels;
+(function (Levels) {
+    Levels[Levels["ERROR"] = 0] = "ERROR";
+    Levels[Levels["WARNING"] = 1] = "WARNING";
+    Levels[Levels["INFO"] = 2] = "INFO";
+    Levels[Levels["DEBUG"] = 3] = "DEBUG";
+    Levels[Levels["NIT"] = 4] = "NIT";
+    Levels[Levels["UNKNOWN"] = 5] = "UNKNOWN";
+})(Levels || (Levels = {}));
+const IN_OUT_REG = 7;
+/**
+ * Log message to the console
+ *
+ * https://docs.jamcha.in/knowledge/testing/pvm/host-call-log
+ */
+export class LogHostCall {
+    currentServiceId;
+    index = tryAsHostCallIndex(100);
+    basicGasCost = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? tryAsSmallGas(10) : tryAsSmallGas(0);
+    // intentionally not tracing anything here, since the message will be printed anyway.
+    tracedRegisters = traceRegisters();
+    constructor(currentServiceId) {
+        this.currentServiceId = currentServiceId;
+    }
+    async execute(_gas, regs, memory) {
+        const lvl = regs.get(7);
+        const targetStart = regs.get(8);
+        const targetLength = regs.get(9);
+        const msgStart = regs.get(10);
+        const msgLength = regs.get(11);
+        const target = safeAllocUint8Array(clampU64ToU32(targetLength));
+        const message = safeAllocUint8Array(clampU64ToU32(msgLength));
+        if (targetStart !== 0n) {
+            memory.loadInto(target, targetStart);
+        }
+        memory.loadInto(message, msgStart);
+        const level = clampU64ToU32(lvl);
+        logger.trace `[${this.currentServiceId}] LOG(${this.currentServiceId}, ${level < Levels.UNKNOWN ? Levels[level] : Levels[Levels.UNKNOWN]}(${lvl}), ${decoder.decode(target)}, ${decoder.decode(message)})`;
+        if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)) {
+            regs.set(IN_OUT_REG, HostCallResult.WHAT);
+        }
+    }
+}

package/packages/jam/jam-host-calls/general/lookup.d.ts

@@ -0,0 +1,26 @@
+import type { ServiceId } from "#@typeberry/block";
+import { type BytesBlob } from "#@typeberry/bytes";
+import { type Blake2bHash } from "#@typeberry/hash";
+import type { HostCallHandler, HostCallMemory, HostCallRegisters } from "#@typeberry/pvm-host-calls";
+import { PvmExecution } from "#@typeberry/pvm-host-calls";
+import { type IGasCounter } from "#@typeberry/pvm-interface";
+/** Account data interface for lookup host calls. */
+export interface AccountsLookup {
+    /** Lookup a preimage. */
+    lookup(serviceId: ServiceId | null, hash: Blake2bHash): BytesBlob | null;
+}
+/**
+ * Lookup a preimage.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/329902329902?v=0.6.7
+ */
+export declare class Lookup implements HostCallHandler {
+    readonly currentServiceId: ServiceId;
+    private readonly account;
+    index: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"HostCallIndex[U32]">;
+    basicGasCost: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"SmallGas[U32]">;
+    tracedRegisters: (number & import("@typeberry/utils").WithOpaque<"register index">)[];
+    constructor(currentServiceId: ServiceId, account: AccountsLookup);
+    execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined | PvmExecution>;
+}
+//# sourceMappingURL=lookup.d.ts.map

package/packages/jam/jam-host-calls/general/lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/lookup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAS,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,EAAE,KAAK,WAAW,EAAa,MAAM,iBAAiB,CAAC;AAE9D,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACpG,OAAO,EAAE,YAAY,EAAsC,MAAM,2BAA2B,CAAC;AAC7F,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAM3E,oDAAoD;AACpD,MAAM,WAAW,cAAc;IAC7B,yBAAyB;IACzB,MAAM,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,EAAE,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAAC;CAC1E;AAID;;;;GAIG;AACH,qBAAa,MAAO,YAAW,eAAe;aAO1B,gBAAgB,EAAE,SAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAP1B,KAAK,iIAAyB;IAE9B,YAAY,4HAAqB;IACjC,eAAe,uEAA4C;gBAGzC,gBAAgB,EAAE,SAAS,EAC1B,OAAO,EAAE,cAAc;IAGpC,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC;CAgDrH"}

package/packages/jam/jam-host-calls/general/lookup.js

@@ -0,0 +1,64 @@
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { minU64, tryAsU64 } from "#@typeberry/numbers";
+import { PvmExecution, traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { safeAllocUint8Array } from "#@typeberry/utils";
+import { logger } from "../logger.js";
+import { getServiceIdOrCurrent } from "../utils.js";
+import { HostCallResult } from "./results.js";
+const IN_OUT_REG = 7;
+/**
+ * Lookup a preimage.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/329902329902?v=0.6.7
+ */
+export class Lookup {
+    currentServiceId;
+    account;
+    index = tryAsHostCallIndex(2);
+    basicGasCost = tryAsSmallGas(10);
+    tracedRegisters = traceRegisters(IN_OUT_REG, 8, 9, 10, 11);
+    constructor(currentServiceId, account) {
+        this.currentServiceId = currentServiceId;
+        this.account = account;
+    }
+    async execute(_gas, regs, memory) {
+        // a
+        const serviceId = getServiceIdOrCurrent(IN_OUT_REG, regs, this.currentServiceId);
+        // h
+        const hashAddress = regs.get(8);
+        // o
+        const destinationAddress = regs.get(9);
+        const preImageHash = Bytes.zero(HASH_SIZE);
+        const memoryReadResult = memory.loadInto(preImageHash.raw, hashAddress);
+        if (memoryReadResult.isError) {
+            logger.trace `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- PANIC`;
+            return PvmExecution.Panic;
+        }
+        // v
+        const preImage = this.account.lookup(serviceId, preImageHash);
+        logger.trace `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage?.toStringTruncated() ?? "<missing>"}...`;
+        logger.insane `[${this.currentServiceId}] LOOKUP(${serviceId}, ${preImageHash}) <- ${preImage ?? "<missing>"}`;
+        const preImageLength = preImage === null ? tryAsU64(0) : tryAsU64(preImage.raw.length);
+        const preimageBlobOffset = regs.get(10);
+        const lengthToWrite = regs.get(11);
+        // f
+        const offset = minU64(preimageBlobOffset, preImageLength);
+        // l
+        const length = minU64(lengthToWrite, tryAsU64(preImageLength - offset));
+        // NOTE [MaSo] this is ok to cast to number, because we are bounded by the
+        // valueLength in both cases and valueLength is WC (4,000,000,000) + metadata
+        // which is less than 2^32
+        const chunk = preImage === null ? safeAllocUint8Array(0) : preImage.raw.subarray(Number(offset), Number(offset + length));
+        const memoryWriteResult = memory.storeFrom(destinationAddress, chunk);
+        if (memoryWriteResult.isError) {
+            return PvmExecution.Panic;
+        }
+        if (preImage === null) {
+            regs.set(IN_OUT_REG, HostCallResult.NONE);
+            return;
+        }
+        regs.set(IN_OUT_REG, preImageLength);
+    }
+}

package/packages/jam/jam-host-calls/general/lookup.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=lookup.test.d.ts.map

package/packages/jam/jam-host-calls/general/lookup.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lookup.test.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/general/lookup.test.ts"],"names":[],"mappings":""}