@proto-kit/module 0.1.1-develop.164 → 0.1.1-develop.1661

package/test/runtimeMethod.test.ts

@@ -1,37 +1,101 @@
 import "reflect-metadata";
-import { Bool, PublicKey } from "snarkyjs";
+import {
+  PublicKey,
+  Struct,
+  Bool,
+  PrivateKey,
+  Field,
+  UInt64,
+  Poseidon,
+} from "o1js";
+import {
+  MethodPublicOutput,
+  NetworkState,
+  RuntimeMethodExecutionContext,
+  RuntimeTransaction,
+} from "@proto-kit/protocol";
+import { container } from "tsyringe";
+import { AreProofsEnabled, log } from "@proto-kit/common";
 
-import { InMemoryStateService, Runtime } from "../src";
-import { MethodParameterDecoder } from "../src/method/MethodParameterDecoder";
+import {
+  Runtime,
+  MethodParameterEncoder,
+  runtimeModule,
+  RuntimeModule,
+  runtimeMethod,
+  toEventsHash,
+  RuntimeEvents,
+} from "../src";
 
 import { Balances } from "./modules/Balances";
+import { createTestingRuntime } from "./TestingRuntime";
 
-describe("runtimeMethod", () => {
-  const parameters = [PublicKey.empty()];
+export class PrimaryTestEvent extends Struct({
+  message: Bool,
+}) {}
 
-  it("should create correct param types", () => {
-    // eslint-disable-next-line jest/prefer-expect-assertions
-    expect.assertions(1 + parameters.length);
+export class SecondaryTestEvent extends Struct({
+  message: Bool,
+}) {}
+
+@runtimeModule()
+class EventMaker extends RuntimeModule {
+  public constructor() {
+    super();
+  }
 
-    const runtime = Runtime.from({
-      state: new InMemoryStateService(),
+  public events = new RuntimeEvents({
+    primary: PrimaryTestEvent,
+    secondary: SecondaryTestEvent,
+  });
 
-      modules: {
+  @runtimeMethod()
+  public async makeEvent() {
+    this.events.emit("primary", new PrimaryTestEvent({ message: Bool(false) }));
+    // Should not emit as condition is false.
+    this.events.emitIf(
+      Bool(false),
+      "primary",
+      new PrimaryTestEvent({ message: Bool(false) })
+    );
+    this.events.emit(
+      "secondary",
+      new SecondaryTestEvent({ message: Bool(true) })
+    );
+  }
+}
+
+describe("runtimeMethod", () => {
+  const parameters = [PublicKey.empty<typeof PublicKey>()];
+
+  let runtime: Runtime<{
+    Balances: typeof Balances;
+    EventMaker: typeof EventMaker;
+  }>;
+
+  beforeEach(() => {
+    log.setLevel(log.levels.DEBUG);
+    ({ runtime } = createTestingRuntime(
+      {
         Balances,
+        EventMaker,
       },
+      {
+        Balances: {},
+        EventMaker: {},
+      }
+    ));
+  });
 
-      config: {
-        Balances: {
-          test: Bool(true),
-        },
-      },
-    });
+  it("should create correct param types", async () => {
+    expect.assertions(1 + parameters.length);
 
     const module = runtime.resolve("Balances");
 
-    const decoder = MethodParameterDecoder.fromMethod(module, "getBalance");
-    const recodedParameters = decoder.fromFields(
-      parameters.flatMap((x) => x.toFields())
+    const decoder = MethodParameterEncoder.fromMethod(module, "getBalance");
+    const recodedParameters = await decoder.decode(
+      parameters.flatMap((x) => x.toFields()),
+      []
     );
 
     expect(parameters).toHaveLength(recodedParameters.length);
@@ -40,4 +104,112 @@ 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,
+    });
+
+    context.setup({
+      transaction: RuntimeTransaction.dummyTransaction(),
+      networkState: NetworkState.empty(),
+    });
+
+    const module = runtime.resolve("Balances");
+    await module.getBalance(PublicKey.empty<typeof PublicKey>());
+
+    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"
+    );
+  });
+
+  it("should capture event", async () => {
+    expect.assertions(5);
+
+    const context = container.resolve(RuntimeMethodExecutionContext);
+
+    runtime.registerValue({
+      AppChain: {
+        areProofsEnabled: false,
+      } as AreProofsEnabled,
+    });
+
+    const eventMakerMethodId = runtime.methodIdResolver.getMethodId(
+      "EventMaker",
+      "makeEvent"
+    );
+
+    const privateKey = PrivateKey.random();
+    context.setup({
+      transaction: RuntimeTransaction.fromTransaction({
+        sender: privateKey.toPublicKey(),
+        nonce: UInt64.from(0),
+        methodId: Field(eventMakerMethodId),
+        argsHash: Poseidon.hash([]),
+      }),
+      networkState: NetworkState.empty(),
+    });
+
+    const module = runtime.resolve("EventMaker");
+    await module.makeEvent();
+
+    const firstExpectedEvent = {
+      eventType: PrimaryTestEvent,
+      event: new PrimaryTestEvent({
+        message: Bool(false),
+      }),
+      eventName: "primary",
+      condition: Bool(true),
+    };
+
+    const secondExpectedEvent = {
+      eventType: PrimaryTestEvent,
+      event: new PrimaryTestEvent({
+        message: Bool(false),
+      }),
+      eventName: "primary",
+      condition: Bool(false),
+    };
+
+    const thirdExpectedEvent = {
+      eventType: SecondaryTestEvent,
+      event: new SecondaryTestEvent({
+        message: Bool(true),
+      }),
+      eventName: "secondary",
+      condition: Bool(true),
+    };
+
+    const eventsResults = context.current().result.events;
+    expect(eventsResults).toHaveLength(3);
+    expect(eventsResults[0]).toStrictEqual(firstExpectedEvent);
+    expect(eventsResults[1]).toStrictEqual(secondExpectedEvent);
+    expect(eventsResults[2]).toStrictEqual(thirdExpectedEvent);
+
+    context.afterMethod();
+
+    const proof = await context.current().result.prover!();
+    const publicOuput = proof.publicOutput as MethodPublicOutput;
+    const { eventsHash } = publicOuput;
+    //  Note that we omit the second event from below as it was
+    //  not emitted due to the condition being false.
+    expect(eventsHash).toStrictEqual(
+      toEventsHash([
+        { ...firstExpectedEvent, condition: Bool(true) },
+        { ...secondExpectedEvent, condition: Bool(false) },
+        { ...thirdExpectedEvent, condition: Bool(true) },
+      ])
+    );
+  });
 });

package/test/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./../../../tsconfig.json",
+  "compilerOptions": {
+    "experimentalDecorators": true
+  },
+  "include": ["../src/**/*.test.ts", "./**/*.ts", "./*.ts", "../src/**/*.ts"]
+}

package/tsconfig.json

@@ -3,6 +3,6 @@
   "compilerOptions": {
     "outDir": "./dist"
   },
-  "include": ["./src", "src/index.ts"],
-  "exclude": ["./dist/**/*.ts", "./**/*.test.ts", "./test/**/*.ts"]
+  "include": ["./src/index.ts"],
+  "exclude": ["./dist/**/*.ts"]
 }

package/dist/chain/Chain.d.ts

@@ -1,109 +0,0 @@
-import { Experimental, Proof } from "snarkyjs";
-import { MethodPublicInput, Subclass } from "@yab/protocol";
-import { type AnyConstructor } from "../module/decorator.js";
-import type { StateService } from "../state/InMemoryStateService.js";
-export interface RuntimeModules {
-    [name: string]: AnyConstructor;
-}
-export interface ChainConfig<ChainRuntimeModules extends RuntimeModules> {
-    state: StateService;
-    runtimeModules: ChainRuntimeModules;
-}
-/**
- * Wrapper for an application specific chain, which helps orchestrate
- * runtime modules into an interoperable runtime.
- */
-export declare class Chain<ChainRuntimeModules extends RuntimeModules> {
-    config: ChainConfig<ChainRuntimeModules>;
-    /**
-     * Alternative constructor for `Chain`.
-     *
-     * @param config - Configuration for the returned Chain
-     * @returns Chain with the provided config
-     */
-    static from<ChainRuntimeModules extends RuntimeModules>(config: ChainConfig<ChainRuntimeModules>): Chain<ChainRuntimeModules>;
-    private readonly runtimeContainer;
-    areProofsEnabled: boolean;
-    program?: ReturnType<typeof Experimental.ZkProgram>;
-    /**
-     * Creates a new Chain from the provided config
-     *
-     * @param config - Configuration object for the constructed Chain
-     */
-    constructor(config: ChainConfig<ChainRuntimeModules>);
-    /**
-     * Add a name and other respective properties required by RuntimeModules,
-     * that come from the current Chain
-     *
-     * @param name - Name of the runtime module to decorate
-     */
-    private decorateRuntimeModule;
-    /**
-     * @returns A list of
-     */
-    get runtimeModuleNames(): string[];
-    /**
-     * Returns a runtime module registred under the given key.
-     *
-     * @param name - Name of the runtime module to get
-     * @returns A runtime module stored under the given key
-     */
-    getRuntimeModule<Key extends keyof ChainRuntimeModules>(name: Key): InstanceType<ChainRuntimeModules[Key]>;
-    /**
-     * Registers a runtime module under the given name.
-     *
-     * @param name - Name of the runtime module to identify it by
-     * @param runtimeModule - Runtime module to register
-     */
-    registerRuntimeModule(name: string, runtimeModule: AnyConstructor): void;
-    /**
-     * Sets if proofs are enabled or not
-     * @param areProofsEnabled
-     */
-    setProofsEnabled(areProofsEnabled: boolean): void;
-    /**
-     * Precompiles the current runtime modules into a ZkProgram.
-     *
-     * @returns - Analysis of the precompiled ZkProgram
-     */
-    precompile(): {
-        analyze: (this: Chain<RuntimeModules>) => {
-            methodName: string;
-            analysis: {
-                rows: number;
-                gates: import("snarkyjs/dist/node/snarky.js").Gate[];
-                inputs: [] | [import("snarkyjs/dist/node/snarky.js").Provable<any> | ((new (...args: any) => Proof<unknown>) & {
-                    prototype: Proof<any>;
-                    publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
-                    tag: () => {
-                        name: string;
-                    };
-                    fromJSON: typeof Proof.fromJSON;
-                } & {
-                    prototype: Proof<unknown>;
-                }), ...(import("snarkyjs/dist/node/snarky.js").Provable<any> | ((new (...args: any) => Proof<unknown>) & {
-                    prototype: Proof<any>;
-                    publicInputType: import("snarkyjs/dist/node/lib/circuit_value.js").FlexibleProvablePure<any>;
-                    tag: () => {
-                        name: string;
-                    };
-                    fromJSON: typeof Proof.fromJSON;
-                } & {
-                    prototype: Proof<unknown>;
-                }))[]];
-            };
-        }[];
-        toPretty: () => void;
-    };
-    getProofClass(): Subclass<typeof Proof<MethodPublicInput>>;
-    /**
-     * Compiles the current runtime modules configuration
-     * into a ZkProgram and then into a verification key.
-     *
-     * @returns The resulting artifact of ZkProgram compilation (verification key)
-     */
-    compile(): Promise<{
-        verificationKey: string;
-    }>;
-}
-//# sourceMappingURL=Chain.d.ts.map

package/dist/chain/Chain.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Chain.d.ts","sourceRoot":"","sources":["../../src/chain/Chain.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAO5D,OAAO,EAAE,KAAK,cAAc,EAAmB,MAAM,wBAAwB,CAAC;AAE9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAErE,MAAM,WAAW,cAAc;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAAC;CAChC;AAED,MAAM,WAAW,WAAW,CAAC,mBAAmB,SAAS,cAAc;IACrE,KAAK,EAAE,YAAY,CAAC;IACpB,cAAc,EAAE,mBAAmB,CAAC;CACrC;AAyCD;;;GAGG;AACH,qBAAa,KAAK,CAAC,mBAAmB,SAAS,cAAc;IA2BjC,MAAM,EAAE,WAAW,CAAC,mBAAmB,CAAC;IA1BlE;;;;;OAKG;WACW,IAAI,CAAC,mBAAmB,SAAS,cAAc,EAC3D,MAAM,EAAE,WAAW,CAAC,mBAAmB,CAAC;IAM1C,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAsB;IAGhD,gBAAgB,UAAS;IAGzB,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,SAAS,CAAC,CAAC;IAE3D;;;;OAIG;gBACuB,MAAM,EAAE,WAAW,CAAC,mBAAmB,CAAC;IASlE;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,IAAW,kBAAkB,aAE5B;IAED;;;;;OAKG;IACI,gBAAgB,CAAC,GAAG,SAAS,MAAM,mBAAmB,EAAE,IAAI,EAAE,GAAG;IAexE;;;;;OAKG;IACI,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,cAAc;IAkCxE;;;OAGG;IACI,gBAAgB,CAAC,gBAAgB,EAAE,OAAO;IAIjD;;;;OAIG;IACI,UAAU;wBA8EQ,MAAM,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4CvC,aAAa,IAAI,QAAQ,CAAC,OAAO,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAcjE;;;;;OAKG;IACU,OAAO;;;CAcrB"}

package/dist/chain/Chain.js

@@ -1,229 +0,0 @@
-/* eslint-disable max-lines */
-import { container, Lifecycle } from "tsyringe";
-import { Experimental, Proof } from "snarkyjs";
-import { MethodPublicInput } from "@yab/protocol";
-import { combineMethodName, isMethod, toWrappedMethod, } from "../method/decorator.js";
-import { isRuntimeModule } from "../module/decorator.js";
-const errors = {
-    onlyStringNames: () => new TypeError("Only string names are supported"),
-    notRegistredRuntimeModule: (name) => new Error(`Unable to retrieve module: ${name}, it is not registred as a runtime module for this chain`),
-    missingDecorator: (name, runtimeModuleName) => new Error(`Unable to register module: ${name} / ${runtimeModuleName},
-      did you forget to add @runtimeModule()?`),
-    nonModuleDependecy: (runtimeModuleName) => new Error(`
-  Unable to register module: ${runtimeModuleName}, attempting to inject a non-module dependency`),
-    unknownDependency: (runtimeModuleName, name) => new Error(`Unable to register module: ${runtimeModuleName}, 
-      attempting to inject a dependency that is not registred 
-      as a runtime module for this chain: ${name}`),
-    unableToAnalyze: (name) => new Error(`Unable to analyze program for chain: ${name}`),
-    precompileFirst: () => new Error("You have to call precompile() before being able to create the proof class"),
-    zkProgramMissing: () => new Error("Unable to compile chain, pre-compilation did not produce a zkProgram"),
-};
-/**
- * Wrapper for an application specific chain, which helps orchestrate
- * runtime modules into an interoperable runtime.
- */
-export class Chain {
-    /**
-     * Alternative constructor for `Chain`.
-     *
-     * @param config - Configuration for the returned Chain
-     * @returns Chain with the provided config
-     */
-    static from(config) {
-        return new Chain(config);
-    }
-    /**
-     * Creates a new Chain from the provided config
-     *
-     * @param config - Configuration object for the constructed Chain
-     */
-    constructor(config) {
-        this.config = config;
-        // determines whether any proving should be done when running methods
-        this.areProofsEnabled = false;
-        this.runtimeContainer = container.createChildContainer();
-        Object.entries(this.config.runtimeModules).forEach(([name, runtimeModule]) => {
-            this.registerRuntimeModule(name, runtimeModule);
-        });
-    }
-    /**
-     * Add a name and other respective properties required by RuntimeModules,
-     * that come from the current Chain
-     *
-     * @param name - Name of the runtime module to decorate
-     */
-    decorateRuntimeModule(name) {
-        const runtimeModuleInstance = this.runtimeContainer.resolve(name);
-        runtimeModuleInstance.name = name;
-        runtimeModuleInstance.chain = this;
-    }
-    /**
-     * @returns A list of
-     */
-    get runtimeModuleNames() {
-        return Object.keys(this.config.runtimeModules);
-    }
-    /**
-     * Returns a runtime module registred under the given key.
-     *
-     * @param name - Name of the runtime module to get
-     * @returns A runtime module stored under the given key
-     */
-    getRuntimeModule(name) {
-        if (typeof name !== "string") {
-            throw errors.onlyStringNames();
-        }
-        if (!this.runtimeModuleNames.includes(name)) {
-            throw errors.notRegistredRuntimeModule(name);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return this.runtimeContainer.resolve(name);
-    }
-    /**
-     * Registers a runtime module under the given name.
-     *
-     * @param name - Name of the runtime module to identify it by
-     * @param runtimeModule - Runtime module to register
-     */
-    registerRuntimeModule(name, runtimeModule) {
-        if (!isRuntimeModule(runtimeModule)) {
-            throw errors.missingDecorator(name, runtimeModule.name);
-        }
-        this.runtimeContainer.register(name, {
-            useClass: runtimeModule,
-        }, {
-            lifecycle: Lifecycle.ContainerScoped,
-        });
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const dependencies = Reflect.getMetadata("design:paramtypes", runtimeModule);
-        dependencies?.forEach((dependency) => {
-            const name = typeof dependency === "string" ? dependency : dependency.name;
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-            if (!name) {
-                throw errors.nonModuleDependecy(runtimeModule.name);
-            }
-            if (!this.runtimeModuleNames.includes(name)) {
-                throw errors.unknownDependency(runtimeModule.name, name);
-            }
-        });
-        this.decorateRuntimeModule(name);
-    }
-    /**
-     * Sets if proofs are enabled or not
-     * @param areProofsEnabled
-     */
-    setProofsEnabled(areProofsEnabled) {
-        this.areProofsEnabled = areProofsEnabled;
-    }
-    /**
-     * Precompiles the current runtime modules into a ZkProgram.
-     *
-     * @returns - Analysis of the precompiled ZkProgram
-     */
-    precompile() {
-        const methods = this.runtimeModuleNames.reduce((allMethods, runtimeModuleName) => {
-            // eslint-disable-next-line max-len
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const runtimeModule = this.getRuntimeModule(runtimeModuleName);
-            // eslint-disable-next-line max-len
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            const modulePrototype = Object.getPrototypeOf(runtimeModule);
-            const modulePrototypeMethods = Object.getOwnPropertyNames(modulePrototype);
-            const moduleMethods = modulePrototypeMethods.reduce((allModuleMethods, methodName) => {
-                if (isMethod(runtimeModule, methodName)) {
-                    const combinedMethodName = combineMethodName(runtimeModuleName, methodName);
-                    const method = modulePrototype[methodName];
-                    const wrappedMethod = Reflect.apply(toWrappedMethod, runtimeModule, [methodName, method]);
-                    // eslint-disable-next-line no-warning-comments
-                    // TODO: find out how to import the Tuple type
-                    // eslint-disable-next-line max-len
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    const privateInputs = Reflect.getMetadata("design:paramtypes", runtimeModule, methodName);
-                    return {
-                        ...allModuleMethods,
-                        [combinedMethodName]: {
-                            // eslint-disable-next-line max-len
-                            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                            privateInputs,
-                            method: wrappedMethod,
-                        },
-                    };
-                }
-                return allModuleMethods;
-            }, {});
-            return {
-                ...allMethods,
-                ...moduleMethods,
-            };
-        }, {});
-        // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
-        const sortedMethods = Object.fromEntries(Object.entries(methods).sort());
-        this.program = Experimental.ZkProgram({
-            publicInput: MethodPublicInput,
-            methods: sortedMethods,
-        });
-        function analyze() {
-            if (!this.program) {
-                throw errors.unableToAnalyze(this.constructor.name);
-            }
-            const zkProgramAnalysis = this.program.analyzeMethods();
-            return Object.keys(sortedMethods).map((methodName, index) => {
-                const { rows, gates } = zkProgramAnalysis[index];
-                const { privateInputs: inputs } = sortedMethods[methodName];
-                return {
-                    methodName,
-                    analysis: {
-                        rows,
-                        gates,
-                        inputs,
-                    },
-                };
-            });
-        }
-        return {
-            analyze,
-            toPretty: () => {
-                Reflect.apply(analyze, this, []).forEach(({ methodName, analysis: methodAnalysis }) => {
-                    const inputs = methodAnalysis.inputs.map(
-                    // eslint-disable-next-line max-len
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
-                    (input) => input.name);
-                    console.log(`
-Method: ${methodName}
-Rows: ${methodAnalysis.rows},
-Gates: ${methodAnalysis.gates.length}
-Inputs: [${inputs.join(", ")}]
-`);
-                });
-            },
-        };
-    }
-    getProofClass() {
-        if (this.program === undefined) {
-            throw errors.precompileFirst();
-        }
-        const { program } = this;
-        return ((programClosure) => { var _a; return _a = class AppChainProof extends Proof {
-            },
-            _a.publicInputType = MethodPublicInput,
-            _a.tag = () => programClosure,
-            _a; })(program);
-    }
-    /**
-     * Compiles the current runtime modules configuration
-     * into a ZkProgram and then into a verification key.
-     *
-     * @returns The resulting artifact of ZkProgram compilation (verification key)
-     */
-    async compile() {
-        this.precompile();
-        if (!this.program) {
-            throw errors.zkProgramMissing();
-        }
-        const { areProofsEnabled, program } = this;
-        this.setProofsEnabled(false);
-        const artifact = await program.compile();
-        this.setProofsEnabled(areProofsEnabled);
-        return artifact;
-    }
-}

package/dist/method/MethodExecutionContext.d.ts

@@ -1,73 +0,0 @@
-import { Bool, type Proof } from "snarkyjs";
-import type { StateTransition, MethodPublicInput } from "@yab/protocol";
-export declare class MethodExecutionResult<ResultValue> {
-    stateTransitions: StateTransition<any>[];
-    status: Bool;
-    statusMessage?: string;
-    value?: ResultValue;
-    publicInput?: MethodPublicInput;
-    prove?: () => Promise<Proof<MethodPublicInput>>;
-}
-/**
- * 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 MethodExecutionContext<ResultValue> {
-    result: MethodExecutionResult<ResultValue>;
-    methods: string[];
-    constructor(result?: MethodExecutionResult<ResultValue>);
-    /**
-     * Adds an in-method generated state transition to the current context
-     * @param stateTransition - State transition to add to the context
-     */
-    addStateTransition<Value>(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 value = Return value of the executed method
-     */
-    setValue(value: ResultValue): void;
-    /**
-     * Adds a method prover to the current execution context,
-     * which can be collected and ran asynchronously at a later point in time.
-     *
-     * @param prove - Prover function to be ran later,
-     * when the method execution needs to be proven
-     */
-    setProve(prove: () => Promise<Proof<MethodPublicInput>>): void;
-    setPublicInput(publicInput: MethodPublicInput): void;
-    /**
-     * Adds a method to the method execution stack, reseting the execution context
-     * in a case a new top-level (non nested) method call is made.
-     *
-     * @param methodName - Name of the method being captured in the context
-     */
-    beforeMethod(methodName: string): void;
-    /**
-     * Removes the latest method from the execution context stack,
-     * keeping track of the amount of 'unfinished' methods. Allowing
-     * for the context to distinguish between top-level and nested method calls.
-     */
-    afterMethod(): void;
-    get isTopLevel(): boolean;
-    get isFinished(): boolean;
-    /**
-     * @returns - Current execution context state
-     */
-    current(): {
-        isFinished: boolean;
-        result: MethodExecutionResult<ResultValue>;
-    };
-    /**
-     * Manually clears/resets the execution context
-     */
-    clear(): void;
-}
-//# sourceMappingURL=MethodExecutionContext.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"MethodExecutionContext.d.ts","sourceRoot":"","sources":["../../src/method/MethodExecutionContext.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,KAAK,EAAE,MAAM,UAAU,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAExE,qBAAa,qBAAqB,CAAC,WAAW;IAErC,gBAAgB,EAAE,eAAe,CAAC,GAAG,CAAC,EAAE,CAAM;IAE9C,MAAM,EAAE,IAAI,CAAc;IAE1B,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,KAAK,CAAC,EAAE,WAAW,CAAC;IAEpB,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAEhC,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;CACxD;AAED;;;;GAIG;AACH,qBACa,sBAAsB,CAAC,WAAW;IAIpC,MAAM,EAAE,qBAAqB,CAAC,WAAW,CAAC;IAH5C,OAAO,EAAE,MAAM,EAAE,CAAM;gBAGrB,MAAM,GAAE,qBAAqB,CAAC,WAAW,CAA+B;IAGjF;;;OAGG;IACI,kBAAkB,CAAC,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,KAAK,CAAC;IAIxE;;OAEG;IACI,gBAAgB,CAAC,OAAO,CAAC,EAAE,MAAM;IAIxC;;OAEG;IACI,SAAS,CAAC,MAAM,EAAE,IAAI;IAI7B;;OAEG;IACI,QAAQ,CAAC,KAAK,EAAE,WAAW;IAIlC;;;;;;OAMG;IACI,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAIvD,cAAc,CAAC,WAAW,EAAE,iBAAiB;IAEpD;;;;;OAKG;IACI,YAAY,CAAC,UAAU,EAAE,MAAM;IAOtC;;;;OAIG;IACI,WAAW;IAIlB,IAAW,UAAU,YAEpB;IAED,IAAW,UAAU,YAEpB;IAED;;OAEG;IACI,OAAO,IAAI;QAChB,UAAU,EAAE,OAAO,CAAC;QACpB,MAAM,EAAE,qBAAqB,CAAC,WAAW,CAAC,CAAC;KAC5C;IAOD;;OAEG;IACI,KAAK;CAGb"}