@proto-kit/protocol 0.1.1-develop.190 → 0.1.1-develop.2024

package/dist/prover/accumulators/BlockHashList.js

@@ -0,0 +1,97 @@
+import { Field, Struct } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+export class BundlePreimage extends Struct({
+    preimage: Field,
+    fromStateTransitionsHash: Field,
+    fromWitnessedRootsHash: Field,
+}) {
+}
+export class FieldTransition extends Struct({
+    from: Field,
+    to: Field,
+}) {
+}
+/**
+ * A bundle represents an ordered list of transactions and their evaluated effects.
+ * Specifically, this includes beforeTransaction, runtime and afterTransaction evaluation,
+ * but not block hooks.
+ */
+export class Bundle extends Struct({
+    // Those are per-block trackers
+    networkStateHash: Field,
+    transactionsHash: Field,
+    // Those are non-linear trackers that we assert later in the blockprover
+    pendingSTBatchesHash: FieldTransition,
+    witnessedRootsHash: FieldTransition,
+}) {
+}
+/**
+ * This hash list collects an ordered list of Bundle instances.
+ * "Pushing" onto this list can mean either appending a new bundle or updating the
+ * bundle at the tip of this list, according to the following rules:
+ * The validated preimage (via checkLastBundleElement) is:
+ * - == commitment: A new bundle will be appended
+ * - something else: The preimage is the actual preimage, therefore as a operation,
+ *   the old one will be popped (silently) and the updates bundle will be pushed,
+ *   resulting in an semantic update of the tip.
+ */
+export class BundleHashList extends DefaultProvableHashList {
+    constructor(commitment = Field(0), 
+    // TODO Refactor this into preimage and "auxiliary batch information" - this is confusing
+    preimage) {
+        super(Bundle, commitment);
+        this.preimage = preimage;
+    }
+    /** Verifies this list's preimage against the prover's state
+     * The main impact this function has is that it makes the preimage trusted
+     * i.e. we can safely use it to add to the bundle/open a new bundle
+     */
+    checkLastBundleElement(state, networkState) {
+        const { preimage, fromWitnessedRootsHash, fromStateTransitionsHash } = this.preimage;
+        // Check and append to bundlelist
+        const lastElement = new Bundle({
+            networkStateHash: networkState.hash(),
+            transactionsHash: state.transactionList.commitment,
+            pendingSTBatchesHash: {
+                from: fromStateTransitionsHash,
+                to: state.pendingSTBatches.commitment,
+            },
+            witnessedRootsHash: {
+                from: fromWitnessedRootsHash,
+                to: state.witnessedRoots.commitment,
+            },
+        });
+        const newBundle = this.commitment.equals(preimage);
+        this.witnessTip(preimage, lastElement)
+            .or(newBundle)
+            .assertTrue("Last element not valid");
+        newBundle
+            .implies(state.transactionList.isEmpty())
+            .assertTrue("Transaction list not empty for new bundle");
+    }
+    /**
+     * This function pushes a new bundle onto this list or updates the bundle at
+     * the tip of this list, according to the rules of the preimage algorithms (see class docs)
+     */
+    addToBundle(state, networkState) {
+        const { preimage, fromWitnessedRootsHash, fromStateTransitionsHash } = this.preimage;
+        const newElement = new Bundle({
+            networkStateHash: networkState.hash(),
+            transactionsHash: state.transactionList.commitment,
+            pendingSTBatchesHash: {
+                from: fromStateTransitionsHash,
+                to: state.pendingSTBatches.commitment,
+            },
+            witnessedRootsHash: {
+                from: fromWitnessedRootsHash,
+                to: state.witnessedRoots.commitment,
+            },
+        });
+        // We always overwrite here, the invariant is that the preimage is
+        // either the actual preimage in case of addition to the existing bundle
+        // or the current commitment in case of a new bundle
+        this.commitment = preimage;
+        this.push(newElement);
+    }
+}
+//# sourceMappingURL=BlockHashList.js.map

