@proto-kit/module 0.1.1-develop.600 → 0.1.1-develop.833

package/dist/test/TestingRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestingRuntime.d.ts","sourceRoot":"","sources":["../../test/TestingRuntime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIlD,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAE7E,wBAAgB,oBAAoB,CAAC,OAAO,SAAS,oBAAoB,EACvE,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAgCA"}

package/dist/test/TestingRuntime.js

@@ -0,0 +1,29 @@
+import { StateServiceProvider } from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { InMemoryStateService, Runtime } from "../src";
+export function createTestingRuntime(modules, config) {
+    const state = new InMemoryStateService();
+    const Runtimeclass = Runtime.from({
+        modules,
+    });
+    const runtime = new Runtimeclass();
+    runtime.configure(config);
+    runtime.create(() => container.createChildContainer());
+    runtime.dependencyContainer.register("AreProofsEnabled", {
+        useValue: {
+            areProofsEnabled: false,
+            setProofsEnabled(areProofsEnabled) {
+                this.areProofsEnabled = areProofsEnabled;
+            },
+        },
+    });
+    runtime.registerValue({
+        StateServiceProvider: new StateServiceProvider(),
+        Runtime: runtime,
+    });
+    runtime.stateServiceProvider.setCurrentStateService(state);
+    return {
+        runtime,
+        state,
+    };
+}

package/dist/test/method/runtimeMethod.test.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=runtimeMethod.test.d.ts.map

package/dist/test/method/runtimeMethod.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeMethod.test.d.ts","sourceRoot":"","sources":["../../../test/method/runtimeMethod.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/method/runtimeMethod.test.js

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+import { Bool, Field } from "o1js";
+import { Option, StateTransition } from "@proto-kit/protocol";
+import { toStateTransitionsHash } from "../../src/method/runtimeMethod";
+describe.skip("toStateTransitionsHash", () => {
+    const noneStateTransition = StateTransition.from(Field(0), new Option(Bool(false), Field(0), Field));
+    const someStateTransition = StateTransition.from(Field(0), new Option(Bool(true), Field(0), Field));
+    it.each([
+        [
+            [noneStateTransition],
+            "7067243248312463521220230733411703436580237248681301130001246160136823979683",
+        ],
+        [
+            [someStateTransition],
+            "12841542804403638489097503092490970035615082088155587790175618374946575398395",
+        ],
+        [
+            [noneStateTransition, someStateTransition],
+            "20641278138648130746922286021889771603940136555847557324578879341962747943601",
+        ],
+        [
+            [someStateTransition, noneStateTransition],
+            "10362098987098600767020985423446775093761176563902435645494178193997179006954",
+        ],
+    ])("should calculate a hash of all provided state transitions", (stateTransitions, expectedHash) => {
+        expect.assertions(1);
+        const hash = toStateTransitionsHash(stateTransitions).toString();
+        expect(hash).toBe(expectedHash);
+    });
+});

package/dist/test/modules/Admin.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from "o1js";
+import { RuntimeModule } from "../../src/runtime/RuntimeModule.js";
+interface AdminConfig {
+    publicKey: string;
+}
+export declare class Admin extends RuntimeModule<AdminConfig> {
+    isAdmin(publicKey: PublicKey): void;
+}
+export {};
+//# sourceMappingURL=Admin.d.ts.map

package/dist/test/modules/Admin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Admin.d.ts","sourceRoot":"","sources":["../../../test/modules/Admin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAIjC,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAGnE,UAAU,WAAW;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,qBACa,KAAM,SAAQ,aAAa,CAAC,WAAW,CAAC;IAE5C,OAAO,CAAC,SAAS,EAAE,SAAS;CAIpC"}

