@proto-kit/common 0.1.1-develop.153

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./config/ModuleContainer";
+export * from "./config/ConfigurableModule";
+export * from "./types";
+export * from "./zkProgrammable/ZkProgrammable";
+export * from "./zkProgrammable/ProvableMethodExecutionContext";
+export * from "./zkProgrammable/provableMethod";
+export * from "./utils";
+export { default as log } from "loglevel";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,SAAS,CAAC;AACxB,cAAc,iCAAiC,CAAC;AAChD,cAAc,iDAAiD,CAAC;AAChE,cAAc,iCAAiC,CAAC;AAChD,cAAc,SAAS,CAAC;AAExB,OAAO,EAAE,OAAO,IAAI,GAAG,EAAE,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./config/ModuleContainer";
+export * from "./config/ConfigurableModule";
+export * from "./types";
+export * from "./zkProgrammable/ZkProgrammable";
+export * from "./zkProgrammable/ProvableMethodExecutionContext";
+export * from "./zkProgrammable/provableMethod";
+export * from "./utils";
+// eslint-disable-next-line import/no-unused-modules
+export { default as log } from "loglevel";

package/dist/model/MethodPublicInput.d.ts

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,11 @@
+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/model/Option.d.ts

@@ -0,0 +1,89 @@
+import { Bool, Field, type FlexibleProvablePure } from "snarkyjs";
+declare const ProvableOption_base: (new (value: {
+    isSome: Bool;
+    value: Field;
+}) => {
+    isSome: Bool;
+    value: Field;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky").ProvablePure<{
+    isSome: Bool;
+    value: Field;
+}> & {
+    toInput: (x: {
+        isSome: Bool;
+        value: Field;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        isSome: Bool;
+        value: Field;
+    }) => {
+        isSome: boolean;
+        value: string;
+    };
+    fromJSON: (x: {
+        isSome: boolean;
+        value: string;
+    }) => {
+        isSome: Bool;
+        value: Field;
+    };
+};
+export declare class ProvableOption extends ProvableOption_base {
+    toSome(): this;
+}
+/**
+ * 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>;
+    /**
+     * Creates a new Option from the provided parameters
+     *
+     * @param value
+     * @param valueType
+     * @returns New option from the provided parameters.
+     */
+    static fromValue<Value>(value: Value, valueType: FlexibleProvablePure<Value>): Option<Value>;
+    /**
+     * @returns Empty / none option
+     */
+    static none(): Option<Field>;
+    static dummyValueFields<Value>(valueType: FlexibleProvablePure<Value>): Field[];
+    /**
+     * Computes a dummy value for the given value type.
+     *
+     * @param valueType - Value type to generate the dummy value for
+     * @returns Dummy value for the given value type
+     */
+    static dummyValue<Value>(valueType: FlexibleProvablePure<Value>): Value;
+    isForcedSome: Bool;
+    constructor(isSome: Bool, value: Value, valueType: FlexibleProvablePure<Value>);
+    clone(): Option<Value>;
+    forceSome(): void;
+    /**
+     * @returns Tree representation of the current value
+     */
+    get treeValue(): Field;
+    /**
+     * @returns Provable representation of the current option.
+     */
+    toProvable(): ProvableOption;
+}
+export {};
+//# sourceMappingURL=Option.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Option.d.ts","sourceRoot":"","sources":["../../src/model/Option.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAEJ,KAAK,EACL,KAAK,oBAAoB,EAG1B,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElB,qBAAa,cAAe,SAAQ,mBAGlC;IACO,MAAM;CAId;AAED;;GAEG;AACH,qBAAa,MAAM,CAAC,KAAK;IA+Dd,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAhE/C;;;;;;;OAOG;WACW,IAAI,CAAC,KAAK,EACtB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAKxC;;;;;;OAMG;WACW,SAAS,CAAC,KAAK,EAC3B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAKxC;;OAEG;WACW,IAAI;WAIJ,gBAAgB,CAAC,KAAK,EAClC,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,GACrC,KAAK,EAAE;IAKV;;;;;OAKG;WACW,UAAU,CAAC,KAAK,EAC5B,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,GACrC,KAAK;IAOD,YAAY,OAAe;gBAGzB,MAAM,EAAE,IAAI,EACZ,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAGxC,KAAK;IAIL,SAAS;IAKhB;;OAEG;IACH,IAAW,SAAS,UAQnB;IAED;;OAEG;IACI,UAAU;CAMlB"}

package/dist/model/Option.js