package/dist/prover/accumulators/BlockHashList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockHashList.js","sourceRoot":"","sources":["../../../src/prover/accumulators/BlockHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAIvE,MAAM,OAAO,cAAe,SAAQ,MAAM,CAAC;IACzC,QAAQ,EAAE,KAAK;IACf,wBAAwB,EAAE,KAAK;IAC/B,sBAAsB,EAAE,KAAK;CAC9B,CAAC;CAAG;AAEL,MAAM,OAAO,eAAgB,SAAQ,MAAM,CAAC;IAC1C,IAAI,EAAE,KAAK;IACX,EAAE,EAAE,KAAK;CACV,CAAC;CAAG;AAEL;;;;GAIG;AACH,MAAM,OAAO,MAAO,SAAQ,MAAM,CAAC;IACjC,+BAA+B;IAC/B,gBAAgB,EAAE,KAAK;IACvB,gBAAgB,EAAE,KAAK;IAEvB,wEAAwE;IACxE,oBAAoB,EAAE,eAAe;IACrC,kBAAkB,EAAE,eAAe;CACpC,CAAC;CAAG;AAEL;;;;;;;;;GASG;AACH,MAAM,OAAO,cAAe,SAAQ,uBAA+B;IACjE,YACE,aAAoB,KAAK,CAAC,CAAC,CAAC;IAC5B,yFAAyF;IAClF,QAAyB;QAEhC,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAFnB,aAAQ,GAAR,QAAQ,CAAiB;IAGlC,CAAC;IAED;;;OAGG;IACI,sBAAsB,CAC3B,KAA6B,EAC7B,YAA0B;QAE1B,MAAM,EAAE,QAAQ,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,GAClE,IAAI,CAAC,QAAS,CAAC;QAEjB,iCAAiC;QACjC,MAAM,WAAW,GAAG,IAAI,MAAM,CAAC;YAC7B,gBAAgB,EAAE,YAAY,CAAC,IAAI,EAAE;YACrC,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,UAAU;YAClD,oBAAoB,EAAE;gBACpB,IAAI,EAAE,wBAAwB;gBAC9B,EAAE,EAAE,KAAK,CAAC,gBAAgB,CAAC,UAAU;aACtC;YACD,kBAAkB,EAAE;gBAClB,IAAI,EAAE,sBAAsB;gBAC5B,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,UAAU;aACpC;SACF,CAAC,CAAC;QAEH,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;QACnD,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,WAAW,CAAC;aACnC,EAAE,CAAC,SAAS,CAAC;aACb,UAAU,CAAC,wBAAwB,CAAC,CAAC;QAExC,SAAS;aACN,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;aACxC,UAAU,CAAC,2CAA2C,CAAC,CAAC;IAC7D,CAAC;IAED;;;OAGG;IACI,WAAW,CAChB,KAA6B,EAC7B,YAA0B;QAE1B,MAAM,EAAE,QAAQ,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,GAClE,IAAI,CAAC,QAAS,CAAC;QAEjB,MAAM,UAAU,GAAG,IAAI,MAAM,CAAC;YAC5B,gBAAgB,EAAE,YAAY,CAAC,IAAI,EAAE;YACrC,gBAAgB,EAAE,KAAK,CAAC,eAAe,CAAC,UAAU;YAClD,oBAAoB,EAAE;gBACpB,IAAI,EAAE,wBAAwB;gBAC9B,EAAE,EAAE,KAAK,CAAC,gBAAgB,CAAC,UAAU;aACtC;YACD,kBAAkB,EAAE;gBAClB,IAAI,EAAE,sBAAsB;gBAC5B,EAAE,EAAE,KAAK,CAAC,cAAc,CAAC,UAAU;aACpC;SACF,CAAC,CAAC;QAEH,kEAAkE;QAClE,wEAAwE;QACxE,oDAAoD;QACpD,IAAI,CAAC,UAAU,GAAG,QAAQ,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACxB,CAAC;CACF"}

package/dist/prover/accumulators/StateTransitionReductionList.d.ts

