@proto-kit/protocol 0.1.1-develop.165 → 0.1.1-develop.186

package/dist/config/ConfigurationAggregator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConfigurationAggregator.d.ts","sourceRoot":"","sources":["../../src/config/ConfigurationAggregator.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,eAAe,EACf,UAAU,EACV,mBAAmB,EACnB,4BAA4B,EAC7B,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,8BAAsB,uBAAuB,CAAC,KAAK,SAAS,UAAU;IACpE,SAAS,CAAC,WAAW,CACnB,OAAO,EAAE,KAAK,EACd,aAAa,EAAE,4BAA4B,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,EACnE,MAAM,EAAE,mBAAmB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,GAClD,eAAe,CAAC,KAAK,CAAC;aAgCT,SAAS,CACvB,MAAM,EAAE,mBAAmB,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,GAClD,IAAI;CACR"}

package/dist/config/ConfigurationAggregator.js

@@ -1,35 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any,guard-for-in,@typescript-eslint/no-unsafe-member-access,max-len,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/consistent-type-assertions */
-import merge from "lodash/merge";
-/**
- * In this context, a "Component" is just a way of generalizing Modules,
- * because they don't have to be modules, they can be any configurable unit
- */
-export class ConfigurationAggregator {
-    applyConfig(modules, currentConfig, config) {
-        const nextConfig = {};
-        for (const key in config) {
-            // Set config to module
-            if (currentConfig[key] === undefined) {
-                // Initialize config with merge between config and defaultConfig
-                // eslint-disable-next-line prefer-destructuring,putout/putout
-                const defaultConfig = modules[key].defaultConfig;
-                const newConfig = config[key];
-                for (const configKey in newConfig) {
-                    defaultConfig[configKey] = newConfig[configKey];
-                }
-                // The result of that is always a valid Required<Config> since FlipOptional<Config> requires the exact opposite of Config
-                modules[key].config = defaultConfig;
-                nextConfig[key] = defaultConfig;
-            }
-            else {
-                // Append/overwrite to existing config
-                const newConfig = config[key];
-                const moduleConfig = currentConfig[key];
-                merge(moduleConfig, newConfig);
-                modules[key].config = moduleConfig;
-                nextConfig[key] = moduleConfig;
-            }
-        }
-        return nextConfig;
-    }
-}

package/dist/config/ConfigurationReceiver.d.ts

@@ -1,25 +0,0 @@
-import type { FlipOptional } from "./types";
-/**
- * Configs:
- *
- * A property that accepts undefined, is an optional argument.
- * That means that you will have to provide it via defaultConfig() and it will
- * be non-undefined via this.config. This is used by devs to indicate
- * configurability but not necessary explicit definition.
- * I.e. when the default arguments will work most of the time
- *
- * If devs want a property that can be undefined, they should use null instead
- *
- */
-export declare abstract class ConfigurationReceiver<Config> {
-    private currentConfig?;
-    /**
-     * Retrieves the configured config object.
-     * This is only available in instance methods like start(), using this in
-     * the constructor will throw an Exception
-     */
-    get config(): Required<Config>;
-    set config(config: Required<Config>);
-    abstract get defaultConfig(): FlipOptional<Config>;
-}
-//# sourceMappingURL=ConfigurationReceiver.d.ts.map

package/dist/config/ConfigurationReceiver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ConfigurationReceiver.d.ts","sourceRoot":"","sources":["../../src/config/ConfigurationReceiver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAO5C;;;;;;;;;;;GAWG;AACH,8BAAsB,qBAAqB,CAAC,MAAM;IAChD,OAAO,CAAC,aAAa,CAAC,CAA+B;IAErD;;;;OAIG;IACH,IAAW,MAAM,IAAI,QAAQ,CAAC,MAAM,CAAC,CAOpC;IAED,IAAW,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EAEzC;IAED,aAAoB,aAAa,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;CAC3D"}

package/dist/config/ConfigurationReceiver.js