package/dist/test/modules/Admin.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { PublicKey } from "o1js";
+import { assert } from "@proto-kit/protocol";
+import { runtimeModule } from "../../src/module/decorator.js";
+import { RuntimeModule } from "../../src/runtime/RuntimeModule.js";
+import { runtimeMethod } from "../../src/method/runtimeMethod.js";
+export let Admin = class Admin extends RuntimeModule {
+    isAdmin(publicKey) {
+        const admin = PublicKey.empty().toConstant();
+        assert(admin.equals(publicKey));
+    }
+};
+__decorate([
+    runtimeMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PublicKey]),
+    __metadata("design:returntype", void 0)
+], Admin.prototype, "isAdmin", null);
+Admin = __decorate([
+    runtimeModule()
+], Admin);

package/dist/test/modules/Balances.d.ts

@@ -0,0 +1,23 @@
+import { PublicKey, UInt64 } from "o1js";
+import { State, StateMap } from "@proto-kit/protocol";
+import { RuntimeModule } from "../../src";
+import { Admin } from "./Admin.js";
+interface BalancesConfig {
+}
+export declare class Balances extends RuntimeModule<BalancesConfig> {
+    admin: Admin;
+    /**
+     * We use `satisfies` here in order to be able to access
+     * presets by key in a type safe way.
+     */
+    static presets: {};
+    totalSupply: State<UInt64>;
+    balances: StateMap<PublicKey, UInt64>;
+    constructor(admin: Admin);
+    getTotalSupply(): void;
+    setTotalSupply(): void;
+    getBalance(address: PublicKey): void;
+    transientState(): void;
+}
+export {};
+//# sourceMappingURL=Balances.d.ts.map

package/dist/test/modules/Balances.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Balances.d.ts","sourceRoot":"","sources":["../../../test/modules/Balances.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGtD,OAAO,EAAE,aAAa,EAAuC,MAAM,WAAW,CAAC;AAE/E,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,UAAU,cAAc;CAAG;AAE3B,qBACa,QAAS,SAAQ,aAAa,CAAC,cAAc,CAAC;IAc/B,KAAK,EAAE,KAAK;IAbtC;;;OAGG;IACH,OAAc,OAAO,KAAwC;IAE7C,WAAW,gBAA8B;IAEzC,QAAQ,8BAGtB;gBAEwB,KAAK,EAAE,KAAK;IAK/B,cAAc;IAKd,cAAc;IAMd,UAAU,CAAC,OAAO,EAAE,SAAS;IAK7B,cAAc;CAOtB"}

package/dist/test/modules/Balances.js