@@ -0,0 +1,12 @@
+import { ProvableStateTransition, StateTransition } from "../../model/StateTransition";
+import { ProvableReductionHashList } from "../../utils/ProvableReductionHashList";
+export declare class StateTransitionReductionList extends ProvableReductionHashList<ProvableStateTransition> {
+    push(value: ProvableStateTransition): this;
+    pushWithMetadata(value: ProvableStateTransition): {
+        popLast: import("o1js/dist/node/lib/provable/bool").Bool;
+        value: ProvableStateTransition;
+    };
+    toField(): import("o1js/dist/node/lib/provable/field").Field;
+}
+export declare function reduceStateTransitions(transitions: StateTransition<unknown>[]): StateTransition<unknown>[];
+//# sourceMappingURL=StateTransitionReductionList.d.ts.map

package/dist/prover/accumulators/StateTransitionReductionList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionReductionList.d.ts","sourceRoot":"","sources":["../../../src/prover/accumulators/StateTransitionReductionList.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,uBAAuB,EACvB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAElF,qBAAa,4BAA6B,SAAQ,yBAAyB,CAAC,uBAAuB,CAAC;IAC3F,IAAI,CAAC,KAAK,EAAE,uBAAuB;IAMnC,gBAAgB,CAAC,KAAK,EAAE,uBAAuB;;;;IA0C/C,OAAO;CAGf;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,eAAe,CAAC,OAAO,CAAC,EAAE,GACtC,eAAe,CAAC,OAAO,CAAC,EAAE,CA0B5B"}

package/dist/prover/accumulators/StateTransitionReductionList.js

@@ -0,0 +1,64 @@
+import { Provable } from "o1js";
+import { ProvableOption } from "../../model/Option";
+import { ProvableStateTransition, StateTransition, } from "../../model/StateTransition";
+import { ProvableReductionHashList } from "../../utils/ProvableReductionHashList";
+export class StateTransitionReductionList extends ProvableReductionHashList {
+    push(value) {
+        this.pushWithMetadata(value);
+        return this;
+    }
+    pushWithMetadata(value) {
+        return this.pushAndReduce(value, (previous) => {
+            const pathsMatch = previous.path.equals(value.path);
+            // Take the previous.from if the paths match, otherwise leave ST as is
+            const from = Provable.if(pathsMatch, ProvableOption, previous.from, value.from);
+            // In case we have a layout like
+            // { from: 5, to: 10 }, { from: 10, to: none }
+            // we just take the first and discard the second
+            const to = Provable.if(value.to.isSome.or(pathsMatch.not()), ProvableOption, value.to, previous.to);
+            const transition = new ProvableStateTransition({
+                path: value.path,
+                from: new ProvableOption(from),
+                to: new ProvableOption(to),
+            });
+            // Assert that connection is correct
+            previous.to.value
+                .equals(value.from.value)
+                .or(previous.to.isSome
+                .not()
+                .and(previous.from.value.equals(value.from.value)))
+                .or(pathsMatch.not())
+                .assertTrue();
+            return [transition, pathsMatch];
+        });
+    }
+    toField() {
+        return this.commitment;
+    }
+}
+export function reduceStateTransitions(transitions) {
+    const reduced = [];
+    transitions.forEach((st) => {
+        if (reduced.length === 0) {
+            reduced.push(st);
+            return;
+        }
+        const last = reduced.at(-1);
+        if (last.path.equals(st.path).toBoolean()) {
+            if (st.toValue.isSome.toBoolean()) {
+                reduced.pop();
+                reduced.push(new StateTransition(st.path, last.fromValue, st.toValue));
+            }
+            else {
+                // Do nothing, because we discard that ST
+                // { from: 5, to: 10 }, { from: 10, to: none }
+                // cancel the 2nd
+            }
+        }
+        else {
+            reduced.push(st);
+        }
+    });
+    return reduced;
+}
+//# sourceMappingURL=StateTransitionReductionList.js.map

package/dist/prover/accumulators/StateTransitionReductionList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StateTransitionReductionList.js","sourceRoot":"","sources":["../../../src/prover/accumulators/StateTransitionReductionList.ts"],"names":[],"mappings":"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"}

package/dist/prover/accumulators/TransactionHashList.d.ts

