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

package/src/runtime/RuntimeModule.ts

@@ -7,6 +7,7 @@ import {
   RuntimeMethodExecutionData,
 } from "../method/RuntimeMethodExecutionContext";
 import { StateService } from "../state/InMemoryStateService";
+import { runtimeMethodNamesMetadataKey } from "../method/runtimeMethod";
 
 import type {
   Runtime,
@@ -36,6 +37,11 @@ export interface PartialRuntime
 export class RuntimeModule<Config> extends ConfigurableModule<Config> {
   public static presets: Presets<unknown> = {};
 
+  /**
+   * Holds all method names that are callable throw transactions
+   */
+  public readonly runtimeMethodNames: string[] = [];
+
   /**
    * This property exists only to typecheck that the RuntimeModule
    * was extended correctly in e.g. a decorator. We need at least
@@ -45,8 +51,20 @@ export class RuntimeModule<Config> extends ConfigurableModule<Config> {
 
   public name?: string;
 
+  public test?: number;
+
   public runtime?: Runtime<RuntimeModulesRecord>;
 
+  public constructor() {
+    super();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const methodNames: string[] | undefined = Reflect.getMetadata(
+      runtimeMethodNamesMetadataKey,
+      this
+    );
+    this.runtimeMethodNames = methodNames ?? [];
+  }
+
   private getInputs(): RuntimeMethodExecutionData {
     const { input } = container.resolve<RuntimeMethodExecutionContext>(
       RuntimeMethodExecutionContext

package/test/Runtime.test.ts

@@ -1,23 +1,29 @@
+import { Bool } from "snarkyjs";
+
 import { InMemoryStateService, Runtime } from "../src";
+
 import { Balances } from "./modules/Balances";
-import { Bool } from "snarkyjs";
 
 describe("runtime", () => {
-
   it("should encode methodnames correctly", () => {
+    expect.assertions(2);
+
     const runtime = Runtime.from({
       state: new InMemoryStateService(),
+
       modules: {
-        Balances: Balances
+        Balances,
       },
+
       config: {
         Balances: {
-          test: Bool(true)
-        }
-      }
-    })
+          test: Bool(true),
+        },
+      },
+    });
+
+    const balances = runtime.resolve("Balances");
 
-    const balances = runtime.resolve("Balances")
     expect(balances).toBeDefined();
 
     console.log(Object.keys(balances));
@@ -26,12 +32,13 @@ describe("runtime", () => {
     const moduleName = "Balances";
     const methodName = "getTotalSupply";
 
-    const methodId = runtime.getMethodId(moduleName, methodName);
-    const method = runtime.getMethodById(methodId)
+    const methodId = runtime.methodIdResolver.getMethodId(
+      moduleName,
+      methodName
+    );
+    const method = runtime.getMethodById(methodId);
 
     // eslint-disable-next-line jest/no-restricted-matchers
     expect(method).toBeDefined();
-
-  })
-
-})
+  });
+});

package/test/modules/Balances.ts

@@ -48,4 +48,9 @@ export class Balances extends RuntimeModule<BalancesConfig> {
   public getBalance(address: PublicKey): Option<UInt64> {
     return this.balances.get(address);
   }
+
+  @runtimeMethod()
+  public setBalanceIf() {
+
+  }
 }

package/test/modules/methodId.test.ts

@@ -0,0 +1,85 @@
+import "reflect-metadata";
+import { Bool, Field } from "snarkyjs";
+import { beforeAll, beforeEach } from "@jest/globals";
+
+import { Runtime } from "../../src/runtime/Runtime";
+import { MethodIdResolver } from "../../src/runtime/MethodIdResolver";
+import {
+  assert,
+  InMemoryStateService,
+  runtimeMethod,
+  RuntimeModule,
+  runtimeModule,
+} from "../../src";
+import { container } from "tsyringe";
+import { Balances } from "./Balances";
+
+interface AdminConfig {}
+
+@runtimeModule()
+class Admin extends RuntimeModule<AdminConfig> {
+  @runtimeMethod()
+  public isAdminWithAVeryVeryVeryVeryLongName() {
+    assert(Field(1).equals(Field(1)));
+  }
+}
+
+describe("methodId", () => {
+  let runtime: Runtime<{ Admin: typeof Admin; Balance: typeof Balances }>;
+  let resolver: MethodIdResolver;
+
+  beforeAll(() => {
+    container.clearInstances();
+
+    runtime = Runtime.from({
+      modules: {
+        Admin,
+        Balance: Balances,
+      },
+
+      config: {
+        Admin: {},
+        Balance: {
+          test: Bool(true),
+        },
+      },
+
+      state: new InMemoryStateService(),
+    });
+    runtime.start();
+
+    resolver =
+      runtime.dependencyContainer.resolve<MethodIdResolver>("MethodIdResolver");
+  });
+
+  it.each([
+    ["Admin", "isAdminWithAVeryVeryVeryVeryLongName"],
+    ["Balance", "getTotalSupply"],
+    ["Balance", "getBalance"],
+    ["Balance", "setBalanceIf"],
+  ])(
+    "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/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"}