@@ -0,0 +1,86 @@
+import { Bool, Circuit, Field, Poseidon, Struct, } from "snarkyjs";
+export class ProvableOption extends Struct({
+    isSome: Bool,
+    value: Field,
+}) {
+    toSome() {
+        this.isSome = Bool(true);
+        return this;
+    }
+}
+/**
+ * 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);
+    }
+    /**
+     * Creates a new Option from the provided parameters
+     *
+     * @param value
+     * @param valueType
+     * @returns New option from the provided parameters.
+     */
+    static fromValue(value, valueType) {
+        return this.from(Bool(true), value, valueType);
+    }
+    /**
+     * @returns Empty / none option
+     */
+    static none() {
+        return new Option(Bool(false), Field(0), Field);
+    }
+    static dummyValueFields(valueType) {
+        const length = valueType.sizeInFields();
+        return Array.from({ length }, () => Field(0));
+    }
+    /**
+     * Computes a dummy value for the given value type.
+     *
+     * @param valueType - Value type to generate the dummy value for
+     * @returns Dummy value for the given value type
+     */
+    static dummyValue(valueType) {
+        const fields = Option.dummyValueFields(valueType);
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return valueType.fromFields(fields);
+    }
+    constructor(isSome, value, valueType) {
+        this.isSome = isSome;
+        this.value = value;
+        this.valueType = valueType;
+        this.isForcedSome = Bool(false);
+    }
+    clone() {
+        return new Option(this.isSome, this.value, this.valueType);
+    }
+    forceSome() {
+        this.isForcedSome = Circuit.if(this.isSome, Bool(false), Bool(true));
+        this.isSome = Bool(true);
+    }
+    /**
+     * @returns Tree representation of the current value
+     */
+    get treeValue() {
+        const treeValue = Poseidon.hash(this.valueType.toFields(this.value));
+        return Circuit.if(this.isSome.and(this.isForcedSome.not()), treeValue, Field(0));
+    }
+    /**
+     * @returns Provable representation of the current option.
+     */
+    toProvable() {
+        return new ProvableOption({
+            isSome: this.isSome,
+            value: this.treeValue,
+        });
+    }
+}

package/dist/model/Path.d.ts

@@ -0,0 +1,31 @@
+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/model/Path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Path.d.ts","sourceRoot":"","sources":["../../src/model/Path.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAE,KAAK,oBAAoB,EAAY,MAAM,UAAU,CAAC;AAItE;;GAEG;AACH,qBAAa,IAAI;IACf;;;;;OAKG;WACW,OAAO,CAAC,KAAK,EAAE,MAAM;IAInC;;;;;;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/model/Path.js

@@ -0,0 +1,44 @@
+/* eslint-disable @typescript-eslint/no-extraneous-class */
+/* eslint-disable @shopify/no-fully-static-classes */
+import { Field, Poseidon } from "snarkyjs";
+import { stringToField } from "../utils/utils";
+/**
+ * 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) {
+        return stringToField(value);
+    }
+    /**
+     * 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]);
+    }
+}

package/dist/model/StateTransition.d.ts

@@ -0,0 +1,85 @@
+import { Field } from "snarkyjs";
+import { Option, ProvableOption } from "./Option.js";
+declare const ProvableStateTransition_base: (new (value: {
+    path: Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}) => {
+    path: Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
+    path: Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}> & {
+    toInput: (x: {
+        path: Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        path: Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    }) => {
+        path: string;
+        from: {
+            isSome: boolean;
+            value: string;
+        };
+        to: {
+            isSome: boolean;
+            value: string;
+        };
+    };
+    fromJSON: (x: {
+        path: string;
+        from: {
+            isSome: boolean;
+            value: string;
+        };
+        to: {
+            isSome: boolean;
+            value: string;
+        };
+    }) => {
+        path: Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+};
+/**
+ * Provable representation of a State Transition, used to
+ * normalize state transitions of various value types for
+ * the state transition circuit.
+ */
+export declare class ProvableStateTransition extends ProvableStateTransition_base {
+    static dummy(): ProvableStateTransition;
+}
+/**
+ * Generic state transition that constraints the current method circuit
+ * to external state, by providing a state anchor.
+ */
+export declare class StateTransition<Value> {
+    path: Field;
+    fromValue: Option<Field> | Option<Value>;
+    toValue: Option<Field> | Option<Value>;
+    static from<Value>(path: Field, fromValue: Option<Value>): StateTransition<Value>;
+    static fromTo<Value>(path: Field, fromValue: Option<Value>, toValue: Option<Value>): StateTransition<Value>;
+    constructor(path: Field, fromValue: Option<Field> | Option<Value>, toValue: Option<Field> | Option<Value>);
+    get from(): Option<Field> | Option<Value>;
+    get to(): Option<Field> | Option<Value>;
+    /**
+     * Converts a StateTransition to a ProvableStateTransition,
+     * while enforcing the 'from' property to be 'Some' in all cases.
+     */
+    toProvable(): ProvableStateTransition;
+}
+export {};
+//# sourceMappingURL=StateTransition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransition.d.ts","sourceRoot":"","sources":["../../src/model/StateTransition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,UAAU,CAAC;AAEzC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAErD;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,4BAQ3C;WACc,KAAK,IAAI,uBAAuB;CAO/C;AAED;;;GAGG;AACH,qBAAa,eAAe,CAAC,KAAK;IAcvB,IAAI,EAAE,KAAK;IACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;WAfjC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC;WAIjD,MAAM,CAAC,KAAK,EACxB,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;gBAMf,IAAI,EAAE,KAAK,EACX,SAAS,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,EACxC,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,kCAId;IAED,IAAW,EAAE,kCAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;CAO7C"}