@@ -1,36 +0,0 @@
-const errors = {
-    configNotSet: (name) => new Error(`RuntimeModule (${name}) config has not been set!`),
-};
-/**
- * Configs:
- *
- * A property that accepts undefined, is an optional argument.
- * That means that you will have to provide it via defaultConfig() and it will
- * be non-undefined via this.config. This is used by devs to indicate
- * configurability but not necessary explicit definition.
- * I.e. when the default arguments will work most of the time
- *
- * If devs want a property that can be undefined, they should use null instead
- *
- */
-export class ConfigurationReceiver {
-    constructor() {
-        this.currentConfig = undefined;
-    }
-    /**
-     * Retrieves the configured config object.
-     * This is only available in instance methods like start(), using this in
-     * the constructor will throw an Exception
-     */
-    get config() {
-        if (this.currentConfig === undefined) {
-            // eslint-disable-next-line no-warning-comments
-            // TODO Check properly, Config could also be void
-            throw errors.configNotSet(this.constructor.name);
-        }
-        return this.currentConfig;
-    }
-    set config(config) {
-        this.currentConfig = config;
-    }
-}

package/dist/config/ModuleContainer.d.ts

@@ -1,44 +0,0 @@
-import { Frequency, InjectionToken } from "tsyringe";
-import { TypedClassConstructor } from "../utils/utils";
-import { Configurable, ConfigurableModule } from "./ConfigurableModule";
-export declare const errors: {
-    configNotSet: (moduleName: string) => Error;
-    configNotSetInContainer: (moduleName: string) => Error;
-    onlyStringModuleNames: (moduleName: NonNullable<unknown>) => Error;
-    unableToDecorateModule: (moduleName: InjectionToken<unknown>) => Error;
-    nonModuleDependecy: (runtimeModuleName: string) => Error;
-    unknownDependency: (runtimeModuleName: string, name: string) => Error;
-};
-export type BaseModuleType = TypedClassConstructor<Configurable<unknown>>;
-export interface ModulesRecord<ModuleType extends BaseModuleType = BaseModuleType> {
-    [name: string]: ModuleType;
-}
-export type ModulesConfig<Modules extends ModulesRecord> = {
-    [ConfigKey in keyof Modules]: InstanceType<Modules[ConfigKey]>["config"];
-};
-export declare abstract class ModuleContainer<Modules extends ModulesRecord, Config extends ModulesConfig<Modules>> {
-    definition: {
-        modules: Modules;
-        config?: Config;
-    };
-    static moduleDecorationFrequency: Frequency;
-    container: import("tsyringe").DependencyContainer;
-    constructor(definition: {
-        modules: Modules;
-        config?: Config;
-    });
-    get moduleNames(): string[];
-    validateModule<ModuleName extends keyof Modules>(moduleName: ModuleName | string, containedModule: ConfigurableModule<unknown>): void;
-    registerModules(modules: Modules): void;
-    registerValue<Value>(modules: Record<string, Value>): void;
-    configure(config: Config): void;
-    resolve<ModuleName extends keyof Modules>(moduleName: ModuleName): InstanceType<Modules[ModuleName]>;
-    moduleNameToString<ModuleName extends keyof Modules>(moduleName: ModuleName | string): string;
-    /**
-     * Override this in the child class to provide custom
-     * features or module checks
-     */
-    decorateModule<ModuleName extends keyof Modules>(moduleName: ModuleName | string, containedModule: InstanceType<Modules[ModuleName]>): void;
-    onAfterModuleResolution<ModuleName extends keyof Modules>(moduleName: ModuleName | string): void;
-}
-//# sourceMappingURL=ModuleContainer.d.ts.map

