@proto-kit/protocol 0.1.1-develop.164 → 0.1.1-develop.1661

package/dist/protocol/ProtocolModule.js

@@ -1,10 +1,13 @@
-import { ZkProgrammable, } from "@proto-kit/common";
-export class ProtocolModule extends ZkProgrammable {
-    get appChain() {
-        return this.protocol?.dependencyContainer.resolve("AppChain");
+import { ConfigurableModule, noop, } from "@proto-kit/common";
+export class ProtocolModule extends ConfigurableModule {
+    get areProofsEnabled() {
+        return this.parent?.getAreProofsEnabled();
     }
-    constructor() {
-        super();
-        this.config = {};
+    create(childContainerProvider) {
+        noop();
+    }
+    async start() {
+        noop();
     }
 }
+//# sourceMappingURL=ProtocolModule.js.map

package/dist/protocol/ProtocolModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolModule.js","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,kBAAkB,EAElB,IAAI,GACL,MAAM,mBAAmB,CAAC;AAI3B,MAAM,OAAgB,cAEpB,SAAQ,kBAA0B;IAGlC,IAAW,gBAAgB;QACzB,OAAO,IAAI,CAAC,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC5C,CAAC;IAEM,MAAM,CAAC,sBAA8C;QAC1D,IAAI,EAAE,CAAC;IACT,CAAC;IAEM,KAAK,CAAC,KAAK;QAChB,IAAI,EAAE,CAAC;IACT,CAAC;CACF"}

package/dist/protocol/ProvableBlockHook.d.ts

@@ -0,0 +1,19 @@
+import { Field } from "o1js";
+import { NoConfig } from "@proto-kit/common";
+import { NetworkState } from "../model/network/NetworkState";
+import { MethodPublicOutput } from "../model/MethodPublicOutput";
+import { BlockProverTransactionArguments } from "../prover/block/BlockProvable";
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+import { AfterTransactionHookArguments, BeforeTransactionHookArguments, ProvableHookBlockState, toProvableHookBlockState } from "./ProvableTransactionHook";
+export interface BeforeBlockHookArguments extends ProvableHookBlockState {
+}
+export interface AfterBlockHookArguments extends BeforeBlockHookArguments {
+    stateRoot: Field;
+}
+export declare function toBeforeTransactionHookArgument(executionData: Omit<BlockProverTransactionArguments, "verificationKeyAttestation">, networkState: NetworkState, state: Parameters<typeof toProvableHookBlockState>[0]): BeforeTransactionHookArguments;
+export declare function toAfterTransactionHookArgument(executionData: Omit<BlockProverTransactionArguments, "verificationKeyAttestation">, networkState: NetworkState, state: Parameters<typeof toProvableHookBlockState>[0], runtimeResult: MethodPublicOutput): AfterTransactionHookArguments;
+export declare abstract class ProvableBlockHook<Config = NoConfig> extends TransitioningProtocolModule<Config> {
+    abstract beforeBlock(networkState: NetworkState, state: BeforeBlockHookArguments): Promise<NetworkState>;
+    abstract afterBlock(networkState: NetworkState, state: AfterBlockHookArguments): Promise<NetworkState>;
+}
+//# sourceMappingURL=ProvableBlockHook.d.ts.map

package/dist/protocol/ProvableBlockHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableBlockHook.d.ts","sourceRoot":"","sources":["../../src/protocol/ProvableBlockHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,+BAA+B,EAAE,MAAM,+BAA+B,CAAC;AAEhF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EACL,6BAA6B,EAC7B,8BAA8B,EAC9B,sBAAsB,EACtB,wBAAwB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,WAAW,wBAAyB,SAAQ,sBAAsB;CAAG;AAE3E,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE,SAAS,EAAE,KAAK,CAAC;CAClB;AAED,wBAAgB,+BAA+B,CAC7C,aAAa,EAAE,IAAI,CACjB,+BAA+B,EAC/B,4BAA4B,CAC7B,EACD,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,GACpD,8BAA8B,CAShC;AAED,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,IAAI,CACjB,+BAA+B,EAC/B,4BAA4B,CAC7B,EACD,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,UAAU,CAAC,OAAO,wBAAwB,CAAC,CAAC,CAAC,CAAC,EACrD,aAAa,EAAE,kBAAkB,GAChC,6BAA6B,CAK/B;AAGD,8BAAsB,iBAAiB,CACrC,MAAM,GAAG,QAAQ,CACjB,SAAQ,2BAA2B,CAAC,MAAM,CAAC;aAC3B,WAAW,CACzB,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,wBAAwB,GAC9B,OAAO,CAAC,YAAY,CAAC;aAER,UAAU,CACxB,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,uBAAuB,GAC7B,OAAO,CAAC,YAAY,CAAC;CACzB"}

package/dist/protocol/ProvableBlockHook.js

@@ -0,0 +1,21 @@
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+import { toProvableHookBlockState, } from "./ProvableTransactionHook";
+export function toBeforeTransactionHookArgument(executionData, networkState, state) {
+    const { transaction, signature } = executionData;
+    return {
+        networkState,
+        transaction,
+        signature,
+        prover: toProvableHookBlockState(state),
+    };
+}
+export function toAfterTransactionHookArgument(executionData, networkState, state, runtimeResult) {
+    return {
+        ...toBeforeTransactionHookArgument(executionData, networkState, state),
+        runtimeResult,
+    };
+}
+// Purpose is to build transition from -> to network state
+export class ProvableBlockHook extends TransitioningProtocolModule {
+}
+//# sourceMappingURL=ProvableBlockHook.js.map

package/dist/protocol/ProvableBlockHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableBlockHook.js","sourceRoot":"","sources":["../../src/protocol/ProvableBlockHook.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAIL,wBAAwB,GACzB,MAAM,2BAA2B,CAAC;AAQnC,MAAM,UAAU,+BAA+B,CAC7C,aAGC,EACD,YAA0B,EAC1B,KAAqD;IAErD,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,GAAG,aAAa,CAAC;IAEjD,OAAO;QACL,YAAY;QACZ,WAAW;QACX,SAAS;QACT,MAAM,EAAE,wBAAwB,CAAC,KAAK,CAAC;KACxC,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,aAGC,EACD,YAA0B,EAC1B,KAAqD,EACrD,aAAiC;IAEjC,OAAO;QACL,GAAG,+BAA+B,CAAC,aAAa,EAAE,YAAY,EAAE,KAAK,CAAC;QACtE,aAAa;KACd,CAAC;AACJ,CAAC;AAED,0DAA0D;AAC1D,MAAM,OAAgB,iBAEpB,SAAQ,2BAAmC;CAU5C"}

package/dist/protocol/ProvableTransactionHook.d.ts

@@ -0,0 +1,34 @@
+import { NoConfig } from "@proto-kit/common";
+import { Signature } from "o1js";
+import { RuntimeTransaction } from "../model/transaction/RuntimeTransaction";
+import { NetworkState } from "../model/network/NetworkState";
+import { MethodPublicOutput } from "../model/MethodPublicOutput";
+import type { BlockProverState, BlockProverStateCommitments } from "../prover/block/BlockProvable";
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export type ProvableHookBlockState = Pick<BlockProverStateCommitments, "transactionsHash" | "eternalTransactionsHash" | "incomingMessagesHash" | "blockHashRoot">;
+export declare function toProvableHookBlockState(state: Pick<BlockProverState, "transactionList" | "eternalTransactionsList" | "incomingMessages" | "blockHashRoot">): {
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    eternalTransactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    incomingMessagesHash: import("o1js/dist/node/lib/provable/field").Field;
+    blockHashRoot: import("o1js/dist/node/lib/provable/field").Field;
+};
+/**
+ * This type is a reduced set of the runtime method's public output.
+ * It omits internal commitments to data that is already present as data in
+ * the hook arguments
+ */
+export type TransactionResult = Omit<MethodPublicOutput, "networkStateHash" | "transactionHash">;
+export interface BeforeTransactionHookArguments {
+    transaction: RuntimeTransaction;
+    signature: Signature;
+    networkState: NetworkState;
+    prover: ProvableHookBlockState;
+}
+export interface AfterTransactionHookArguments extends BeforeTransactionHookArguments {
+    runtimeResult: TransactionResult;
+}
+export declare abstract class ProvableTransactionHook<Config = NoConfig> extends TransitioningProtocolModule<Config> {
+    abstract beforeTransaction(executionData: BeforeTransactionHookArguments): Promise<void>;
+    abstract afterTransaction(execution: AfterTransactionHookArguments): Promise<void>;
+}
+//# sourceMappingURL=ProvableTransactionHook.d.ts.map

package/dist/protocol/ProvableTransactionHook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableTransactionHook.d.ts","sourceRoot":"","sources":["../../src/protocol/ProvableTransactionHook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,KAAK,EACV,gBAAgB,EAChB,2BAA2B,EAC5B,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,2BAA2B,EACzB,kBAAkB,GAClB,yBAAyB,GACzB,sBAAsB,GACtB,eAAe,CAClB,CAAC;AAEF,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,IAAI,CACT,gBAAgB,EACd,iBAAiB,GACjB,yBAAyB,GACzB,kBAAkB,GAClB,eAAe,CAClB;;;;;EAcF;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,kBAAkB,EAClB,kBAAkB,GAAG,iBAAiB,CACvC,CAAC;AAEF,MAAM,WAAW,8BAA8B;IAC7C,WAAW,EAAE,kBAAkB,CAAC;IAChC,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,sBAAsB,CAAC;CAChC;AAED,MAAM,WAAW,6BACf,SAAQ,8BAA8B;IACtC,aAAa,EAAE,iBAAiB,CAAC;CAClC;AAED,8BAAsB,uBAAuB,CAC3C,MAAM,GAAG,QAAQ,CACjB,SAAQ,2BAA2B,CAAC,MAAM,CAAC;aAC3B,iBAAiB,CAC/B,aAAa,EAAE,8BAA8B,GAC5C,OAAO,CAAC,IAAI,CAAC;aAEA,gBAAgB,CAC9B,SAAS,EAAE,6BAA6B,GACvC,OAAO,CAAC,IAAI,CAAC;CACjB"}

package/dist/protocol/ProvableTransactionHook.js

@@ -0,0 +1,13 @@
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export function toProvableHookBlockState(state) {
+    const { transactionList, eternalTransactionsList, incomingMessages, blockHashRoot, } = state;
+    return {
+        transactionsHash: transactionList.commitment,
+        eternalTransactionsHash: eternalTransactionsList.commitment,
+        incomingMessagesHash: incomingMessages.commitment,
+        blockHashRoot,
+    };
+}
+export class ProvableTransactionHook extends TransitioningProtocolModule {
+}
+//# sourceMappingURL=ProvableTransactionHook.js.map

package/dist/protocol/ProvableTransactionHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProvableTransactionHook.js","sourceRoot":"","sources":["../../src/protocol/ProvableTransactionHook.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAU5E,MAAM,UAAU,wBAAwB,CACtC,KAMC;IAED,MAAM,EACJ,eAAe,EACf,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,GACd,GAAG,KAAK,CAAC;IACV,OAAO;QACL,gBAAgB,EAAE,eAAe,CAAC,UAAU;QAC5C,uBAAuB,EAAE,uBAAuB,CAAC,UAAU;QAC3D,oBAAoB,EAAE,gBAAgB,CAAC,UAAU;QACjD,aAAa;KACd,CAAC;AACJ,CAAC;AAwBD,MAAM,OAAgB,uBAEpB,SAAQ,2BAAmC;CAQ5C"}

package/dist/protocol/TransitioningProtocolModule.d.ts

@@ -0,0 +1,10 @@
+import { ProtocolModule } from "./ProtocolModule";
+/**
+ * TransitioningProtocolModule is a base interface that allows inheriting
+ * classes to use State and StateMap since it requires the implementation
+ * of a `name: string` property, which those classes need to function.
+ */
+export declare abstract class TransitioningProtocolModule<Config> extends ProtocolModule<Config> {
+    name?: string;
+}
+//# sourceMappingURL=TransitioningProtocolModule.d.ts.map

package/dist/protocol/TransitioningProtocolModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransitioningProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/TransitioningProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;GAIG;AACH,8BAAsB,2BAA2B,CAC/C,MAAM,CACN,SAAQ,cAAc,CAAC,MAAM,CAAC;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/protocol/TransitioningProtocolModule.js

@@ -0,0 +1,9 @@
+import { ProtocolModule } from "./ProtocolModule";
+/**
+ * TransitioningProtocolModule is a base interface that allows inheriting
+ * classes to use State and StateMap since it requires the implementation
+ * of a `name: string` property, which those classes need to function.
+ */
+export class TransitioningProtocolModule extends ProtocolModule {
+}
+//# sourceMappingURL=TransitioningProtocolModule.js.map

package/dist/protocol/TransitioningProtocolModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TransitioningProtocolModule.js","sourceRoot":"","sources":["../../src/protocol/TransitioningProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAElD;;;;GAIG;AACH,MAAM,OAAgB,2BAEpB,SAAQ,cAAsB;CAE/B"}

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

@@ -0,0 +1,18 @@
+import { Bool, Field } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { NonMethods } from "../../utils/utils";
+import { AppliedStateTransitionBatch } from "../../model/AppliedStateTransitionBatch";
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export declare class AppliedBatchHashList extends DefaultProvableHashList<NonMethods<AppliedStateTransitionBatch>> {
+    constructor(commitment?: Field);
+    private isNotEmpty;
+    push(value: AppliedStateTransitionBatch): this;
+    pushIf(value: AppliedStateTransitionBatch, condition: Bool): this;
+}
+//# sourceMappingURL=AppliedBatchHashList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppliedBatchHashList.d.ts","sourceRoot":"","sources":["../../../src/prover/accumulators/AppliedBatchHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AAEtF;;;;;;GAMG;AACH,qBAAa,oBAAqB,SAAQ,uBAAuB,CAC/D,UAAU,CAAC,2BAA2B,CAAC,CACxC;gBACoB,UAAU,GAAE,KAAgB;IAI/C,OAAO,CAAC,UAAU;IAIX,IAAI,CAAC,KAAK,EAAE,2BAA2B;IAIvC,MAAM,CAAC,KAAK,EAAE,2BAA2B,EAAE,SAAS,EAAE,IAAI;CAGlE"}

package/dist/prover/accumulators/AppliedBatchHashList.js

@@ -0,0 +1,25 @@
+import { Field } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import { AppliedStateTransitionBatch } from "../../model/AppliedStateTransitionBatch";
+/**
+ * A HashList for AppliedSTBatches, that in addition to the default
+ * functionality, checks that the pushed batches are not empty.
+ * If they are, the pushing is skipped.
+ * Note that if the batch has applied: false, the batch still has to be appended
+ * if it has STs inside
+ */
+export class AppliedBatchHashList extends DefaultProvableHashList {
+    constructor(commitment = Field(0)) {
+        super(AppliedStateTransitionBatch, commitment);
+    }
+    isNotEmpty(value) {
+        return value.batchHash.equals(Field(0)).not();
+    }
+    push(value) {
+        return super.pushIf(value, this.isNotEmpty(value));
+    }
+    pushIf(value, condition) {
+        return super.pushIf(value, condition.and(this.isNotEmpty(value)));
+    }
+}
+//# sourceMappingURL=AppliedBatchHashList.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AppliedBatchHashList.js","sourceRoot":"","sources":["../../../src/prover/accumulators/AppliedBatchHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,EAAE,MAAM,MAAM,CAAC;AAEnC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAEvE,OAAO,EAAE,2BAA2B,EAAE,MAAM,yCAAyC,CAAC;AAEtF;;;;;;GAMG;AACH,MAAM,OAAO,oBAAqB,SAAQ,uBAEzC;IACC,YAAmB,aAAoB,KAAK,CAAC,CAAC,CAAC;QAC7C,KAAK,CAAC,2BAA2B,EAAE,UAAU,CAAC,CAAC;IACjD,CAAC;IAEO,UAAU,CAAC,KAAkC;QACnD,OAAO,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;IAChD,CAAC;IAEM,IAAI,CAAC,KAAkC;QAC5C,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC;IACrD,CAAC;IAEM,MAAM,CAAC,KAAkC,EAAE,SAAe;QAC/D,OAAO,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACpE,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,137 @@
+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;
+    preimage: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+    preimage: 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;
+    preimage: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    witnessedRoot: bigint;
+    preimage: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        witnessedRoot: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        preimage: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+        preimage: 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;
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        witnessedRoot: string;
+        preimage: string;
+    };
+    fromJSON: (x: {
+        witnessedRoot: string;
+        preimage: string;
+    }) => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        witnessedRoot: import("o1js/dist/node/lib/provable/field").Field;
+        preimage: 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> {
+    constructor(commitment?: 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.
+     *
+     * @param preimage The preimage to the **current** state of the list.
+     */
+    witnessRoot(witnessedRoot: WitnessedRoot, preimage: Field, condition: Bool): this;
+}
+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,EAAU,MAAM,MAAM,CAAC;AAE3C,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEvE;;;GAGG;AACH,qBAAa,aAAc,SAAQ,kBAGjC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,oBAAqB,SAAQ,yBAGxC;CAAG;AAEL;;GAEG;AAEH,qBAAa,qBAAsB,SAAQ,uBAAuB,CAAC,aAAa,CAAC;gBAC5D,UAAU,GAAE,KAAgB;IAI/C;;;;;;;;;;;OAWG;IACI,WAAW,CAChB,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,KAAK,EACf,SAAS,EAAE,IAAI;CAkBlB"}

package/dist/prover/accumulators/WitnessedRootHashList.js

@@ -0,0 +1,50 @@
+import { Field, 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,
+    preimage: Field,
+}) {
+}
+/**
+ * Accumulator as of section "Intermediary state roots" of the STProver v2 spec
+ */
+export class WitnessedRootHashList extends DefaultProvableHashList {
+    constructor(commitment = Field(0)) {
+        super(WitnessedRoot, commitment);
+    }
+    /**
+     * 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.
+     *
+     * @param preimage The preimage to the **current** state of the list.
+     */
+    witnessRoot(witnessedRoot, preimage, 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(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);
+        return this.pushIf(witnessedRoot, condition.and(skipPush.not()));
+    }
+}
+//# 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,MAAM,EAAE,MAAM,MAAM,CAAC;AAE3C,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;IACpB,QAAQ,EAAE,KAAK;CAChB,CAAC;CAAG;AAEL;;GAEG;AAEH,MAAM,OAAO,qBAAsB,SAAQ,uBAAsC;IAC/E,YAAmB,aAAoB,KAAK,CAAC,CAAC,CAAC;QAC7C,KAAK,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IACnC,CAAC;IAED;;;;;;;;;;;OAWG;IACI,WAAW,CAChB,aAA4B,EAC5B,QAAe,EACf,SAAe;QAEf,6EAA6E;QAC7E,6EAA6E;QAC7E,8BAA8B;QAC9B,+EAA+E;QAC/E,uFAAuF;QACvF,MAAM,iBAAiB,GAAG,IAAI,qBAAqB,CAAC,QAAQ,CAAC,CAAC,IAAI,CAChE,aAAa,CACd,CAAC;QAEF,cAAc;QACd,wFAAwF;QACxF,gGAAgG;QAChG,MAAM,QAAQ,GAAG,iBAAiB,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAEtE,OAAO,IAAI,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACnE,CAAC;CACF"}