package/dist/model/StateTransition.js

@@ -0,0 +1,58 @@
+import { Field, Struct } from "snarkyjs";
+import { Option, ProvableOption } from "./Option.js";
+/**
+ * Provable representation of a State Transition, used to
+ * normalize state transitions of various value types for
+ * the state transition circuit.
+ */
+export class ProvableStateTransition extends Struct({
+    path: Field,
+    // must be applied even if `None`
+    from: ProvableOption,
+    // must be ignored if `None`
+    to: ProvableOption,
+}) {
+    static dummy() {
+        return new ProvableStateTransition({
+            path: Field(0),
+            from: Option.none().toProvable(),
+            to: Option.none().toProvable(),
+        });
+    }
+}
+/**
+ * Generic state transition that constraints the current method circuit
+ * to external state, by providing a state anchor.
+ */
+export class StateTransition {
+    static from(path, fromValue) {
+        return new StateTransition(path, fromValue, Option.none());
+    }
+    static fromTo(path, fromValue, toValue) {
+        return new StateTransition(path, fromValue, toValue);
+    }
+    constructor(path, fromValue, toValue) {
+        this.path = path;
+        this.fromValue = fromValue;
+        this.toValue = toValue;
+    }
+    get from() {
+        const from = this.fromValue.clone();
+        from.forceSome();
+        return from;
+    }
+    get to() {
+        return this.toValue.clone();
+    }
+    /**
+     * Converts a StateTransition to a ProvableStateTransition,
+     * while enforcing the 'from' property to be 'Some' in all cases.
+     */
+    toProvable() {
+        return new ProvableStateTransition({
+            path: this.path,
+            from: this.from.toProvable(),
+            to: this.to.toProvable(),
+        });
+    }
+}

package/dist/model/StateTransitionProvableBatch.d.ts

@@ -0,0 +1,56 @@
+import { ProvableStateTransition } from "./StateTransition.js";
+declare const StateTransitionProvableBatch_base: (new (value: {
+    batch: ProvableStateTransition[];
+}) => {
+    batch: ProvableStateTransition[];
+}) & {
+    _isStruct: true;
+} & import("snarkyjs/dist/node/snarky.js").ProvablePure<{
+    batch: ProvableStateTransition[];
+}> & {
+    toInput: (x: {
+        batch: ProvableStateTransition[];
+    }) => {
+        fields?: import("snarkyjs/dist/node/snarky.js").Field[] | undefined;
+        packed?: [import("snarkyjs/dist/node/snarky.js").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        batch: ProvableStateTransition[];
+    }) => {
+        batch: {
+            path: string;
+            from: {
+                isSome: boolean;
+                value: string;
+            };
+            to: {
+                isSome: boolean;
+                value: string;
+            };
+        }[];
+    };
+    fromJSON: (x: {
+        batch: {
+            path: string;
+            from: {
+                isSome: boolean;
+                value: string;
+            };
+            to: {
+                isSome: boolean;
+                value: string;
+            };
+        }[];
+    }) => {
+        batch: ProvableStateTransition[];
+    };
+};
+/**
+ * A Batch of StateTransitions to be consumed by the StateTransitionProver
+ * to prove multiple STs at once
+ */
+export declare class StateTransitionProvableBatch extends StateTransitionProvableBatch_base {
+    static fromTransitions(transitions: ProvableStateTransition[]): StateTransitionProvableBatch;
+}
+export {};
+//# sourceMappingURL=StateTransitionProvableBatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionProvableBatch.d.ts","sourceRoot":"","sources":["../../src/model/StateTransitionProvableBatch.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAM/D;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,iCAKhD;WACc,eAAe,CAC3B,WAAW,EAAE,uBAAuB,EAAE,GACrC,4BAA4B;CAShC"}

package/dist/model/StateTransitionProvableBatch.js

@@ -0,0 +1,20 @@
+import { Circuit, Struct } from "snarkyjs";
+import { ProvableStateTransition } from "./StateTransition.js";
+const constants = {
+    stateTransitionProverBatchSize: 8,
+};
+/**
+ * A Batch of StateTransitions to be consumed by the StateTransitionProver
+ * to prove multiple STs at once
+ */
+export class StateTransitionProvableBatch extends Struct({
+    batch: Circuit.array(ProvableStateTransition, constants.stateTransitionProverBatchSize),
+}) {
+    static fromTransitions(transitions) {
+        const array = transitions.slice();
+        while (array.length < constants.stateTransitionProverBatchSize) {
+            array.push(ProvableStateTransition.dummy());
+        }
+        return new StateTransitionProvableBatch({ batch: array });
+    }
+}