package/dist/config/ModuleContainer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModuleContainer.d.ts","sourceRoot":"","sources":["../../src/config/ModuleContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAE,cAAc,EAAa,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAExE,eAAO,MAAM,MAAM;+BACU,MAAM;0CAKK,MAAM;wCAKR,YAAY,OAAO,CAAC;yCAMnB,eAAe,OAAO,CAAC;4CAIpB,MAAM;2CAIP,MAAM,QAAQ,MAAM;CAM5D,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,qBAAqB,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC;AAC1E,MAAM,WAAW,aAAa,CAC5B,UAAU,SAAS,cAAc,GAAG,cAAc;IAElD,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC5B;AAED,MAAM,MAAM,aAAa,CAAC,OAAO,SAAS,aAAa,IAAI;KACxD,SAAS,IAAI,MAAM,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC;CACzE,CAAC;AAEF,8BAAsB,eAAe,CACnC,OAAO,SAAS,aAAa,EAC7B,MAAM,SAAS,aAAa,CAAC,OAAO,CAAC;IAO5B,UAAU,EAAE;QACjB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IARH,OAAc,yBAAyB,EAAE,SAAS,CAAU;IAErD,SAAS,yCAAoC;gBAG3C,UAAU,EAAE;QACjB,OAAO,EAAE,OAAO,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IAKH,IAAW,WAAW,aAErB;IAEM,cAAc,CAAC,UAAU,SAAS,MAAM,OAAO,EACpD,UAAU,EAAE,UAAU,GAAG,MAAM,EAC/B,eAAe,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAC3C,IAAI;IAsBA,eAAe,CAAC,OAAO,EAAE,OAAO;IAahC,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC;IAMnD,SAAS,CAAC,MAAM,EAAE,MAAM;IAIxB,OAAO,CAAC,UAAU,SAAS,MAAM,OAAO,EAC7C,UAAU,EAAE,UAAU,GACrB,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAI7B,kBAAkB,CAAC,UAAU,SAAS,MAAM,OAAO,EACxD,UAAU,EAAE,UAAU,GAAG,MAAM,GAC9B,MAAM;IAQT;;;OAGG;IACI,cAAc,CAAC,UAAU,SAAS,MAAM,OAAO,EACpD,UAAU,EAAE,UAAU,GAAG,MAAM,EAC/B,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAa7C,uBAAuB,CAAC,UAAU,SAAS,MAAM,OAAO,EAC7D,UAAU,EAAE,UAAU,GAAG,MAAM;CAclC"}

package/dist/config/ModuleContainer.js

