@typeberry/lib 0.5.1-aff8b4f → 0.5.1-eb84786

package/packages/jam/jam-host-calls/accumulate/solicit.js

@@ -0,0 +1,53 @@
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { PvmExecution, traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { assertNever, resultToString } from "#@typeberry/utils";
+import { RequestPreimageError } from "../externalities/partial-state.js";
+import { HostCallResult } from "../general/results.js";
+import { logger } from "../logger.js";
+const IN_OUT_REG = 7;
+/**
+ * Request a preimage to be available.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/383b00383b00?v=0.6.7
+ */
+export class Solicit {
+    currentServiceId;
+    partialState;
+    index = tryAsHostCallIndex(23);
+    basicGasCost = tryAsSmallGas(10);
+    tracedRegisters = traceRegisters(IN_OUT_REG, 8);
+    constructor(currentServiceId, partialState) {
+        this.currentServiceId = currentServiceId;
+        this.partialState = partialState;
+    }
+    async execute(_gas, regs, memory) {
+        // `o`
+        const hashStart = regs.get(IN_OUT_REG);
+        // `z`
+        const length = regs.get(8);
+        const hash = Bytes.zero(HASH_SIZE);
+        const memoryReadResult = memory.loadInto(hash.raw, hashStart);
+        if (memoryReadResult.isError) {
+            logger.trace `[${this.currentServiceId}] SOLICIT(${hash}, ${length}) <- PANIC`;
+            return PvmExecution.Panic;
+        }
+        const result = this.partialState.requestPreimage(hash.asOpaque(), length);
+        logger.trace `[${this.currentServiceId}] SOLICIT(${hash}, ${length}) <- ${resultToString(result)}`;
+        if (result.isOk) {
+            regs.set(IN_OUT_REG, HostCallResult.OK);
+            return;
+        }
+        const e = result.error;
+        if (e === RequestPreimageError.AlreadyAvailable || e === RequestPreimageError.AlreadyRequested) {
+            regs.set(IN_OUT_REG, HostCallResult.HUH);
+            return;
+        }
+        if (e === RequestPreimageError.InsufficientFunds) {
+            regs.set(IN_OUT_REG, HostCallResult.FULL);
+            return;
+        }
+        assertNever(e);
+    }
+}

package/packages/jam/jam-host-calls/accumulate/solicit.test.d.ts

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

package/packages/jam/jam-host-calls/accumulate/solicit.test.d.ts.map

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

package/packages/jam/jam-host-calls/accumulate/solicit.test.js

@@ -0,0 +1,99 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceId } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { 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/gas.js";
+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 { Result } from "#@typeberry/utils";
+import { RequestPreimageError } from "../externalities/partial-state.js";
+import { PartialStateMock } from "../externalities/partial-state-mock.js";
+import { HostCallResult } from "../general/results.js";
+import { emptyRegistersBuffer } from "../utils.js";
+import { Solicit } from "./solicit.js";
+const gas = gasCounter(tryAsGas(0));
+const RESULT_REG = 7;
+const HASH_START_REG = 7;
+const LENGTH_REG = 8;
+function prepareRegsAndMemory(preimageHash, preimageLength, { skipPreimageHash = false } = {}) {
+    const memStart = 2 ** 16;
+    const registers = new HostCallRegisters(emptyRegistersBuffer());
+    registers.set(HASH_START_REG, tryAsU64(memStart));
+    registers.set(LENGTH_REG, preimageLength);
+    const builder = new MemoryBuilder();
+    if (!skipPreimageHash) {
+        builder.setReadablePages(tryAsMemoryIndex(memStart), tryAsMemoryIndex(memStart + PAGE_SIZE), preimageHash.raw);
+    }
+    const memory = new HostCallMemory(builder.finalize(tryAsMemoryIndex(0), tryAsSbrkIndex(0)));
+    return {
+        registers,
+        memory,
+    };
+}
+describe("HostCalls: Solicit", () => {
+    it("should request a preimage hash", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const solicit = new Solicit(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(4_096));
+        // when
+        await solicit.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.OK);
+        assert.deepStrictEqual(accumulate.requestPreimageData, [[Bytes.fill(HASH_SIZE, 0x69), 4096n]]);
+    });
+    it("should fail if hash not available", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const solicit = new Solicit(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(4_096), {
+            skipPreimageHash: true,
+        });
+        // when
+        const result = await solicit.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(result, PvmExecution.Panic);
+        assert.deepStrictEqual(accumulate.requestPreimageData, []);
+    });
+    it("should fail if already requested", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const solicit = new Solicit(currentServiceId, accumulate);
+        accumulate.requestPreimageResponse = Result.error(RequestPreimageError.AlreadyRequested, () => "Test: preimage already requested for solicit");
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(4_096));
+        // when
+        await solicit.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.HUH);
+        assert.deepStrictEqual(accumulate.requestPreimageData, [[Bytes.fill(HASH_SIZE, 0x69), 4096n]]);
+    });
+    it("should fail if already available", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const solicit = new Solicit(currentServiceId, accumulate);
+        accumulate.requestPreimageResponse = Result.error(RequestPreimageError.AlreadyAvailable, () => "Test: preimage already available for solicit");
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(4_096));
+        // when
+        await solicit.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.HUH);
+        assert.deepStrictEqual(accumulate.requestPreimageData, [[Bytes.fill(HASH_SIZE, 0x69), 4096n]]);
+    });
+    it("should fail if balance too low", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const solicit = new Solicit(currentServiceId, accumulate);
+        accumulate.requestPreimageResponse = Result.error(RequestPreimageError.InsufficientFunds, () => "Test: insufficient funds for solicit");
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(4_096));
+        // when
+        await solicit.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.FULL);
+        assert.deepStrictEqual(accumulate.requestPreimageData, [[Bytes.fill(HASH_SIZE, 0x69), 4096n]]);
+    });
+});

