@proto-kit/module 0.1.1-develop.245 → 0.1.1-develop.254

package/dist/method/runtimeMethod.d.ts

@@ -1,8 +1,9 @@
 import { StateTransition, MethodPublicOutput } from "@proto-kit/protocol";
+import { ToFieldable } from "@proto-kit/common";
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
 export declare function toStateTransitionsHash(stateTransitions: StateTransition<any>[]): import("snarkyjs/dist/node/lib/field.js").Field;
 export type WrappedMethod = (...args: unknown[]) => MethodPublicOutput;
-export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: unknown[]) => unknown): WrappedMethod;
+export declare function toWrappedMethod(this: RuntimeModule<unknown>, methodName: string, moduleMethod: (...args: unknown[]) => unknown, methodArguments: ToFieldable[]): WrappedMethod;
 export declare function combineMethodName(runtimeModuleName: string, methodName: string): string;
 export declare const runtimeMethodMetadataKey = "yab-method";
 export declare const runtimeMethodNamesMetadataKey = "proto-kit-runtime-methods";

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

@@ -1 +1 @@
-{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAYjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,mDAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,kBAAkB,CAAC;AAEvE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,iBAoC9C;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED,eAAO,MAAM,wBAAwB,eAAe,CAAC;AACrD,eAAO,MAAM,6BAA6B,8BAA8B,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,wBAAgB,aAAa,aAEjB,cAAc,OAAO,CAAC,cAClB,MAAM,cACN,kBAAkB,UAuFjC"}
+{"version":3,"file":"runtimeMethod.d.ts","sourceRoot":"","sources":["../../src/method/runtimeMethod.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EAGf,kBAAkB,EAEnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAIL,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAoBjE,wBAAgB,sBAAsB,CAEpC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,mDAczC;AAGD,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,kBAAkB,CAAC;AAEvE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,CAAC,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EAC7C,eAAe,EAAE,WAAW,EAAE,iBA0E/B;AAED,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,UAAU,EAAE,MAAM,UAGnB;AAED,eAAO,MAAM,wBAAwB,eAAe,CAAC;AACrD,eAAO,MAAM,6BAA6B,8BAA8B,CAAC;AAEzE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,EAC9B,WAAW,EAAE,MAAM,WAKpB;AAED,wBAAgB,aAAa,aAEjB,cAAc,OAAO,CAAC,cAClB,MAAM,cACN,kBAAkB,UAwFjC"}

package/dist/method/runtimeMethod.js

@@ -1,9 +1,12 @@
+import { Field, Poseidon } from "snarkyjs";
 import { container } from "tsyringe";
-import { DefaultProvableHashList, ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext } from "@proto-kit/protocol";
-import { toProver } from "@proto-kit/common";
+import { DefaultProvableHashList, ProvableStateTransition, MethodPublicOutput, RuntimeMethodExecutionContext, } from "@proto-kit/protocol";
+import { toProver, } from "@proto-kit/common";
 const errors = {
     runtimeNotProvided: (name) => new Error(`Runtime was not provided for module: ${name}`),
     methodInputsNotProvided: () => new Error("Method execution inputs not provided, provide them via context.inputs"),
+    runtimeNameNotSet: () => new Error("Runtime name was not set"),
+    fieldNotConstant: (name) => new Error(`In-circuit field ${name} not a constant, this is likely a framework bug`),
 };
 export function toStateTransitionsHash(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -14,7 +17,7 @@ stateTransitions) {
         .reduce((allStateTransitionsHashList, stateTransition) => allStateTransitionsHashList.push(stateTransition), stateTransitionsHashList)
         .toField();
 }
-export function toWrappedMethod(methodName, moduleMethod) {
+export function toWrappedMethod(methodName, moduleMethod, methodArguments) {
     const executionContext = container.resolve(RuntimeMethodExecutionContext);
     const wrappedMethod = (...args) => {
         Reflect.apply(moduleMethod, this, args);
@@ -23,6 +26,28 @@ export function toWrappedMethod(methodName, moduleMethod) {
         if (input === undefined) {
             throw errors.methodInputsNotProvided();
         }
+        const { name, runtime } = this;
+        if (name === undefined) {
+            throw errors.runtimeNameNotSet();
+        }
+        if (runtime === undefined) {
+            throw errors.runtimeNotProvided(name);
+        }
+        // Assert that the given transaction has the correct methodId
+        const methodIdResolver = runtime.dependencyContainer.resolve("MethodIdResolver");
+        const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
+        if (!thisMethodId.isConstant()) {
+            throw errors.fieldNotConstant("methodId");
+        }
+        input.transaction.methodId.assertEquals(thisMethodId, "Runtimemethod called with wrong methodId on the transaction object");
+        // Assert that the argsHash that has been signed matches the given arguments
+        // We can use js-if here, because methodArguments is statically sizes
+        // i.e. the result of the if-statement will be the same for all executions
+        // of this method
+        const argsHash = methodArguments.length > 0
+            ? Poseidon.hash(methodArguments.flatMap((argument) => argument.toFields()))
+            : Field(0);
+        input.transaction.argsHash.assertEquals(argsHash, "argsHash and therefore arguments of transaction and runtime call does not match");
         const transactionHash = input.transaction.hash();
         const networkStateHash = input.networkState.hash();
         return new MethodPublicOutput({
@@ -81,6 +106,7 @@ export function runtimeMethod() {
             const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
                 methodName,
                 simulatedMethod,
+                args,
             ]);
             /**
              * Before the prover runs, make sure it is operating on the correct

package/package.json

@@ -2,7 +2,7 @@
   "name": "@proto-kit/module",
   "license": "MIT",
   "private": false,
-  "version": "0.1.1-develop.245+b1d7d07",
+  "version": "0.1.1-develop.254+2fba72e",
   "type": "module",
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -31,5 +31,5 @@
     "snarkyjs": "0.12.0",
     "tsyringe": "^4.7.0"
   },
-  "gitHead": "b1d7d0756743006192c20bf6b2bf152b6a81e723"
+  "gitHead": "2fba72ec580c20289658d5c831430ca601ea5a71"
 }

package/src/method/runtimeMethod.ts

@@ -1,15 +1,21 @@
-import { FlexibleProvable } from "snarkyjs";
+import { Field, Poseidon } from "snarkyjs";
 import { container } from "tsyringe";
 import {
   StateTransition,
   DefaultProvableHashList,
   ProvableStateTransition,
   MethodPublicOutput,
-  RuntimeMethodExecutionContext
+  RuntimeMethodExecutionContext,
 } from "@proto-kit/protocol";
-import { DecoratedMethod, toProver, ZkProgrammable } from "@proto-kit/common";
+import {
+  DecoratedMethod,
+  toProver,
+  ZkProgrammable,
+  ToFieldable,
+} from "@proto-kit/common";
 
 import type { RuntimeModule } from "../runtime/RuntimeModule.js";
+import { MethodIdResolver } from "../runtime/MethodIdResolver";
 
 const errors = {
   runtimeNotProvided: (name: string) =>
@@ -19,6 +25,13 @@ const errors = {
     new Error(
       "Method execution inputs not provided, provide them via context.inputs"
     ),
+
+  runtimeNameNotSet: () => new Error("Runtime name was not set"),
+
+  fieldNotConstant: (name: string) =>
+    new Error(
+      `In-circuit field ${name} not a constant, this is likely a framework bug`
+    ),
 };
 
 export function toStateTransitionsHash(
@@ -45,7 +58,8 @@ export type WrappedMethod = (...args: unknown[]) => MethodPublicOutput;
 export function toWrappedMethod(
   this: RuntimeModule<unknown>,
   methodName: string,
-  moduleMethod: (...args: unknown[]) => unknown
+  moduleMethod: (...args: unknown[]) => unknown,
+  methodArguments: ToFieldable[]
 ) {
   const executionContext = container.resolve<RuntimeMethodExecutionContext>(
     RuntimeMethodExecutionContext
@@ -64,6 +78,44 @@ export function toWrappedMethod(
       throw errors.methodInputsNotProvided();
     }
 
+    const { name, runtime } = this;
+
+    if (name === undefined) {
+      throw errors.runtimeNameNotSet();
+    }
+    if (runtime === undefined) {
+      throw errors.runtimeNotProvided(name);
+    }
+
+    // Assert that the given transaction has the correct methodId
+    const methodIdResolver =
+      runtime.dependencyContainer.resolve<MethodIdResolver>("MethodIdResolver");
+    const thisMethodId = Field(methodIdResolver.getMethodId(name, methodName));
+    if (!thisMethodId.isConstant()) {
+      throw errors.fieldNotConstant("methodId");
+    }
+
+    input.transaction.methodId.assertEquals(
+      thisMethodId,
+      "Runtimemethod called with wrong methodId on the transaction object"
+    );
+
+    // Assert that the argsHash that has been signed matches the given arguments
+    // We can use js-if here, because methodArguments is statically sizes
+    // i.e. the result of the if-statement will be the same for all executions
+    // of this method
+    const argsHash =
+      methodArguments.length > 0
+        ? Poseidon.hash(
+            methodArguments.flatMap((argument) => argument.toFields())
+          )
+        : Field(0);
+
+    input.transaction.argsHash.assertEquals(
+      argsHash,
+      "argsHash and therefore arguments of transaction and runtime call does not match"
+    );
+
     const transactionHash = input.transaction.hash();
     const networkStateHash = input.networkState.hash();
 
@@ -139,7 +191,7 @@ export function runtimeMethod() {
 
     descriptor.value = function value(
       this: RuntimeModule<unknown>,
-      ...args: FlexibleProvable<unknown>[]
+      ...args: ToFieldable[]
     ) {
       const constructorName = this.constructor.name;
 
@@ -153,6 +205,7 @@ export function runtimeMethod() {
       const simulatedWrappedMethod = Reflect.apply(toWrappedMethod, this, [
         methodName,
         simulatedMethod,
+        args,
       ]);
 
       /**

package/test/modules/Balances.test.ts

@@ -14,16 +14,12 @@ import {
   type ProvableStateTransition,
   Path,
   MethodPublicOutput,
-  StateService, NetworkState, RuntimeTransaction
+  StateService,
+  RuntimeMethodExecutionContext,
 } from "@proto-kit/protocol";
 
-import {
-  InMemoryStateService,
-} from "../../src/state/InMemoryStateService.js";
-import {
-  Runtime,
-  RuntimeMethodExecutionContext,
-} from "../../src";
+import { InMemoryStateService } from "../../src/state/InMemoryStateService.js";
+import { Runtime } from "../../src";
 
 import { Balances } from "./Balances.js";
 import { Admin } from "./Admin.js";

package/test/modules/Balances.ts

@@ -1,11 +1,8 @@
 import { Bool, PublicKey, UInt64 } from "snarkyjs";
-import { Option } from "@proto-kit/protocol";
+import { Option, State, StateMap } from "@proto-kit/protocol";
 import { Presets } from "@proto-kit/common";
 
-import { State } from "../../../protocol/src/state/State.js";
-import { state } from "../../src/state/decorator.js";
-import { StateMap } from "../../../protocol/src/state/StateMap.js";
-import { RuntimeModule, runtimeMethod, runtimeModule } from "../../src";
+import { RuntimeModule, runtimeMethod, runtimeModule, state } from "../../src";
 
 import { Admin } from "./Admin.js";
 

package/test/modules/State.test.ts

@@ -1,12 +1,17 @@
 import "reflect-metadata";
 import { Bool, PublicKey, UInt64 } from "snarkyjs";
 import { container } from "tsyringe";
-import { NetworkState, Option, RuntimeTransaction, StateService } from "@proto-kit/protocol";
+import {
+  NetworkState,
+  Option,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+  StateService
+} from "@proto-kit/protocol";
 
 import {
   InMemoryStateService,
-  Runtime,
-  RuntimeMethodExecutionContext,
+  Runtime
 } from "../../src";
 
 import { Admin } from "./Admin";

package/test/runtimeMethod.test.ts

@@ -1,7 +1,14 @@
 import "reflect-metadata";
-import { Bool, PublicKey } from "snarkyjs";
+import { Bool, Field, PublicKey, UInt64 } from "snarkyjs";
+import {
+  NetworkState,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+} from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { AreProofsEnabled, log } from "@proto-kit/common";
 
-import { InMemoryStateService, Runtime } from "../src";
+import { InMemoryStateService, MethodIdResolver, Runtime } from "../src";
 import { MethodParameterDecoder } from "../src/method/MethodParameterDecoder";
 
 import { Balances } from "./modules/Balances";
@@ -9,11 +16,11 @@ import { Balances } from "./modules/Balances";
 describe("runtimeMethod", () => {
   const parameters = [PublicKey.empty()];
 
-  it("should create correct param types", () => {
-    // eslint-disable-next-line jest/prefer-expect-assertions
-    expect.assertions(1 + parameters.length);
+  let runtime: Runtime<{ Balances: typeof Balances }>;
 
-    const runtime = Runtime.from({
+  beforeEach(() => {
+    log.setLevel(log.levels.DEBUG);
+    runtime = Runtime.from({
       state: new InMemoryStateService(),
 
       modules: {
@@ -26,6 +33,12 @@ describe("runtimeMethod", () => {
         },
       },
     });
+    runtime.start();
+  });
+
+  it("should create correct param types", () => {
+    // eslint-disable-next-line jest/prefer-expect-assertions
+    expect.assertions(1 + parameters.length);
 
     const module = runtime.resolve("Balances");
 
@@ -40,4 +53,40 @@ describe("runtimeMethod", () => {
       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,
+      } as AreProofsEnabled,
+    });
+
+    const transaction = new RuntimeTransaction({
+      methodId: Field(0),
+      nonce: UInt64.zero,
+      argsHash: Field(0),
+      sender: PublicKey.empty(),
+    });
+
+    context.setup({
+      transaction,
+      networkState: new NetworkState({ block: { height: UInt64.zero } }),
+    });
+
+    const module = runtime.resolve("Balances");
+    module.getBalance(PublicKey.empty());
+
+    context.setup({
+      transaction,
+      networkState: new NetworkState({ block: { height: UInt64.zero } }),
+    });
+
+    await expect(context.current().result.prover!()).rejects.toThrow(
+      "Runtimemethod called with wrong methodId on the transaction object"
+    );
+  });
 });

package/test/transaction.test.ts

@@ -10,7 +10,7 @@ import {
 } from "../src";
 import { runtimeModule } from "../src/module/decorator";
 import { RuntimeModule } from "../src/runtime/RuntimeModule";
-import { state } from "../src/state/decorator";
+import { state } from "../../protocol/src/state/decorator";
 import { StateMap } from "@proto-kit/protocol";
 
 interface BalancesConfig {}

package/dist/method/RuntimeMethodExecutionContext.d.ts

@@ -1,57 +0,0 @@
-import { Bool } from "snarkyjs";
-import type { StateTransition, NetworkState, ToFieldable } from "@proto-kit/protocol";
-import { ProvableMethodExecutionContext, ProvableMethodExecutionResult } from "@proto-kit/common";
-import { RuntimeTransaction } from "@proto-kit/protocol/src/model/transaction/RuntimeTransaction";
-export declare class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
-    stateTransitions: StateTransition<any>[];
-    status: Bool;
-    statusMessage?: string;
-}
-export interface RuntimeMethodExecutionData {
-    transaction: RuntimeTransaction;
-    networkState: NetworkState;
-}
-/**
- * Execution context used to wrap runtime module methods,
- * allowing them to post relevant information (such as execution status)
- * into the context without any unnecessary 'prop drilling'.
- */
-export declare class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
-    methods: string[];
-    input: RuntimeMethodExecutionData | undefined;
-    private lastInput;
-    result: RuntimeProvableMethodExecutionResult;
-    private assertSetupCalled;
-    /**
-     * Adds an in-method generated state transition to the current context
-     * @param stateTransition - State transition to add to the context
-     */
-    addStateTransition<Value extends ToFieldable>(stateTransition: StateTransition<Value>): void;
-    /**
-     * @param message - Status message to acompany the current status
-     */
-    setStatusMessage(message?: string): void;
-    /**
-     * @param status - Execution status of the current method
-     */
-    setStatus(status: Bool): void;
-    /**
-     * @param input Input witness data required for a runtime execution
-     */
-    setup(input: RuntimeMethodExecutionData): void;
-    /**
-     * Manually clears/resets the execution context
-     */
-    clear(): void;
-    afterMethod(): void;
-    /**
-     * Had to override current() otherwise it would not infer
-     * the type of result correctly (parent type would be reused)
-     */
-    current(): {
-        isFinished: boolean;
-        result: RuntimeProvableMethodExecutionResult;
-        input: RuntimeMethodExecutionData | undefined;
-    };
-}
-//# sourceMappingURL=RuntimeMethodExecutionContext.d.ts.map

package/dist/method/RuntimeMethodExecutionContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RuntimeMethodExecutionContext.d.ts","sourceRoot":"","sources":["../../src/method/RuntimeMethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,UAAU,CAAC;AAEhC,OAAO,KAAK,EACV,eAAe,EACf,YAAY,EACZ,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,kBAAkB,EAAE,MAAM,8DAA8D,CAAC;AASlG,qBAAa,oCAAqC,SAAQ,6BAA6B;IAE9E,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,kBAAkB,CAAC;IAChC,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;GAIG;AACH,qBACa,6BAA8B,SAAQ,8BAA8B;IACxE,OAAO,EAAE,MAAM,EAAE,CAAM;IAEvB,KAAK,EAAE,0BAA0B,GAAG,SAAS,CAAC;IAGrD,OAAO,CAAC,SAAS,CAAyC;IAE1C,MAAM,uCAA8C;IAEpE,OAAO,CAAC,iBAAiB;IAQzB;;;OAGG;IACI,kBAAkB,CAAC,KAAK,SAAS,WAAW,EACjD,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAMzC;;OAEG;IACI,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAKxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAK7B;;OAEG;IACI,KAAK,CAAC,KAAK,EAAE,0BAA0B;IAI9C;;OAEG;IACI,KAAK;IAIL,WAAW;IAMlB;;;OAGG;IACI,OAAO;;;;;CAOf"}

package/dist/method/RuntimeMethodExecutionContext.js

@@ -1,92 +0,0 @@
-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;
-};
-import { Bool } from "snarkyjs";
-import { singleton } from "tsyringe";
-import { ProvableMethodExecutionContext, ProvableMethodExecutionResult, } from "@proto-kit/common";
-const errors = {
-    setupNotCalled: () => new Error("Setup has not been called prior to executing a runtime method. Be sure to do that so that the Runtime is setup property for execution"),
-};
-export class RuntimeProvableMethodExecutionResult extends ProvableMethodExecutionResult {
-    constructor() {
-        super(...arguments);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        this.stateTransitions = [];
-        this.status = Bool(true);
-    }
-}
-/**
- * Execution context used to wrap runtime module methods,
- * allowing them to post relevant information (such as execution status)
- * into the context without any unnecessary 'prop drilling'.
- */
-let RuntimeMethodExecutionContext = class RuntimeMethodExecutionContext extends ProvableMethodExecutionContext {
-    constructor() {
-        super(...arguments);
-        this.methods = [];
-        this.result = new RuntimeProvableMethodExecutionResult();
-    }
-    assertSetupCalled() {
-        if (this.input === undefined) {
-            throw errors.setupNotCalled();
-        }
-    }
-    /**
-     * Adds an in-method generated state transition to the current context
-     * @param stateTransition - State transition to add to the context
-     */
-    addStateTransition(stateTransition) {
-        this.assertSetupCalled();
-        this.result.stateTransitions.push(stateTransition);
-    }
-    /**
-     * @param message - Status message to acompany the current status
-     */
-    setStatusMessage(message) {
-        var _a;
-        this.assertSetupCalled();
-        (_a = this.result).statusMessage ?? (_a.statusMessage = message);
-    }
-    /**
-     * @param status - Execution status of the current method
-     */
-    setStatus(status) {
-        this.assertSetupCalled();
-        this.result.status = status;
-    }
-    /**
-     * @param input Input witness data required for a runtime execution
-     */
-    setup(input) {
-        this.input = input;
-    }
-    /**
-     * Manually clears/resets the execution context
-     */
-    clear() {
-        this.result = new RuntimeProvableMethodExecutionResult();
-    }
-    afterMethod() {
-        super.afterMethod();
-        this.lastInput = this.input;
-        this.input = undefined;
-    }
-    /**
-     * Had to override current() otherwise it would not infer
-     * the type of result correctly (parent type would be reused)
-     */
-    current() {
-        return {
-            isFinished: this.isFinished,
-            result: this.result,
-            input: this.lastInput,
-        };
-    }
-};
-RuntimeMethodExecutionContext = __decorate([
-    singleton()
-], RuntimeMethodExecutionContext);
-export { RuntimeMethodExecutionContext };

package/dist/method/assert.d.ts

@@ -1,12 +0,0 @@
-import { Bool } from "snarkyjs";
-/**
- * Maintains an execution status of the current runtime module method,
- * while prioritizing one-time failures. The assertion won't change the
- * execution status if it has previously failed at least once within the
- * same method execution context.
- *
- * @param condition - Result of the assertion made about the execution status
- * @param message - Optional message describing the prior status
- */
-export declare function assert(condition: Bool, message?: string): void;
-//# sourceMappingURL=assert.d.ts.map

package/dist/method/assert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/method/assert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAY,MAAM,UAAU,CAAC;AAM1C;;;;;;;;GAQG;AACH,wBAAgB,MAAM,CAAC,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,MAAM,QAWvD"}

package/dist/method/assert.js

@@ -1,23 +0,0 @@
-import { Bool, Provable } from "snarkyjs";
-import { container } from "tsyringe";
-import { RuntimeMethodExecutionContext } from "./RuntimeMethodExecutionContext";
-import { log } from "@proto-kit/common";
-/**
- * Maintains an execution status of the current runtime module method,
- * while prioritizing one-time failures. The assertion won't change the
- * execution status if it has previously failed at least once within the
- * same method execution context.
- *
- * @param condition - Result of the assertion made about the execution status
- * @param message - Optional message describing the prior status
- */
-export function assert(condition, message) {
-    const executionContext = container.resolve(RuntimeMethodExecutionContext);
-    const previousStatus = executionContext.current().result.status;
-    const status = Provable.if(previousStatus, Bool, condition, previousStatus);
-    if (!condition.toBoolean()) {
-        log.debug("Assertion failed: ", message);
-        executionContext.setStatusMessage(message);
-    }
-    executionContext.setStatus(status);
-}

package/dist/module/src/factories/MethodIdFactory.d.ts

@@ -1,9 +0,0 @@
-import { DependencyFactory } from "@proto-kit/common";
-import { MethodIdResolver } from "../runtime/MethodIdResolver";
-import type { Runtime, RuntimeModulesRecord } from "../runtime/Runtime";
-export declare class MethodIdFactory extends DependencyFactory {
-    private readonly runtime;
-    constructor(runtime: Runtime<RuntimeModulesRecord>);
-    methodIdResolver(): MethodIdResolver;
-}
-//# sourceMappingURL=MethodIdFactory.d.ts.map

package/dist/module/src/factories/MethodIdFactory.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MethodIdFactory.d.ts","sourceRoot":"","sources":["../../../../src/factories/MethodIdFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,iBAAiB,EAClB,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAExE,qBACa,eAAgB,SAAQ,iBAAiB;IAE/B,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAMrE,gBAAgB,IAAI,gBAAgB;CAG5C"}

package/dist/module/src/factories/MethodIdFactory.js

@@ -1,36 +0,0 @@
-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);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
-import { dependency, dependencyFactory, DependencyFactory } from "@proto-kit/common";
-import { inject } from "tsyringe";
-import { MethodIdResolver } from "../runtime/MethodIdResolver";
-let MethodIdFactory = class MethodIdFactory extends DependencyFactory {
-    constructor(runtime) {
-        super();
-        this.runtime = runtime;
-    }
-    methodIdResolver() {
-        return new MethodIdResolver(this.runtime, this.runtime.definition.modules);
-    }
-};
-__decorate([
-    dependency(),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", []),
-    __metadata("design:returntype", MethodIdResolver)
-], MethodIdFactory.prototype, "methodIdResolver", null);
-MethodIdFactory = __decorate([
-    dependencyFactory(),
-    __param(0, inject("Runtime")),
-    __metadata("design:paramtypes", [Function])
-], MethodIdFactory);
-export { MethodIdFactory };

package/dist/module/src/index.d.ts

@@ -1,11 +0,0 @@
-export * from "../../protocol/src/state/assert/assert";
-export * from "./method/runtimeMethod";
-export * from "./module/decorator";
-export * from "./runtime/RuntimeModule";
-export * from "./runtime/Runtime";
-export * from "./state/InMemoryStateService";
-export * from "@proto-kit/protocol/src/state/StateServiceProvider";
-export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
-export * from "./runtime/MethodIdResolver";
-//# sourceMappingURL=index.d.ts.map

package/dist/module/src/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oDAAoD,CAAC;AACnE,cAAc,mBAAmB,CAAC;AAClC,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC"}

package/dist/module/src/index.js

@@ -1,10 +0,0 @@
-export * from "../../protocol/src/state/assert/assert";
-export * from "./method/runtimeMethod";
-export * from "./module/decorator";
-export * from "./runtime/RuntimeModule";
-export * from "./runtime/Runtime";
-export * from "./state/InMemoryStateService";
-export * from "@proto-kit/protocol/src/state/StateServiceProvider";
-export * from "./state/decorator";
-export * from "./method/MethodParameterDecoder";
-export * from "./runtime/MethodIdResolver";

package/dist/module/src/method/MethodParameterDecoder.d.ts

@@ -1,22 +0,0 @@
-import { Field } from "snarkyjs";
-import { RuntimeModule } from "../runtime/RuntimeModule";
-export interface Fieldable {
-    toFields: () => Field[];
-}
-export interface FromFieldClass {
-    new: (...args: any[]) => any;
-    fromFields: (fields: Field[]) => Fieldable;
-    name: string;
-    prototype: {
-        _fields?: any[];
-    };
-    sizeInFields?: () => number;
-}
-export declare class MethodParameterDecoder {
-    private readonly types;
-    static fromMethod(target: RuntimeModule<unknown>, methodName: string): MethodParameterDecoder;
-    private constructor();
-    fromFields(fields: Field[]): Fieldable[];
-    get fieldSize(): number;
-}
-//# sourceMappingURL=MethodParameterDecoder.d.ts.map