@@ -1,89 +0,0 @@
-import { container, Lifecycle } from "tsyringe";
-export const errors = {
-    configNotSet: (moduleName) => new Error(`Trying to retrieve config of ${moduleName}, which was not yet set`),
-    configNotSetInContainer: (moduleName) => new Error(`Trying to set config of ${moduleName}, but it was not yet set in the module container`),
-    onlyStringModuleNames: (moduleName) => new Error(
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
-    `Only string module names, using ${typeof moduleName} instead: ${moduleName.toString()}`),
-    unableToDecorateModule: (moduleName) => 
-    // eslint-disable-next-line @typescript-eslint/no-base-to-string
-    new Error(`Unable to decorate module ${moduleName.toString()}`),
-    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}`),
-};
-export class ModuleContainer {
-    constructor(definition) {
-        this.definition = definition;
-        this.container = container.createChildContainer();
-        this.registerModules(definition.modules);
-    }
-    get moduleNames() {
-        return Object.keys(this.definition.modules);
-    }
-    validateModule(moduleName, containedModule) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const dependencies = Reflect.getMetadata("design:paramtypes", containedModule);
-        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(this.moduleNameToString(moduleName));
-            }
-            if (!this.moduleNames.includes(name)) {
-                throw errors.unknownDependency(this.moduleNameToString(moduleName), name);
-            }
-        });
-    }
-    registerModules(modules) {
-        for (const moduleName in modules) {
-            if (Object.prototype.hasOwnProperty.call(modules, moduleName)) {
-                this.container.register(moduleName, { useClass: modules[moduleName] }, { lifecycle: Lifecycle.ContainerScoped });
-                this.onAfterModuleResolution(moduleName);
-            }
-        }
-    }
-    registerValue(modules) {
-        Object.entries(modules).forEach(([moduleName, useValue]) => {
-            this.container.register(moduleName, { useValue });
-        });
-    }
-    configure(config) {
-        this.definition.config = config;
-    }
-    resolve(moduleName) {
-        return this.container.resolve(this.moduleNameToString(moduleName));
-    }
-    moduleNameToString(moduleName) {
-        if (typeof moduleName !== "string") {
-            throw errors.onlyStringModuleNames(moduleName);
-        }
-        return moduleName;
-    }
-    /**
-     * Override this in the child class to provide custom
-     * features or module checks
-     */
-    decorateModule(moduleName, containedModule) {
-        const moduleNameString = this.moduleNameToString(moduleName);
-        const config = this.definition.config?.[moduleNameString];
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (!config) {
-            throw errors.configNotSetInContainer(moduleNameString);
-        }
-        containedModule.config = config;
-    }
-    onAfterModuleResolution(moduleName) {
-        this.container.afterResolution(
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        moduleName, (containedModuleName, containedModule) => {
-            if (Array.isArray(containedModule)) {
-                throw errors.unableToDecorateModule(containedModuleName);
-            }
-            this.decorateModule(moduleName, containedModule);
-        }, { frequency: ModuleContainer.moduleDecorationFrequency });
-    }
-}
-ModuleContainer.moduleDecorationFrequency = "Once";

package/dist/config/types.d.ts

@@ -1,2 +0,0 @@
-export type TypedClassConstructor<Type> = new (...args: any[]) => Type;
-//# sourceMappingURL=types.d.ts.map

package/dist/config/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/config/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,CAAC,IAAI,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC"}

package/dist/config/types.js

@@ -1 +0,0 @@
-export {};

package/dist/model/MethodPublicInput.d.ts

@@ -1,51 +0,0 @@
-import { Bool, Field } from "snarkyjs";
-declare const MethodPublicInput_base: (new (value: {
-    stateTransitionsHash: Field;
-    status: Bool;
-    transactionHash: Field;
-}) => {
-    stateTransitionsHash: Field;
-    status: Bool;
-    transactionHash: Field;
-}) & {
-    _isStruct: true;
-} & import("snarkyjs/dist/node/snarky").ProvablePure<{
-    stateTransitionsHash: Field;
-    status: Bool;
-    transactionHash: Field;
-}> & {
-    toInput: (x: {
-        stateTransitionsHash: Field;
-        status: Bool;
-        transactionHash: Field;
-    }) => {
-        fields?: Field[] | undefined;
-        packed?: [Field, number][] | undefined;
-    };
-    toJSON: (x: {
-        stateTransitionsHash: Field;
-        status: Bool;
-        transactionHash: Field;
-    }) => {
-        stateTransitionsHash: string;
-        status: boolean;
-        transactionHash: string;
-    };
-    fromJSON: (x: {
-        stateTransitionsHash: string;
-        status: boolean;
-        transactionHash: string;
-    }) => {
-        stateTransitionsHash: Field;
-        status: Bool;
-        transactionHash: Field;
-    };
-};
-/**
- * Public input used to link in-circuit execution with
- * the proof's public input.
- */
-export declare class MethodPublicInput extends MethodPublicInput_base {
-}
-export {};
-//# sourceMappingURL=MethodPublicInput.d.ts.map

package/dist/model/MethodPublicInput.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MethodPublicInput.d.ts","sourceRoot":"","sources":["../../src/model/MethodPublicInput.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAU,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE/C;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,sBAIrC;CAAG"}

package/dist/model/MethodPublicInput.js

@@ -1,11 +0,0 @@
-import { Bool, Field, Struct } from "snarkyjs";
-/**
- * Public input used to link in-circuit execution with
- * the proof's public input.
- */
-export class MethodPublicInput extends Struct({
-    stateTransitionsHash: Field,
-    status: Bool,
-    transactionHash: Field,
-}) {
-}

package/dist/prover/block/BlockScopedModule.d.ts

@@ -1,3 +0,0 @@
-declare const nothing = 1;
-export { nothing };
-//# sourceMappingURL=BlockScopedModule.d.ts.map

package/dist/prover/block/BlockScopedModule.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BlockScopedModule.d.ts","sourceRoot":"","sources":["../../../src/prover/block/BlockScopedModule.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,OAAO,IAAI,CAAC;AAClB,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/prover/block/BlockScopedModule.js

@@ -1,6 +0,0 @@
-// Placeholder for a future module architecture that can plug into the BlockProver
-// export interface BlockScopedModule {
-//
-// }
-const nothing = 1;
-export { nothing };

package/dist/src/model/Option.d.ts

@@ -1,158 +0,0 @@
-import { Bool, Field, type FlexibleProvablePure } from "snarkyjs";
-export declare function ProvableOption(value: { isSome: Bool; value: Field }): {
-  isSome: {
-    toField: {};
-    not: {};
-    and: {};
-    or: {};
-    assertEquals: {};
-    assertTrue: {};
-    assertFalse: {};
-    equals: {};
-    sizeInFields: {};
-    toFields: {};
-    toString: {};
-    toJSON: {};
-    toBoolean: {};
-  };
-  value: {
-    neg: {};
-    inv: {};
-    add: {};
-    sub: {};
-    mul: {};
-    div: {};
-    square: {};
-    sqrt: {};
-    toString: {};
-    toBigInt: {};
-    toJSON: {};
-    sizeInFields: {};
-    toFields: {};
-    lessThan: {};
-    lessThanOrEqual: {};
-    greaterThan: {};
-    greaterThanOrEqual: {};
-    assertLessThan: {};
-    assertLessThanOrEqual: {};
-    assertGreaterThan: {};
-    assertGreaterThanOrEqual: {};
-    lt: {};
-    lte: {};
-    gt: {};
-    gte: {};
-    assertLt: {};
-    assertLte: {};
-    assertGt: {};
-    assertGte: {};
-    assertEquals: {};
-    assertBool: {};
-    assertBoolean: {};
-    isZero: {};
-    toBits: {};
-    equals: {};
-    seal: {};
-    rangeCheckHelper: {};
-    isConstant: {};
-    toConstant: {};
-    fromFields: {};
-  };
-};
-export type ProvableOptionStruct = ReturnType<typeof ProvableOption>;
-/**
- * Option facilitating in-circuit values that may or may not exist.
- */
-export declare class Option<Value> {
-  isSome: Bool;
-  value: Value;
-  valueType: FlexibleProvablePure<Value>;
-  /**
-   * Creates a new Option from the provided parameters
-   *
-   * @param isSome
-   * @param value
-   * @param valueType
-   * @returns New option from the provided parameters.
-   */
-  static from<Value>(
-    isSome: Bool,
-    value: Value,
-    valueType: FlexibleProvablePure<Value>
-  ): Option<Value>;
-  /**
-   * @returns Empty / none option
-   */
-  static none(): Option<Field>;
-  constructor(
-    isSome: Bool,
-    value: Value,
-    valueType: FlexibleProvablePure<Value>
-  );
-  /**
-   * @returns Tree representation of the current value
-   */
-  get treeValue(): Field;
-  /**
-   * @returns Provable representation of the current option.
-   */
-  toProvable(): {
-    isSome: {
-      toField: {};
-      not: {};
-      and: {};
-      or: {};
-      assertEquals: {};
-      assertTrue: {};
-      assertFalse: {};
-      equals: {};
-      sizeInFields: {};
-      toFields: {};
-      toString: {};
-      toJSON: {};
-      toBoolean: {};
-    };
-    value: {
-      neg: {};
-      inv: {};
-      add: {};
-      sub: {};
-      mul: {};
-      div: {};
-      square: {};
-      sqrt: {};
-      toString: {};
-      toBigInt: {};
-      toJSON: {};
-      sizeInFields: {};
-      toFields: {};
-      lessThan: {};
-      lessThanOrEqual: {};
-      greaterThan: {};
-      greaterThanOrEqual: {};
-      assertLessThan: {};
-      assertLessThanOrEqual: {};
-      assertGreaterThan: {};
-      assertGreaterThanOrEqual: {};
-      lt: {};
-      lte: {};
-      gt: {};
-      gte: {};
-      assertLt: {};
-      assertLte: {};
-      assertGt: {};
-      assertGte: {};
-      assertEquals: {};
-      assertBool: {};
-      assertBoolean: {};
-      isZero: {};
-      toBits: {};
-      equals: {};
-      seal: {};
-      rangeCheckHelper: {};
-      isConstant: {};
-      toConstant: {};
-      fromFields: {};
-    };
-  };
-}
-//# sourceMappingURL=Option.d.ts.map

package/dist/src/model/Option.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../../src/model/Option.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAW,KAAK,EAAE,KAAK,oBAAoB,EAAoB,MAAM,UAAU,CAAC;AAE7F,wBAAgB,cAAc,CAAC,KAAK,EAAE;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAInE;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AAErE;;GAEG;AACH,qBAAa,MAAM,CAAC,KAAK;IAoBG,MAAM,EAAE,IAAI;IAAS,KAAK,EAAE,KAAK;IAAS,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAnB1G;;;;;;;OAOG;WACW,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAI5F;;OAEG;WACW,IAAI;gBAIQ,MAAM,EAAE,IAAI,EAAS,KAAK,EAAE,KAAK,EAAS,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAE1G;;OAEG;IACH,IAAW,SAAS,UAMnB;IAED;;OAEG;IACI,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMlB"}

package/dist/src/model/Option.js

@@ -1,53 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-/* eslint-disable new-cap */
-/* eslint-disable max-classes-per-file */
-import { Bool, Circuit, Field, Poseidon, Struct } from "snarkyjs";
-export function ProvableOption(value) {
-  class ProvableOptionStruct extends Struct(value) {}
-  return new ProvableOptionStruct(value);
-}
-/**
- * Option facilitating in-circuit values that may or may not exist.
- */
-export class Option {
-  /**
-   * Creates a new Option from the provided parameters
-   *
-   * @param isSome
-   * @param value
-   * @param valueType
-   * @returns New option from the provided parameters.
-   */
-  static from(isSome, value, valueType) {
-    return new Option(isSome, value, valueType);
-  }
-  /**
-   * @returns Empty / none option
-   */
-  static none() {
-    return new Option(Bool(false), Field(0), Field);
-  }
-  constructor(isSome, value, valueType) {
-    this.isSome = isSome;
-    this.value = value;
-    this.valueType = valueType;
-  }
-  /**
-   * @returns Tree representation of the current value
-   */
-  get treeValue() {
-    const treeValue = Poseidon.hash(this.valueType.toFields(this.value));
-    // if the sequencer claims the value is `None`,
-    // then we use Field(0) as the treeValue so it can be proven later
-    return Circuit.if(this.isSome, treeValue, Field(0));
-  }
-  /**
-   * @returns Provable representation of the current option.
-   */
-  toProvable() {
-    return ProvableOption({
-      isSome: this.isSome,
-      value: this.treeValue,
-    });
-  }
-}

package/dist/src/model/Path.d.ts

@@ -1,35 +0,0 @@
-import { Field, type FlexibleProvablePure } from "snarkyjs";
-/**
- * Helps manage path (key) identifiers for key-values in trees.
- */
-export declare class Path {
-  /**
-   * Encodes a JS string as a Field
-   *
-   * @param value
-   * @returns Field representation of the provided value
-   */
-  static toField(value: string): Field;
-  /**
-   * Encodes a class name and its property name into a Field
-   *
-   * @param className
-   * @param propertyKey
-   * @returns Field representation of class name + property name
-   */
-  static fromProperty(className: string, propertyKey: string): Field;
-  /**
-   * Encodes an existing path with the provided key into a single Field.
-   *
-   * @param path
-   * @param keyType
-   * @param key
-   * @returns Field representation of the leading path + the provided key.
-   */
-  static fromKey<KeyType>(
-    path: Field,
-    keyType: FlexibleProvablePure<KeyType>,
-    key: KeyType
-  ): Field;
-}
-//# sourceMappingURL=Path.d.ts.map

package/dist/src/model/Path.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../../src/model/Path.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,KAAK,oBAAoB,EAAY,MAAM,UAAU,CAAC;AAEtE;;GAEG;AACH,qBAAa,IAAI;IACf;;;;;OAKG;WACW,OAAO,CAAC,KAAK,EAAE,MAAM;IAUnC;;;;;;OAMG;WACW,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,KAAK;IAQzE;;;;;;;OAOG;WACW,OAAO,CAAC,OAAO,EAC3B,IAAI,EAAE,KAAK,EACX,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,GAAG,EAAE,OAAO,GACX,KAAK;CAIT"}

package/dist/src/model/Path.js

@@ -1,51 +0,0 @@
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-/* eslint-disable new-cap */
-/* eslint-disable @typescript-eslint/no-extraneous-class */
-/* eslint-disable @shopify/no-fully-static-classes */
-/* eslint-disable import/prefer-default-export */
-import { Field, Poseidon } from "snarkyjs";
-/**
- * Helps manage path (key) identifiers for key-values in trees.
- */
-export class Path {
-  /**
-   * Encodes a JS string as a Field
-   *
-   * @param value
-   * @returns Field representation of the provided value
-   */
-  static toField(value) {
-    const fields = value
-      .split("")
-      .map((character) => character.codePointAt(0))
-      .filter((code) => code !== undefined)
-      .map((code) => Field(code));
-    return Poseidon.hash(fields);
-  }
-  /**
-   * Encodes a class name and its property name into a Field
-   *
-   * @param className
-   * @param propertyKey
-   * @returns Field representation of class name + property name
-   */
-  static fromProperty(className, propertyKey) {
-    return Poseidon.hash([
-      Path.toField(className),
-      Path.toField(propertyKey),
-      Field(0),
-    ]);
-  }
-  /**
-   * Encodes an existing path with the provided key into a single Field.
-   *
-   * @param path
-   * @param keyType
-   * @param key
-   * @returns Field representation of the leading path + the provided key.
-   */
-  static fromKey(path, keyType, key) {
-    const keyHash = Poseidon.hash(keyType.toFields(key));
-    return Poseidon.hash([path, keyHash]);
-  }
-}