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

package/dist/protocol/ProtocolEnvironment.d.ts

@@ -0,0 +1,9 @@
+import { AreProofsEnabled } from "@proto-kit/common";
+import { SimpleAsyncStateService } from "../state/StateService";
+import { StateServiceProvider } from "../state/StateServiceProvider";
+export interface ProtocolEnvironment {
+    get stateService(): SimpleAsyncStateService;
+    get stateServiceProvider(): StateServiceProvider;
+    getAreProofsEnabled(): AreProofsEnabled;
+}
+//# sourceMappingURL=ProtocolEnvironment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolEnvironment.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAErE,MAAM,WAAW,mBAAmB;IAClC,IAAI,YAAY,IAAI,uBAAuB,CAAC;IAC5C,IAAI,oBAAoB,IAAI,oBAAoB,CAAC;IACjD,mBAAmB,IAAI,gBAAgB,CAAC;CACzC"}

package/dist/protocol/ProtocolEnvironment.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ProtocolEnvironment.js.map

package/dist/protocol/ProtocolEnvironment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolEnvironment.js","sourceRoot":"","sources":["../../src/protocol/ProtocolEnvironment.ts"],"names":[],"mappings":""}

package/dist/protocol/ProtocolModule.d.ts

@@ -1,9 +1,9 @@
-import { AreProofsEnabled, Configurable, ZkProgrammable } from "@proto-kit/common";
-import type { Protocol, ProtocolModulesRecord } from "./Protocol";
-export declare abstract class ProtocolModule<PublicInput, PublicOutput> extends ZkProgrammable<PublicInput, PublicOutput> implements Configurable<unknown> {
-    config: {};
-    protocol?: Protocol<ProtocolModulesRecord>;
-    constructor();
-    get appChain(): AreProofsEnabled | undefined;
+import { AreProofsEnabled, ChildContainerProvider, ConfigurableModule, NoConfig } from "@proto-kit/common";
+import { ProtocolEnvironment } from "./ProtocolEnvironment";
+export declare abstract class ProtocolModule<Config = NoConfig> extends ConfigurableModule<Config> {
+    parent?: ProtocolEnvironment;
+    get areProofsEnabled(): AreProofsEnabled | undefined;
+    create(childContainerProvider: ChildContainerProvider): void;
+    start(): Promise<void>;
 }
 //# sourceMappingURL=ProtocolModule.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACf,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EAAE,QAAQ,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAElE,8BAAsB,cAAc,CAAC,WAAW,EAAE,YAAY,CAC5D,SAAQ,cAAc,CAAC,WAAW,EAAE,YAAY,CAChD,YAAW,YAAY,CAAC,OAAO,CAAC;IAEzB,MAAM,KAAM;IAEZ,QAAQ,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,CAAC;;IAMlD,IAAW,QAAQ,IAAI,gBAAgB,GAAG,SAAS,CAIlD;CACF"}
+{"version":3,"file":"ProtocolModule.d.ts","sourceRoot":"","sources":["../../src/protocol/ProtocolModule.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAClB,QAAQ,EAET,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D,8BAAsB,cAAc,CAClC,MAAM,GAAG,QAAQ,CACjB,SAAQ,kBAAkB,CAAC,MAAM,CAAC;IAC3B,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAEpC,IAAW,gBAAgB,IAAI,gBAAgB,GAAG,SAAS,CAE1D;IAEM,MAAM,CAAC,sBAAsB,EAAE,sBAAsB,GAAG,IAAI;IAItD,KAAK;CAGnB"}

package/dist/protocol/ProtocolModule.js

@@ -1,10 +1,13 @@
-import { ZkProgrammable, } from "@proto-kit/common";
-export class ProtocolModule extends ZkProgrammable {
-    constructor() {
-        super();
-        this.config = {};
+import { ConfigurableModule, noop, } from "@proto-kit/common";
+export class ProtocolModule extends ConfigurableModule {
+    get areProofsEnabled() {
+        return this.parent?.getAreProofsEnabled();
     }
-    get appChain() {
-        return this.protocol?.dependencyContainer.resolve("AppChain");
+    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,29 @@
+import { Field } from "o1js";
+import { NoConfig } from "@proto-kit/common";
+import { NetworkState } from "../model/network/NetworkState";
+import { BlockProverPublicInput, BlockArguments, BlockProverState } from "../prover/block/BlockProvable";
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export type ProvableHookBlockState = Pick<BlockProverPublicInput & BlockArguments, "eternalTransactionsHash" | "incomingMessagesHash" | "blockHashRoot">;
+export declare function toBeforeBlockHookArgument(state: Pick<BlockProverState, "eternalTransactionsList" | "incomingMessages" | "blockHashRoot">): {
+    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;
+};
+export declare function toAfterBlockHookArgument(state: Pick<BlockProverState, "eternalTransactionsList" | "incomingMessages" | "blockHashRoot">, stateRoot: Field, transactionsHash: Field): {
+    stateRoot: import("o1js/dist/node/lib/provable/field").Field;
+    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;
+};
+export interface BeforeBlockHookArguments extends ProvableHookBlockState {
+}
+export interface AfterBlockHookArguments extends BeforeBlockHookArguments {
+    stateRoot: Field;
+    transactionsHash: Field;
+}
+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,EACL,sBAAsB,EACtB,cAAc,EACd,gBAAgB,EACjB,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,MAAM,MAAM,sBAAsB,GAAG,IAAI,CACvC,sBAAsB,GAAG,cAAc,EACvC,yBAAyB,GAAG,sBAAsB,GAAG,eAAe,CACrE,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,IAAI,CACT,gBAAgB,EAChB,yBAAyB,GAAG,kBAAkB,GAAG,eAAe,CACjE;;;;EAQF;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,IAAI,CACT,gBAAgB,EAChB,yBAAyB,GAAG,kBAAkB,GAAG,eAAe,CACjE,EACD,SAAS,EAAE,KAAK,EAChB,gBAAgB,EAAE,KAAK;;;;;;EAOxB;AAED,MAAM,WAAW,wBAAyB,SAAQ,sBAAsB;CAAG;AAE3E,MAAM,WAAW,uBAAwB,SAAQ,wBAAwB;IACvE,SAAS,EAAE,KAAK,CAAC;IACjB,gBAAgB,EAAE,KAAK,CAAC;CACzB;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,20 @@
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export function toBeforeBlockHookArgument(state) {
+    const { eternalTransactionsList, incomingMessages, blockHashRoot } = state;
+    return {
+        eternalTransactionsHash: eternalTransactionsList.commitment,
+        incomingMessagesHash: incomingMessages.commitment,
+        blockHashRoot,
+    };
+}
+export function toAfterBlockHookArgument(state, stateRoot, transactionsHash) {
+    return {
+        ...toBeforeBlockHookArgument(state),
+        stateRoot,
+        transactionsHash,
+    };
+}
+// 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":"AAUA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAO5E,MAAM,UAAU,yBAAyB,CACvC,KAGC;IAED,MAAM,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,aAAa,EAAE,GAAG,KAAK,CAAC;IAC3E,OAAO;QACL,uBAAuB,EAAE,uBAAuB,CAAC,UAAU;QAC3D,oBAAoB,EAAE,gBAAgB,CAAC,UAAU;QACjD,aAAa;KACd,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,wBAAwB,CACtC,KAGC,EACD,SAAgB,EAChB,gBAAuB;IAEvB,OAAO;QACL,GAAG,yBAAyB,CAAC,KAAK,CAAC;QACnC,SAAS;QACT,gBAAgB;KACjB,CAAC;AACJ,CAAC;AASD,0DAA0D;AAC1D,MAAM,OAAgB,iBAEpB,SAAQ,2BAAmC;CAU5C"}

package/dist/protocol/ProvableTransactionHook.d.ts

@@ -0,0 +1,35 @@
+import { NoConfig } from "@proto-kit/common";
+import { Field } from "o1js";
+import { NetworkState } from "../model/network/NetworkState";
+import { MethodPublicOutput } from "../model/MethodPublicOutput";
+import { TransactionProverState } from "../prover/transaction/TransactionProvable";
+import { AuthorizedTransaction } from "../model/transaction/AuthorizedTransaction";
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export type ProvableHookTransactionState = {
+    transactionsHash: Field;
+    eternalTransactionsHash: Field;
+    incomingMessagesHash: Field;
+};
+export declare function toProvableHookTransactionState(state: Pick<TransactionProverState, "transactionList" | "eternalTransactionsList" | "incomingMessages">): ProvableHookTransactionState;
+export declare function toBeforeTransactionHookArgument(authorizedTransaction: AuthorizedTransaction, networkState: NetworkState, state: Parameters<typeof toProvableHookTransactionState>[0]): BeforeTransactionHookArguments;
+export declare function toAfterTransactionHookArgument(authorizedTransaction: AuthorizedTransaction, networkState: NetworkState, state: Parameters<typeof toProvableHookTransactionState>[0], runtimeResult: MethodPublicOutput): AfterTransactionHookArguments;
+/**
+ * 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: AuthorizedTransaction;
+    networkState: NetworkState;
+    prover: ProvableHookTransactionState;
+}
+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>;
+    removeTransactionWhen(execution: BeforeTransactionHookArguments): Promise<boolean>;
+}
+//# 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,KAAK,EAAE,MAAM,MAAM,CAAC;AAE7B,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AACnF,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAEnF,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAE5E,MAAM,MAAM,4BAA4B,GAAG;IACzC,gBAAgB,EAAE,KAAK,CAAC;IACxB,uBAAuB,EAAE,KAAK,CAAC;IAC/B,oBAAoB,EAAE,KAAK,CAAC;CAC7B,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,IAAI,CACT,sBAAsB,EACtB,iBAAiB,GAAG,yBAAyB,GAAG,kBAAkB,CACnE,GACA,4BAA4B,CAO9B;AAED,wBAAgB,+BAA+B,CAC7C,qBAAqB,EAAE,qBAAqB,EAC5C,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAC,CAAC,GAC1D,8BAA8B,CAMhC;AAED,wBAAgB,8BAA8B,CAC5C,qBAAqB,EAAE,qBAAqB,EAC5C,YAAY,EAAE,YAAY,EAC1B,KAAK,EAAE,UAAU,CAAC,OAAO,8BAA8B,CAAC,CAAC,CAAC,CAAC,EAC3D,aAAa,EAAE,kBAAkB,GAChC,6BAA6B,CAS/B;AAED;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAClC,kBAAkB,EAClB,kBAAkB,GAAG,iBAAiB,CACvC,CAAC;AAEF,MAAM,WAAW,8BAA8B;IAC7C,WAAW,EAAE,qBAAqB,CAAC;IACnC,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,4BAA4B,CAAC;CACtC;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;IAEH,qBAAqB,CAChC,SAAS,EAAE,8BAA8B,GACxC,OAAO,CAAC,OAAO,CAAC;CAGpB"}

package/dist/protocol/ProvableTransactionHook.js

@@ -0,0 +1,28 @@
+import { TransitioningProtocolModule } from "./TransitioningProtocolModule";
+export function toProvableHookTransactionState(state) {
+    const { transactionList, eternalTransactionsList, incomingMessages } = state;
+    return {
+        transactionsHash: transactionList.commitment,
+        eternalTransactionsHash: eternalTransactionsList.commitment,
+        incomingMessagesHash: incomingMessages.commitment,
+    };
+}
+export function toBeforeTransactionHookArgument(authorizedTransaction, networkState, state) {
+    return {
+        networkState,
+        transaction: authorizedTransaction,
+        prover: toProvableHookTransactionState(state),
+    };
+}
+export function toAfterTransactionHookArgument(authorizedTransaction, networkState, state, runtimeResult) {
+    return {
+        ...toBeforeTransactionHookArgument(authorizedTransaction, networkState, state),
+        runtimeResult,
+    };
+}
+export class ProvableTransactionHook extends TransitioningProtocolModule {
+    async removeTransactionWhen(execution) {
+        return false;
+    }
+}
+//# 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":"AAQA,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAQ5E,MAAM,UAAU,8BAA8B,CAC5C,KAGC;IAED,MAAM,EAAE,eAAe,EAAE,uBAAuB,EAAE,gBAAgB,EAAE,GAAG,KAAK,CAAC;IAC7E,OAAO;QACL,gBAAgB,EAAE,eAAe,CAAC,UAAU;QAC5C,uBAAuB,EAAE,uBAAuB,CAAC,UAAU;QAC3D,oBAAoB,EAAE,gBAAgB,CAAC,UAAU;KAClD,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,+BAA+B,CAC7C,qBAA4C,EAC5C,YAA0B,EAC1B,KAA2D;IAE3D,OAAO;QACL,YAAY;QACZ,WAAW,EAAE,qBAAqB;QAClC,MAAM,EAAE,8BAA8B,CAAC,KAAK,CAAC;KAC9C,CAAC;AACJ,CAAC;AAED,MAAM,UAAU,8BAA8B,CAC5C,qBAA4C,EAC5C,YAA0B,EAC1B,KAA2D,EAC3D,aAAiC;IAEjC,OAAO;QACL,GAAG,+BAA+B,CAChC,qBAAqB,EACrB,YAAY,EACZ,KAAK,CACN;QACD,aAAa;KACd,CAAC;AACJ,CAAC;AAuBD,MAAM,OAAgB,uBAEpB,SAAQ,2BAAmC;IASpC,KAAK,CAAC,qBAAqB,CAChC,SAAyC;QAEzC,OAAO,KAAK,CAAC;IACf,CAAC;CACF"}

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/BlockHashList.d.ts

@@ -0,0 +1,263 @@
+import { Field } from "o1js";
+import { DefaultProvableHashList } from "../../utils/ProvableHashList";
+import type { TransactionProverState } from "../transaction/TransactionProvable";
+import { NetworkState } from "../../model/network/NetworkState";
+declare const BundlePreimage_base: (new (value: {
+    preimage: import("o1js/dist/node/lib/provable/field").Field;
+    fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    preimage: import("o1js/dist/node/lib/provable/field").Field;
+    fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    preimage: import("o1js/dist/node/lib/provable/field").Field;
+    fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    preimage: bigint;
+    fromStateTransitionsHash: bigint;
+    fromWitnessedRootsHash: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        preimage: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: 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: {
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        preimage: string;
+        fromStateTransitionsHash: string;
+        fromWitnessedRootsHash: string;
+    };
+    fromJSON: (x: {
+        preimage: string;
+        fromStateTransitionsHash: string;
+        fromWitnessedRootsHash: string;
+    }) => {
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        preimage: import("o1js/dist/node/lib/provable/field").Field;
+        fromStateTransitionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        fromWitnessedRootsHash: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class BundlePreimage extends BundlePreimage_base {
+}
+declare const FieldTransition_base: (new (value: {
+    from: import("o1js/dist/node/lib/provable/field").Field;
+    to: import("o1js/dist/node/lib/provable/field").Field;
+}) => {
+    from: import("o1js/dist/node/lib/provable/field").Field;
+    to: import("o1js/dist/node/lib/provable/field").Field;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    from: import("o1js/dist/node/lib/provable/field").Field;
+    to: import("o1js/dist/node/lib/provable/field").Field;
+}, {
+    from: bigint;
+    to: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        from: import("o1js/dist/node/lib/provable/field").Field;
+        to: import("o1js/dist/node/lib/provable/field").Field;
+    };
+} & {
+    fromValue: (value: {
+        from: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        to: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        from: import("o1js/dist/node/lib/provable/field").Field;
+        to: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    toInput: (x: {
+        from: import("o1js/dist/node/lib/provable/field").Field;
+        to: 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: {
+        from: import("o1js/dist/node/lib/provable/field").Field;
+        to: import("o1js/dist/node/lib/provable/field").Field;
+    }) => {
+        from: string;
+        to: string;
+    };
+    fromJSON: (x: {
+        from: string;
+        to: string;
+    }) => {
+        from: import("o1js/dist/node/lib/provable/field").Field;
+        to: import("o1js/dist/node/lib/provable/field").Field;
+    };
+    empty: () => {
+        from: import("o1js/dist/node/lib/provable/field").Field;
+        to: import("o1js/dist/node/lib/provable/field").Field;
+    };
+};
+export declare class FieldTransition extends FieldTransition_base {
+}
+declare const Bundle_base: (new (value: {
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    pendingSTBatchesHash: FieldTransition;
+    witnessedRootsHash: FieldTransition;
+}) => {
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    pendingSTBatchesHash: FieldTransition;
+    witnessedRootsHash: FieldTransition;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+    transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+    pendingSTBatchesHash: FieldTransition;
+    witnessedRootsHash: FieldTransition;
+}, {
+    networkStateHash: bigint;
+    transactionsHash: bigint;
+    pendingSTBatchesHash: {
+        from: bigint;
+        to: bigint;
+    };
+    witnessedRootsHash: {
+        from: bigint;
+        to: bigint;
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition;
+        witnessedRootsHash: FieldTransition;
+    };
+} & {
+    fromValue: (value: {
+        networkStateHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition | {
+            from: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            to: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+        witnessedRootsHash: FieldTransition | {
+            from: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+            to: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        };
+    }) => {
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition;
+        witnessedRootsHash: FieldTransition;
+    };
+    toInput: (x: {
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition;
+        witnessedRootsHash: FieldTransition;
+    }) => {
+        fields?: import("o1js/dist/node/lib/provable/field").Field[] | undefined;
+        packed?: [import("o1js/dist/node/lib/provable/field").Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition;
+        witnessedRootsHash: FieldTransition;
+    }) => {
+        networkStateHash: string;
+        transactionsHash: string;
+        pendingSTBatchesHash: {
+            from: string;
+            to: string;
+        };
+        witnessedRootsHash: {
+            from: string;
+            to: string;
+        };
+    };
+    fromJSON: (x: {
+        networkStateHash: string;
+        transactionsHash: string;
+        pendingSTBatchesHash: {
+            from: string;
+            to: string;
+        };
+        witnessedRootsHash: {
+            from: string;
+            to: string;
+        };
+    }) => {
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition;
+        witnessedRootsHash: FieldTransition;
+    };
+    empty: () => {
+        networkStateHash: import("o1js/dist/node/lib/provable/field").Field;
+        transactionsHash: import("o1js/dist/node/lib/provable/field").Field;
+        pendingSTBatchesHash: FieldTransition;
+        witnessedRootsHash: FieldTransition;
+    };
+};
+/**
+ * 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 declare class Bundle extends Bundle_base {
+}
+/**
+ * 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 declare class BundleHashList extends DefaultProvableHashList<Bundle> {
+    preimage?: BundlePreimage | undefined;
+    constructor(commitment?: Field, preimage?: BundlePreimage | undefined);
+    /** 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: TransactionProverState, networkState: NetworkState): void;
+    /**
+     * 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: TransactionProverState, networkState: NetworkState): void;
+}
+export {};
+//# sourceMappingURL=BlockHashList.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BlockHashList.d.ts","sourceRoot":"","sources":["../../../src/prover/accumulators/BlockHashList.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAU,MAAM,MAAM,CAAC;AAErC,OAAO,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEhE,qBAAa,cAAe,SAAQ,mBAIlC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAGnC;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL;;;;GAIG;AACH,qBAAa,MAAO,SAAQ,WAQ1B;CAAG;AAEL;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,uBAAuB,CAAC,MAAM,CAAC;IAIxD,QAAQ,CAAC;gBAFhB,UAAU,GAAE,KAAgB,EAErB,QAAQ,CAAC,4BAAgB;IAKlC;;;OAGG;IACI,sBAAsB,CAC3B,KAAK,EAAE,sBAAsB,EAC7B,YAAY,EAAE,YAAY;IA6B5B;;;OAGG;IACI,WAAW,CAChB,KAAK,EAAE,sBAAsB,EAC7B,YAAY,EAAE,YAAY;CAwB7B"}