package/packages/jam/jam-host-calls/accumulate/transfer.d.ts

@@ -0,0 +1,30 @@
+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 { type PartialState } from "../externalities/partial-state.js";
+/**
+ * Transfer balance from one service account to another.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/373f00373f00?v=0.7.2
+ */
+export declare class Transfer implements HostCallHandler {
+    readonly currentServiceId: ServiceId;
+    private readonly partialState;
+    index: number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"HostCallIndex[U32]">;
+    /**
+     * `g = 10 + t`
+     *
+     * `t` has positive value, only when status of a transfer is `OK`
+     * `0` otherwise
+     *
+     * Pre0.7.2: `g = 10 + ω9`
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/373f00373f00?v=0.7.2
+     */
+    basicGasCost: (number & import("@typeberry/numbers").WithBytesRepresentation<4> & import("@typeberry/utils").WithOpaque<"SmallGas[U32]">) | ((regs: HostCallRegisters) => import("@typeberry/pvm-interface").Gas);
+    tracedRegisters: (number & import("@typeberry/utils").WithOpaque<"register index">)[];
+    constructor(currentServiceId: ServiceId, partialState: PartialState);
+    execute(gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined | PvmExecution>;
+}
+//# sourceMappingURL=transfer.d.ts.map

package/packages/jam/jam-host-calls/accumulate/transfer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/accumulate/transfer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAmB,MAAM,kBAAkB,CAAC;AAEnE,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,EAA2B,MAAM,0BAA0B,CAAC;AAErF,OAAO,EAAE,KAAK,YAAY,EAAsC,MAAM,mCAAmC,CAAC;AAU1G;;;;GAIG;AACH,qBAAa,QAAS,YAAW,eAAe;aAmB5B,gBAAgB,EAAE,SAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAnB/B,KAAK,iIAA0B;IAC/B;;;;;;;;;OASG;IACH,YAAY,wIAED,iBAAiB,6CAAoD;IAEhF,eAAe,uEAAgF;gBAG7E,gBAAgB,EAAE,SAAS,EAC1B,YAAY,EAAE,YAAY;IAGvC,OAAO,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC;CAsDpH"}

package/packages/jam/jam-host-calls/accumulate/transfer.js

@@ -0,0 +1,86 @@
+import { tryAsServiceGas } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { PvmExecution, traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsGas, tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { assertNever, Compatibility, GpVersion, resultToString } from "#@typeberry/utils";
+import { TRANSFER_MEMO_BYTES, TransferError } from "../externalities/partial-state.js";
+import { HostCallResult } from "../general/results.js";
+import { logger } from "../logger.js";
+import { getServiceId } from "../utils.js";
+const IN_OUT_REG = 7; // `d`
+const AMOUNT_REG = 8; // `a`
+const TRANSFER_GAS_FEE_REG = 9; // `l`
+const MEMO_START_REG = 10; // `o`
+/**
+ * Transfer balance from one service account to another.
+ *
+ * https://graypaper.fluffylabs.dev/#/ab2cdbd/373f00373f00?v=0.7.2
+ */
+export class Transfer {
+    currentServiceId;
+    partialState;
+    index = tryAsHostCallIndex(20);
+    /**
+     * `g = 10 + t`
+     *
+     * `t` has positive value, only when status of a transfer is `OK`
+     * `0` otherwise
+     *
+     * Pre0.7.2: `g = 10 + ω9`
+     *
+     * https://graypaper.fluffylabs.dev/#/ab2cdbd/373f00373f00?v=0.7.2
+     */
+    basicGasCost = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)
+        ? tryAsSmallGas(10)
+        : (regs) => tryAsGas(10n + regs.get(TRANSFER_GAS_FEE_REG));
+    tracedRegisters = traceRegisters(IN_OUT_REG, AMOUNT_REG, TRANSFER_GAS_FEE_REG, MEMO_START_REG);
+    constructor(currentServiceId, partialState) {
+        this.currentServiceId = currentServiceId;
+        this.partialState = partialState;
+    }
+    async execute(gas, regs, memory) {
+        // `d`: destination
+        const destination = getServiceId(regs.get(IN_OUT_REG));
+        // `a`: amount
+        const amount = regs.get(AMOUNT_REG);
+        // `l`: gas
+        const transferGasFee = tryAsServiceGas(regs.get(TRANSFER_GAS_FEE_REG));
+        // `o`: transfer memo
+        const memoStart = regs.get(MEMO_START_REG);
+        const memo = Bytes.zero(TRANSFER_MEMO_BYTES);
+        const memoryReadResult = memory.loadInto(memo.raw, memoStart);
+        // page fault while reading the memory.
+        if (memoryReadResult.isError) {
+            logger.trace `[${this.currentServiceId}] TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- PANIC`;
+            return PvmExecution.Panic;
+        }
+        const transferResult = this.partialState.transfer(destination, amount, transferGasFee, memo);
+        logger.trace `[${this.currentServiceId}] TRANSFER(${destination}, ${amount}, ${transferGasFee}, ${memo}) <- ${resultToString(transferResult)}`;
+        // All good!
+        if (transferResult.isOk) {
+            if (Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)) {
+                // substracting value `t`
+                const underflow = gas.sub(tryAsGas(transferGasFee));
+                if (underflow) {
+                    return PvmExecution.OOG;
+                }
+            }
+            regs.set(IN_OUT_REG, HostCallResult.OK);
+            return;
+        }
+        const e = transferResult.error;
+        if (e === TransferError.DestinationNotFound) {
+            regs.set(IN_OUT_REG, HostCallResult.WHO);
+            return;
+        }
+        if (e === TransferError.GasTooLow) {
+            regs.set(IN_OUT_REG, HostCallResult.LOW);
+            return;
+        }
+        if (e === TransferError.BalanceBelowThreshold) {
+            regs.set(IN_OUT_REG, HostCallResult.CASH);
+            return;
+        }
+        assertNever(e);
+    }
+}