@@ -0,0 +1,98 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { PublicKey, UInt64 } from "o1js";
+import { State, StateMap } from "@proto-kit/protocol";
+import { RuntimeModule, runtimeMethod, runtimeModule, state } from "../../src";
+import { Admin } from "./Admin.js";
+export let Balances = class Balances extends RuntimeModule {
+    constructor(admin) {
+        super();
+        Object.defineProperty(this, "admin", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: admin
+        });
+        Object.defineProperty(this, "totalSupply", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: State.from(UInt64)
+        });
+        Object.defineProperty(this, "balances", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: StateMap.from(PublicKey, UInt64)
+        });
+    }
+    getTotalSupply() {
+        this.totalSupply.get();
+    }
+    setTotalSupply() {
+        this.totalSupply.set(UInt64.from(20));
+        this.admin.isAdmin(this.transaction.sender.value);
+    }
+    getBalance(address) {
+        this.balances.get(address).orElse(UInt64.zero);
+    }
+    transientState() {
+        const totalSupply = this.totalSupply.get();
+        this.totalSupply.set(totalSupply.orElse(UInt64.zero).add(100));
+        const totalSupply2 = this.totalSupply.get();
+        this.totalSupply.set(totalSupply2.orElse(UInt64.zero).add(100));
+    }
+};
+/**
+ * We use `satisfies` here in order to be able to access
+ * presets by key in a type safe way.
+ */
+Object.defineProperty(Balances, "presets", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {}
+});
+__decorate([
+    state(),
+    __metadata("design:type", Object)
+], Balances.prototype, "totalSupply", void 0);
+__decorate([
+    state(),
+    __metadata("design:type", Object)
+], Balances.prototype, "balances", void 0);
+__decorate([
+    runtimeMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Balances.prototype, "getTotalSupply", null);
+__decorate([
+    runtimeMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Balances.prototype, "setTotalSupply", null);
+__decorate([
+    runtimeMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [PublicKey]),
+    __metadata("design:returntype", void 0)
+], Balances.prototype, "getBalance", null);
+__decorate([
+    runtimeMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Balances.prototype, "transientState", null);
+Balances = __decorate([
+    runtimeModule(),
+    __metadata("design:paramtypes", [Admin])
+], Balances);

package/dist/test/modules/Balances.test.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=Balances.test.d.ts.map

package/dist/test/modules/Balances.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Balances.test.d.ts","sourceRoot":"","sources":["../../../test/modules/Balances.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/modules/Balances.test.js

@@ -0,0 +1,201 @@
+import "reflect-metadata";
+import { Field, Poseidon, PrivateKey, PublicKey, UInt64 } from "o1js";
+import { container } from "tsyringe";
+import { Path, RuntimeMethodExecutionContext, RuntimeTransaction, NetworkState, } from "@proto-kit/protocol";
+import { createTestingRuntime } from "../TestingRuntime";
+import { Balances } from "./Balances.js";
+import { Admin } from "./Admin.js";
+describe("balances", () => {
+    let balances;
+    let state;
+    let runtime;
+    function getStateValue(path) {
+        if (!path) {
+            throw new Error("Path not found");
+        }
+        const stateValue = state.get(path);
+        if (!stateValue) {
+            throw new Error("stateValue is undefined");
+        }
+        return stateValue;
+    }
+    function createChain() {
+        ({ runtime, state } = createTestingRuntime({
+            Balances,
+            Admin,
+        }, {
+            Admin: {
+                publicKey: PublicKey.empty().toBase58(),
+            },
+            Balances: {},
+        }));
+        balances = runtime.resolve("Balances");
+        state.set(balances.totalSupply.path, UInt64.from(10).toFields());
+    }
+    describe.skip("compile and prove", () => {
+        beforeAll(createChain);
+        // Disabled until we implement a mechanism to enable/disable compiling tests
+        it("should compile and prove a method execution", async () => {
+            expect.assertions(3);
+            runtime.zkProgrammable.appChain?.setProofsEnabled(true);
+            const executionContext = container.resolve(RuntimeMethodExecutionContext);
+            executionContext.setup({
+                transaction: RuntimeTransaction.dummyTransaction(),
+                networkState: NetworkState.empty(),
+            });
+            const expectedStateTransitionsHash = "1439144406936083177718146178121957896974210157062549589517697792374542035761";
+            const expectedStatus = true;
+            await runtime.zkProgrammable.zkProgram.compile();
+            balances.getTotalSupply();
+            const { result } = executionContext.current();
+            const proof = await result.prove();
+            const verified = await runtime.zkProgrammable.zkProgram.verify(proof);
+            runtime.zkProgrammable.appChain?.setProofsEnabled(false);
+            expect(verified).toBe(true);
+            expect(proof.publicOutput.stateTransitionsHash.toString()).toStrictEqual(expectedStateTransitionsHash);
+            expect(proof.publicOutput.status.toBoolean()).toBe(expectedStatus);
+        }, 180000);
+    });
+    describe("getTotalSupply", () => {
+        beforeAll(createChain);
+        describe("state transitions", () => {
+            let stateTransitions;
+            beforeEach(() => {
+                const executionContext = container.resolve(RuntimeMethodExecutionContext);
+                executionContext.setup({
+                    transaction: RuntimeTransaction.dummyTransaction(),
+                    networkState: NetworkState.empty(),
+                });
+                balances.getTotalSupply();
+                stateTransitions = executionContext
+                    .current()
+                    .result.stateTransitions.map((stateTransition) => stateTransition.toProvable());
+            });
+            it("should return a single state transition", () => {
+                expect.assertions(1);
+                expect(stateTransitions).toHaveLength(1);
+            });
+            it("should have a state transition for the correct path", () => {
+                expect.assertions(1);
+                const path = Path.fromProperty("Balances", "totalSupply");
+                expect(stateTransitions[0].path.toString()).toStrictEqual(path.toString());
+            });
+            it("should produce a from-only state transition", () => {
+                expect.assertions(3);
+                const [stateTransition] = stateTransitions;
+                const value = UInt64.fromFields(getStateValue(balances.totalSupply.path));
+                const treeValue = Poseidon.hash(value.toFields());
+                expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+                expect(stateTransition.from.value.toString()).toBe(treeValue.toString());
+                expect(stateTransition.to.isSome.toBoolean()).toBe(false);
+            });
+        });
+        describe("state transitions from empty state", () => {
+            let stateTransitions;
+            beforeAll(() => {
+                createChain();
+                state.set(balances.totalSupply.path, undefined);
+            });
+            beforeEach(() => {
+                const executionContext = container.resolve(RuntimeMethodExecutionContext);
+                executionContext.setup({
+                    transaction: RuntimeTransaction.dummyTransaction(),
+                    networkState: NetworkState.empty(),
+                });
+                balances.getTotalSupply();
+                stateTransitions = executionContext
+                    .current()
+                    .result.stateTransitions.map((stateTransition) => stateTransition.toProvable());
+            });
+            it("should return a single state transition", () => {
+                expect.assertions(1);
+                expect(stateTransitions).toHaveLength(1);
+            });
+            it("should have a state transition for the correct path", () => {
+                expect.assertions(1);
+                const path = Path.fromProperty("Balances", "totalSupply");
+                expect(stateTransitions[0].path.toString()).toStrictEqual(path.toString());
+            });
+            it("should produce a from-only state transition", () => {
+                expect.assertions(3);
+                const [stateTransition] = stateTransitions;
+                const treeValue = Field(0);
+                expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+                expect(stateTransition.from.value.toString()).toBe(treeValue.toString());
+                expect(stateTransition.to.isSome.toBoolean()).toBe(false);
+            });
+        });
+    });
+    describe("setTotalSupply", () => {
+        beforeAll(createChain);
+        describe("state transitions", () => {
+            let stateTransitions;
+            beforeEach(() => {
+                const executionContext = container.resolve(RuntimeMethodExecutionContext);
+                executionContext.setup({
+                    transaction: RuntimeTransaction.dummyTransaction(),
+                    networkState: NetworkState.empty(),
+                });
+                balances.setTotalSupply();
+                stateTransitions = executionContext
+                    .current()
+                    .result.stateTransitions.map((stateTransition) => stateTransition.toProvable());
+            });
+            it("should return a single state transition", () => {
+                expect.assertions(1);
+                expect(stateTransitions).toHaveLength(1);
+            });
+            it("should have a state transition for the correct path", () => {
+                expect.assertions(1);
+                const path = Path.fromProperty("Balances", "totalSupply");
+                expect(stateTransitions[0].path.toString()).toStrictEqual(path.toString());
+            });
+            it("should produce a from-to state transition", () => {
+                expect.assertions(4);
+                const [stateTransition] = stateTransitions;
+                const fromValue = UInt64.fromFields(getStateValue(balances.totalSupply.path));
+                const fromTreeValue = Poseidon.hash(fromValue.toFields());
+                const toValue = UInt64.from(20);
+                const toTreeValue = Poseidon.hash(toValue.toFields());
+                expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+                expect(stateTransition.from.value.toString()).toBe(fromTreeValue.toString());
+                expect(stateTransition.to.isSome.toBoolean()).toBe(true);
+                expect(stateTransition.to.value.toString()).toBe(toTreeValue.toString());
+            });
+        });
+    });
+    describe("getBalance", () => {
+        beforeAll(createChain);
+        describe("state transitions", () => {
+            let stateTransitions;
+            const address = PrivateKey.random().toPublicKey();
+            beforeEach(() => {
+                const executionContext = container.resolve(RuntimeMethodExecutionContext);
+                executionContext.setup({
+                    transaction: RuntimeTransaction.dummyTransaction(),
+                    networkState: NetworkState.empty(),
+                });
+                balances.getBalance(address);
+                stateTransitions = executionContext
+                    .current()
+                    .result.stateTransitions.map((stateTransition) => stateTransition.toProvable());
+            });
+            it("should return a single state transition", () => {
+                expect.assertions(1);
+                expect(stateTransitions).toHaveLength(1);
+            });
+            it("should have a state transition for the correct path", () => {
+                expect.assertions(1);
+                const path = Path.fromKey(Path.fromProperty("Balances", "balances"), PublicKey, address);
+                expect(stateTransitions[0].path.toString()).toStrictEqual(path.toString());
+            });
+            it("should produce a from-only state transition, for non-existing state", () => {
+                expect.assertions(3);
+                const [stateTransition] = stateTransitions;
+                expect(stateTransition.from.isSome.toBoolean()).toBe(true);
+                expect(stateTransition.from.value.toString()).toBe(Field(0).toString());
+                expect(stateTransition.to.isSome.toBoolean()).toBe(false);
+            });
+        });
+    });
+});

package/dist/test/modules/MethodIdResolver.test.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=MethodIdResolver.test.d.ts.map

package/dist/test/modules/MethodIdResolver.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MethodIdResolver.test.d.ts","sourceRoot":"","sources":["../../../test/modules/MethodIdResolver.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/modules/MethodIdResolver.test.js

@@ -0,0 +1,67 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import "reflect-metadata";
+import { assert } from "@proto-kit/protocol";
+import { Field } from "o1js";
+import { beforeAll } from "@jest/globals";
+import { container } from "tsyringe";
+import { runtimeMethod, RuntimeModule, runtimeModule } from "../../src";
+import { createTestingRuntime } from "../TestingRuntime";
+import { Balances } from "./Balances";
+let Admin = class Admin extends RuntimeModule {
+    isAdminWithAVeryVeryVeryVeryLongName() {
+        assert(Field(1).equals(Field(1)));
+    }
+};
+__decorate([
+    runtimeMethod(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Admin.prototype, "isAdminWithAVeryVeryVeryVeryLongName", null);
+Admin = __decorate([
+    runtimeModule()
+], Admin);
+describe("methodId", () => {
+    let runtime;
+    let resolver;
+    beforeAll(() => {
+        container.clearInstances();
+        ({ runtime } = createTestingRuntime({
+            Admin,
+            Balance: Balances,
+        }, {
+            Admin: {},
+            Balance: {},
+        }));
+        resolver =
+            runtime.dependencyContainer.resolve("MethodIdResolver");
+    });
+    it.each([
+        ["Admin", "isAdminWithAVeryVeryVeryVeryLongName"],
+        ["Balance", "getTotalSupply"],
+        ["Balance", "getBalance"],
+    ])("should pass and encode correctly", (givenModuleName, givenMethodName) => {
+        expect.assertions(2);
+        const methodId = resolver.getMethodId(givenModuleName, givenMethodName);
+        const [moduleName, methodName] = resolver.getMethodNameFromId(methodId) ?? [
+            undefined,
+            undefined,
+        ];
+        expect(moduleName).toBe(givenModuleName);
+        expect(methodName).toBe(givenMethodName);
+    });
+    it("should fail for invalid module name", () => {
+        expect.assertions(1);
+        expect(() => {
+            resolver.getMethodId("Admin2", "isAdminWithAVeryVeryVeryVeryLongName");
+        }).toThrow("Only known module names are allowed, using unknown module name: Admin2");
+    });
+});

package/dist/test/modules/State.test.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=State.test.d.ts.map

package/dist/test/modules/State.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"State.test.d.ts","sourceRoot":"","sources":["../../../test/modules/State.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/modules/State.test.js

@@ -0,0 +1,42 @@
+import "reflect-metadata";
+import { PublicKey, UInt64 } from "o1js";
+import { container } from "tsyringe";
+import { NetworkState, Option, RuntimeMethodExecutionContext, RuntimeTransaction, } from "@proto-kit/protocol";
+import { createTestingRuntime } from "../TestingRuntime";
+import { Admin } from "./Admin";
+import { Balances } from "./Balances";
+describe("transient state", () => {
+    let balances;
+    let runtime;
+    function createChain() {
+        ({ runtime } = createTestingRuntime({
+            Admin,
+            Balances,
+        }, {
+            Admin: {
+                publicKey: PublicKey.empty().toBase58(),
+            },
+            Balances: {},
+        }));
+        balances = runtime.resolve("Balances");
+    }
+    beforeEach(() => {
+        createChain();
+    });
+    it("should track previously set state", () => {
+        expect.assertions(2);
+        const executionContext = container.resolve(RuntimeMethodExecutionContext);
+        executionContext.setup({
+            networkState: NetworkState.empty(),
+            transaction: RuntimeTransaction.dummyTransaction(),
+        });
+        balances.transientState();
+        const stateTransitions = executionContext
+            .current()
+            .result.stateTransitions.map((stateTransition) => stateTransition.toProvable());
+        const expectedLastOption = Option.fromValue(UInt64.from(200), UInt64).toProvable();
+        const last = stateTransitions.at(-1);
+        expect(last).toBeDefined();
+        expect(last.to.value).toStrictEqual(expectedLastOption.value);
+    });
+});

package/dist/test/runtimeMethod.test.d.ts

@@ -0,0 +1,2 @@
+import "reflect-metadata";
+//# sourceMappingURL=runtimeMethod.test.d.ts.map

package/dist/test/runtimeMethod.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeMethod.test.d.ts","sourceRoot":"","sources":["../../test/runtimeMethod.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/test/runtimeMethod.test.js

@@ -0,0 +1,50 @@
+import "reflect-metadata";
+import { PublicKey } from "o1js";
+import { NetworkState, RuntimeMethodExecutionContext, RuntimeTransaction, } from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { log } from "@proto-kit/common";
+import { MethodParameterEncoder } from "../src";
+import { Balances } from "./modules/Balances";
+import { createTestingRuntime } from "./TestingRuntime";
+describe("runtimeMethod", () => {
+    const parameters = [PublicKey.empty()];
+    let runtime;
+    beforeEach(() => {
+        log.setLevel(log.levels.DEBUG);
+        ({ runtime } = createTestingRuntime({
+            Balances,
+        }, {
+            Balances: {},
+        }));
+    });
+    it("should create correct param types", () => {
+        expect.assertions(1 + parameters.length);
+        const module = runtime.resolve("Balances");
+        const decoder = MethodParameterEncoder.fromMethod(module, "getBalance");
+        const recodedParameters = decoder.decodeFields(parameters.flatMap((x) => x.toFields()));
+        expect(parameters).toHaveLength(recodedParameters.length);
+        parameters.forEach((parameter, index) => {
+            expect(parameter).toStrictEqual(recodedParameters[index]);
+        });
+    });
+    it("should throw on incorrect methodId on tx", async () => {
+        expect.assertions(1);
+        const context = container.resolve(RuntimeMethodExecutionContext);
+        runtime.registerValue({
+            AppChain: {
+                areProofsEnabled: false,
+            },
+        });
+        context.setup({
+            transaction: RuntimeTransaction.dummyTransaction(),
+            networkState: NetworkState.empty(),
+        });
+        const module = runtime.resolve("Balances");
+        module.getBalance(PublicKey.empty());
+        context.setup({
+            transaction: RuntimeTransaction.dummyTransaction(),
+            networkState: NetworkState.empty(),
+        });
+        await expect(context.current().result.prover()).rejects.toThrow("Runtimemethod called with wrong methodId on the transaction object");
+    });
+});