@@ -0,0 +1,6 @@
+import { Field } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+export declare class TransactionHashList extends DefaultProvableHashList<Field> {
+    constructor(commitment?: Field);
+}
+//# sourceMappingURL=TransactionHashList.d.ts.map

package/dist/prover/accumulators/TransactionHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionHashList.d.ts","sourceRoot":"","sources":["../../../src/prover/accumulators/TransactionHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,qBAAa,mBAAoB,SAAQ,uBAAuB,CAAC,KAAK,CAAC;gBAClD,UAAU,GAAE,KAAgB;CAGhD"}

package/dist/prover/accumulators/TransactionHashList.js

@@ -0,0 +1,8 @@
+import { Field } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+export class TransactionHashList extends DefaultProvableHashList {
+    constructor(commitment = Field(0)) {
+        super(Field, commitment);
+    }
+}
+//# sourceMappingURL=TransactionHashList.js.map

package/dist/prover/accumulators/TransactionHashList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransactionHashList.js","sourceRoot":"","sources":["../../../src/prover/accumulators/TransactionHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7B,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,MAAM,OAAO,mBAAoB,SAAQ,uBAA8B;IACrE,YAAmB,aAAoB,KAAK,CAAC,CAAC,CAAC;QAC7C,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,CAAC;IAC3B,CAAC;CACF"}

package/dist/prover/accumulators/WitnessedRootHashList.d.ts

