@proto-kit/protocol 0.1.1-develop.1086

package/dist/model/MethodPublicOutput.d.ts

@@ -0,0 +1,113 @@
+declare const MethodPublicOutput_base: (new (value: {
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    status: import("o1js/dist/node/lib/provable/bool").Bool;
+    transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+    eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    status: import("o1js/dist/node/lib/provable/bool").Bool;
+    transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+    eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    status: import("o1js/dist/node/lib/provable/bool").Bool;
+    transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+    eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    stateTransitionsHash: bigint;
+    status: boolean;
+    transactionHash: bigint;
+    networkStateHash: bigint;
+    isMessage: boolean;
+    eventsHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        status: import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        stateTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        status: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        status: import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        status: import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        status: import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        stateTransitionsHash: string;
+        status: boolean;
+        transactionHash: string;
+        networkStateHash: string;
+        isMessage: boolean;
+        eventsHash: string;
+    };
+    fromJSON: (x: {
+        stateTransitionsHash: string;
+        status: boolean;
+        transactionHash: string;
+        networkStateHash: string;
+        isMessage: boolean;
+        eventsHash: string;
+    }) => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        status: import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        stateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        status: import("o1js/dist/node/lib/provable/bool").Bool;
+        transactionHash: import("o1js/dist/node/lib/provable/field").Field;
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        isMessage: import("o1js/dist/node/lib/provable/bool").Bool;
+        eventsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+/**
+ * Public input used to link in-circuit execution with
+ * the proof's public input.
+ */
+export declare class MethodPublicOutput extends MethodPublicOutput_base {
+}
+export {};
+//# sourceMappingURL=MethodPublicOutput.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MethodPublicOutput.d.ts","sourceRoot":"","sources":["../../src/model/MethodPublicOutput.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,uBAOtC;CAAG"}

package/dist/model/MethodPublicOutput.js

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

package/dist/model/Option.d.ts

@@ -0,0 +1,122 @@
+import { Bool, Field, type FlexibleProvablePure } from "o1js";
+declare const ProvableOption_base: (new (value: {
+    isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+    value: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+    value: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+    value: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    isSome: boolean;
+    value: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+        value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        isSome: boolean;
+        value: string;
+    };
+    fromJSON: (x: {
+        isSome: boolean;
+        value: string;
+    }) => {
+        isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        isSome: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class ProvableOption extends ProvableOption_base {
+    toSome(): this;
+}
+export declare abstract class OptionBase {
+    isSome: Bool;
+    isForcedSome: Bool;
+    protected constructor(isSome: Bool, isForcedSome: Bool);
+    protected abstract encodeValueToFields(): Field[];
+    protected abstract clone(): OptionBase;
+    /**
+     * @returns Tree representation of the current value
+     */
+    get treeValue(): import("o1js/dist/node/lib/provable/field").Field;
+    forceSome(): void;
+    /**
+     * Returns the `to`-value as decoded as a list of fields
+     * Not in circuit
+     */
+    toFields(): Field[];
+    /**
+     * @returns Provable representation of the current option.
+     */
+    toProvable(): ProvableOption;
+    toJSON(): {
+        isSome: boolean;
+        isForcedSome: boolean;
+        value: string[];
+    };
+}
+/**
+ * Option facilitating in-circuit values that may or may not exist.
+ */
+export declare class Option<Value> extends OptionBase {
+    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<import("o1js/dist/node/lib/provable/field").Field>;
+    constructor(isSome: Bool, value: Value, valueType: FlexibleProvablePure<Value>, isForcedSome?: import("o1js/dist/node/lib/provable/bool").Bool);
+    encodeValueToFields(): Field[];
+    clone(): Option<Value>;
+    /**
+     * @returns Returns the value of this option if it isSome,
+     * otherwise returns the given defaultValue
+     */
+    orElse(defaultValue: Value): Value;
+    toConstant(): Option<Value>;
+}
+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,EACJ,KAAK,EACL,KAAK,oBAAoB,EAK1B,MAAM,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEd,qBAAa,cAAe,SAAQ,mBAGlC;IACO,MAAM;CAId;AAED,8BAAsB,UAAU;IAErB,MAAM,EAAE,IAAI;IACZ,YAAY,EAAE,IAAI;IAF3B,SAAS,aACA,MAAM,EAAE,IAAI,EACZ,YAAY,EAAE,IAAI;IAG3B,SAAS,CAAC,QAAQ,CAAC,mBAAmB,IAAI,KAAK,EAAE;IAEjD,SAAS,CAAC,QAAQ,CAAC,KAAK,IAAI,UAAU;IAEtC;;OAEG;IACH,IAAW,SAAS,sDAQnB;IAEM,SAAS;IAKhB;;;OAGG;IACI,QAAQ,IAAI,KAAK,EAAE;IAO1B;;OAEG;IACI,UAAU;IAOV,MAAM;;;;;CASd;AAED;;GAEG;AACH,qBAAa,MAAM,CAAC,KAAK,CAAE,SAAQ,UAAU;IAwClC,KAAK,EAAE,KAAK;IACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC;IAxC/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;gBAKhB,MAAM,EAAE,IAAI,EACL,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,oBAAoB,CAAC,KAAK,CAAC,EAC7C,YAAY,kDAAc;IAKrB,mBAAmB,IAAI,KAAK,EAAE;IAI9B,KAAK,IAAI,MAAM,CAAC,KAAK,CAAC;IAS7B;;;OAGG;IACI,MAAM,CAAC,YAAY,EAAE,KAAK,GAAG,KAAK;IASlC,UAAU;CAelB"}

package/dist/model/Option.js

@@ -0,0 +1,110 @@
+import { Bool, Field, Poseidon, Provable, Struct, } from "o1js";
+export class ProvableOption extends Struct({
+    isSome: Bool,
+    value: Field,
+}) {
+    toSome() {
+        this.isSome = Bool(true);
+        return this;
+    }
+}
+export class OptionBase {
+    constructor(isSome, isForcedSome) {
+        this.isSome = isSome;
+        this.isForcedSome = isForcedSome;
+    }
+    /**
+     * @returns Tree representation of the current value
+     */
+    get treeValue() {
+        const treeValue = Poseidon.hash(this.encodeValueToFields());
+        return Provable.if(this.isSome.and(this.isForcedSome.not()), treeValue, Field(0));
+    }
+    forceSome() {
+        this.isForcedSome = Provable.if(this.isSome, Bool(false), Bool(true));
+        this.isSome = Bool(true);
+    }
+    /**
+     * Returns the `to`-value as decoded as a list of fields
+     * Not in circuit
+     */
+    toFields() {
+        if (this.isSome.toBoolean()) {
+            return this.encodeValueToFields();
+        }
+        return [Field(0)];
+    }
+    /**
+     * @returns Provable representation of the current option.
+     */
+    toProvable() {
+        return new ProvableOption({
+            isSome: this.isSome,
+            value: this.treeValue,
+        });
+    }
+    toJSON() {
+        const value = this.encodeValueToFields().map((field) => field.toString());
+        return {
+            isSome: this.isSome.toBoolean(),
+            isForcedSome: this.isForcedSome.toBoolean(),
+            value,
+        };
+    }
+}
+/**
+ * Option facilitating in-circuit values that may or may not exist.
+ */
+export class Option extends OptionBase {
+    /**
+     * 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);
+    }
+    constructor(isSome, value, valueType, isForcedSome = Bool(false)) {
+        super(isSome, isForcedSome);
+        this.value = value;
+        this.valueType = valueType;
+    }
+    encodeValueToFields() {
+        return this.valueType.toFields(this.value);
+    }
+    clone() {
+        return new Option(this.isSome, this.value, this.valueType, this.isForcedSome);
+    }
+    /**
+     * @returns Returns the value of this option if it isSome,
+     * otherwise returns the given defaultValue
+     */
+    orElse(defaultValue) {
+        return Provable.if(this.isSome, this.valueType, this.value, defaultValue);
+    }
+    toConstant() {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const valueConstant = this.valueType.fromFields(this.valueType.toFields(this.value).map((field) => field.toConstant()));
+        const boolConstant = (bool) => Bool.fromFields([bool.toField().toConstant()]);
+        return new Option(boolConstant(this.isSome), valueConstant, this.valueType, boolConstant(this.isForcedSome));
+    }
+}

package/dist/model/Path.d.ts

@@ -0,0 +1,31 @@
+import { Field, type FlexibleProvablePure } from "o1js";
+/**
+ * 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): import("o1js/dist/node/lib/provable/field").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":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,oBAAoB,EAAY,MAAM,MAAM,CAAC;AAIlE;;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,42 @@
+import { Field, Poseidon } from "o1js";
+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/RuntimeLike.d.ts

@@ -0,0 +1,11 @@
+export type RuntimeMethodInvocationType = "INCOMING_MESSAGE" | "SIGNATURE";
+export type RuntimeMethodIdMapping = Record<`${string}.${string}`, {
+    methodId: bigint;
+    type: RuntimeMethodInvocationType;
+}>;
+export interface RuntimeLike {
+    get methodIdResolver(): {
+        methodIdMap: () => RuntimeMethodIdMapping;
+    };
+}
+//# sourceMappingURL=RuntimeLike.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeLike.d.ts","sourceRoot":"","sources":["../../src/model/RuntimeLike.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,2BAA2B,GAAG,kBAAkB,GAAG,WAAW,CAAC;AAE3E,MAAM,MAAM,sBAAsB,GAAG,MAAM,CACzC,GAAG,MAAM,IAAI,MAAM,EAAE,EACrB;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,2BAA2B,CAAA;CAAE,CACxD,CAAC;AAEF,MAAM,WAAW,WAAW;IAC1B,IAAI,gBAAgB,IAAI;QACtB,WAAW,EAAE,MAAM,sBAAsB,CAAC;KAC3C,CAAC;CACH"}

package/dist/model/RuntimeLike.js

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

package/dist/model/StateTransition.d.ts

@@ -0,0 +1,135 @@
+import { Field } from "o1js";
+import { Option, ProvableOption } from "./Option";
+declare const ProvableStateTransition_base: (new (value: {
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}) => {
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    path: import("o1js/dist/node/lib/provable/field").Field;
+    from: ProvableOption;
+    to: ProvableOption;
+}, {
+    path: bigint;
+    from: {
+        isSome: boolean;
+        value: bigint;
+    };
+    to: {
+        isSome: boolean;
+        value: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+} & {
+    fromValue: (value: {
+        path: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        to: ProvableOption | {
+            isSome: boolean | import("o1js/dist/node/lib/provable/bool").Bool;
+            value: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+    }) => {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+    toInput: (x: {
+        path: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        path: import("o1js/dist/node/lib/provable/field").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: import("o1js/dist/node/lib/provable/field").Field;
+        from: ProvableOption;
+        to: ProvableOption;
+    };
+    empty: () => {
+        path: import("o1js/dist/node/lib/provable/field").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<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<Value>, toValue: Option<Field> | Option<Value>);
+    get from(): Option<Value>;
+    get to(): Option<import("o1js/dist/node/lib/provable/field").Field> | Option<Value>;
+    /**
+     * Converts a StateTransition to a ProvableStateTransition,
+     * while enforcing the 'from' property to be 'Some' in all cases.
+     */
+    toProvable(): ProvableStateTransition;
+    toJSON(): {
+        path: string;
+        from: {
+            isSome: boolean;
+            isForcedSome: boolean;
+            value: string[];
+        };
+        to: {
+            isSome: boolean;
+            isForcedSome: boolean;
+            value: string[];
+        };
+    };
+    toConstant(): StateTransition<Value>;
+}
+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,MAAM,CAAC;AAErC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAElD;;;;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;IACxB,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,EACxB,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAG/C,IAAW,IAAI,kBAId;IAED,IAAW,EAAE,8EAEZ;IAED;;;OAGG;IACI,UAAU,IAAI,uBAAuB;IAQrC,MAAM;;;;;;;;;;;;;IAQN,UAAU,IAAI,eAAe,CAAC,KAAK,CAAC;CAO5C"}

package/dist/model/StateTransition.js

@@ -0,0 +1,68 @@
+import { Field, Struct } from "o1js";
+import { Option, ProvableOption } from "./Option";
+/**
+ * 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(),
+        });
+    }
+    toJSON() {
+        return {
+            path: this.path.toString(),
+            from: this.fromValue.toJSON(),
+            to: this.toValue.toJSON(),
+        };
+    }
+    toConstant() {
+        return new StateTransition(this.path.toConstant(), this.fromValue.toConstant(), this.toValue.toConstant());
+    }
+}