package/packages/jam/jam-host-calls/accumulate/transfer.test.d.ts

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

package/packages/jam/jam-host-calls/accumulate/transfer.test.d.ts.map

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

package/packages/jam/jam-host-calls/accumulate/transfer.test.js

@@ -0,0 +1,166 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceId } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { tryAsU64 } from "#@typeberry/numbers";
+import { HostCallMemory, HostCallRegisters, PvmExecution } from "#@typeberry/pvm-host-calls";
+import { tryAsGas } from "#@typeberry/pvm-interface";
+import { MemoryBuilder } from "#@typeberry/pvm-interpreter";
+import { gasCounter } from "#@typeberry/pvm-interpreter/gas.js";
+import { 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 { Compatibility, GpVersion, Result } from "#@typeberry/utils";
+import { TRANSFER_MEMO_BYTES, TransferError } from "../externalities/partial-state.js";
+import { PartialStateMock } from "../externalities/partial-state-mock.js";
+import { HostCallResult } from "../general/results.js";
+import { emptyRegistersBuffer } from "../utils.js";
+import { Transfer } from "./transfer.js";
+const RESULT_REG = 7;
+const DESTINATION_REG = 7;
+const AMOUNT_REG = 8; // `a`
+const ON_TRANSFER_GAS_REG = 9; // `l`
+const MEMO_START_REG = 10; // `o`
+function prepareRegsAndMemory(destination, amount, gas, memo, { skipMemo = false } = {}) {
+    const memStart = 2 ** 16;
+    const registers = new HostCallRegisters(emptyRegistersBuffer());
+    registers.set(DESTINATION_REG, tryAsU64(destination));
+    registers.set(AMOUNT_REG, amount);
+    registers.set(ON_TRANSFER_GAS_REG, gas);
+    registers.set(MEMO_START_REG, tryAsU64(memStart));
+    const builder = new MemoryBuilder();
+    if (!skipMemo) {
+        builder.setReadablePages(tryAsMemoryIndex(memStart), tryAsMemoryIndex(memStart + PAGE_SIZE), memo.raw);
+    }
+    const memory = new HostCallMemory(builder.finalize(tryAsMemoryIndex(0), tryAsSbrkIndex(0)));
+    return {
+        registers,
+        memory,
+    };
+}
+describe("HostCalls: Transfer", () => {
+    const itPost072 = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? it : it.skip;
+    it("should perform a transfer to self?", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(transfer.currentServiceId, tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33));
+        const gas = gasCounter(tryAsGas(10_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = 8990n;
+        // when
+        gas.sub(basicGasCost);
+        await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.OK);
+        assert.deepStrictEqual(accumulate.transferData, [
+            [transfer.currentServiceId, 2n ** 45n, 1000n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)],
+        ]);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+    it("should perform a transfer to different account", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(tryAsServiceId(15_000), tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33));
+        const gas = gasCounter(tryAsGas(10_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = 8990n;
+        // when
+        gas.sub(basicGasCost);
+        await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.OK);
+        assert.deepStrictEqual(accumulate.transferData, [[15_000, 2n ** 45n, 1000n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+    itPost072("should OOG if gas is too low", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(tryAsServiceId(15_000), tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33));
+        const gas = gasCounter(tryAsGas(1_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = 0n;
+        // when
+        gas.sub(basicGasCost);
+        const result = await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(result, PvmExecution.OOG);
+        assert.deepStrictEqual(accumulate.transferData, [[15_000, 2n ** 45n, 1000n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+    it("should fail if there is no memory for memo", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(tryAsServiceId(15_000), tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33), { skipMemo: true });
+        const gas = gasCounter(tryAsGas(10_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9990n : 8990n;
+        // when
+        gas.sub(basicGasCost);
+        const result = await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(result, PvmExecution.Panic);
+        assert.deepStrictEqual(accumulate.transferData, []);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+    it("should fail if gas is too low", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(tryAsServiceId(15_000), tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33));
+        const gas = gasCounter(tryAsGas(10_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9990n : 8990n;
+        // when
+        gas.sub(basicGasCost);
+        accumulate.transferReturnValue = Result.error(TransferError.GasTooLow, () => "Test: gas too low for transfer");
+        await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.LOW);
+        assert.deepStrictEqual(accumulate.transferData, Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)
+            ? [[15_000, 2n ** 45n, 0n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]
+            : [[15_000, 2n ** 45n, 1000n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+    it("should fail if amount is too big", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(tryAsServiceId(15_000), tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33));
+        const gas = gasCounter(tryAsGas(10_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9990n : 8990n;
+        // when
+        gas.sub(basicGasCost);
+        accumulate.transferReturnValue = Result.error(TransferError.BalanceBelowThreshold, () => "Test: balance below threshold for transfer");
+        await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.CASH);
+        assert.deepStrictEqual(accumulate.transferData, Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)
+            ? [[15_000, 2n ** 45n, 0n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]
+            : [[15_000, 2n ** 45n, 1000n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+    it("should fail if destination does not exist", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const transfer = new Transfer(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(tryAsServiceId(15_000), tryAsU64(2n ** 45n), tryAsU64(1000n), Bytes.fill(TRANSFER_MEMO_BYTES, 33));
+        const gas = gasCounter(tryAsGas(10_000));
+        const basicGasCost = typeof transfer.basicGasCost === "number" ? transfer.basicGasCost : transfer.basicGasCost(registers);
+        const expectedGas = Compatibility.isGreaterOrEqual(GpVersion.V0_7_2) ? 9990n : 8990n;
+        // when
+        gas.sub(basicGasCost);
+        accumulate.transferReturnValue = Result.error(TransferError.DestinationNotFound, () => "Test: destination not found for transfer");
+        await transfer.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.WHO);
+        assert.deepStrictEqual(accumulate.transferData, Compatibility.isGreaterOrEqual(GpVersion.V0_7_2)
+            ? [[15_000, 2n ** 45n, 0n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]
+            : [[15_000, 2n ** 45n, 1000n, Bytes.fill(TRANSFER_MEMO_BYTES, 33)]]);
+        assert.deepStrictEqual(gas.get(), expectedGas);
+    });
+});

package/packages/jam/jam-host-calls/accumulate/upgrade.d.ts

@@ -0,0 +1,20 @@
+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 type { PartialState } from "../externalities/partial-state.js";
+/**
+ * Upgrade the code of the service.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/36d00336d003?v=0.6.7
+ */
+export declare class Upgrade implements HostCallHandler {
+    readonly currentServiceId: ServiceId;
+    private readonly partialState;
+    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, partialState: PartialState);
+    execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<undefined | PvmExecution>;
+}
+//# sourceMappingURL=upgrade.d.ts.map

package/packages/jam/jam-host-calls/accumulate/upgrade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upgrade.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/accumulate/upgrade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,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,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAQtE;;;;GAIG;AACH,qBAAa,OAAQ,YAAW,eAAe;aAM3B,gBAAgB,EAAE,SAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAN/B,KAAK,iIAA0B;IAC/B,YAAY,4HAAqB;IACjC,eAAe,uEAAsD;gBAGnD,gBAAgB,EAAE,SAAS,EAC1B,YAAY,EAAE,YAAY;IAGvC,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,SAAS,GAAG,YAAY,CAAC;CAqBrH"}

package/packages/jam/jam-host-calls/accumulate/upgrade.js

@@ -0,0 +1,43 @@
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { PvmExecution, traceRegisters, tryAsHostCallIndex } from "#@typeberry/pvm-host-calls";
+import { tryAsSmallGas } from "#@typeberry/pvm-interface";
+import { HostCallResult } from "../general/results.js";
+import { logger } from "../logger.js";
+const IN_OUT_REG = 7; // `o`
+const GAS_REG = 8; // `g`
+const ALLOWANCE_REG = 9; // `m`
+/**
+ * Upgrade the code of the service.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/36d00336d003?v=0.6.7
+ */
+export class Upgrade {
+    currentServiceId;
+    partialState;
+    index = tryAsHostCallIndex(19);
+    basicGasCost = tryAsSmallGas(10);
+    tracedRegisters = traceRegisters(IN_OUT_REG, GAS_REG, ALLOWANCE_REG);
+    constructor(currentServiceId, partialState) {
+        this.currentServiceId = currentServiceId;
+        this.partialState = partialState;
+    }
+    async execute(_gas, regs, memory) {
+        // `o`
+        const codeHashStart = regs.get(IN_OUT_REG);
+        // `g`
+        const gas = regs.get(GAS_REG);
+        // `m`
+        const allowance = regs.get(ALLOWANCE_REG);
+        // `c`
+        const codeHash = Bytes.zero(HASH_SIZE);
+        const memoryReadResult = memory.loadInto(codeHash.raw, codeHashStart);
+        if (memoryReadResult.isError) {
+            logger.trace `[${this.currentServiceId}] UPGRADE(${codeHash}, ${gas}, ${allowance}) <- PANIC`;
+            return PvmExecution.Panic;
+        }
+        this.partialState.upgradeService(codeHash.asOpaque(), gas, allowance);
+        logger.trace `[${this.currentServiceId}] UPGRADE(${codeHash}, ${gas}, ${allowance})`;
+        regs.set(IN_OUT_REG, HostCallResult.OK);
+    }
+}

package/packages/jam/jam-host-calls/accumulate/upgrade.test.d.ts

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

package/packages/jam/jam-host-calls/accumulate/upgrade.test.d.ts.map

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

package/packages/jam/jam-host-calls/accumulate/upgrade.test.js

@@ -0,0 +1,61 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import { tryAsServiceId } from "#@typeberry/block";
+import { Bytes } from "#@typeberry/bytes";
+import { HASH_SIZE } from "#@typeberry/hash";
+import { 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/gas.js";
+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 { PartialStateMock } from "../externalities/partial-state-mock.js";
+import { HostCallResult } from "../general/results.js";
+import { emptyRegistersBuffer } from "../utils.js";
+import { Upgrade } from "./upgrade.js";
+const gas = gasCounter(tryAsGas(0));
+const RESULT_REG = 7;
+const CODE_HASH_START_REG = 7;
+const GAS_REG = 8;
+const BALANCE_REG = 9;
+function prepareRegsAndMemory(codeHash, gas, balance, { skipCodeHash = false } = {}) {
+    const memStart = 2 ** 16;
+    const registers = new HostCallRegisters(emptyRegistersBuffer());
+    registers.set(CODE_HASH_START_REG, tryAsU64(memStart));
+    registers.set(GAS_REG, gas);
+    registers.set(BALANCE_REG, balance);
+    const builder = new MemoryBuilder();
+    if (!skipCodeHash) {
+        builder.setReadablePages(tryAsMemoryIndex(memStart), tryAsMemoryIndex(memStart + PAGE_SIZE), codeHash.raw);
+    }
+    const memory = new HostCallMemory(builder.finalize(tryAsMemoryIndex(0), tryAsSbrkIndex(0)));
+    return {
+        registers,
+        memory,
+    };
+}
+describe("HostCalls: Upgrade", () => {
+    it("should upgrade a service", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const upgrade = new Upgrade(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(2n ** 40n), tryAsU64(2n ** 50n));
+        // when
+        await upgrade.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(registers.get(RESULT_REG), HostCallResult.OK);
+        assert.deepStrictEqual(accumulate.upgradeData, [[Bytes.fill(HASH_SIZE, 0x69), 2n ** 40n, 2n ** 50n]]);
+    });
+    it("should fail when code not readable", async () => {
+        const accumulate = new PartialStateMock();
+        const currentServiceId = tryAsServiceId(10_000);
+        const upgrade = new Upgrade(currentServiceId, accumulate);
+        const { registers, memory } = prepareRegsAndMemory(Bytes.fill(HASH_SIZE, 0x69).asOpaque(), tryAsU64(2n ** 40n), tryAsU64(2n ** 50n), { skipCodeHash: true });
+        // when
+        const result = await upgrade.execute(gas, registers, memory);
+        // then
+        assert.deepStrictEqual(result, PvmExecution.Panic);
+        assert.deepStrictEqual(accumulate.upgradeData, []);
+    });
+});

package/packages/jam/jam-host-calls/accumulate/yield.d.ts

@@ -0,0 +1,19 @@
+import type { ServiceId } from "#@typeberry/block";
+import { type HostCallHandler, type HostCallMemory, type HostCallRegisters, PvmExecution } from "#@typeberry/pvm-host-calls";
+import { type IGasCounter } from "#@typeberry/pvm-interface";
+import type { PartialState } from "../externalities/partial-state.js";
+/**
+ * Yield accumulation trie result.
+ *
+ * https://graypaper.fluffylabs.dev/#/7e6ff6a/381c02381c02?v=0.6.7
+ */
+export declare class Yield implements HostCallHandler {
+    readonly currentServiceId: ServiceId;
+    private readonly partialState;
+    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, partialState: PartialState);
+    execute(_gas: IGasCounter, regs: HostCallRegisters, memory: HostCallMemory): Promise<PvmExecution | undefined>;
+}
+//# sourceMappingURL=yield.d.ts.map

package/packages/jam/jam-host-calls/accumulate/yield.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yield.d.ts","sourceRoot":"","sources":["../../../../../../packages/jam/jam-host-calls/accumulate/yield.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAGlD,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,YAAY,EAGb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,KAAK,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAMtE;;;;GAIG;AACH,qBAAa,KAAM,YAAW,eAAe;aAMzB,gBAAgB,EAAE,SAAS;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY;IAN/B,KAAK,iIAA0B;IAC/B,YAAY,4HAAqB;IACjC,eAAe,uEAA8B;gBAG3B,gBAAgB,EAAE,SAAS,EAC1B,YAAY,EAAE,YAAY;IAGvC,OAAO,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,iBAAiB,EAAE,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC;CAgBrH"}