@@ -0,0 +1,123 @@
+import { Bool, Field } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+declare const WitnessedRoot_base: (new (value: {
+    appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+    root: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    appliedBatchListState: bigint;
+    root: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        appliedBatchListState: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        root: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+        root: 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: {
+        appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        appliedBatchListState: string;
+        root: string;
+    };
+    fromJSON: (x: {
+        appliedBatchListState: string;
+        root: string;
+    }) => {
+        appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        appliedBatchListState: import("o1js/dist/node/lib/provable/field").Field;
+        root: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+/**
+ * Link between a certain applied batch stack and a given root hash that the
+ * stack has to evaluate to at that given point in time
+ */
+export declare class WitnessedRoot extends WitnessedRoot_base {
+}
+declare const WitnessedRootWitness_base: (new (value: {
+    witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    witnessedRoot: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        witnessedRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        witnessedRoot: 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: {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        witnessedRoot: string;
+    };
+    fromJSON: (x: {
+        witnessedRoot: string;
+    }) => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class WitnessedRootWitness extends WitnessedRootWitness_base {
+}
+/**
+ * Accumulator as of section "Intermediary state roots" of the STProver v2 spec
+ */
+export declare class WitnessedRootHashList extends DefaultProvableHashList<WitnessedRoot> {
+    preimage: Field;
+    constructor(commitment?: Field, preimage?: Field);
+    /**
+     * To be used by the BlockProver or for tracing
+     *
+     * The main purpose of this method compared to the simple push methods
+     * is for deduplicating witnessed roots. We need to do this because the
+     * STProver can only witness once per batch, therefore if multiple witness
+     * points fall back to the same ST (because any batches in between were empty),
+     * this has to be detected and compensated for.
+     * This function does this using the preimage of the current list state.
+     */
+    witnessRoot(witnessedRoot: WitnessedRoot, condition: Bool): void;
+}
+export {};
+//# sourceMappingURL=WitnessedRootHashList.d.ts.map

package/dist/prover/accumulators/WitnessedRootHashList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WitnessedRootHashList.d.ts","sourceRoot":"","sources":["../../../src/prover/accumulators/WitnessedRootHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAoB,MAAM,MAAM,CAAC;AAErD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvE;;;GAGG;AACH,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAExC;CAAG;AAEL;;GAEG;AAEH,qBAAa,qBAAsB,SAAQ,uBAAuB,CAAC,aAAa,CAAC;IAGtE,QAAQ,EAAE,KAAK;gBADtB,UAAU,GAAE,KAAgB,EACrB,QAAQ,GAAE,KAAgB;IAKnC;;;;;;;;;OASG;IACI,WAAW,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,EAAE,IAAI;CAsBjE"}

package/dist/prover/accumulators/WitnessedRootHashList.js

@@ -0,0 +1,51 @@
+import { Field, Provable, Struct } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+/**
+ * Link between a certain applied batch stack and a given root hash that the
+ * stack has to evaluate to at that given point in time
+ */
+export class WitnessedRoot extends Struct({
+    appliedBatchListState: Field,
+    root: Field,
+}) {
+}
+export class WitnessedRootWitness extends Struct({
+    witnessedRoot: Field,
+}) {
+}
+/**
+ * Accumulator as of section "Intermediary state roots" of the STProver v2 spec
+ */
+export class WitnessedRootHashList extends DefaultProvableHashList {
+    constructor(commitment = Field(0), preimage = Field(0)) {
+        super(WitnessedRoot, commitment);
+        this.preimage = preimage;
+    }
+    /**
+     * To be used by the BlockProver or for tracing
+     *
+     * The main purpose of this method compared to the simple push methods
+     * is for deduplicating witnessed roots. We need to do this because the
+     * STProver can only witness once per batch, therefore if multiple witness
+     * points fall back to the same ST (because any batches in between were empty),
+     * this has to be detected and compensated for.
+     * This function does this using the preimage of the current list state.
+     */
+    witnessRoot(witnessedRoot, condition) {
+        // Note, we don't have to validate the preimage here because of the following
+        // 1. If the sequencer doesn't provide the correct witness, the BlockProver's
+        //    equality check will fail
+        // 2. If the list is empty, no preimage exists, therefore condition (2) doesn't
+        //    apply, which is the same outcome when the sequencer provides an arbitrary witness
+        const preimageCheckList = new WitnessedRootHashList(this.preimage).push(witnessedRoot);
+        // Conditions:
+        // (1) don't append if witnessedRoot == finalizedRoot -> Already covered in BlockProver
+        // (2) don't append if preimage.push({ finalizedRoot, pendingSTBatchesHash }) == this.commitment
+        const skipPush = preimageCheckList.commitment.equals(this.commitment);
+        const fromCommitment = this.commitment;
+        const pushCondition = condition.and(skipPush.not());
+        this.pushIf(witnessedRoot, pushCondition);
+        this.preimage = Provable.if(pushCondition, fromCommitment, this.preimage);
+    }
+}
+//# sourceMappingURL=WitnessedRootHashList.js.map

package/dist/prover/accumulators/WitnessedRootHashList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WitnessedRootHashList.js","sourceRoot":"","sources":["../../../src/prover/accumulators/WitnessedRootHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AAErD,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE;;;GAGG;AACH,MAAM,OAAO,aAAc,SAAQ,MAAM,CAAC;IACxC,qBAAqB,EAAE,KAAK;IAC5B,IAAI,EAAE,KAAK;CACZ,CAAC;CAAG;AAEL,MAAM,OAAO,oBAAqB,SAAQ,MAAM,CAAC;IAC/C,aAAa,EAAE,KAAK;CACrB,CAAC;CAAG;AAEL;;GAEG;AAEH,MAAM,OAAO,qBAAsB,SAAQ,uBAAsC;IAC/E,YACE,aAAoB,KAAK,CAAC,CAAC,CAAC,EACrB,WAAkB,KAAK,CAAC,CAAC,CAAC;QAEjC,KAAK,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;QAF1B,aAAQ,GAAR,QAAQ,CAAkB;IAGnC,CAAC;IAED;;;;;;;;;OASG;IACI,WAAW,CAAC,aAA4B,EAAE,SAAe;QAC9D,6EAA6E;QAC7E,6EAA6E;QAC7E,8BAA8B;QAC9B,+EAA+E;QAC/E,uFAAuF;QACvF,MAAM,iBAAiB,GAAG,IAAI,qBAAqB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CACrE,aAAa,CACd,CAAC;QAEF,cAAc;QACd,uFAAuF;QACvF,gGAAgG;QAChG,MAAM,QAAQ,GAAG,iBAAiB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEtE,MAAM,cAAc,GAAG,IAAI,CAAC,UAAU,CAAC;QAEvC,MAAM,aAAa,GAAG,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;QAE1C,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC,EAAE,CAAC,aAAa,EAAE,cAAc,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5E,CAAC;CACF"}